Pierwsze kroki z umiejętnościami w Google Antigravity

1. Wprowadzenie

Google Antigravity (w dalszej części dokumentu nazywane Antigravity) to oparte na agentach środowisko IDE od Google. W tym kursie (dostępnym w języku angielskim) poznasz podstawy Antigravity. W tym ćwiczeniu użyjemy Antigravity do tworzenia umiejętności agenta, czyli lekkiego, otwartego formatu rozszerzania możliwości agentów AI o specjalistyczną wiedzę i przepływy pracy. Dowiesz się, czym są umiejętności agenta, jakie korzyści z nich płyną i jak są one tworzone. Następnie utworzysz wiele umiejętności agenta, od formatowania Git, przez generator szablonów, po szkielet kodu narzędzia i inne, które można wykorzystać w Antigravity.

Wymagania wstępne:

2. Dlaczego umiejętności

Nowoczesne agenty AI przeszły ewolucję od prostych słuchaczy do złożonych systemów rozumowania, które integrują się z lokalnymi systemami plików i narzędziami zewnętrznymi (za pomocą serwerów MCP). Jednak bezkrytyczne ładowanie agenta całymi bazami kodu i setkami narzędzi prowadzi do nasycenia kontekstu i „przeładowania narzędziami”. Nawet w przypadku dużych okien kontekstowych umieszczanie w aktywnej pamięci 40–50 tys. tokenów nieużywanych narzędzi powoduje duże opóźnienia, marnotrawstwo środków i „psucie się kontekstu”, w którym model jest zdezorientowany przez nieistotne dane.

Rozwiązanie: umiejętności agenta

Aby rozwiązać ten problem, firma Anthropic wprowadziła umiejętności agenta, zmieniając architekturę z monolitycznego wczytywania kontekstu na stopniowe ujawnianie informacji. Zamiast zmuszać model do „zapamiętywania” każdego konkretnego przepływu pracy (np. migracji baz danych lub audytów bezpieczeństwa) na początku sesji, te funkcje są pakowane w modułowe, wykrywalne jednostki.

Jak to działa

Model jest początkowo udostępniany tylko w uproszczonym „menu” metadanych. Wczytuje on obszerną wiedzę proceduralną (instrukcje i skrypty) tylko wtedy, gdy intencja użytkownika jest zgodna z określonymi umiejętnościami. Dzięki temu programista, który chce refaktoryzować oprogramowanie pośredniczące uwierzytelniania, uzyskuje kontekst bezpieczeństwa bez wczytywania niezwiązanych z nim potoków CSS, co sprawia, że kontekst jest prosty, szybki i oszczędny.

d3f4bcb065a19fea.png

3. Umiejętności agenta i Antigravity

W ekosystemie Antigravity, jeśli Menedżer agentów jest mózgiem, a Edytor jest płótnem, umiejętności działają jako specjalistyczne moduły szkoleniowe, które wypełniają lukę między ogólnym modelem Gemini 3 a konkretnym kontekstem. Umożliwiają one „wyposażenie” agenta w określony zestaw instrukcji i protokołów, takich jak standardy migracji baz danych czy kontrole bezpieczeństwa, tylko wtedy, gdy zostanie zgłoszone odpowiednie żądanie. Dzięki dynamicznemu wczytywaniu tych protokołów wykonawczych umiejętności skutecznie przekształcają AI z ogólnego programisty w specjalistę, który ściśle przestrzega skodyfikowanych sprawdzonych metod i standardów bezpieczeństwa organizacji.

Czym jest umiejętność w Antigravity?

W kontekście Google Antigravity umiejętność to pakiet oparty na katalogu, który zawiera plik definicji (SKILL.md) i opcjonalne zasoby pomocnicze (skrypty, odwołania, szablony).

Jest to mechanizm rozszerzania możliwości na żądanie.

  • Na żądanie: w przeciwieństwie do prompta systemowego (który jest zawsze wczytywany) umiejętność jest wczytywana do kontekstu agenta tylko wtedy, gdy agent uzna, że jest ona istotna dla bieżącego żądania użytkownika. Optymalizuje to okno kontekstu i zapobiega rozpraszaniu uwagi agenta przez nieistotne instrukcje. W przypadku dużych projektów z dziesiątkami narzędzi selektywne wczytywanie ma kluczowe znaczenie dla wydajności i dokładności wnioskowania.
  • Rozszerzenie możliwości: umiejętności mogą nie tylko wydawać polecenia, ale też je wykonywać. Dzięki pakietom skryptów w języku Python lub Bash usługa może wykonywać złożone, wieloetapowe działania na komputerze lokalnym lub w sieciach zewnętrznych bez konieczności ręcznego uruchamiania poleceń przez użytkownika. Dzięki temu agent przestaje być generatorem tekstu i zaczyna korzystać z narzędzi.

Umiejętności a ekosystem (narzędzia, reguły i przepływy pracy)

Protokół kontekstu modelu (MCP) działa jak „ręce” agenta, zapewniając trwałe połączenia z systemami zewnętrznymi, takimi jak GitHub czy PostgreSQL, a umiejętności działają jak „mózg”, który nimi kieruje.

MCP zarządza infrastrukturą stanową, a umiejętności to lekkie, efemeryczne definicje zadań, które zawierają metodologię korzystania z tych narzędzi. To podejście bezserwerowe umożliwia agentom wykonywanie zadań ad hoc (takich jak generowanie dzienników zmian lub migracji) bez obciążenia operacyjnego związanego z uruchamianiem trwałych procesów. Kontekst jest wczytywany tylko wtedy, gdy zadanie jest aktywne, i zwalniany natychmiast po jego zakończeniu.

Funkcjonalnie umiejętności zajmują unikalne miejsce pomiędzy „Regułami” (pasywne, zawsze aktywne zabezpieczenia) a „Przepływami pracy” (aktywne, wywoływane przez użytkownika makra). W przeciwieństwie do przepływów pracy, które wymagają określonych poleceń (np. /test), umiejętności są wywoływane przez agenta: model automatycznie wykrywa intencje użytkownika i dynamicznie dobiera odpowiednie umiejętności. Ta architektura umożliwia zaawansowane komponowanie. Na przykład reguła globalna może wymuszać używanie umiejętności „Bezpieczna migracja” podczas zmian w bazie danych, a pojedynczy przepływ pracy może koordynować wiele umiejętności w celu utworzenia niezawodnego potoku wdrażania.

4. Tworzenie umiejętności

Tworzenie umiejętności w Antigravity wymaga zachowania określonej struktury katalogów i formatu pliku. Ta standaryzacja zapewnia przenośność umiejętności oraz możliwość ich niezawodnego analizowania i wykonywania przez agenta. Projekt jest celowo prosty i opiera się na powszechnie znanych formatach, takich jak Markdown i YAML, co obniża próg wejścia dla deweloperów, którzy chcą rozszerzyć możliwości swojego środowiska IDE.

Struktura katalogu

Umiejętności można zdefiniować w 2 zakresach, co umożliwia dostosowanie ich do konkretnego projektu i użytkownika :

  1. Workspace Scope: znajduje się w <workspace-root>/.agent/skills/. Te umiejętności są dostępne tylko w ramach konkretnego projektu. Jest to idealne rozwiązanie w przypadku skryptów związanych z konkretnym projektem, takich jak wdrażanie w określonym środowisku, zarządzanie bazą danych aplikacji czy generowanie kodu szablonowego dla zastrzeżonych platform.
  2. Zakres globalny: lokalizacja: ~/.gemini/antigravity/skills/. Te umiejętności są dostępne we wszystkich projektach na urządzeniu użytkownika. Jest to odpowiednie w przypadku ogólnych narzędzi, takich jak „Format JSON”, „Generate UUIDs”, „Review Code Style” czy integracja z osobistymi narzędziami zwiększającymi produktywność.

Typowy katalog umiejętności wygląda tak:

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)

Ta struktura skutecznie rozdziela poszczególne kwestie. Logika (scripts) jest oddzielona od instrukcji (SKILL.md) i wiedzy (references), co odzwierciedla standardowe praktyki inżynierii oprogramowania.

Plik definicji SKILL.md

Plik SKILL.md to najważniejszy element szkolenia. Informuje ona agenta, czym jest funkcja, kiedy jej używać i jak ją wykonać.

Składa się z 2 części:

  • YAML Frontmatter
  • Treść w formacie Markdown.

YAML Frontmatter

Jest to warstwa metadanych. Jest to jedyna część umiejętności indeksowana przez router wysokiego poziomu agenta. Gdy użytkownik wyśle prompt, agent dopasuje go semantycznie do pól opisu wszystkich dostępnych umiejętności.

---
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.
---

Kluczowe pola:

  • name: ten element nie jest obowiązkowy. Musi być niepowtarzalna w zakresie. Dozwolone są małe litery i łączniki (np. postgres-query, pr-reviewer). Jeśli nie zostanie podana, domyślnie będzie to nazwa katalogu.
  • description: to pole jest obowiązkowe i najważniejsze. Pełni funkcję „frazy wywołującej”. Musi być wystarczająco opisowy, aby model LLM mógł rozpoznać trafność semantyczną. Nie wystarczy ogólny opis, np. „Narzędzia do baz danych”. Dokładny opis, np. „Wykonuje zapytania SQL tylko do odczytu w lokalnej bazie danych PostgreSQL, aby pobrać dane użytkownika lub transakcji. Użyj tego do debugowania stanów danych" zapewnia prawidłowe rozpoznanie umiejętności.

The Markdown Body

Treść zawiera instrukcje. Jest to „tworzenie promptów” zapisane w pliku. Gdy umiejętność jest aktywowana, ta treść jest wstrzykiwana do okna kontekstu agenta.

Treść powinna zawierać:

  1. Cel: jasne określenie, co osiąga umiejętność.
  2. Instrukcje: logika krok po kroku.
  3. Przykłady: przykłady danych wejściowych i wyjściowych, które pomagają modelowi osiągać lepsze wyniki.
  4. Ograniczenia: reguły „Nie” (np. „Nie uruchamiaj zapytań DELETE”).

Przykład treści pliku SKILL.md:

Database Inspector

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

Instructions
- Analyze the user's 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.

Integracja skryptu

Jedną z najważniejszych funkcji umiejętności jest możliwość delegowania wykonywania zadań do skryptów. Umożliwia to agentowi wykonywanie działań, które są trudne lub niemożliwe do wykonania bezpośrednio przez LLM (np. wykonywanie kodu binarnego, złożone obliczenia matematyczne lub interakcje z systemami starszego typu).

Skrypty są umieszczane w podkatalogu scripts/. SKILL.md odwołuje się do nich za pomocą ścieżki względnej.

5. Umiejętności tworzenia

Celem tej sekcji jest tworzenie umiejętności, które można zintegrować z Antigravity i stopniowo prezentować różne funkcje, takie jak zasoby czy skrypty.

Umiejętności możesz pobrać z repozytorium GitHub: https://github.com/rominirani/antigravity-skills.

Możemy umieścić każdą z tych umiejętności w folderze ~/.gemini/antigravity/skills lub /.agent/skills.

Poziom 1. Podstawowy router ( git-commit-formatter )

Można to uznać za „Hello World” w przypadku umiejętności.

Deweloperzy często piszą leniwe komunikaty o zatwierdzeniu, np. „wip”, „fix bug”, „updates”. Ręczne egzekwowanie „Conventional Commits” jest żmudne i często zapominane. Wdrożymy umiejętność, która wymusza stosowanie specyfikacji Conventional Commits. Wystarczy, że poinstruujesz agenta w zakresie zasad, a będzie on mógł egzekwować ich przestrzeganie.

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

Plik SKILL.md jest widoczny poniżej:

---
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`

Jak uruchomić ten przykład:

  1. Wprowadź niewielką zmianę w dowolnym pliku w obszarze roboczym.
  2. Otwórz czat i wpisz: Zatwierdź te zmiany.
  3. Agent nie uruchomi tylko polecenia git commit. Najpierw aktywuje ona umiejętność git-commit-formatter.
  4. Wynik: zostanie zaproponowany standardowy komunikat zatwierdzenia Git.

Na przykład poprosiłem Antigravity o dodanie komentarzy do przykładowego pliku Pythona, a w rezultacie otrzymałem komunikat zatwierdzenia Git w formacie docs: add detailed comments to demo_primes.py.

Poziom 2. Wykorzystanie komponentów (license-header-adder)

To jest wzorzec „Odwołanie”.

Każdy plik źródłowy w projekcie firmowym może wymagać nagłówka licencji Apache 2.0 o długości 20 wierszy. Umieszczanie tego tekstu statycznego bezpośrednio w prompcie (lub SKILL.md) jest nieefektywne. Za każdym razem, gdy umiejętność jest indeksowana, zużywa tokeny, a model może „halucynować” błędy w tekście prawnym.

Przeniesienie tekstu statycznego do pliku tekstowego w resources/ folderze. Umiejętność instruuje agenta, aby odczytywał ten plik tylko w razie potrzeby.

Konwertowanie luźnych danych (np. odpowiedzi interfejsu JSON API) na ścisły kod (np. modele Pydantic) wymaga podjęcia wielu decyzji. Jak powinniśmy nazywać zajęcia? Czy powinniśmy używać Optional? snake_case czy camelCase? Wypisanie tych 50 reguł w języku angielskim jest żmudne i podatne na błędy.

Modele LLM to silniki dopasowujące wzorce.

Pokazanie im przykładu (Input -> Output) jest często skuteczniejsze niż obszerne instrukcje.

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

Plik SKILL.md jest widoczny poniżej:

---
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 `<!-- ... -->`.

Jak uruchomić ten przykład:

  1. Utwórz nowy przykładowy plik w Pythonie: touch my_script.py
  2. Typ: Add the license header to my_script.py.
  3. Agent odczyta license-header-adder/resources/HEADER_TEMPLATE.txt.
  4. Wklei on zawartość do pliku w dokładnie takiej samej formie.

Poziom 3. Uczenie się na przykładach (json-to-pydantic)

Wzorzec „Few-Shot”.

Konwertowanie luźnych danych (np. odpowiedzi interfejsu JSON API) na ścisły kod (np. modele Pydantic) wymaga podjęcia wielu decyzji. Jak powinniśmy nazywać zajęcia? Czy powinniśmy używać Optional? snake_case czy camelCase? Wypisanie tych 50 reguł w języku angielskim jest żmudne i podatne na błędy.

Modele LLM to silniki dopasowujące wzorce. Pokazanie im przykładu (Input -> Output) jest często skuteczniejsze niż obszerne instrukcje.

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

Plik SKILL.md jest widoczny poniżej:

---
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`.

W folderze /examples znajduje się plik JSON i plik wyjściowy , czyli plik Pythona. Oba znajdziesz poniżej:

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

Jak uruchomić ten przykład:

  1. Podaj agentowi fragment kodu JSON (wklej go na czacie lub wskaż plik).

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

  1. Typ: Convert this JSON to a Pydantic model.
  2. Agent sprawdza parę examples w folderze umiejętności.
  3. Generuje klasę Pythona, która doskonale odzwierciedla styl kodowania, importy i strukturę output_model.py, w tym obsługę pustych zasobów jako opcjonalnych.

Przykładowe dane wyjściowe (product_model.py) są pokazane poniżej:

from pydantic import BaseModel
from typing import Optional

class Product(BaseModel):
   product: str
   cost: float
   stock: Optional[int] = None

Poziom 4. Logika proceduralna (database-schema-validator)

To jest wzorzec „Korzystanie z narzędzi”.

Jeśli zapytasz LLM „Czy ten schemat jest bezpieczny?”, może odpowiedzieć, że wszystko jest w porządku, nawet jeśli brakuje kluczowego klucza podstawowego, ponieważ kod SQL wygląda prawidłowo.

Przekażmy to sprawdzenie do skryptu deterministycznego. Używamy umiejętności, aby skierować agenta do uruchomienia napisanego przez nas skryptu w Pythonie. Skrypt podaje prawdę w formie binarnej (prawda/fałsz).

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

Plik SKILL.md jest widoczny poniżej:

---
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.

Plik validate_schema.py jest widoczny poniżej:

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])

Jak uruchomić ten przykład:

  1. Utwórz nieprawidłowy plik SQL bad_schema.sql: CREATE TABLE users (name TEXT);
  2. Typ: Validate bad_schema.sql.
  3. Agent nie zgaduje. Wywoła to skrypt, który zakończy się niepowodzeniem (kod zakończenia 1) i zgłosi nam, że „weryfikacja nie powiodła się, ponieważ w tabeli „users” brakuje klucza podstawowego”.

Poziom 5. Architekt (adk-tool-scaffold)

Ten wzorzec obejmuje większość funkcji dostępnych w umiejętnościach.

Złożone zadania często wymagają sekwencji operacji, które łączą wszystkie poznane dotychczas elementy: tworzenie plików, korzystanie z szablonów i pisanie logiki. Utworzenie nowego narzędzia w pakiecie ADK (Agent Development Kit) wymaga wszystkich tych elementów.

Łączymy:

  • Skrypt (do obsługi tworzenia plików i szkieletów)
  • Szablon (do obsługi powtarzalnych elementów w zasobach)
  • Przykład (aby ułatwić generowanie logiki).
adk-tool-scaffold/
├── SKILL.md
├── resources/
│   └── ToolTemplate.py.hbs (Jinja2 Template)
├── scripts/
│   └── scaffold_tool.py    (Generator Script)
└── examples/
    └── WeatherTool.py      (Reference Implementation)

Plik SKILL.md jest widoczny poniżej. Aby sprawdzić pliki w folderach scripts, resources i examples, możesz zajrzeć do repozytorium umiejętności. W przypadku konkretnej umiejętności przejdź do adk-tool-scaffold.

---
name: adk-tool-scaffold
description: Scaffolds a new custom Tool class for the Agent Development Kit (ADK).
---

# ADK Tool Scaffold Skill

This skill automates the creation of standard `BaseTool` implementations for the Agent Development Kit.

Instructions

1. **Identify the Tool Name**:
  Extract the name of the tool the user wants to build (e.g., "StockPrice", "EmailSender").
 
2. **Review the Example**:
  Check `examples/WeatherTool.py` to understand the expected structure of an ADK tool (imports, inheritance, schema).

3. **Run the Scaffolder**:
  Execute the python script to generate the initial file.
 
  `python scripts/scaffold_tool.py <ToolName>`

4. **Refine**:
  After generation, you must edit the file to:
  - Update the `execute` method with real logic.
  - Define the JSON schema in `get_schema`.
 
Example Usage
User: "Create a tool to search Wikipedia."
Agent:
1. Runs `python scripts/scaffold_tool.py WikipediaSearch`
2. Editing `WikipediaSearchTool.py` to add the `requests` logic and `query` argument schema.

Jak uruchomić ten przykład:

  1. Typ: Create a new ADK tool called StockPrice to fetch data from an API.
  2. Krok 1 (Scaffolding): agent uruchamia skrypt w Pythonie. Spowoduje to natychmiastowe utworzenie pliku StockPriceTool.py z prawidłową strukturą klasy, importami i nazwą klasy StockPriceTool.
  3. Krok 2 (wdrożenie): agent „odczytuje” utworzony przez siebie plik. Widzi # TODO: Implement logic.
  4. Krok 3 (wskazówki): nie wiadomo, jak zdefiniować schemat JSON dla argumentów narzędzia. Sprawdza examples/WeatherTool.py.
  5. Ukończenie: edytuje plik, aby dodać requests.get(...), i definiuje argument ticker w schemacie, dokładnie dopasowując go do stylu ADK.

6. Gratulacje

Udało Ci się ukończyć moduł dotyczący umiejętności antygrawitacyjnych i utworzyć te umiejętności:

  • Formatowanie zatwierdzeń w Git.
  • Dodawanie nagłówka licencji.
  • JSON do Pydantic.
  • Walidator schematu bazy danych.
  • Scaffolding narzędzia ADK.

Umiejętności agenta to świetny sposób na to, aby Antigravity pisał kod w Twoim stylu, przestrzegał zasad i korzystał z Twoich narzędzi.

Dokumentacja