Google ADK (Agent Development Kit) คืออะไร? คู่มือใช้งานจริง

Google ADK เป็นเฟรมเวิร์กโอเพนซอร์สสำหรับสร้าง ประเมิน และปรับใช้ AI เอเจนต์ และเป็นตัวขับเคลื่อนเอเจนต์จริงภายในผลิตภัณฑ์ของ Google เช่น Agentspace หากคุณเคยดูสแต็กเอเจนต์อื่น ๆ มาก่อน เช่น OpenAI Agents SDK, ADK ครอบคลุมพื้นที่เดียวกันในขณะที่ยังคงใกล้ชิดกับ Gemini และ Vertex AI คู่มือนี้อธิบายว่า ADK คืออะไร ชิ้นส่วนหลักของมันประกอบกันอย่างไร และเครื่องมืออย่าง Apidog ช่วยคุณทดสอบ API ที่เอเจนต์ของคุณเรียกใช้ได้อย่างไร

button

Google ADK คืออะไร

ADK ย่อมาจาก Agent Development Kit Google เปิดตัวที่ Google Cloud Next ในเดือนเมษายน 2025 ในฐานะชุดเครื่องมือโอเพนซอร์สสำหรับวงจรชีวิตเอเจนต์เต็มรูปแบบ: กำหนดเอเจนต์ ให้เครื่องมือ จัดองค์ประกอบเอเจนต์หลายตัว ประเมินพฤติกรรม และปรับใช้ในการใช้งานจริง

เริ่มต้นด้วย Python เป็นอันดับแรก และ Google ได้เพิ่ม Java เข้ามาแล้ว โดยจะมี Go และ TypeScript ตามมา เฟรมเวิร์กนี้เป็นอันเดียวกันที่ Google ใช้ภายในสำหรับเอเจนต์ใน Agentspace และ Customer Engagement Suite ดังนั้นจึงไม่ใช่ SDK ของเล่น สร้างขึ้นสำหรับการใช้งานจริง

ADK เป็นแบบ model-agnostic แต่ได้รับการปรับให้เหมาะสมกับ Google ทำงานได้ดีที่สุดกับ Gemini และโมเดลใด ๆ ที่มีให้ผ่าน Vertex AI Model Garden และเชื่อมต่อกับ LiteLLM เพื่อให้คุณสามารถชี้เอเจนต์ไปยัง Anthropic, Meta, Mistral และผู้ให้บริการอื่น ๆ คุณจะได้รับการผสานรวม Gemini ที่แน่นแฟ้นโดยไม่ต้องผูกติดกับโมเดลเดียว

ADK อยู่ในระบบนิเวศของ Gemini และ Vertex AI ตรงไหน

มันช่วยให้แยกสามเลเยอร์:

โมเดล. Gemini (หรือผู้ให้บริการอื่นผ่าน Vertex AI Model Garden หรือ LiteLLM) ทำการให้เหตุผล
เฟรมเวิร์ก. ADK เป็นเลเยอร์โค้ดที่คุณกำหนดเอเจนต์ เชื่อมต่อเครื่องมือ และจัดการเวิร์กโฟลว์ของเอเจนต์หลายตัว
รันไทม์. Vertex AI Agent Engine คือโฮสต์ที่จัดการและปรับขนาดได้ ซึ่งเอเจนต์ของคุณทำงานในการใช้งานจริง คุณยังสามารถปรับใช้กับ Cloud Run หรือรันไทม์คอนเทนเนอร์ใด ๆ ได้

ดังนั้น ADK จึงเป็นเลเยอร์ที่นักพัฒนาใช้งาน Gemini ให้ความฉลาดอยู่ภายใต้ และ Vertex AI Agent Engine ให้บ้านที่จัดการอยู่เหนือมัน คุณสามารถใช้ทั้งสามร่วมกัน หรือรัน ADK ในเครื่องและปรับใช้ที่อื่น ไม่มีอะไรบังคับให้คุณต้องเลือกเส้นทางเดียว

แนวคิดหลัก

ส่วนประกอบพื้นฐานสองสามอย่างครอบคลุมสิ่งที่คุณจะเขียนส่วนใหญ่

เอเจนต์

หน่วยพื้นฐานคือเอเจนต์ที่ขับเคลื่อนด้วย LLM ใน Python คุณจะอิมพอร์ตจาก google.adk.agents คลาสคือ LlmAgent และ Agent เป็นชื่อเรียกที่สะดวกสำหรับมัน คุณให้โมเดล ชื่อ คำสั่งที่กำหนดพฤติกรรม และรายการเครื่องมือ

from google.adk.agents import Agent

def get_exchange_rate(base: str, target: str) -> dict:
    """Return the exchange rate between two currencies."""
    # call your real FX API here
    return {"base": base, "target": target, "rate": 1.08}

currency_agent = Agent(
    name="currency_exchange_agent",
    model="gemini-2.0-flash",
    instruction="You help users convert between currencies. Stick to the facts.",
    tools=[get_exchange_rate],
)

นั่นคือเอเจนต์เดี่ยวที่ทำงานได้ คำสั่งบอกให้มันทำอะไร และรายการเครื่องมือบอกว่ามันสามารถเรียกใช้ได้อะไรบ้าง

เครื่องมือ

เครื่องมือคือวิธีที่เอเจนต์ทำอะไรบางอย่างนอกเหนือจากการสร้างข้อความ ใน ADK ฟังก์ชัน Python ธรรมดาคือเครื่องมือ ชื่อฟังก์ชัน คำใบ้ชนิด และ docstring จะบอกโมเดลว่าเมื่อใดและอย่างไรจึงจะเรียกใช้ ดังนั้น docstring ที่ชัดเจนจึงมีความสำคัญมากกว่าที่คุณคาดไว้

นอกเหนือจากฟังก์ชันของคุณเอง ADK ยังมาพร้อมกับเครื่องมือในตัว เช่น google_search และการดำเนินการโค้ด และรองรับ Model Context Protocol (MCP) สำหรับการเชื่อมต่อเซิร์ฟเวอร์เครื่องมือภายนอก คุณยังสามารถห่อหุ้มไลบรารีของบุคคลที่สาม เช่น LangChain หรือ LlamaIndex หรือใช้เอเจนต์อื่นเป็นเครื่องมือ เอเจนต์ส่วนใหญ่ลงเอยด้วยการเรียกใช้ REST API ภายนอกผ่านเครื่องมือเหล่านี้ ซึ่งเป็นจุดที่การทดสอบและการจำลองจะเข้ามามีบทบาทในภายหลัง

ระบบเอเจนต์หลายตัว

เอเจนต์ตัวเดียวก็เพียงพอแล้ว แต่ ADK สร้างขึ้นมาเพื่อลำดับชั้น คุณจัดองค์ประกอบเอเจนต์ที่เชี่ยวชาญให้เป็นระบบที่ใหญ่ขึ้น และให้ผู้ประสานงานจัดเส้นทางงานระหว่างกัน

เฟรมเวิร์กนี้มีเอเจนต์เวิร์กโฟลว์สำหรับการควบคุมแบบกำหนดได้: SequentialAgent รันซับเอเจนต์ตามลำดับ, ParallelAgent รันพร้อมกัน, และ LoopAgent ทำซ้ำจนกว่าจะตรงตามเงื่อนไข ผสมสิ่งเหล่านี้กับการกำหนดเส้นทางที่ขับเคลื่อนด้วย LLM และคุณสามารถสร้างเอเจนต์วิจัยที่กระจายไปยังซับเอเจนต์หลายตัวและรวมผลลัพธ์เข้าด้วยกัน

Runner

คุณไม่เรียกใช้เอเจนต์โดยตรงในการใช้งานจริง Runner คือเอนจิ้นการประมวลผลของ ADK มันจัดการเซสชั่น ขับเคลื่อนการไหลของเหตุการณ์ อัปเดตสถานะ เรียกใช้โมเดล และประสานงานการเรียกใช้เครื่องมือ ในระหว่างการพัฒนา คุณสามารถข้ามส่วนที่ไม่จำเป็นได้ด้วย CLI: adk run จะเปิดเซสชั่นเทอร์มินัลแบบอินเทอร์แอคทีฟ และ adk web จะเปิด UI ของเบราว์เซอร์ในเครื่องสำหรับสนทนากับเอเจนต์ของคุณและตรวจสอบแต่ละขั้นตอน

การประเมินและการปรับใช้

ADK มีเครื่องมือประเมินผลเพื่อให้คุณสามารถให้คะแนนเอเจนต์เทียบกับเส้นทางและการตอบสนองที่คาดหวัง ไม่ใช่แค่การดูผลลัพธ์เท่านั้น ซึ่งสำคัญเพราะพฤติกรรมของเอเจนต์จะเปลี่ยนแปลงไปเมื่อคุณเปลี่ยนพร้อมท์ เครื่องมือ หรือโมเดล

สำหรับการปรับใช้ คุณมีเส้นทางที่จัดการได้และเส้นทางที่พกพาได้ Vertex AI Agent Engine มอบรันไทม์ที่จัดการได้เต็มรูปแบบและปรับขนาดได้ พร้อมโครงสร้างพื้นฐานที่จัดการให้คุณ หากคุณต้องการความยืดหยุ่นในการพกพามากกว่า ให้แพ็คเอเจนต์ลงในคอนเทนเนอร์แล้วส่งไปยัง Cloud Run หรือแพลตฟอร์มคอนเทนเนอร์ใดก็ได้

ตัวอย่างระดับสูง

นี่คือรูปแบบของการตั้งค่าเอเจนต์หลายตัวขนาดเล็ก ผู้ประสานงานจะมอบหมายงานให้ผู้เชี่ยวชาญสองคน

from google.adk.agents import Agent

flights = Agent(
    name="flight_agent",
    model="gemini-2.0-flash",
    instruction="Find flight options for the user's route and dates.",
    tools=[search_flights],   # your function wrapping a flights API
)

hotels = Agent(
    name="hotel_agent",
    model="gemini-2.0-flash",
    instruction="Find hotel options near the destination.",
    tools=[search_hotels],    # your function wrapping a hotels API
)

trip_planner = Agent(
    name="trip_planner",
    model="gemini-2.0-flash",
    instruction="Plan a trip. Delegate flight and hotel lookups to your sub-agents.",
    sub_agents=[flights, hotels],
)

ผู้ประสานงานจะให้เหตุผลเกี่ยวกับคำขอและส่งต่อไปยังซับเอเจนต์ที่เหมาะสม ซับเอเจนต์แต่ละตัวจะเรียกใช้ API จริงผ่านฟังก์ชันเครื่องมือของมัน คุณรันทั้งหมดผ่าน Runner หรือทดสอบแบบโต้ตอบด้วย adk web

ADK vs OpenAI Agents SDK

ทั้งสองเป็นเฟรมเวิร์กเอเจนต์ที่เน้นโค้ดเป็นหลัก พร้อมเครื่องมือ การส่งต่อ และการติดตาม ความแตกต่างอยู่ที่แรงโน้มถ่วงของระบบนิเวศ

	Google ADK	OpenAI Agents SDK
Default model	Gemini (Vertex AI)	OpenAI models
Other models	Vertex AI Model Garden, LiteLLM	LiteLLM and others
Languages	Python, Java, Go, TypeScript	Python, JavaScript/TypeScript
Multi-agent	Sub-agents plus Sequential, Parallel, Loop workflow agents	Agents-as-tools and handoffs
Managed runtime	Vertex AI Agent Engine	Bring your own
Tool protocol	MCP, built-in tools, function tools	MCP, function tools

หากสแต็กของคุณอยู่บน Google Cloud อยู่แล้ว ADK บวกกับ Vertex AI เป็นสิ่งที่เหมาะสมอย่างเป็นธรรมชาติ หากคุณเป็น OpenAI-first, OpenAI Agents SDK จะทำให้คุณอยู่ในเส้นทางนั้น ทั้งคู่พูด MCP ได้ ดังนั้นเซิร์ฟเวอร์เครื่องมือจึงสามารถใช้ร่วมกันได้

ควรใช้ ADK เมื่อใด

เลือกใช้ ADK เมื่อ:

คุณกำลังสร้างบน Google Cloud และต้องการ Gemini พร้อมรันไทม์ที่จัดการใน Vertex AI Agent Engine
คุณต้องการการจัดการเอเจนต์หลายตัวพร้อมการควบคุมแบบลำดับ แบบขนาน หรือแบบวนซ้ำที่ชัดเจน
คุณต้องการการประเมินผลที่สร้างขึ้นในเฟรมเวิร์ก แทนที่จะต้องมาเพิ่มทีหลัง
คุณคาดว่าจะสลับโมเดล และคุณต้องการ LiteLLM และ Vertex AI Model Garden เป็นทางออกสำรอง

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

Apidog เข้ามาช่วยตรงไหน: การทดสอบและจำลอง API ที่เอเจนต์ของคุณเรียกใช้

ADK จัดการเอเจนต์ของคุณ ไม่ได้ทดสอบ API ภายนอกที่เอเจนต์พึ่งพา และนั่นคือช่องว่างที่ควรปิดให้เร็วที่สุด

เครื่องมือที่มีความหมายทุกอย่างในเอเจนต์ของคุณเรียกใช้บางสิ่ง: จุดสิ้นสุด LLM, API การชำระเงิน, ไมโครเซอร์วิสภายใน, แหล่งข้อมูลบุคคลที่สาม เมื่อหนึ่งในนั้นส่งคืนข้อมูลที่ไม่คาดคิด เอเจนต์ของคุณจะให้เหตุผลกับข้อมูลอินพุตที่ไม่ถูกต้อง และความล้มเหลวก็ยากที่จะตรวจสอบ Apidog คือที่ที่คุณกำหนดสัญญาเหล่านั้นก่อนที่จะเกิดปัญหา พูดให้ชัดเจน: Apidog ไม่ใช่เฟรมเวิร์กเอเจนต์และไม่ได้มาแทนที่ ADK แต่มันอยู่หนึ่งเลเยอร์ด้านล่างบน API ที่เครื่องมือของคุณเข้าถึง

การใช้งานที่เป็นรูปธรรมบางประการในระหว่างการพัฒนา ADK:

จำลองจุดสิ้นสุดที่เครื่องมือของคุณเรียกใช้ ตั้งค่า mock API สำหรับ LLM หรือจุดสิ้นสุด REST ของเครื่องมือ เพื่อให้คุณสามารถพัฒนาและรันเอเจนต์ของคุณได้โดยไม่ต้องเสียโทเค็นหรือชนข้อจำกัดอัตรา คุณควบคุมการตอบสนอง รวมถึงกรณีข้อผิดพลาดที่เอเจนต์ของคุณต้องจัดการ
ยืนยันรูปแบบการตอบสนองของเครื่องมือ ใช้ การยืนยัน API เพื่อยืนยันว่าจุดสิ้นสุดของเครื่องมือส่งคืนฟิลด์ที่เอเจนต์ของคุณคาดหวังอย่างถูกต้อง หากสัญญาเปลี่ยนแปลงไป คุณจะจับได้ในการทดสอบ ไม่ใช่ในข้อความถอดเสียงเอเจนต์ที่สับสน
จัดการคีย์ต่อสภาพแวดล้อม เก็บ dev, staging และ production keys ไว้ใน Apidog environments เพื่อให้การเรียกใช้เครื่องมือเดียวกันทำงานได้อย่างราบรื่นในแต่ละขั้นตอน

หากคุณต้องการคำแนะนำเชิงลึกที่มุ่งเน้นไปที่เอเจนต์โดยเฉพาะ โปรดดูวิธี ทดสอบการเรียกใช้เครื่องมือของ AI เอเจนต์ ก่อนที่จะเกิดปัญหาในการใช้งานจริง คุณสามารถ ดาวน์โหลด Apidog และจำลองจุดสิ้นสุดเดียวได้ในเวลาไม่กี่นาที

คำถามที่พบบ่อย

Google ADK ฟรีและโอเพนซอร์สหรือไม่

ใช่. ADK เป็นโอเพนซอร์สภายใต้ Apache-licensed repository บน GitHub และคุณสามารถรันในเครื่องได้โดยไม่มีค่าใช้จ่าย คุณชำระเงินสำหรับโมเดลที่คุณเรียกใช้และสำหรับรันไทม์ที่จัดการใด ๆ ที่คุณปรับใช้ เช่น Vertex AI Agent Engine ตัวเฟรมเวิร์กเองนั้นฟรี

ADK ทำงานกับ Gemini เท่านั้นหรือไม่

ไม่ ADK ได้รับการปรับให้เหมาะสมกับ Gemini และ Vertex AI แต่เป็นแบบ model-agnostic ผ่าน Vertex AI Model Garden และ LiteLLM คุณสามารถเรียกใช้เอเจนต์บน Anthropic, Meta, Mistral และผู้ให้บริการอื่น ๆ Gemini เป็นค่าเริ่มต้น แต่ไม่ใช่ข้อกำหนด

ADK รองรับภาษาอะไรบ้าง

Python เป็นภาษาแรกและยังคงสมบูรณ์ที่สุด Google ได้เพิ่ม Java เข้ามาแล้ว โดยมี Go และ TypeScript ตามมา หากคุณต้องการความครอบคลุมฟีเจอร์ที่กว้างที่สุดในปัจจุบัน Python คือทางเลือกที่ปลอดภัยที่สุด

ฉันจะทดสอบ API ที่เอเจนต์ ADK ของฉันพึ่งพาได้อย่างไร

ทดสอบแยกต่างหากจากเอเจนต์ จำลองจุดสิ้นสุด LLM หรือเครื่องมือเพื่อให้เอเจนต์ของคุณทำงานได้โดยไม่ต้องเรียกใช้จริง และยืนยันว่าการตอบสนองแต่ละครั้งตรงกับที่เอเจนต์ของคุณคาดหวัง Apidog ครอบคลุมทั้งสองอย่าง และคู่มือเกี่ยวกับวิธี ทดสอบ ChatGPT API แสดงรูปแบบเดียวกันสำหรับจุดสิ้นสุด LLM ที่เครื่องมือของคุณอาจเรียกใช้

สรุป

Google ADK มอบวิธีที่สะอาดและมุ่งเน้นการใช้งานจริงในการสร้างเอเจนต์และระบบหลายเอเจนต์ โดยมี Gemini และ Vertex AI ใกล้แค่เอื้อม แต่โมเดลอื่น ๆ สามารถเปลี่ยนได้ง่าย เริ่มต้นด้วยเอเจนต์หนึ่งตัวและเครื่องมือสองสามชิ้น พึ่งพา adk web เพื่อดูการทำงาน แล้วขยายไปสู่ซับเอเจนต์และรันไทม์ที่จัดการตามความต้องการของงาน เมื่อเอเจนต์ของคุณพึ่งพา API ภายนอกมากขึ้น ให้ถือว่า API เหล่านั้นเป็นสิ่งที่คุณจำลองและยืนยัน นั่นคือเลเยอร์ที่ Apidog จัดการ และเป็นจุดที่พฤติกรรมเอเจนต์ที่ไม่แน่นอนมักจะเริ่มต้นขึ้น

button