Google Antigravity में स्किल का इस्तेमाल शुरू करना

1. परिचय

Google Antigravity, Google का एक एजेंटिक IDE है. इस दस्तावेज़ में इसे Antigravity कहा गया है. Antigravity कोडलैब का इस्तेमाल शुरू करना में, Antigravity के बारे में बुनियादी जानकारी दी गई है. इस कोडलैब में, हम एजेंट की क्षमताओं को बढ़ाने के लिए Antigravity का इस्तेमाल करेंगे. एजेंट की क्षमताओं को बढ़ाने के लिए, खास जानकारी और वर्कफ़्लो के साथ, हल्के वज़न वाले ओपन फ़ॉर्मैट का इस्तेमाल किया जाता है. आपको एजेंट स्किल के बारे में पता चलेगा. साथ ही, आपको उनके फ़ायदों और उन्हें बनाने के तरीके के बारे में जानकारी मिलेगी. इसके बाद, आपको कई एजेंट स्किल बनानी होंगी. जैसे, Git फ़ॉर्मेटर, टेंप्लेट जनरेटर, टूल कोड स्केफ़ोल्डिंग वगैरह. इन सभी का इस्तेमाल Antigravity में किया जा सकता है.

ज़रूरी शर्तें:

Google Antigravity इंस्टॉल और कॉन्फ़िगर किया गया हो.
Google Antigravity के बारे में बुनियादी जानकारी. हमारा सुझाव है कि आप यह कोडलैब पूरा करें: Google Antigravity का इस्तेमाल शुरू करना.

2. कौशल क्यों

आधुनिक एआई एजेंट, सिर्फ़ सुनने वाले एजेंट से बदलकर, जटिल तर्क देने वाले एजेंट बन गए हैं. ये लोकल फ़ाइल सिस्टम और बाहरी टूल (एमसीपी सर्वर के ज़रिए) के साथ इंटिग्रेट होते हैं. हालांकि, किसी एजेंट को पूरे कोडबेस और सैकड़ों टूल के साथ लोड करने से, कॉन्टेक्स्ट सैचुरेशन और "टूल ब्लोट" की समस्या होती है. कॉन्टेक्स्ट विंडो बड़ी होने पर भी, इस्तेमाल न किए गए टूल के 40 से 50 हज़ार टोकन को ऐक्टिव मेमोरी में डालने से, ज़्यादा इंतज़ार करना पड़ता है, पैसे बर्बाद होते हैं, और "कॉन्टेक्स्ट रॉट" की समस्या होती है. इसमें मॉडल, काम के न होने वाले डेटा की वजह से भ्रमित हो जाता है.

समाधान: एजेंट की क्षमताएं

इस समस्या को हल करने के लिए, Anthropic ने Agent Skills को लॉन्च किया. इससे आर्किटेक्चर को मोनोलिथिक कॉन्टेक्स्ट लोडिंग से Progressive Disclosure में बदल दिया गया. सेशन की शुरुआत में, मॉडल को हर वर्कफ़्लो (जैसे, डेटाबेस माइग्रेशन या सुरक्षा ऑडिट) को "याद रखने" के लिए मजबूर करने के बजाय, इन क्षमताओं को मॉड्यूलर और खोजने लायक इकाइयों में पैकेज किया जाता है.

यह कैसे काम करता है

शुरुआत में, मॉडल को सिर्फ़ मेटाडेटा के हल्के-फुल्के "मेन्यू" के बारे में बताया जाता है. यह भारी-भरकम प्रोसेस से जुड़ी जानकारी (निर्देश और स्क्रिप्ट) सिर्फ़ तब लोड करता है, जब उपयोगकर्ता का मकसद किसी स्किल से मैच करता हो. इससे यह पक्का होता है कि पुष्टि करने वाले मिडलवेयर को फिर से फ़ैक्टर करने का अनुरोध करने वाले डेवलपर को सुरक्षा से जुड़ा कॉन्टेक्स्ट मिल जाए. इसके लिए, उसे काम की नहीं होने वाली सीएसएस पाइपलाइन लोड करने की ज़रूरत नहीं पड़ती. इससे कॉन्टेक्स्ट को कम, तेज़, और किफ़ायती रखा जा सकता है.

3. एजेंट के कौशल और एंटीग्रैविटी

Antigravity के इकोसिस्टम में, अगर एजेंट मैनेजर को दिमाग़ और एडिटर को कैनवस माना जाए, तो स्किल को खास ट्रेनिंग मॉड्यूल के तौर पर इस्तेमाल किया जाता है. ये मॉड्यूल, Gemini 3 मॉडल और आपके खास कॉन्टेक्स्ट के बीच के अंतर को कम करते हैं. ये एजेंट को निर्देशों और प्रोटोकॉल का तय किया गया सेट "इस्तेमाल" करने की अनुमति देते हैं. जैसे, डेटाबेस माइग्रेशन के स्टैंडर्ड या सुरक्षा जांच. ऐसा सिर्फ़ तब किया जाता है, जब कोई काम का अनुरोध किया जाता है. इन एक्ज़ीक्यूशन प्रोटोकॉल को डाइनैमिक तरीके से लोड करके, Skills एआई को एक सामान्य प्रोग्रामर से एक विशेषज्ञ में बदल देती हैं. यह विशेषज्ञ, किसी संगठन के तय किए गए सबसे सही तरीकों और सुरक्षा मानकों का सख्ती से पालन करता है.

Antigravity में स्किल क्या होती है?

Google Antigravity के हिसाब से, स्किल एक डायरेक्ट्री-आधारित पैकेज होता है. इसमें एक डेफ़िनिशन फ़ाइल (SKILL.md) और ज़रूरी नहीं कि साथ में काम करने वाली ऐसेट (स्क्रिप्ट, रेफ़रंस, टेंप्लेट) शामिल हों.

यह मांग पर उपलब्ध सुविधा एक्सटेंशन के लिए एक तरीका है.

ऑन-डिमांड: सिस्टम प्रॉम्प्ट हमेशा लोड होता है. हालांकि, स्किल को सिर्फ़ तब एजेंट के कॉन्टेक्स्ट में लोड किया जाता है, जब एजेंट को लगता है कि यह उपयोगकर्ता के मौजूदा अनुरोध के लिए काम की है. इससे कॉन्टेक्स्ट विंडो को ऑप्टिमाइज़ किया जाता है. साथ ही, एजेंट को काम के न होने वाले निर्देशों से ध्यान भटकने से रोका जाता है. कई टूल वाले बड़े प्रोजेक्ट में, परफ़ॉर्मेंस और तर्क की सटीकता के लिए, चुनिंदा टूल लोड करना ज़रूरी होता है.
क्षमता बढ़ाने वाला एक्सटेंशन: स्किल सिर्फ़ निर्देश देने के अलावा, उन्हें पूरा भी कर सकती हैं. Python या Bash स्क्रिप्ट बंडल करके, कोई स्किल एजेंट को लोकल मशीन या बाहरी नेटवर्क पर मुश्किल और कई चरणों वाली कार्रवाइयां करने की सुविधा दे सकती है. इसके लिए, उपयोगकर्ता को मैन्युअल तरीके से कमांड चलाने की ज़रूरत नहीं होती. इससे एजेंट, टेक्स्ट जनरेट करने वाले टूल से बदलकर टूल का इस्तेमाल करने वाला एजेंट बन जाता है.

स्किल बनाम इकोसिस्टम (टूल, नियम, और वर्कफ़्लो)

मॉडल कॉन्टेक्स्ट प्रोटोकॉल (एमसीपी), एजेंट के "हाथ" के तौर पर काम करता है. यह GitHub या PostgreSQL जैसे बाहरी सिस्टम से लगातार कनेक्ट रहता है. वहीं, स्किल, एजेंट के "दिमाग" के तौर पर काम करती हैं. ये एजेंट को निर्देश देती हैं.

एमसीपी, स्टेटफ़ुल इन्फ़्रास्ट्रक्चर को मैनेज करता है. वहीं, स्किल, टास्क की ऐसी परिभाषाएं होती हैं जो कम समय के लिए होती हैं और जिनमें उन टूल को इस्तेमाल करने का तरीका शामिल होता है. सर्वरलेस अप्रोच की मदद से, एजेंट बिना किसी रुकावट के विज्ञापन से जुड़े टास्क (जैसे, बदलावों का लॉग जनरेट करना या माइग्रेशन करना) पूरे कर सकते हैं. साथ ही, एजेंट को लगातार प्रोसेस चलाने की ज़रूरत नहीं होती. वे टास्क के चालू होने पर ही कॉन्टेक्स्ट लोड करते हैं और टास्क पूरा होने के तुरंत बाद उसे रिलीज़ कर देते हैं.

फ़ंक्शन के हिसाब से, "कौशल" "नियमों" (निष्क्रिय, हमेशा चालू रहने वाले गार्डरेल) और "वर्कफ़्लो" (सक्रिय, उपयोगकर्ता के ट्रिगर किए गए मैक्रो) के बीच एक यूनीक जगह रखते हैं. ऐसे वर्कफ़्लो के उलट जिनमें खास कमांड की ज़रूरत होती है (जैसे, /test), Skills are agent-triggered: the model automatically detects the user's intent and dynamically equips the specific expertise required. इस आर्किटेक्चर की मदद से, कई तरह के काम किए जा सकते हैं. उदाहरण के लिए, डेटाबेस में बदलाव करते समय, ग्लोबल नियम "सुरक्षित माइग्रेशन" स्किल का इस्तेमाल करने के लिए लागू किया जा सकता है. इसके अलावा, एक वर्कफ़्लो कई स्किल को व्यवस्थित करके, मज़बूत डिप्लॉयमेंट पाइपलाइन बना सकता है.

4. स्किल बनाना

Antigravity में कोई स्किल बनाने के लिए, डायरेक्ट्री के स्ट्रक्चर और फ़ाइल फ़ॉर्मैट का पालन करना होता है. मानकीकरण से यह पक्का होता है कि स्किल को एक जगह से दूसरी जगह ले जाया जा सकता है. साथ ही, एजेंट उन्हें भरोसेमंद तरीके से पार्स और लागू कर सकता है. इस डिज़ाइन को जान-बूझकर आसान बनाया गया है. इसमें Markdown और YAML जैसे फ़ॉर्मैट का इस्तेमाल किया गया है, जिनके बारे में ज़्यादातर लोगों को पता होता है. इससे, अपने IDE की क्षमताओं को बढ़ाने वाले डेवलपर के लिए, इस प्लैटफ़ॉर्म का इस्तेमाल करना आसान हो जाता है.

डायरेक्ट्री स्ट्रक्चर

स्किल को दो स्कोप में तय किया जा सकता है. इससे प्रोजेक्ट और उपयोगकर्ता, दोनों के हिसाब से स्किल को पसंद के मुताबिक बनाया जा सकता है :

Workspace का दायरा: यह <workspace-root>/.agent/skills/ में मौजूद होता है. ये स्किल सिर्फ़ किसी खास प्रोजेक्ट में उपलब्ध होती हैं. यह प्रोजेक्ट से जुड़ी स्क्रिप्ट के लिए सबसे सही है. जैसे, किसी खास एनवायरमेंट में डिप्लॉयमेंट, उस ऐप्लिकेशन के लिए डेटाबेस मैनेजमेंट या मालिकाना हक वाले फ़्रेमवर्क के लिए बॉयलरप्लेट कोड जनरेट करना.
ग्लोबल स्कोप: ~/.gemini/antigravity/skills/ में मौजूद है. ये स्किल, उपयोगकर्ता के मशीन पर मौजूद सभी प्रोजेक्ट के लिए उपलब्ध होती हैं. यह "JSON फ़ॉर्मैट करें", "यूयूआईडी जनरेट करें", "कोड स्टाइल की समीक्षा करें" या निजी प्रॉडक्टिविटी टूल के साथ इंटिग्रेट करने जैसी सामान्य सुविधाओं के लिए सही है.

सामान्य तौर पर, कौशल की डायरेक्ट्री ऐसी दिखती है:

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 फ़्रंटमैटर
मार्कडाउन फ़ॉर्मैट में मुख्य हिस्सा.

YAML फ़्रंटमैटर

यह मेटाडेटा लेयर है. यह स्किल का सिर्फ़ वही हिस्सा है जिसे एजेंट का हाई-लेवल राउटर इंडेक्स करता है. जब कोई उपयोगकर्ता प्रॉम्प्ट भेजता है, तो एजेंट सभी उपलब्ध स्किल के ब्यौरे वाले फ़ील्ड के साथ प्रॉम्प्ट का सिमैंटिक मिलान करता है.

---
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). अगर यह जानकारी नहीं दी जाती है, तो डिफ़ॉल्ट रूप से डायरेक्ट्री का नाम इस्तेमाल किया जाएगा.
description: यह ज़रूरी और सबसे अहम फ़ील्ड है. यह "ट्रिगर फ़्रेज़" के तौर पर काम करता है. यह इतना जानकारी देने वाला होना चाहिए कि एलएलएम, सिमैंटिक तौर पर मिलते-जुलते शब्दों को पहचान सके. "डेटाबेस टूल" जैसे सामान्य ब्यौरे से काम नहीं चलेगा. सटीक ब्यौरा, जैसे कि "यह कुकी, उपयोगकर्ता या लेन-देन का डेटा वापस पाने के लिए, स्थानीय PostgreSQL डेटाबेस के ख़िलाफ़ सिर्फ़ पढ़ने वाली SQL क्वेरी को एक्ज़ीक्यूट करती है. Use this for debugging data states" से यह पक्का होता है कि स्किल को सही तरीके से चुना गया है.

मार्कडाउन बॉडी

मुख्य हिस्से में निर्देश शामिल होते हैं. यह "प्रॉम्प्ट इंजीनियरिंग" है, जिसे किसी फ़ाइल में सेव किया गया है. स्किल चालू होने पर, इस कॉन्टेंट को एजेंट की कॉन्टेक्स्ट विंडो में डाला जाता है.

ईमेल के मुख्य हिस्से में यह जानकारी शामिल होनी चाहिए:

लक्ष्य: साफ़ तौर पर यह बताना कि स्किल क्या काम करती है.
निर्देश: चरण-दर-चरण लॉजिक.
उदाहरण: मॉडल की परफ़ॉर्मेंस को बेहतर बनाने के लिए, इनपुट और आउटपुट के कुछ उदाहरण.
पाबंदियां: "ऐसा न करें" वाले नियम (जैसे, "DELETE क्वेरी न चलाएं").

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.

स्क्रिप्ट इंटिग्रेशन

Skills की सबसे अहम सुविधाओं में से एक यह है कि स्क्रिप्ट को टास्क पूरा करने की अनुमति दी जा सकती है. इससे एजेंट को ऐसी कार्रवाइयां करने की अनुमति मिलती है जिन्हें एलएलएम सीधे तौर पर नहीं कर सकता. जैसे, बाइनरी एक्ज़ीक्यूशन, जटिल गणितीय हिसाब-किताब या लेगसी सिस्टम के साथ इंटरैक्ट करना.

स्क्रिप्ट, scripts/ सबडायरेक्ट्री में रखी जाती हैं. SKILL.md, रिलेटिव पाथ के हिसाब से उनका रेफ़रंस देता है.

5. लेखन कौशल

इस सेक्शन का मकसद, ऐसी स्किल बनाना है जो Antigravity में इंटिग्रेट हो सकें. साथ ही, धीरे-धीरे अलग-अलग सुविधाएं दिखा सकें. जैसे, संसाधन / स्क्रिप्ट / वगैरह.

Github repo से Skills को यहां डाउनलोड किया जा सकता है: https://github.com/rominirani/antigravity-skills.

हम इन सभी स्किल को ~/.gemini/antigravity/skills फ़ोल्डर या /.agent/skills फ़ोल्डर में रख सकते हैं.

पहला लेवल : बेसिक राउटर ( `git-commit-formatter` )

इसे स्किल का "नमस्ते दुनिया" माना जाता है.

डेवलपर अक्सर कम शब्दों में कमिट मैसेज लिखते हैं. जैसे, "wip", "fix bug", "updates". "कन्वेंशनल कमिट" को मैन्युअल तरीके से लागू करना मुश्किल होता है. साथ ही, अक्सर इसे लागू करना भूल जाते हैं. चलिए, एक ऐसी स्किल लागू करते हैं जो कन्वेंशनल कमिट स्पेसिफ़िकेशन को लागू करती है. हम एजेंट को सिर्फ़ नियमों के बारे में बताकर, उसे नियमों को लागू करने की अनुमति देते हैं.

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`

इस उदाहरण को कैसे चलाएं:

अपने Workspace में मौजूद किसी भी फ़ाइल में थोड़ा बदलाव करें.
चैट खोलें और टाइप करें: इन बदलावों को सेव करें.
एजेंट सिर्फ़ git commit नहीं करेगा. यह सबसे पहले git-commit-formatter स्किल को चालू करेगा.
नतीजा: Git के कमिट मैसेज का सुझाव दिया जाएगा.

उदाहरण के लिए, मैंने Antigravity को Python की किसी सैंपल फ़ाइल में कुछ टिप्पणियां जोड़ने के लिए कहा. इसके बाद, मुझे Git कमिट मैसेज मिला, जैसे कि docs: add detailed comments to demo_primes.py.

दूसरा लेवल: ऐसेट का इस्तेमाल (license-header-adder)

यह "रेफ़रंस" पैटर्न है.

किसी कॉर्पोरेट प्रोजेक्ट की हर सोर्स फ़ाइल के लिए, Apache 2.0 लाइसेंस का 20 लाइन वाला हेडर ज़रूरी हो सकता है. इस स्टैटिक टेक्स्ट को सीधे तौर पर प्रॉम्प्ट (या SKILL.md) में डालने से कोई फ़ायदा नहीं होता. हर बार स्किल को इंडेक्स करने पर, यह टोकन का इस्तेमाल करता है. साथ ही, मॉडल कानूनी टेक्स्ट में टाइप की गई गलतियों के बारे में "भ्रमित" हो सकता है.

स्टैटिक टेक्स्ट को resources/ फ़ोल्डर में मौजूद, सादे टेक्स्ट वाली फ़ाइल में ऑफ़लोड करना. स्किल, एजेंट को यह फ़ाइल सिर्फ़ तब पढ़ने का निर्देश देती है, जब इसकी ज़रूरत होती है.

JSON API रिस्पॉन्स जैसे लूज़ डेटा को Pydantic मॉडल जैसे स्ट्रिक्ट कोड में बदलने के लिए, कई फ़ैसले लेने पड़ते हैं. हमें क्लास के नाम कैसे रखने चाहिए? क्या हमें Optional का इस्तेमाल करना चाहिए? snake_case या camelCase? इन 50 नियमों को अंग्रेज़ी में लिखना मुश्किल है और इसमें गलतियां हो सकती हैं.

एलएलएम, पैटर्न मैच करने वाले इंजन होते हैं.

ज़्यादा जानकारी देने वाले निर्देशों के बजाय, उन्हें एक बेहतरीन उदाहरण (इनपुट -> आउटपुट) दिखाना ज़्यादा असरदार होता है.

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

इस उदाहरण को कैसे चलाएं:

कोई नई डमी Python फ़ाइल बनाएं: touch my_script.py
टाइप: Add the license header to my_script.py.
एजेंट license-header-adder/resources/HEADER_TEMPLATE.txt पढ़ेगा.
इससे कॉन्टेंट को आपकी फ़ाइल में बिलकुल उसी तरह चिपकाया जाएगा जैसा वह है.

तीसरा लेवल: उदाहरण से सीखना (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

इस उदाहरण को कैसे चलाएं:

एजेंट को JSON का स्निपेट दें. इसे चैट में चिपकाएं या किसी फ़ाइल की ओर ले जाएं.

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

टाइप: Convert this JSON to a Pydantic model.
एजेंट, स्किल फ़ोल्डर में मौजूद examples पेयर को देखता है.
यह एक Python क्लास जनरेट करता है, जो output_model.py की कोडिंग स्टाइल, इंपोर्ट, और स्ट्रक्चर की पूरी तरह से नकल करती है. इसमें, शून्य स्टॉक को Optional के तौर पर हैंडल करना भी शामिल है.

यहां आउटपुट का एक सैंपल (product_model.py) दिखाया गया है:

from pydantic import BaseModel
from typing import Optional

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

लेवल 4: प्रोसीज़र लॉजिक (database-schema-validator)

यह "टूल का इस्तेमाल" पैटर्न है.

अगर एलएलएम से पूछा जाए कि "क्या यह स्कीमा सुरक्षित है?", तो वह कह सकता है कि सब ठीक है. भले ही, कोई अहम प्राइमरी कुंजी मौजूद न हो. ऐसा इसलिए, क्योंकि एसक्यूएल सही दिखता है.

आइए, इस जांच को डिटरमिनिस्टिक स्क्रिप्ट को सौंपते हैं. हम स्किल का इस्तेमाल, एजेंट को उस Python स्क्रिप्ट को चलाने के लिए रूट करने के लिए करते हैं जिसे हमने लिखा है. यह स्क्रिप्ट, बाइनरी (सही/गलत) के तौर पर जवाब देती है.

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

इस उदाहरण को कैसे चलाएं:

खराब एसक्यूएल फ़ाइल बनाएं bad_schema.sql: CREATE TABLE users (name TEXT);
टाइप: Validate bad_schema.sql.
एजेंट अनुमान नहीं लगाता है. इससे स्क्रिप्ट शुरू हो जाएगी, जो काम नहीं करेगी (एक्ज़िट कोड 1). साथ ही, हमें यह सूचना मिलेगी कि "मान्य करने की प्रोसेस पूरी नहीं हो सकी, क्योंकि ‘users' टेबल में प्राइमरी कुंजी मौजूद नहीं है."

लेवल 5: आर्किटेक्ट (adk-tool-scaffold)

इस पैटर्न में, Skills में उपलब्ध ज़्यादातर सुविधाएँ शामिल हैं.

जटिल टास्क के लिए, अक्सर कई कार्रवाइयों को एक क्रम में करने की ज़रूरत होती है. इनमें फ़ाइलें बनाना, टेंप्लेट का इस्तेमाल करना, और लॉजिक लिखना शामिल है. ADK (एजेंट डेवलपमेंट किट) के लिए नया टूल बनाने के लिए, इन सभी चीज़ों की ज़रूरत होती है.

हम इन चीज़ों को एक साथ इस्तेमाल करते हैं:

स्क्रिप्ट (फ़ाइल बनाने/स्केफ़ोल्डिंग को मैनेज करने के लिए)
टेंप्लेट (संसाधनों में बॉयलरप्लेट को मैनेज करने के लिए)
उदाहरण (लॉजिक जनरेट करने के लिए).

adk-tool-scaffold/
├── SKILL.md
├── resources/
│   └── ToolTemplate.py.hbs (Jinja2 Template)
├── scripts/
│   └── scaffold_tool.py    (Generator Script)
└── examples/
    └── WeatherTool.py      (Reference Implementation)

SKILL.md फ़ाइल यहां दिखाई गई है. स्क्रिप्ट, संसाधन, और उदाहरण फ़ोल्डर में मौजूद फ़ाइलें देखने के लिए, कौशल की रिपॉज़िटरी देखें. इस खास स्किल के लिए, 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.

इस उदाहरण को कैसे चलाएं:

टाइप: Create a new ADK tool called StockPrice to fetch data from an API.
पहला चरण (स्केफ़ोल्डिंग): एजेंट, Python स्क्रिप्ट चलाता है. इससे, क्लास के सही स्ट्रक्चर, इंपोर्ट, और क्लास के नाम StockPriceTool के साथ StockPriceTool.py तुरंत बन जाता है.
दूसरा चरण (लागू करना): एजेंट, अभी बनाई गई फ़ाइल को "पढ़ता है". इसे # TODO: Implement logic. दिखता है
तीसरा चरण (दिशा-निर्देश): टूल के तर्कों के लिए JSON स्कीमा को कैसे तय किया जाए, इस बारे में जानकारी नहीं है. यह examples/WeatherTool.py की जांच करता है.
पूरा करना: यह फ़ाइल में बदलाव करके requests.get(...) जोड़ता है. साथ ही, स्कीमा में टिकर आर्ग्युमेंट को इस तरह से तय करता है कि वह ADK स्टाइल से पूरी तरह मेल खाए.

6. बधाई हो

आपने ऐंटीग्रैविटी स्किल से जुड़ा लैब पूरा कर लिया है. साथ ही, आपने ये स्किल बनाई हैं:

Git कमिट फ़ॉर्मेटर.
लाइसेंस हेडर जोड़ने वाला टूल.
JSON को Pydantic में बदलें.
डेटाबेस स्कीमा की पुष्टि करने वाला टूल.
ADK टूल स्कैफ़ोल्डिंग.

एजेंट की क्षमताओं का इस्तेमाल करके, Antigravity को अपनी पसंद के मुताबिक कोड लिखने, नियमों का पालन करने, और आपके टूल इस्तेमाल करने के लिए कहा जा सकता है.

रेफ़रंस दस्तावेज़

कोडलैब : Google Antigravity का इस्तेमाल शुरू करना
आधिकारिक साइट : https://antigravity.google/
दस्तावेज़: https://antigravity.google/docs
डाउनलोड करें : https://antigravity.google/download
Antigravity Skills के दस्तावेज़: https://antigravity.google/docs/skills

Google Antigravity में स्किल का इस्तेमाल शुरू करना

1. परिचय

2. कौशल क्यों

समाधान: एजेंट की क्षमताएं

यह कैसे काम करता है

3. एजेंट के कौशल और एंटीग्रैविटी

Antigravity में स्किल क्या होती है?

स्किल बनाम इकोसिस्टम (टूल, नियम, और वर्कफ़्लो)

4. स्किल बनाना

डायरेक्ट्री स्ट्रक्चर

SKILL.md डेफ़िनिशन फ़ाइल

स्क्रिप्ट इंटिग्रेशन

5. लेखन कौशल

पहला लेवल : बेसिक राउटर ( git-commit-formatter )

दूसरा लेवल: ऐसेट का इस्तेमाल (license-header-adder)

तीसरा लेवल: उदाहरण से सीखना (json-to-pydantic)

लेवल 4: प्रोसीज़र लॉजिक (database-schema-validator)

लेवल 5: आर्किटेक्ट (adk-tool-scaffold)

6. बधाई हो

रेफ़रंस दस्तावेज़

पहला लेवल : बेसिक राउटर ( `git-commit-formatter` )