เริ่มต้นใช้งานทักษะใน Google Antigravity

1. บทนำ

Google Antigravity (ต่อไปในเอกสารนี้จะเรียกว่า Antigravity) เป็น IDE แบบเอเจนต์จาก Google ใน Getting started with Antigravity codelab คุณจะได้เรียนรู้พื้นฐานของ Antigravity ในโค้ดแล็บนี้ เราจะใช้ Antigravity เพื่อสร้างทักษะของเอเจนต์ ซึ่งเป็นรูปแบบเปิดที่มีน้ำหนักเบาสำหรับการขยายความสามารถของเอเจนต์ AI ด้วยความรู้และเวิร์กโฟลว์เฉพาะทาง คุณจะได้ทราบว่าทักษะของเอเจนต์คืออะไร ประโยชน์ของทักษะ และวิธีสร้างทักษะ จากนั้นคุณจะสร้างทักษะของเอเจนต์หลายอย่าง ตั้งแต่ตัวจัดรูปแบบ Git, ตัวสร้างเทมเพลต, โครงสร้างโค้ดเครื่องมือ และอื่นๆ ซึ่งทั้งหมดนี้ใช้ได้ภายใน Antigravity

ข้อกำหนดเบื้องต้น

  • ติดตั้งและกำหนดค่า Google Antigravity แล้ว
  • มีความเข้าใจพื้นฐานเกี่ยวกับ Google Antigravity ขอแนะนำให้ทำ Codelab การเริ่มต้นใช้งาน Google Antigravity ให้เสร็จสมบูรณ์

2. เหตุผลที่ต้องมีทักษะ

เอเจนต์ AI สมัยใหม่พัฒนาจากผู้ฟังที่เรียบง่ายไปเป็นผู้ให้เหตุผลที่ซับซ้อนซึ่งผสานรวมกับระบบไฟล์ในเครื่องและเครื่องมือภายนอก (ผ่านเซิร์ฟเวอร์ MCP) อย่างไรก็ตาม การโหลดเอเจนต์ด้วยโค้ดเบสทั้งหมดและเครื่องมือนับร้อยโดยไม่เลือกจะทำให้เกิดบริบทอิ่มตัวและ "เครื่องมือบวม" แม้จะมีหน้าต่างบริบทขนาดใหญ่ การทิ้งโทเค็น 40,000-50,000 รายการของเครื่องมือที่ไม่ได้ใช้ลงในหน่วยความจำที่ใช้งานอยู่จะทำให้เกิดเวลาในการตอบสนองสูง การสิ้นเปลืองทางการเงิน และ "บริบทเสื่อม" ซึ่งโมเดลจะสับสนกับข้อมูลที่ไม่เกี่ยวข้อง

โซลูชัน: ทักษะของตัวแทน

Anthropic จึงได้เปิดตัวทักษะของเอเจนต์เพื่อแก้ปัญหานี้ โดยเปลี่ยนสถาปัตยกรรมจากการโหลดบริบทแบบโมโนลิธเป็นการเปิดเผยข้อมูลแบบค่อยเป็นค่อยไป ความสามารถเหล่านี้จะรวมอยู่ในหน่วยแบบแยกส่วนที่ค้นพบได้ แทนที่จะบังคับให้โมเดล "จดจำ" เวิร์กโฟลว์ที่เฉพาะเจาะจงทุกรายการ (เช่น การย้ายข้อมูลฐานข้อมูลหรือการตรวจสอบความปลอดภัย) เมื่อเริ่มเซสชัน

วิธีการทำงาน

โดยในตอนแรก โมเดลจะแสดงเฉพาะ "เมนู" ข้อมูลเมตาแบบเบา โดยจะโหลดความรู้เชิงกระบวนการที่ซับซ้อน (คำสั่งและสคริปต์) ก็ต่อเมื่อความตั้งใจของผู้ใช้ตรงกับทักษะอย่างเจาะจงเท่านั้น ซึ่งจะช่วยให้มั่นใจได้ว่านักพัฒนาแอปที่ขอให้ปรับโครงสร้างมิดเดิลแวร์การตรวจสอบสิทธิ์จะได้รับบริบทความปลอดภัยโดยไม่ต้องโหลดไปป์ไลน์ CSS ที่ไม่เกี่ยวข้อง ทำให้บริบทมีขนาดเล็ก รวดเร็ว และประหยัดค่าใช้จ่าย

d3f4bcb065a19fea.png

3. ทักษะของเอเจนต์และ Antigravity

ในระบบนิเวศ Antigravity หาก Agent Manager เป็นสมองและ Editor เป็น Canvas Skills จะทำหน้าที่เป็นโมดูลการฝึกอบรมเฉพาะทางที่เชื่อมช่องว่างระหว่างโมเดล Gemini 3 แบบทั่วไปกับบริบทเฉพาะของคุณ ซึ่งจะช่วยให้เอเจนต์ "ติดตั้ง" ชุดคำสั่งและโปรโตคอลที่กำหนดไว้ เช่น มาตรฐานการย้ายข้อมูลฐานข้อมูลหรือการตรวจสอบความปลอดภัย เฉพาะเมื่อมีการขอให้ทำงานที่เกี่ยวข้องเท่านั้น การโหลดโปรโตคอลการดำเนินการเหล่านี้แบบไดนามิกช่วยให้ทักษะเปลี่ยน AI จากโปรแกรมเมอร์ทั่วไปให้กลายเป็นผู้เชี่ยวชาญที่ยึดมั่นในแนวทางปฏิบัติแนะนำและมาตรฐานความปลอดภัยที่กำหนดไว้ขององค์กรอย่างเคร่งครัด

ทักษะใน Antigravity คืออะไร

ในบริบทของ Google Antigravity ทักษะคือแพ็กเกจที่อิงตามไดเรกทอรีซึ่งมีไฟล์คำจำกัดความ (SKILL.md) และเนื้อหาที่รองรับ (สคริปต์ การอ้างอิง เทมเพลต) ซึ่งไม่บังคับ

ซึ่งเป็นกลไกสำหรับการขยายความสามารถตามความต้องการ

  • ตามต้องการ: ต่างจากพรอมต์ระบบ (ซึ่งจะโหลดเสมอ) ทักษะจะโหลดลงในบริบทของเอเจนต์ก็ต่อเมื่อเอเจนต์พิจารณาแล้วว่าเกี่ยวข้องกับคำขอปัจจุบันของผู้ใช้ ซึ่งจะช่วยเพิ่มประสิทธิภาพหน้าต่างบริบทและป้องกันไม่ให้เอเจนต์เสียสมาธิกับคำสั่งที่ไม่เกี่ยวข้อง ในโปรเจ็กต์ขนาดใหญ่ที่มีเครื่องมือหลายสิบรายการ การโหลดแบบเลือกนี้มีความสําคัญอย่างยิ่งต่อประสิทธิภาพและความแม่นยําในการให้เหตุผล
  • การขยายความสามารถ: สกิลทำได้มากกว่าแค่สั่งการ แต่ยังสามารถดำเนินการได้ด้วย การรวมสคริปต์ Python หรือ Bash ทำให้ทักษะสามารถให้ความสามารถแก่เอเจนต์ในการดำเนินการที่ซับซ้อนแบบหลายขั้นตอนในเครื่องหรือเครือข่ายภายนอกได้โดยที่ผู้ใช้ไม่ต้องเรียกใช้คำสั่งด้วยตนเอง ซึ่งจะเปลี่ยนเอเจนต์จากเครื่องมือสร้างข้อความเป็นผู้ใช้เครื่องมือ

ทักษะเทียบกับระบบนิเวศ (เครื่องมือ กฎ และเวิร์กโฟลว์)

ในขณะที่ Model Context Protocol (MCP) ทำหน้าที่เป็น "มือ" ของเอเจนต์ ซึ่งให้การเชื่อมต่อแบบถาวรที่ใช้งานหนักกับระบบภายนอก เช่น GitHub หรือ PostgreSQL ทักษะจะทำหน้าที่เป็น "สมอง" ที่สั่งการ

MCP จัดการโครงสร้างพื้นฐานแบบมีสถานะ ในขณะที่ทักษะเป็นคำจำกัดความของงานแบบชั่วคราวที่มีน้ำหนักเบาซึ่งรวมวิธีการใช้เครื่องมือเหล่านั้น แนวทางแบบไร้เซิร์ฟเวอร์นี้ช่วยให้เอเจนต์สามารถเรียกใช้งานตามความต้องการ (เช่น การสร้างบันทึกการเปลี่ยนแปลงหรือการย้ายข้อมูล) โดยไม่ต้องมีค่าใช้จ่ายในการดำเนินงานในการเรียกใช้กระบวนการที่ต่อเนื่อง โหลดบริบทเมื่อมีงานที่ใช้งานอยู่เท่านั้น และปล่อยบริบททันทีหลังจากนั้น

ในแง่ของการทำงาน ทักษะจะอยู่ตรงกลางระหว่าง "กฎ" (การป้องกันแบบพาสซีฟที่เปิดอยู่เสมอ) กับ "เวิร์กโฟลว์" (แมโครที่ใช้งานอยู่ซึ่งผู้ใช้เป็นผู้ทริกเกอร์) ซึ่งต่างจากเวิร์กโฟลว์ที่ต้องใช้คำสั่งที่เฉพาะเจาะจง (เช่น /test) ทักษะจะทริกเกอร์โดยเอเจนต์: โมเดลจะตรวจหาความตั้งใจของผู้ใช้โดยอัตโนมัติและติดตั้งความเชี่ยวชาญเฉพาะที่จำเป็นแบบไดนามิก สถาปัตยกรรมนี้ช่วยให้สามารถประกอบกันได้อย่างมีประสิทธิภาพ เช่น กฎส่วนกลางสามารถบังคับใช้ทักษะ "การย้ายข้อมูลอย่างปลอดภัย" ในระหว่างการเปลี่ยนแปลงฐานข้อมูล หรือเวิร์กโฟลว์เดียวสามารถประสานงานทักษะหลายอย่างเพื่อสร้างไปป์ไลน์การติดตั้งใช้งานที่แข็งแกร่ง

4. การสร้างทักษะ

การสร้างทักษะใน Antigravity จะต้องเป็นไปตามโครงสร้างไดเรกทอรีและรูปแบบไฟล์ที่เฉพาะเจาะจง การกำหนดมาตรฐานนี้ช่วยให้มั่นใจได้ว่าทักษะจะสามารถนำไปใช้ได้ และเอเจนต์จะสามารถแยกวิเคราะห์และดำเนินการได้อย่างน่าเชื่อถือ การออกแบบตั้งใจให้เรียบง่าย โดยอาศัยรูปแบบที่เข้าใจกันอย่างกว้างขวาง เช่น Markdown และ YAML เพื่อลดอุปสรรคในการเริ่มต้นใช้งานสำหรับนักพัฒนาซอฟต์แวร์ที่ต้องการขยายความสามารถของ IDE

โครงสร้างไดเรกทอรี

คุณกำหนดทักษะได้ 2 ขอบเขต ซึ่งช่วยให้ปรับแต่งได้ทั้งระดับโปรเจ็กต์และระดับผู้ใช้

  1. ขอบเขตของ Workspace: ตั้งอยู่ใน <workspace-root>/.agent/skills/ โดยทักษะเหล่านี้จะใช้ได้ภายในโปรเจ็กต์ที่เฉพาะเจาะจงเท่านั้น ซึ่งเหมาะสำหรับสคริปต์เฉพาะโปรเจ็กต์ เช่น การติดตั้งใช้งานในสภาพแวดล้อมที่เฉพาะเจาะจง การจัดการฐานข้อมูลสำหรับแอปนั้น หรือการสร้างโค้ด Boilerplate สำหรับเฟรมเวิร์กที่เป็นกรรมสิทธิ์
  2. ขอบเขตทั่วโลก: ตั้งอยู่ใน ~/.gemini/antigravity/skills/ ทักษะเหล่านี้พร้อมใช้งานในทุกโปรเจ็กต์ในเครื่องของผู้ใช้ เหมาะสำหรับยูทิลิตีทั่วไป เช่น "จัดรูปแบบ JSON" "สร้าง UUID" "ตรวจสอบรูปแบบโค้ด" หรือการผสานรวมกับเครื่องมือเพิ่มประสิทธิภาพส่วนบุคคล

โดยไดเรกทอรีทักษะทั่วไปจะมีลักษณะดังนี้

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 คือหัวใจของทักษะ โดยจะบอก Agent ว่าทักษะคืออะไร เมื่อใดควรใช้ และวิธีดำเนินการ

โดยประกอบด้วย 2 ส่วน ดังนี้

  • Frontmatter ของ YAML
  • เนื้อความในรูปแบบมาร์กดาวน์

Frontmatter ของ 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: ฟิลด์นี้เป็นฟิลด์ที่สำคัญที่สุดและต้องระบุ ซึ่งทำหน้าที่เป็น "วลีทริกเกอร์" โดยต้องสื่อความหมายมากพอให้ LLM รู้จักความเกี่ยวข้องเชิงความหมาย คำอธิบายที่คลุมเครือ เช่น "เครื่องมือฐานข้อมูล" ไม่เพียงพอ คำอธิบายที่ชัดเจน เช่น "เรียกใช้คำค้นหา SQL แบบอ่านอย่างเดียวกับฐานข้อมูล PostgreSQL ในเครื่องเพื่อดึงข้อมูลผู้ใช้หรือข้อมูลธุรกรรม ใช้สำหรับสถานะข้อมูลการแก้ไขข้อบกพร่อง" เพื่อให้มั่นใจว่าระบบจะเลือกทักษะได้อย่างถูกต้อง

เนื้อหาในรูปแบบมาร์กดาวน์

เนื้อความมีวิธีการ นี่คือ "วิศวกรรมพรอมต์" ที่บันทึกลงในไฟล์ เมื่อเปิดใช้งานทักษะ ระบบจะแทรกเนื้อหานี้ลงในหน้าต่างบริบทของเอเจนต์

เนื้อหาของอีเมลควรมีข้อมูลต่อไปนี้

  1. เป้าหมาย: ข้อความที่ชัดเจนเกี่ยวกับสิ่งที่ทักษะทำได้
  2. วิธีการ: ตรรกะทีละขั้นตอน
  3. ตัวอย่าง: ตัวอย่างอินพุตและเอาต์พุตแบบไม่กี่ช็อตเพื่อเป็นแนวทางในการทำงานของโมเดล
  4. ข้อจำกัด: กฎ "ห้าม" (เช่น "อย่าเรียกใช้การค้นหา 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.

การผสานรวมสคริปต์

ฟีเจอร์ที่มีประสิทธิภาพมากที่สุดอย่างหนึ่งของทักษะคือความสามารถในการมอบหมายการดำเนินการให้กับสคริปต์ ซึ่งช่วยให้เอเจนต์ดำเนินการที่ LLM ทำได้ยากหรือทำไม่ได้โดยตรง (เช่น การดำเนินการไบนารี การคำนวณทางคณิตศาสตร์ที่ซับซ้อน หรือการโต้ตอบกับระบบเดิม)

สคริปต์จะอยู่ในไดเรกทอรีย่อย scripts/ SKILL.md อ้างอิงโดยใช้เส้นทางสัมพัทธ์

5. ทักษะการเขียน

เป้าหมายของส่วนนี้คือการสร้างทักษะที่ผสานรวมเข้ากับ Antigravity และค่อยๆ แสดงฟีเจอร์ต่างๆ เช่น แหล่งข้อมูล / สคริปต์ / ฯลฯ

คุณดาวน์โหลดทักษะจากที่เก็บ GitHub ได้ที่ https://github.com/rominirani/antigravity-skills

เราสามารถพิจารณาจัดวางทักษะแต่ละอย่างเหล่านี้ไว้ในโฟลเดอร์ ~/.gemini/antigravity/skills หรือโฟลเดอร์ /.agent/skills

ระดับ 1 : เราเตอร์พื้นฐาน ( git-commit-formatter )

มาพิจารณาว่านี่คือ "Hello World" ของทักษะ

นักพัฒนามักเขียนข้อความคอมมิตแบบขี้เกียจ เช่น "wip" "แก้ไขข้อบกพร่อง" "อัปเดต" การบังคับใช้ "Conventional Commits" ด้วยตนเองนั้นน่าเบื่อและมักถูกลืม มาใช้ Skill ที่บังคับใช้ข้อกำหนด 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`

วิธีเรียกใช้ตัวอย่างนี้

  1. ทำการเปลี่ยนแปลงเล็กน้อยกับไฟล์ใดก็ได้ในพื้นที่ทำงาน
  2. เปิดแชทแล้วพิมพ์ว่า "Commit การเปลี่ยนแปลงเหล่านี้"
  3. Agent จะไม่เพียงแค่เรียกใช้ git commit โดยจะเปิดใช้งานทักษะ git-commit-formatter ก่อน
  4. ผลลัพธ์: ระบบจะเสนอข้อความคอมมิต Git แบบเดิม

เช่น ฉันสั่งให้ Antigravity เพิ่มความคิดเห็นลงในไฟล์ Python ตัวอย่าง และสุดท้ายก็มีข้อความ Git commit ดังนี้ docs: add detailed comments to demo_primes.py.

ระดับที่ 2: การใช้ประโยชน์จากเนื้อหา (license-header-adder)

นี่คือรูปแบบ "อ้างอิง"

ไฟล์แหล่งที่มาทุกไฟล์ในโปรเจ็กต์ขององค์กรอาจต้องมีส่วนหัวของใบอนุญาต Apache 2.0 แบบ 20 บรรทัดที่เฉพาะเจาะจง การใส่ข้อความแบบคงที่นี้ลงในพรอมต์โดยตรง (หรือ SKILL.md) เป็นการสิ้นเปลือง โดยจะใช้โทเค็นทุกครั้งที่จัดทำดัชนีทักษะ และโมเดลอาจ "หลอน" การสะกดคำผิดในข้อความทางกฎหมาย

การออฟโหลดข้อความแบบคงที่ไปยังไฟล์ข้อความธรรมดาในโฟลเดอร์ resources/ ทักษะจะสั่งให้ตัวแทนอ่านไฟล์นี้เมื่อจำเป็นเท่านั้น

การแปลงข้อมูลที่ไม่เข้มงวด (เช่น การตอบกลับของ JSON API) เป็นโค้ดที่เข้มงวด (เช่น โมเดล Pydantic) ต้องมีการตัดสินใจหลายสิบครั้ง เราควรตั้งชื่อชั้นเรียนอย่างไร เราควรใช้ Optional ไหม snake_case หรือ camelCase การเขียนกฎทั้ง 50 ข้อนี้เป็นภาษาอังกฤษเป็นเรื่องที่น่าเบื่อและมีโอกาสเกิดข้อผิดพลาดได้ง่าย

LLM เป็นเครื่องมือจับคู่รูปแบบ

การแสดงตัวอย่างที่ยอดเยี่ยม (อินพุต -> เอาต์พุต) มักจะมีประสิทธิภาพมากกว่าคำสั่งที่ยาวเหยียด

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

วิธีเรียกใช้ตัวอย่างนี้

  1. สร้างไฟล์ Python ดัมมี่ใหม่: touch my_script.py
  2. ประเภท: Add the license header to my_script.py
  3. ตัวแทนจะอ่าน license-header-adder/resources/HEADER_TEMPLATE.txt
  4. โดยจะวางเนื้อหาลงในไฟล์ของคุณอย่างตรงตามต้นฉบับ

ระดับ 3: การเรียนรู้จากตัวอย่าง (json-to-pydantic)

รูปแบบ "Few-Shot"

การแปลงข้อมูลที่ไม่เข้มงวด (เช่น การตอบกลับของ JSON API) เป็นโค้ดที่เข้มงวด (เช่น โมเดล Pydantic) ต้องมีการตัดสินใจหลายสิบครั้ง เราควรตั้งชื่อชั้นเรียนอย่างไร เราควรใช้ Optional ไหม snake_case หรือ camelCase การเขียนกฎทั้ง 50 ข้อนี้เป็นภาษาอังกฤษเป็นเรื่องที่น่าเบื่อและมีโอกาสเกิดข้อผิดพลาดได้ง่าย

LLM เป็นเครื่องมือจับคู่รูปแบบ การแสดงตัวอย่างที่ยอดเยี่ยม (อินพุต -> เอาต์พุต) มักจะมีประสิทธิภาพมากกว่าคำสั่งที่ยาวเหยียด

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 โดยทั้ง 2 แบบแสดงอยู่ด้านล่าง ดังนี้

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

วิธีเรียกใช้ตัวอย่างนี้

  1. ระบุข้อมูลโค้ด JSON ให้กับตัวแทน (วางในแชทหรือชี้ไปยังไฟล์)

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

  1. ประเภท: Convert this JSON to a Pydantic model
  2. เอเจนต์จะดูคู่ examples ในโฟลเดอร์ทักษะ
  3. โดยจะสร้างคลาส Python ที่เลียนแบบสไตล์การเขียนโค้ด การนำเข้า และโครงสร้างของ output_model.py ได้อย่างสมบูรณ์ รวมถึงการจัดการสต็อกที่เป็น Null เป็น 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)

นี่คือรูปแบบ "การใช้เครื่องมือ"

หากคุณถาม LLM ว่า "สคีมานี้ปลอดภัยไหม" LLM อาจตอบว่าปลอดภัยดี แม้ว่าจะไม่มีคีย์หลักที่สำคัญก็ตาม เพียงเพราะ SQL ดูถูกต้อง

มามอบหมายการตรวจสอบนี้ให้กับสคริปต์ที่อ้างอิงจากข้อมูลที่แม่นยำและเฉพาะเจาะจงกัน เราใช้ทักษะเพื่อกำหนดเส้นทางให้ตัวแทนเรียกใช้สคริปต์ 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])

วิธีเรียกใช้ตัวอย่างนี้

  1. สร้างไฟล์ SQL ที่ไม่ถูกต้อง bad_schema.sql: CREATE TABLE users (name TEXT);
  2. ประเภท: Validate bad_schema.sql
  3. Agent จะไม่คาดเดา ซึ่งจะเรียกใช้สคริปต์ที่ล้มเหลว (รหัสออก 1) และจะรายงานให้เราทราบว่า "การตรวจสอบไม่สำเร็จเนื่องจากตาราง "users" ไม่มีคีย์หลัก"

ระดับ 5: สถาปนิก (adk-tool-scaffold)

รูปแบบนี้ครอบคลุมฟีเจอร์ส่วนใหญ่ที่มีในทักษะ

งานที่ซับซ้อนมักต้องใช้ลำดับการดำเนินการที่รวมทุกอย่างที่เราได้เห็นมาแล้ว ได้แก่ การสร้างไฟล์ การทำตามเทมเพลต และการเขียนตรรกะ การสร้างเครื่องมือใหม่สำหรับ 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.

วิธีเรียกใช้ตัวอย่างนี้

  1. ประเภท: Create a new ADK tool called StockPrice to fetch data from an API
  2. ขั้นตอนที่ 1 (การจัดโครงร่าง): ตัวแทนเรียกใช้สคริปต์ Python ซึ่งจะสร้าง StockPriceTool.py ที่มีโครงสร้างชั้นเรียน การนำเข้า และชื่อชั้นเรียนที่ถูกต้องในทันที StockPriceTool
  3. ขั้นตอนที่ 2 (การติดตั้งใช้งาน): เอเจนต์ "อ่าน" ไฟล์ที่เพิ่งสร้าง โดยจะเห็น # TODO: Implement logic.
  4. ขั้นตอนที่ 3 (คำแนะนำ): ไม่แน่ใจว่าจะกำหนดสคีมา JSON สำหรับอาร์กิวเมนต์ของเครื่องมืออย่างไร โดยจะตรวจสอบ examples/WeatherTool.py
  5. การเติมข้อความ: ระบบจะแก้ไขไฟล์เพื่อเพิ่ม requests.get(...) และกำหนดอาร์กิวเมนต์ของทิกเกอร์ในสคีมาให้ตรงกับสไตล์ ADK

6. ขอแสดงความยินดี

คุณทำแล็บเกี่ยวกับทักษะการต้านแรงโน้มถ่วงและสร้างทักษะต่อไปนี้เสร็จสมบูรณ์แล้ว

  • โปรแกรมจัดรูปแบบการคอมมิต Git
  • ส่วนหัวของใบอนุญาต
  • JSON เป็น Pydantic
  • เครื่องมือตรวจสอบสคีมาฐานข้อมูล
  • การจัดโครงสร้างเครื่องมือ ADK

ทักษะของเอเจนต์เป็นวิธีที่ยอดเยี่ยมในการใช้ Antigravity เขียนโค้ดในแบบของคุณ ทำตามกฎ และใช้เครื่องมือของคุณ

เอกสารอ้างอิง