‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

יצירת מיומנויות ב-Google Antigravity

1. מבוא

‫Google Antigravity היא פלטפורמה לפיתוח בעזרת סוכני AI שנועדה לעזור לכם לפתח אפליקציות בעידן הזה של הסוכנים. ‫Antigravity משמשת כמרכז הבקרה המרכזי של סוכני ה-AI, ומספקת פלטפורמה מאוחדת להפעלת הפעילויות שלהם, למעקב אחריהן ולתזמור שלהן.

בשיעור Codelab הזה נסביר קודם על Agent Skills – פורמט קל משקל ופתוח להרחבת היכולות של סוכני AI באמצעות ידע ותהליכי עבודה מיוחדים. תוכלו ללמוד מהם כישורי סוכן, מה היתרונות שלהם ואיך הם בנויים. לאחר מכן תיצרו כמה מיומנויות של סוכנים, החל מכלי לעיצוב Git, מחולל תבניות, יצירת scaffolding של קוד כלי ועוד, וכולן ניתנות לשימוש ב-Antigravity.

דרישות מוקדמות:

התקנתם והגדרתם את Antigravity.
הבנה בסיסית של Google Antigravity. מומלץ להשלים את ה-Codelab: תחילת העבודה עם Google Antigravity.

2. למה כדאי להשתמש במיומנויות

סוכני AI מודרניים התפתחו ממנגנוני האזנה פשוטים למנגנוני ניתוח מורכבים שמשולבים עם מערכות קבצים מקומיות וכלים חיצוניים (באמצעות שרתי MCP). עם זאת, טעינה לא מבוקרת של סוכן עם בסיסי קוד שלמים ומאות כלים מובילה לרוויית הקשר ול'ריבוי כלים'. גם עם חלונות הקשר גדולים, הוספה של 40,000 עד 50,000 טוקנים של כלים לא בשימוש לזיכרון הפעיל גורמת לחביון גבוה, לבזבוז כספי ול'ריקבון הקשר', שבו המודל מתבלבל מנתונים לא רלוונטיים.

הפתרון: המיומנויות של הסוכן

כדי לפתור את הבעיה הזו, Anthropic הציגה את Agent Skills, והעבירה את הארכיטקטורה מטעינת הקשר מונוליטית לProgressive Disclosure. במקום לחייב את המודל "לזכור" כל תהליך עבודה ספציפי (כמו העברות של מסדי נתונים או ביקורות אבטחה) בתחילת סשן, היכולות האלה מאוגדות ביחידות מודולריות שאפשר לגלות.

איך זה עובד

בתחילה, המודל נחשף רק ל "תפריט" קל משקל של מטא-נתונים. הוא טוען את הידע הפרוצדורלי הכבד (הוראות ותסריטים) רק כשכוונת המשתמש תואמת באופן ספציפי למיומנות. כך מובטח שמפתח שמבקש לבצע רפקטורינג של תוכנת ביניים לאימות יקבל הקשר אבטחה בלי לטעון צינורות CSS לא רלוונטיים, וההקשר יישאר רזה, מהיר וחסכוני.

3. המיומנויות של הסוכן ו-Antigravity

בסביבה העסקית של Antigravity, מיומנויות הן מודולים מיוחדים להדרכה שמגשרים על הפער בין המודלים הכלליים לבין ההקשר הספציפי שלכם. הם מאפשרים לסוכן 'להצטייד' במערך מוגדר של הוראות ופרוטוקולים – כמו תקנים להעברת מסדי נתונים או בדיקות אבטחה – רק כשמתקבלת בקשה למשימה רלוונטית. באמצעות טעינה דינמית של פרוטוקולי הביצוע האלה, המיומנויות הופכות את ה-AI ממתכנת כללי למומחה שמקפיד על השיטות המומלצות ועל תקני הבטיחות של הארגון.

מהי מיומנות ב-Antigravity?

ב-Google Antigravity, מיומנות היא חבילה מבוססת-ספרייה שמכילה קובץ הגדרה (SKILL.md) ונכסי תמיכה אופציונליים (סקריפטים, הפניות, תבניות).

זהו מנגנון להרחבת היכולות על פי דרישה.

על פי דרישה: בניגוד להנחיה מערכתית (שתמיד נטענת), מיומנות נטענת להקשר של הסוכן רק כשהסוכן קובע שהיא רלוונטית לבקשה הנוכחית של המשתמש. כך חלון ההקשר עובר אופטימיזציה והסוכן לא מוסח על ידי הוראות לא רלוונטיות. בפרויקטים גדולים עם עשרות כלים, טעינה סלקטיבית כזו היא קריטית לביצועים ולדיוק של החשיבה הרציונלית.
הרחבת יכולות: סקילים יכולים לעשות יותר מסתם לתת הוראות, הם יכולים לבצע פעולות. באמצעות חבילה של סקריפטים של Python או Bash, מיומנות יכולה לתת לסוכן את היכולת לבצע פעולות מורכבות ומרובות שלבים במחשב המקומי או ברשתות חיצוניות, בלי שהמשתמש יצטרך להריץ פקודות באופן ידני. הפעולה הזו הופכת את הסוכן מכלי ליצירת טקסט למשתמש בכלים.

מיומנויות לעומת המערכת האקולוגית (כלים, כללים ותהליכי עבודה)

פונקציות Model Context Protocol‏ (MCP) הן כמו 'הידיים' של הסוכן – הן מספקות חיבורים חזקים וקבועים למערכות חיצוניות כמו GitHub או PostgreSQL – והמיומנויות הן כמו 'המוח' שמכוון אותן.

פלטפורמת ה-MCP מטפלת בתשתית מבוססת-מצב, בעוד שהמיומנויות הן הגדרות קלות משקל וזמניות של משימות, שכוללות את המתודולוגיה לשימוש בכלים האלה. הגישה הזו ללא שרתים מאפשרת לסוכנים לבצע משימות אד-הוק (כמו יצירת יומני שינויים או העברות) בלי התקורה התפעולית של הפעלת תהליכים מתמשכים, טעינת ההקשר רק כשהמשימה פעילה ושחרורו מיד לאחר מכן.

מיומנויות הן מופעלות על ידי סוכן: המודל מזהה באופן אוטומטי את כוונת המשתמש ומצייד את עצמו באופן דינמי במומחיות הספציפית הנדרשת. הארכיטקטורה הזו מאפשרת יכולת קומפוזיציה חזקה. לדוגמה, כלל גלובלי יכול לאכוף את השימוש במיומנות Safe-Migration (העברה בטוחה) במהלך שינויים במסד נתונים, או שזרימת עבודה אחת יכולה לתזמן כמה מיומנויות כדי לבנות צינור פריסה חזק.

4. יצירת סקילים

יצירת מיומנות ב-Antigravity מתבצעת לפי מבנה ספריות ופורמט קובץ ספציפיים. התקנון הזה מבטיח שאפשר להעביר את הכישורים ושסוכן ה-AI יכול לנתח אותם ולהפעיל אותם בצורה מהימנה. העיצוב פשוט בכוונה, והוא מסתמך על פורמטים מוכרים כמו Markdown ו-YAML, כדי להקל על מפתחים שרוצים להרחיב את היכולות של סביבת הפיתוח המשולבת שלהם.

מבנה הספרייה

ספריית סקילים טיפוסית נראית כך:

my-skill/
├── SKILL.md # The definition file
├── scripts/ # [Optional] Python, Bash, or Node scripts
     ├── run.py
     └── util.sh
├── references/ # [Optional] Documentation or templates
     └── api-docs.md
└── assets/ # [Optional] Static assets (images, logos)

המבנה הזה מפריד בין הנושאים בצורה יעילה. הלוגיקה (scripts) מופרדת מההוראה (SKILL.md) ומהידע (references), בהתאם לשיטות המקובלות בהנדסת תוכנה.

קובץ ההגדרה SKILL.md

קובץ SKILL.md הוא המוח של הסקיל. ההוראות האלה אומרות לסוכן מה הסקיל, מתי להשתמש בו ואיך להפעיל אותו.

הוא מורכב משני חלקים:

YAML Frontmatter
גוף ההודעה בפורמט Markdown.

YAML Frontmatter

זו שכבת המטא-נתונים. זהו החלק היחיד של היכולת שמקוטלג על ידי נתב ברמה גבוהה של הסוכן. כשמשתמש שולח פרומפט, הנציג מבצע התאמה סמנטית של הפרומפט לשדות התיאור של כל הכישורים הזמינים.

---
name: database-inspector
description: Use this skill when the user asks to query the database, check table schemas, or inspect user data in the local PostgreSQL instance.
---

שדות מפתח:

‫name: לא חובה. המזהה חייב להיות ייחודי בהיקף. אפשר להשתמש באותיות קטנות ובמקפים (למשל, postgres-query, pr-reviewer). אם לא מציינים שם, ברירת המחדל היא שם הספרייה.
תיאור: זהו שדה חובה והוא הכי חשוב. הוא פועל כ "ביטוי ההפעלה". התיאור צריך להיות מפורט מספיק כדי שה-LLM יזהה את הרלוונטיות הסמנטית. תיאור לא ברור כמו 'כלים למסדי נתונים' לא מספיק. תיאור מדויק כמו 'מבצע שאילתות SQL לקריאה בלבד במסד הנתונים המקומי של PostgreSQL כדי לאחזר נתוני משתמשים או נתוני עסקאות. השימוש בביטוי הזה 'Use this for debugging data states' מוודא שהמיומנות תזוהה בצורה נכונה.

הגוף של הודעת ה-Markdown

גוף ההודעה מכיל את ההוראות. זוהי 'הנדסת הנחיות' שנשמרת בקובץ. כשהמיומנות מופעלת, התוכן הזה מוזרק לחלון ההקשר של הסוכן.

גוף ההודעה צריך לכלול:

המטרה: הצהרה ברורה לגבי מה שהמיומנות משיגה.
הוראות: לוגיקה מפורטת.
דוגמאות: דוגמאות עם כמה נתונים של קלט ופלט כדי להנחות את ביצועי המודל.
מגבלות: כללים שמתחילים במילים "אל תעשה" (למשל, "אל תריץ שאילתות DELETE").

דוגמה ל-Body בקובץ SKILL.md:

Database Inspector

Goal
To safely query the local database and provide insights on the current data state.

Instructions
- Analyze the users natural language request to understand the data need.
- Formulate a valid SQL query.
 - CRITICAL: Only SELECT statements are allowed.
- Use the script scripts/query_runner.py to execute the SQL.
 - Command: python scripts/query_runner.py "SELECT * FROM..."
- Present the results in a Markdown table.

Constraints
- Never output raw user passwords or API keys.
- If the query returns > 50 rows, summarize the data instead of listing it all.

שילוב סקריפטים

אחד הפיצ'רים הכי שימושיים ב-Skills הוא היכולת להעביר את ההפעלה לסקריפטים. כך הסוכן יכול לבצע פעולות שמודל שפה גדול מתקשה לבצע ישירות (כמו ביצוע בינארי, חישוב מתמטי מורכב או אינטראקציה עם מערכות מדור קודם).

סקריפטים צריכים להיות בספריית המשנה scripts/. התג SKILL.md מפנה אליהם באמצעות נתיב יחסי.

5. יצירת סקילים

המטרה של הקטע הזה היא ליצור מיומנויות שמשתלבות ב-Antigravity ומציגות בהדרגה תכונות שונות כמו משאבים, סקריפטים וכו'.

אפשר להוריד את המיומנויות ממאגר Github כאן: https://github.com/rominirani/antigravity-skills.

לפני שנסביר איך כל אחת מהמיומנויות האלה נבנתה, נראה איך מגדירים אותן ואיך הן זמינות בחבילת המוצרים של Antigravity. התיקיות שמופיעות בהמשך רלוונטיות למועד הפרסום של המעבדה הזו.

שימוש ב-Antigravity או ב-Antigravity CLI

אפשר להגדיר מיומנויות בשני היקפים, כך שיהיו מיומנויות ספציפיות לפרויקט ומיומנויות ספציפיות למשתמש, כלומר מיומנויות גלובליות.

היקף גלובלי (~/.gemini/config/skills/): זמין בכל מוצרי Antigravity (‏Antigravity, ‏ Antigravity IDE, ‏ Antigravity CLI) ובפרויקטים. הכישורים האלה זמינים בכל הפרויקטים במחשב של המשתמש. האפשרות הזו מתאימה לכלים כלליים כמו 'עיצוב JSON', 'יצירת מזהי UUID', 'בדיקת סגנון קוד' או שילוב עם כלים לשיפור הפרודוקטיביות האישית.
היקף הפרויקט/Workspace (<project-root>/.agents/skills/): האפשרות הזו מאפשרת להשתמש במיומנות רק בפרויקט ספציפי. האפשרות הזו אידיאלית לסקריפטים שספציפיים לפרויקט, כמו פריסה בסביבה מסוימת, ניהול מסד נתונים של אפליקציה מסוימת או יצירת קוד תבנית למסגרת קניינית.

התקנת המיומנויות ב-Antigravity או ב-Antigravity CLI

במדריך הזה, כל מה שצריך לעשות הוא לבצע את השלבים הבאים (אפשר גם לעשות את זה בדרך שלכם):

שלב 1: מבצעים git clone של https://github.com/rominirani/antigravity-skills

שלב 2: עכשיו, בהתאם לכלי שבו אתם משתמשים – Antigravity או Antigravity CLI – אתם יכולים לנווט לתיקייה antigravity-skills/skills_tutorial.

שלב 3: תופיע קבוצה של מיומנויות, שמאורגנות בתיקיות שלהן. מעתיקים את 4 התיקיות הבאות:

git-commit-formatter
license-header-adder
database-schema-validator
json-to-pydantic

לתיקיית הכישורים המטורגטים של המוצר (היקף הפרויקט או היקף גלובלי).

שלב 4: אם אתם משתמשים ב-Antigravity או ב-Antigravity CLI , מעתיקים אותו אל <project-root>/.agents/skills/ (היקף הפרויקט).

אם הפעלתם את Antigravity, תוכלו לשאול שאלה פשוטה כמו What skills are available?‎ (אילו מיומנויות זמינות?) והוא יענה לכם. תוכלו לראות את 4 המיומנויות שמופיעות שם. יכול להיות שיש לכם גם מיומנויות נוספות, אם התקנתם אותן בסביבה שלכם.

באופן דומה, אם אתם משתמשים ב-Antigravity CLI, אתם יכולים להריץ את הפקודה /skills והיא אמורה להציג את 4 הכישורים. דוגמה:

אחרי שהסברנו איך מגדירים את היכולות, נסביר על כל אחת מהיכולות ואיך הן בנויות. אתם יכולים גם להשתמש בתבניות האלה כדי ליצור מיומנויות משלכם.

רמה 1 : הנתב הבסיסי ( git-commit-formatter )

אפשר להתייחס לזה כאל 'Hello World' של מיומנויות.

מפתחים כותבים לעיתים קרובות הודעות קומיט עצלות, למשל: 'wip',‏ 'fix bug',‏ 'updates'. האכיפה הידנית של 'הודעות קומיט קונבנציונליות' היא מייגעת ולעתים קרובות נשכחת. בואו ניישם מיומנות שמחילה את המפרט של Conventional Commits. פשוט נותנים לסוכן הוראות לגבי הכללים, והוא פועל כאוכף.

git-commit-formatter/
└── SKILL.md  (Instructions only)

קובץ SKILL.md לדוגמה:

---
name: git-commit-formatter
description: Formats git commit messages according to Conventional Commits specification. Use this when the user asks to commit changes or write a commit message.
---

Git Commit Formatter Skill

When writing a git commit message, you MUST follow the Conventional Commits specification.

Format
`<type>[optional scope]: <description>`

Allowed Types
- **feat**: A new feature
- **fix**: A bug fix
- **docs**: Documentation only changes
- **style**: Changes that do not affect the meaning of the code (white-space, formatting, etc)
- **refactor**: A code change that neither fixes a bug nor adds a feature
- **perf**: A code change that improves performance
- **test**: Adding missing tests or correcting existing tests
- **chore**: Changes to the build process or auxiliary tools and libraries such as documentation generation

Instructions
1. Analyze the changes to determine the primary `type`.
2. Identify the `scope` if applicable (e.g., specific component or file).
3. Write a concise `description` in an imperative mood (e.g., "add feature" not "added feature").
4. If there are breaking changes, add a footer starting with `BREAKING CHANGE:`.

Example
`feat(auth): implement login with google`

איך מריצים את הדוגמה הזו ב-Antigravity

השלבים הבאים מניחים ש-Git זמין במחשב המקומי שלכם ושההגדרה שלו תקינה.

אם הפעלתם את Antigravity או את Antigravity CLI, פועלים לפי השלבים הבאים:

שלב 1: הגדרת מאגר Git לבדיקה

מבקשים מהסוכן להגדיר ספרייה נקייה ומבודדת לבדיקת פעולות Git.

הפרומפט שלך:

Create a folder named git_test in the workspace, initialize a git repository inside it, and create an initial file auth.py with def login(): pass. Stage this file and make an initial commit.

כשמתבצעת פעולת השמירה, הסקיל מופעל והודעת השמירה מעוצבת בהתאם להמלצה שלנו, שמופיעה בסקיל.

יצרתי את התיקייה, הפעלתי את מאגר ה-Git, יצרתי את הקובץ הראשוני, העברתי אותו לאזור ההכנה (staging) וביצעתי commit באמצעות המפרט של Conventional Commits:

 1. Created folder and initialized git repository:
     • Directory: git_test
     • Initialized empty Git repository in git_test/.git/
 2. Created initial file:
     • File: auth.py
     • Defined: auth.py:1-2
 3. Staged and committed changes:
     • Commit message: feat(auth): add initial login function

שלב 2: ביצוע שינוי בקוד

מבקשים מהסוכן לשנות את הקוד כדי שיהיה שינוי שאפשר לבצע לו קומיט.

הפרומפט שלך:

In the git_test folder, modify auth.py to add Google Login functionality.

הסוכן יערוך את הקובץ כדי להוסיף תכונה חדשה, ויכין אותו לשלב השמירה.

שלב 3: העברת השינויים לאזור ההכנה והוספתם למאגר

מפעילים את הסקיל git-commit-formatter על ידי בקשה מהסוכן להכין את השינויים וליצור קומיט.

הפרומפט שלך:

Stage the changes in the git_test folder and commit them. Make sure to format the commit message using the Conventional Commits skill.

הסוכן יריץ את הפקודה git add auth.py, ינתח את ההבדלים כדי לקבוע שתכונה חדשה נוספה למודול auth, וינסח הודעת קומיט קונבנציונלית כמו feat(auth): implement google login לפני שיריץ את הפקודה git commit.

שלב 4: אימות יומן ה-Git

מבקשים מהסוכן לאחזר את היסטוריית ה-git כדי לוודא שהקלטתם בהצלחה את הקומיט המעוצב.

הפרומפט שלך:

Show me the git log in the git_test folder.

הסוכן יפעיל את הפקודה git log -n 5 ויחזיר את הפלט שכולל את הודעת הקומיט המעוצבת.

רמה 2: ניצול נכסים (license-header-adder)

זו תבנית ה'הפניה'.

יכול להיות שכל קובץ מקור בפרויקט ארגוני יצטרך כותרת רישיון ספציפית של Apache 2.0 עם 20 שורות. הוספה של הטקסט הסטטי הזה ישירות להנחיה (או SKILL.md) היא בזבוז. היא צורכת טוקנים בכל פעם שהמיומנות עוברת אינדוקס, ויכול להיות שהמודל ימציא שגיאות הקלדה בטקסט משפטי. מומלץ להעביר את הטקסט הסטטי לקובץ טקסט פשוט בתיקייה resources/. התכונה הזו מאפשרת לסוכן לקרוא את הקובץ רק כשצריך.

הקבצים יופיעו בתיקייה license-header-adder בספרייה skills.

license-header-adder/
├── SKILL.md
└── resources/
   └── HEADER_TEMPLATE.txt  (The heavy text)

קובץ SKILL.md לדוגמה:

---
name: license-header-adder
description: Adds the standard open-source license header to new source files. Use involves creating new code files that require copyright attribution.
---

# License Header Adder Skill

This skill ensures that all new source files have the correct copyright header.

## Instructions

1. **Read the Template**:
  First, read the content of the header template file located at `resources/HEADER_TEMPLATE.txt`.

2. **Prepend to File**:
  When creating a new file (e.g., `.py`, `.java`, `.js`, `.ts`, `.go`), prepend the `target_file` content with the template content.

3. **Modify Comment Syntax**:
  - For C-style languages (Java, JS, TS, C++), keep the `/* ... */` block as is.
  - For Python, Shell, or YAML, convert the block to use `#` comments.
  - For HTML/XML, use `<!-- ... -->`.

איך מריצים את הדוגמה הזו ב-Antigravity

אם הפעלתם את הדוגמה הקודמת, כותרת הרישיון כבר תתווסף. אתם יכולים לבדוק את זה או לנסות הנחיה חדשה כאן.

אם הפעלתם את Antigravity או את Antigravity CLI, פועלים לפי השלבים הבאים:

שלב 1: יצירת קובץ Python עם קוד לדוגמה

ההנחיה שלך:

Create a new file my_script.py with the following python code:

def hello():
   print("Hello, World!")

מה קרה (הסבר): הסוכן הפעיל כלי לכתיבת קבצים (write_to_file) כדי ליצור קובץ חדש בשם my_script.py ישירות בספרייה הפעילה של סביבת העבודה, וכתב בו את פונקציית Python הבסיסית. בנוסף, ההנחיה הפעילה את המיומנות license-header-adder. הסוכן איתר את קובץ תבנית הרישיון (HEADER_TEMPLATE.txt) וקרא אותו, שינה את סגנון התגובה מתגובות בלוק בסגנון C ‏(‎/* ... */‎) לתגובות בסגנון Python ‏ (#), והוסיף אותו בתחילת הקובץ באמצעות הכלי replace_file_content.

שלב 2: אימות התוכן של הקובץ

אפשר לעיין בקובץ my_script.py. הוא יכיל את כותרת הרישיון בחלק העליון.

רמה 3: למידה באמצעות דוגמה (json-to-pydantic)

התבנית 'כמה דוגמאות'.

המרת נתונים לא מאורגנים (כמו תגובת JSON API) לקוד מאורגן (כמו מודלים של Pydantic) כוללת עשרות החלטות. איך לתת שמות לכיתות? כדאי להשתמש ב-Optional? snake_case או camelCase? כתיבה של 50 הכללים האלה באנגלית היא מייגעת ועלולה להוביל לטעויות.

מודלים גדולים של שפה הם מנועים להתאמת תבניות.

לרוב, עדיף לכתוב את הסקיל באמצעות דוגמה מוצלחת (Input -> Output) מאשר באמצעות הוראות מפורטות.

עוברים לתיקייה json-to-pydantic/ שמכילה את קובצי המיומנות, כמו שמוצג בהמשך:

json-to-pydantic/
├── SKILL.md
└── examples/
   ├── input_data.json   (The Before State)
   └── output_model.py   (The After State)

קובץ SKILL.md לדוגמה:

---
name: json-to-pydantic
description: Converts JSON data snippets into Python Pydantic data models.
---

# JSON to Pydantic Skill

This skill helps convert raw JSON data or API responses into structured, strongly-typed Python classes using Pydantic.

Instructions

1. **Analyze the Input**: Look at the JSON object provided by the user.
2. **Infer Types**:
  - `string` -> `str`
  - `number` -> `int` or `float`
  - `boolean` -> `bool`
  - `array` -> `List[Type]`
  - `null` -> `Optional[Type]`
  - Nested Objects -> Create a separate sub-class.
 
3. **Follow the Example**:
  Review `examples/` to see how to structure the output code. notice how nested dictionaries like `preferences` are extracted into their own class.
 
  - Input: `examples/input_data.json`
  - Output: `examples/output_model.py`

Style Guidelines
- Use `PascalCase` for class names.
- Use type hints (`List`, `Optional`) from `typing` module.
- If a field can be missing or null, default it to `None`.

בתיקייה /examples יש קובץ JSON וקובץ פלט , כלומר קובץ Python. שני התגים מוצגים בהמשך:

input_data.json

{
   "user_id": 12345,
   "username": "jdoe_88",
   "is_active": true,
   "preferences": {
       "theme": "dark",
       "notifications": [
           "email",
           "push"
       ]
   },
   "last_login": "2024-03-15T10:30:00Z",
   "meta_tags": null
}

output_model.py

from pydantic import BaseModel, Field
from typing import List, Optional

class Preferences(BaseModel):
   theme: str
   notifications: List[str]

class User(BaseModel):
   user_id: int
   username: str
   is_active: bool
   preferences: Preferences
   last_login: Optional[str] = None
   meta_tags: Optional[List[str]] = None

איך מריצים את הדוגמה הזו ב-Antigravity

אם הפעלתם את Antigravity או את Antigravity CLI, פועלים לפי השלבים הבאים:

שלב 1: יוצרים את קובץ ה-JSON עם נתונים לדוגמה

מבקשים מהסוכן ליצור קובץ חדש product.json שמכיל את מטען ה-JSON הייעודי הגולמי.

ההנחיה שלך:

Create a new file product.json with the following JSON:

{
 "product": "Widget",
 "cost": 10.99,
 "stock": null
}

שלב 2: המרת ה-JSON למודל Pydantic

מפעילים את json-to-pydanticהתכונה כדי להמיר את נתוני ה-JSON למחלקה מובנית של Pydantic.

ההנחיה שלך:

Convert the JSON in product.json to a Pydantic model and save it to product_model.py.

שלב 3: בדיקת הפלט

אפשר לעיין בקובץ product_model.py. הוא יכיל את מודל Pydantic שהושלם.

רמה 4: לוגיקה פרוצדורלית (database-schema-validator)

זהו דפוס השימוש בכלי.

אם תשאלו מודל LLM 'האם הסכימה הזו בטוחה?', יכול להיות שהוא ישיב שהכול בסדר, גם אם חסר מפתח ראשי קריטי, פשוט כי ה-SQL נראה תקין.

נאציל את הבדיקה הזו לסקריפט דטרמיניסטי. ה-database-schema-validator skill שלנו ינתב את הסוכן להרצת סקריפט Python שכתבנו. הסקריפט מספק אמת בינארית (True/False).

database-schema-validator/
├── SKILL.md
└── scripts/
   └── validate_schema.py  (The Validator)

קובץ SKILL.md לדוגמה:

---
name: database-schema-validator
description: Validates SQL schema files for compliance with internal safety and naming policies.
---

# Database Schema Validator Skill

This skill ensures that all SQL files provided by the user comply with our strict database standards.

Policies Enforced
1. **Safety**: No `DROP TABLE` statements.
2. **Naming**: All tables must use `snake_case`.
3. **Structure**: Every table must have an `id` column as PRIMARY KEY.

Instructions

1. **Do not read the file manually** to check for errors. The rules are complex and easily missed by eye.
2. **Run the Validation Script**:
  Use the `run_command` tool to execute the python script provided in the `scripts/` folder against the user's file.
 
  `python scripts/validate_schema.py <path_to_user_file>`

3. **Interpret Output**:
  - If the script returns **exit code 0**: Tell the user the schema looks good.
  - If the script returns **exit code 1**: Report the specific error messages printed by the script to the user and suggest fixes.

קובץ validate_schema.py לדוגמה:

import sys
import re

def validate_schema(filename):
   """
   Validates a SQL schema file against internal policy:
   1. Table names must be snake_case.
   2. Every table must have a primary key named 'id'.
   3. No 'DROP TABLE' statements allowed (safety).
   """
   try:
       with open(filename, 'r') as f:
           content = f.read()
          
       lines = content.split('\n')
       errors = []
      
       # Check 1: No DROP TABLE
       if re.search(r'DROP TABLE', content, re.IGNORECASE):
           errors.append("ERROR: 'DROP TABLE' statements are forbidden.")
          
       # Check 2 & 3: CREATE TABLE checks
       table_defs = re.finditer(r'CREATE TABLE\s+(?P<name>\w+)\s*\((?P<body>.*?)\);', content, re.DOTALL | re.IGNORECASE)
      
       for match in table_defs:
           table_name = match.group('name')
           body = match.group('body')
          
           # Snake case check
           if not re.match(r'^[a-z][a-z0-9_]*$', table_name):
               errors.append(f"ERROR: Table '{table_name}' must be snake_case.")
              
           # Primary key check
           if not re.search(r'\bid\b.*PRIMARY KEY', body, re.IGNORECASE):
               errors.append(f"ERROR: Table '{table_name}' is missing a primary key named 'id'.")

       if errors:
           for err in errors:
               print(err)
           sys.exit(1)
       else:
           print("Schema validation passed.")
           sys.exit(0)
          
   except FileNotFoundError:
       print(f"Error: File '{filename}' not found.")
       sys.exit(1)

if __name__ == "__main__":
   if len(sys.argv) != 2:
       print("Usage: python validate_schema.py <schema_file>")
       sys.exit(1)
      
   validate_schema(sys.argv[1])

איך מריצים את הדוגמה הזו ב-Antigravity

אם הפעלתם את Antigravity או את Antigravity CLI, פועלים לפי השלבים הבאים:

שלב 1: יוצרים את קובץ ה-SQL עם נתונים לדוגמה

מבקשים מהסוכן ליצור קובץ חדש bad_schema.sql שמכיל כמה הפרות מדיניות.

ההנחיה שלך:

Create a new file bad_schema.sql with the following SQL:

DROP TABLE IF EXISTS legacy_users;

CREATE TABLE userProfile (
    id INT PRIMARY KEY,
    bio TEXT
);

CREATE TABLE posts (
    title TEXT,
    content TEXT,
    created_at TIMESTAMP
);

CREATE TABLE comments (
    id INT PRIMARY KEY,
    post_id INT,
    body TEXT
);

קובץ הסכימה שלמעלה מפר את כל שלושת כללי המדיניות: הוא משתמש בהצהרה DROP TABLE אסורה, משתמש ב-camelCase בשם הטבלה userProfile ושוכח את המפתח הראשי id בטבלה posts.

שלב 2: אימות סכימת ה-SQL

מפעילים את database-schema-validator skill כדי להריץ את סקריפט האימות של Python על הקובץ.

הערה: במקרים מסוימים, Antigravity חכם מספיק כדי להפעיל את

database-schema-validator

מיומנות בפני עצמה, אחרי שנוצר קובץ ה-SQL.

הפרומפט שלך:

Validate bad_schema.sql using the database-schema-validator skill.

שלב 3: בדיקת הפלט

הנציג ידווח על הכשל ויציג בצ'אט את השגיאות הספציפיות שנמצאו על ידי הסקריפט. דוגמה לפלט:

Validation of bad_schema.sql failed with the following policy errors:

 ### Validation Errors

   ERROR: 'DROP TABLE' statements are forbidden.
   ERROR: Table 'userProfile' must be snake_case.
   ERROR: Table 'posts' is missing a primary key named 'id'.
 ──────
 ### Suggested Fixes

 1. Remove Destructive Statements:
     • Delete DROP TABLE IF EXISTS legacy_users; to comply with the safety policy prohibiting DROP TABLE operations.
 2. Fix Naming Conventions:
     • Rename table userProfile to user_profile to satisfy the snake_case naming policy.
 3. Add Primary Key:
     • Add an id INT PRIMARY KEY column to the posts table to comply with table structure requirements.

 ──────
 ### Compliant Schema Example

   CREATE TABLE user_profile (
       id INT PRIMARY KEY,
       bio TEXT
   );

   CREATE TABLE posts (
       id INT PRIMARY KEY,
       title TEXT,
       content TEXT,
       created_at TIMESTAMP
   );

   CREATE TABLE comments (
       id INT PRIMARY KEY,
       post_id INT,
       body TEXT
   );

6. ערכת הכלים למפתחים (מיומנויות של Agents CLI)

התבנית 'פעולה ומחזור חיים'.

פיתוח סוכני AI כולל משימות חוזרות במחזור החיים: יצירת קובצי boilerplate, הגדרת סביבות זמן ריצה מקומיות, הפעלת הנחיות בדיקה והפעלת סביבות אינטראקטיביות.

במקום להכריח את עוזר התכנות לנחש מבני ספריות או לכתוב הגדרות סוכן סטנדרטיות מאפס, מיומנויות של סוכנים בממשק שורת הפקודה מאגדות את המומחיות הזו במחזור החיים במיומנויות ספציפיות של סוכנים.

היכולות של Agent CLI (ממשק שורת הפקודה) מספקות אוטומציה יעילה וממוקדת למפתחים ישירות בטרמינל, ומגשרות על הפער בין קוד גולמי לבין ביצוע אוטונומי. ערכת Agent Development Kit (ADK) מתמקדת במסגרת הפרוגרמטית, ומספקת לכם את ערכות ה-SDK, ממשקי ה-API והתוכניות המבניות לבנייה ולניהול של סוכני AI, בעוד שהמיומנויות של Agent CLI מספקות את היכולות התפעוליות. הוא מאפשר למפתחים ליצור סביבת עבודה, לבדוק ולפרוס סוכנים באופן מקומי עם לולאות משוב מהירות, בלי להשתמש בממשק משתמש עמוס.

אופציונלית, כשממפים את הכישורים של Agent CLI ל-Google Cloud, הם פועלים כצינור ישיר לתשתית ברמה ארגונית. במקום ללחוץ על המסופים, אפשר להשתמש בפקודות CLI כדי לארוז באופן מיידי תהליכי עבודה של סוכנים, לנהל הרשאות גישה ולפרוס אותם במערכות אקולוגיות של Google Cloud (כמו Vertex AI או Cloud Run). השימוש ב-ADK הופך משימות מורכבות של ארכיטקטורת ענן לפקודות פשוטות בטרמינל שאפשר לשחזר, וכך קל יותר לשלב סוכנים אוטונומיים בפייפליינים קיימים של פריסת CI/CD.

איך מתקינים

מוודאים שכלי ניהול החבילות Python 3.11+, Node.js ו-uv מותקנים. לאחר מכן, מריצים את פקודת ההגדרה בטרמינל:

uvx google-agents-cli setup

הפקודה הזו מתקינה את הקובץ הבינארי agents-cli ורושמת את הכישורים המיוחדים שלו ליצירת תשתית (scaffolding) ולביצוע הערכה בסביבה של עוזר התכנות.

הערה: הכישורים יותקנו בתיקייה ~/.agents/skills, שגלויות ל-Antigravity. כדי לראות את הכישורים האלה ב-Antigravity CLI, צריך להעביר אותם לתיקייה ~/.gemini/antigravity-cli/skills (היקף גלובלי).

כדי לבדוק שהמיומנויות נטענו ב-Antigravity, פשוט שואלים אילו מיומנויות זמינות. למטה מוצגת דוגמה לתשובה חלקית של מיומנויות ה-CLI של הסוכן שהתקנו זה עתה.

הדרכה מפורטת

אחרי שuvx google-agents-cli setup מסתיים, אפשר להתחיל הרצה של סוכן AI, לקיים איתו אינטראקציה ולבדוק אותו במחשב המקומי.

שלב 1: יצירת שלד והפעלה של פרויקט חדש של סוכן

מריצים את פקודת היצירה כדי ליצור פריסה סטנדרטית. אחרי שיוצרים את הפרויקט, צריך להתקין את התלות שלו לפני שמריצים משימות ביצוע.

# 1. Create a lightweight prototype project structure
agents-cli create weather-assistant --prototype --yes

# 2. Move into the directory and install required ADK dependencies
cd weather-assistant
agents-cli install

מה קורה מאחורי הקלעים: נוצר סביבת עבודה נקייה עם app/agent.py (קוד הליבה), pyproject.toml (מטא-נתונים של החבילה) ו-agents-cli-manifest.yaml (כלי למעקב אחרי פרויקטים).

שלב 2: מריצים שאילתת בדיקה מקומית

להריץ בדיקה מהירה וישירה בשורת הפקודה מול הסוכן. אם אתם לא משתמשים ב-ADC (Application Default Credentials) של Google Cloud, ודאו שייצאתם את GEMINI_API_KEY במסוף. אפשר לקבל מפתח Gemini API כאן. אחרי שמקבלים את המפתח, מייצאים אותו בטרמינל באמצעות הפקודה הבאה. אנחנו גם מגדירים כאן את GOOGLE_GENAI_USE_VERTEXAI ל-FALSE.

export GEMINI_API_KEY="YOUR_GEMINI_API_KEY"
export GOOGLE_GENAI_USE_VERTEXAI=FALSE

מזינים את הפקודה הבאה בטרמינל:

agents-cli run "How are you?"

מה קורה מאחורי הקלעים: ממשק ה-CLI מאתחל את מחזור החיים של Agent Development Kit ‏ (ADK) באופן מלא בזיכרון במסוף. הוא מעביר את ההנחיה באופן מאובטח דרך פרטי הכניסה המקומיים שלכם ומתעד את התגובה של הסטרימינג בשידור חי ישירות בשורת הפקודה.

שלב 3: הפעלת סביבת האינטרנט האינטראקטיבית

מפעילים את סביבת הפיתוח המקומית המובנית שמבוססת על אינטרנט כדי לקיים אינטראקציה עם הסוכן באופן חזותי.

agents-cli playground

מה קורה מאחורי הקלעים: ממשק שורת הפקודה מפעיל שרת של ממשק משתמש אינטרנטי של ADK, שבדרך כלל אפשר לגשת אליו בכתובת http://localhost:8080 או בכתובת חלופית http://127.0.0.1:8000, עם טעינה מחדש של קוד ללא הפסקה. בממשק האינטרנט, בוחרים באפשרות אפליקציה בתפריט הנפתח בחירת אפליקציה בחלק העליון, ומנהלים אינטראקציה עם הסוכן בממשק השיחה בצד שמאל של אפליקציית האינטרנט.

7. התקנת סקילים אג'נטיים באמצעות npx skills

‫npx skills הוא כלי לשורת הפקודה שפותח על ידי Vercel Labs ומשמש כמנהל חבילות לסוכני AI (כמו Antigravity,‏ Claude Code,‏ GitHub Copilot,‏ Cursor ו-Cline). זהו ממשק שורת הפקודה (CLI) למערכת האקולוגית של מיומנויות סוכנים בקוד פתוח.

אם אתם רוצים להוריד ולהתקין את Agent Skills באמצעות חבילת npx skills, חשוב לדעת שהיא מציבה את ה-Skills בתיקייה ~/.agents/skills. במאמר מצוין שכלים כמו Antigravity יזהו את המיומנויות בתיקייה הזו, אבל חשוב לדעת שבזמן כתיבת המאמר, Antigravity מזהה את המיומנויות בתיקייה הזו, אבל Antigravity CLI לא מזהה אותן. כמו שציינו קודם, תצטרכו להעתיק את המיומנויות האלה שמותקנות בתיקייה ~/.agents/skills, לפרויקט או להיקף הגלובלי של תיקיות המיומנויות ב-Antigravity CLI, כלומר:

היקף הפרויקט: נמצא ב<project-root>/.agents/skills/.
היקף גלובלי: ממוקם ב~/.gemini/antigravity-cli/skills/.

8. מזל טוב

מעולה! השתמשתם בהצלחה ב-Google Antigravity כדי ליצור את מיומנות הסוכן הראשונה שלכם, הגדרתם אותה והוספתם לה יכולות מותאמות אישית.

בנוסף, הצלחת להגדיר קבוצה של מיומנויות לסוכן, בהיקף הפרויקט ובהיקף הגלובלי, וכך יצרת כלים מותאמים אישית.

עכשיו אתם יכולים להשתמש ב-Antigravity כדי לכתוב קוד בפרויקטים שלכם.

9. מסמכים לדוגמה

‫Codelab : תחילת העבודה עם Google Antigravity
האתר הרשמי : https://antigravity.google/
תיעוד: https://antigravity.google/docs
הורדה : https://antigravity.google/download
מסמכי תיעוד של Antigravity Skills: https://antigravity.google/docs/skills