1. บทนำ
ใน Codelab นี้ คุณจะได้สร้าง AI Agent ตัวแรกแบบทีละขั้นตอนโดยใช้ Agent Development Kit (ADK) และ Gemini ของ Google คุณจะสร้างเอเจนต์เขียนบล็อกพื้นฐานที่วางแผนและเขียนเนื้อหา ซึ่งแสดงแนวคิดหลักของการให้เหตุผลและการดำเนินการ
สิ่งที่คุณต้องทำ
- ตั้งค่าสภาพแวดล้อมในการพัฒนาซอฟต์แวร์สำหรับ ADK
- สร้างระบบแบบหลาย Agent ด้วย Planner และ Writer
- เรียกใช้ Agent ในเครื่องและโต้ตอบกับ Agent ผ่าน ADK Web UI
สิ่งที่คุณต้องมี
- เว็บเบราว์เซอร์ เช่น Chrome
- ติดตั้ง Python 3.10 ขึ้นไปในเครื่อง
- คีย์ API ของ Google AI Studio
Codelab นี้มีไว้สำหรับนักพัฒนาซอฟต์แวร์ทุกระดับ รวมถึงผู้เริ่มต้น
ระยะเวลาโดยประมาณ: 30 นาที
2. คำแนะนำแบบภาพ: เอเจนต์ AI คืออะไร
ก่อนที่เราจะเริ่มสร้าง มาทำความเข้าใจอย่างรวดเร็วกันก่อนว่าเอเจนต์ AI คืออะไรและมีรูปแบบทั่วไปอย่างไร
AI Agent คืออะไร
ในระดับที่ง่ายที่สุด เอเจนต์คือซอฟต์แวร์ที่ไม่เพียงตอบคำถาม แต่ยังตัดสินใจและดำเนินการได้ด้วย แทนที่จะสร้างคำตอบเดียวเหมือนแชทบอทแบบเดิมๆ มันจะดูคำขอของคุณ คิดว่าควรทำขั้นตอนใดบ้าง อาจเรียกใช้ API เรียกใช้โค้ด ดูผลลัพธ์ แล้วตัดสินใจว่าจะทำอะไรต่อไป
คำอธิบายที่ชัดเจนที่สุดอย่างหนึ่งมาจากเอกสารงานวิจัย ReAct: Synergizing Reasoning and Acting in Language Models แนวคิดในงานวิจัยนั้นเรียบง่ายแต่ทรงพลัง นั่นคือ โมเดลภาษาไม่ควรสร้างข้อความในคราวเดียว แต่ควรให้เหตุผลทีละขั้นตอน ดำเนินการ เช่น เรียกใช้เครื่องมือหรือ API สังเกตผลลัพธ์ แล้วตัดสินใจว่าจะทำอะไรต่อไป
วงจรการให้เหตุผล การดำเนินการ การสังเกต และการปรับเปลี่ยนนี้เป็นพื้นฐานของการทำงานของเอเจนต์ AI สมัยใหม่ และสอดคล้องกับวิธีที่ Google Cloud นิยามไว้ นั่นคือ ระบบที่มีการให้เหตุผล การวางแผน และหน่วยความจำ พร้อมด้วยความเป็นอิสระมากพอที่จะปรับตัวและตัดสินใจในนามของผู้ใช้
รูปแบบพฤติกรรมของเอเจนต์ 3 รูปแบบ
เอเจนต์แต่ละรายอาจมีพฤติกรรมแตกต่างกัน วิธีที่มีประโยชน์ในการพิจารณาการทำงานของโมเดลคือการแบ่งออกเป็น 3 รูปแบบกว้างๆ ดังนี้
- Agent แบบลำดับ: Agent เหล่านี้จะทำงานทีละขั้นตอนเหมือนสายการประกอบ นั่นคือ ขั้นตอนที่ 1 แล้วจึงเป็นขั้นตอนที่ 2 แล้วจึงเป็นขั้นตอนที่ 3 คาดเดาได้ แต่ก็ยืดหยุ่นไม่ได้
- เอเจนต์แบบรีแอ็กทีฟ: เอเจนต์เหล่านี้จะตัดสินใจในขณะนั้น โดยจะดูสถานะปัจจุบันและถามว่า "ฉันควรทำอะไรต่อไป" อาจใช้เครื่องมือ ก. ครั้งหนึ่ง และใช้เครื่องมือ ข. ในครั้งถัดไป เอเจนต์เหล่านี้มีความยืดหยุ่น แต่ไม่ได้วางแผนล่วงหน้า
- เอเจนต์แบบไตร่ตรองหรือวางแผน: เอเจนต์เหล่านี้จะหยุดชั่วคราวเพื่อร่างแผน แล้วจึงดำเนินการ ลองนึกถึงการจองการเดินทาง คุณไม่ได้ซื้อตั๋วเครื่องบินแบบสุ่ม แต่จะเลือกวันที่ โรงแรม จัดลำดับขั้นตอน แล้วทำตามขั้นตอนนั้น
แล้วตัวไหนคือตัวที่ "ใช่" คำตอบขึ้นอยู่กับปัญหา สำหรับโฟลว์ที่เรียบง่ายและคาดการณ์ได้ การใช้แบบลำดับก็ใช้ได้ แต่สำหรับงานแบบไดนามิก การใช้แบบรีแอกทีฟจะดีกว่า สำหรับเป้าหมายแบบหลายขั้นตอนที่มีการขึ้นต่อกัน คุณควรใช้เอเจนต์การวางแผน
ในห้องทดลองนี้ เราจะสร้างเอเจนต์ไตร่ตรอง/วางแผนที่สร้างโครงร่างก่อน แล้วจึงเขียนบล็อกโพสต์
3. ก่อนเริ่มต้น
สร้างบัญชีและโปรเจ็กต์ Google Cloud
หากต้องการติดตั้งใช้งาน Agent ใน Google Cloud Run ในภายหลังในแล็บนี้ คุณต้องมีบัญชี Google Cloud และโปรเจ็กต์ที่เปิดใช้การเรียกเก็บเงิน
- ลงชื่อเข้าใช้ คอนโซล Google Cloud สร้างโปรเจ็กต์ใหม่หรือนำโปรเจ็กต์ที่มีอยู่มาใช้ซ้ำ หากยังไม่มีบัญชี Google คุณต้องสร้างบัญชี
- จากนั้นคุณจะต้องเปิดใช้การเรียกเก็บเงินใน Cloud Console เพื่อใช้ทรัพยากรระบบคลาวด์ การทำตาม Codelab นี้ควรมีค่าใช้จ่ายไม่กี่เซ็นต์ ผู้ใช้ Google Cloud รายใหม่ยังอาจมีสิทธิ์เข้าร่วมโปรแกรมรุ่นทดลองใช้ฟรี$300 USD ด้วย
- จดรหัสโปรเจ็กต์ (ชื่อที่ไม่ซ้ำกันในโปรเจ็กต์ Google Cloud ทั้งหมด) คุณจะต้องใช้ข้อมูลนี้เพื่อกำหนดค่าและติดตั้งใช้งานเอเจนต์
รับคีย์ API ของ Google AI Studio
หากต้องการใช้โมเดล Gemini คุณต้องมีคีย์ API จาก Google AI Studio
- ไปที่ Google AI Studio
- คลิกรับคีย์ API
- สร้างคีย์ใหม่หรือใช้คีย์ที่มีอยู่ คัดลอกคีย์เพื่อใช้ในภายหลัง
4. สร้างโครงสร้างโปรเจ็กต์ของ Agent เขียนบล็อก
ในขั้นตอนนี้ คุณจะตั้งค่าไดเรกทอรีและไฟล์เพื่อจัดเก็บโค้ดของเอเจนต์เขียนบล็อกในเครื่อง
1. สร้างพื้นที่ทำงานของ Agent เขียนบล็อก
เปิดเทอร์มินัลแล้วเรียกใช้คำสั่งต่อไปนี้เพื่อสร้างไดเรกทอรีเฉพาะสำหรับเอเจนต์เขียนบล็อกและไปยังไดเรกทอรีนั้น
mkdir bloggeragent
cd bloggeragent
2. เริ่มต้นไฟล์ Agent
เฟรมเวิร์ก Google ADK จะโหลดเวิร์กโฟลว์ของเอเจนต์จากไดเรกทอรีโปรเจ็กต์โดยตรง สร้างไฟล์ที่จำเป็นในรูทของ bloggeragent โดยตรง
touch requirements.txt .env __init__.py agent.py
5. ติดตั้งการอ้างอิงและตั้งค่าสภาพแวดล้อม
ในขั้นตอนนี้ คุณจะตั้งค่าสภาพแวดล้อมเสมือนของ Python, ติดตั้งเฟรมเวิร์ก Google ADK และกำหนดค่าตัวแปรสภาพแวดล้อมเพื่อตรวจสอบสิทธิ์เอเจนต์บล็อกด้วยโมเดล Gemini
1. กำหนดค่าข้อกำหนดของ Agent
เปิดไฟล์ requirements.txt ในไดเรกทอรี bloggeragent แล้วระบุแพ็กเกจที่จำเป็นสำหรับเอเจนต์เขียนบล็อกโดยเพิ่มข้อมูลต่อไปนี้ลงในไฟล์
google-adk==2.2.0
python-dotenv
2. สร้างสภาพแวดล้อมเสมือนสำหรับ Agent
จากไดเรกทอรี bloggeragent ให้สร้างและเปิดใช้งานสภาพแวดล้อมเสมือนของ Python เพื่อแยกแพ็กเกจของเอเจนต์
python3 -m venv .venv
source .venv/bin/activate
3. ติดตั้งเฟรมเวิร์ก ADK
ติดตั้งการอ้างอิงที่กำหนดไว้ใน requirements.txt เพื่อติดตั้ง Google ADK ในพื้นที่ทำงานของคุณ
pip install -r requirements.txt
4. กำหนดค่าข้อมูลเข้าสู่ระบบ API ของตัวแทน
เปิด.envไฟล์ที่คุณสร้างในรูทของโปรเจ็กต์ แล้วเพิ่มคีย์ Gemini API ดังนี้
GOOGLE_API_KEY=your_api_key
แทนที่ your_api_key ด้วยคีย์ที่คุณคัดลอกจาก Google AI Studio
6. สร้างโปรแกรมเขียนบล็อกแบบ Multi-Agent
ในขั้นตอนนี้ คุณจะใช้เวิร์กโฟลว์หลักของระบบเอเจนต์เขียนบล็อก
แทนที่จะใช้แชทบอทแบบพรอมต์เดียวอย่างง่าย คุณจะสร้างระบบแบบหลายเอเจนต์ที่ซับซ้อนซึ่งใช้ลูปการแก้ไขตัวเองและการยืนยันโครงร่างเพื่อเขียนโพสต์ทางเทคนิคคุณภาพสูง ซึ่งเป็นไปตามรูปแบบการพิจารณา/การวางแผนที่เราพูดถึงก่อนหน้านี้
ภาพรวมของสถาปัตยกรรม
ตัวแทนผู้เชี่ยวชาญในระบบของคุณจะโต้ตอบกันดังนี้
กำหนดค่า init.py
เปิด __init__.py ในโปรแกรมแก้ไขข้อความ แล้วเพิ่มการนำเข้าต่อไปนี้เพื่อแสดงเวิร์กโฟลว์ของเอเจนต์ต่อโปรแกรมเรียกใช้
from . import agent
เขียนเวิร์กโฟลว์ของ Agent สำหรับการเขียนบล็อก
เปิด agent.py ในตัวแก้ไขโค้ด แล้วเพิ่มโค้ดต่อไปนี้ซึ่งกำหนด Planner, Writer, Validation Checkers และตัวแทน Blogger หลัก
import os
import sys
from pathlib import Path
import datetime
from dotenv import load_dotenv
from google.adk.agents import Agent, LoopAgent
from google.adk.tools import agent_tool
# env config
load_dotenv()
MODEL = os.getenv("MODEL", "gemini-flash-latest")
# Sub-Agent: Planner
blog_planner = Agent(
name="BlogPlanner",
model=MODEL,
description="Creates a practical, skimmable outline in Markdown.",
instruction="""
You are a technical content strategist. Produce a clear Markdown outline with:
- Title
- Short intro
- 4–6 main sections (each with 2–3 bullets)
- Conclusion
If `codebase_context` exists in state, weave in specific sections/snippets.
Return only the outline in Markdown.
""",
output_key="blog_outline",
)
class OutlineValidationChecker(Agent):
def __init__(self):
super().__init__(
name="OutlineValidationChecker",
model=MODEL,
description="Validates that the outline is usable.",
instruction="""
Check the outline in state `blog_outline`. If it has a title, intro, 4–6 sections, and a conclusion, respond exactly "ok".
Otherwise respond exactly "retry" and list missing pieces.
""",
output_key="validation_result",
)
robust_blog_planner = LoopAgent(
name="RobustBlogPlanner",
description="Retries planning if validation fails.",
sub_agents=[blog_planner, OutlineValidationChecker()],
max_iterations=3,
)
# Sub-Agent: Writer
blog_writer = Agent(
name="BlogWriter",
model=MODEL,
description="Writes a technical blog post from the outline.",
instruction="""
Write a complete Markdown article from the outline in `blog_outline`.
Guidelines:
- Audience: software engineers; skip basics and focus on practical insight.
- Explain both the 'how' and 'why'.
- Include concise code snippets when helpful.
- Follow the outline's structure (H2/H3).
- Output only the final article in Markdown (no fence around the whole post).
""",
output_key="blog_post",
)
class BlogPostValidationChecker(Agent):
def __init__(self):
super().__init__(
name="BlogPostValidationChecker",
model=MODEL,
description="Validates the final post.",
instruction="""
Check `blog_post` for: intro, clear sections matching the outline, conclusion, and technical clarity.
If passes, respond "ok". Else respond "retry" with the specific fixes.
""",
output_key="validation_result",
)
robust_blog_writer = LoopAgent(
name="RobustBlogWriter",
description="Retries writing if validation fails.",
sub_agents=[blog_writer, BlogPostValidationChecker()],
max_iterations=3,
)
# Expose planner/writer as tools so the root agent can call them explicitly
planner_tool = agent_tool.AgentTool(agent=robust_blog_planner)
writer_tool = agent_tool.AgentTool(agent=robust_blog_writer)
# Root Agent: Plan → Write
root_agent = Agent(
name="Blogger",
model=MODEL,
description="Minimal multi-agent blogger that plans and writes.",
instruction=f"""
If the user gives a topic:
1) Call the planner tool to generate the outline.
2) Call the writer tool to produce the full draft.
3) End with 3 alternate titles and 2 tweet-length hooks.
Date: {datetime.datetime.now().strftime("%Y-%m-%d")}
""",
tools=[
planner_tool, # calls RobustBlogPlanner
writer_tool, # calls RobustBlogWriter
],
)
ทําความเข้าใจสถาปัตยกรรมของเอเจนต์
มาดูองค์ประกอบหลักของโค้ดที่คุณเพิ่งเพิ่มใน agent.py เพื่อทำความเข้าใจวิธีที่โค้ดใช้เวิร์กโฟลว์การวางแผนและการเขียนแบบหลายเอเจนต์กัน
1. The BlogPlanner Sub-Agent
blog_plannerเอเจนต์มีหน้าที่รับผิดชอบในการวางแผนเนื้อหา โดยจะใช้หัวข้อที่ผู้ใช้ระบุและสร้างโครงร่างที่มีโครงสร้างในรูปแบบมาร์กดาวน์ (มีชื่อ เรื่อง บทนำ 4-6 ส่วน และบทสรุป) จากนั้นจะบันทึกโครงร่างลงในพจนานุกรมสถานะที่แชร์ภายใต้คีย์ "blog_outline"
2. The OutlineValidationChecker
OutlineValidationCheckerเอเจนต์ทำหน้าที่เป็นเกณฑ์คุณภาพ โดยจะตรวจสอบ"blog_outline"ที่สร้างขึ้นในรัฐ หากโครงร่างถูกต้อง ระบบจะตอบกลับด้วย "ok" ไม่เช่นนั้น ระบบจะแสดง "retry" พร้อมกับรายการสิ่งที่ขาดหายไป
3. วงจร RobustBlogPlanner
เราจะห่อหุ้มเครื่องมือวางแผนและเครื่องมือตรวจสอบความถูกต้องไว้ภายใน LoopAgent ที่เรียกว่า robust_blog_planner เพื่อป้องกันไม่ให้เอเจนต์สร้างโครงร่างที่ไม่ดี หากการตรวจสอบไม่สำเร็จและแสดงผล "retry" ลูปจะเรียกใช้เครื่องวางแผนอีกครั้งโดยอัตโนมัติสูงสุด 3 ครั้ง เพื่อให้มั่นใจว่ามีการแก้ไขด้วยตนเองก่อนที่จะไปยังขั้นตอนถัดไป
4. The BlogWriter Sub-Agent
เมื่อสรุปโครงร่างแล้ว blog_writerเอเจนต์จะอ่าน "blog_outline" จากสถานะและสร้างบทความทางเทคนิคฉบับเต็มในรูปแบบ Markdown โดยให้ตรงกับโครงสร้างของโครงร่างและปรับให้เหมาะกับวิศวกรซอฟต์แวร์
5. BlogPostValidationChecker & RobustBlogWriter Loop
เช่นเดียวกับโครงร่าง บทความสุดท้ายจะได้รับการตรวจสอบโดย BlogPostValidationChecker เพื่อให้แน่ใจว่ามีส่วนสำคัญทั้งหมดและชัดเจน ผู้เขียนและผู้ตรวจสอบจะอยู่ในลูป robust_blog_writer ซึ่งช่วยให้แก้ไขตัวเองได้สูงสุด 3 ครั้งหากผู้ตรวจสอบพบปัญหา
6. การแสดงลูปเป็นเครื่องมือ
เราจะรวมลูปของเครื่องมือวางแผน (robust_blog_planner) และลูปของนักเขียน (robust_blog_writer) เป็นเครื่องมือ (planner_tool และ writer_tool) โดยใช้ AgentTool ซึ่งช่วยให้ตัวแทนคนอื่นๆ สามารถเรียกใช้เวิร์กโฟลว์ที่ซับซ้อนเหล่านี้ได้ราวกับเป็นเครื่องมือที่ใช้งานง่าย
7. Agent รูทของ Blogger
root_agent (ชื่อ Blogger) จะจัดระเบียบเวิร์กโฟลว์ทั้งหมด เมื่อได้รับหัวข้อ คำสั่งจะนำทางให้โมเดลทำสิ่งต่อไปนี้
- เรียกใช้
planner_toolเพื่อสร้างโครงร่างที่ตรวจสอบแล้ว - เรียกใช้
writer_toolเพื่อเขียนฉบับร่างตามโครงร่างนั้น - ปิดท้ายด้วยการสร้างชื่ออื่น 3 รายการและทวีตฮุก 2 รายการ
สถาปัตยกรรมลูปแบบหลายเอเจนต์นี้ช่วยให้มั่นใจได้ถึงความน่าเชื่อถือด้วยการตรวจจับและแก้ไขข้อผิดพลาดในการจัดรูปแบบหรือโครงสร้างของ LLM ก่อนที่จะแสดงเอาต์พุตต่อผู้ใช้
7. เรียกใช้และทดสอบเอเจนต์
ตอนนี้ก็ถึงเวลาดู Agent ของคุณทำงานแล้ว
1. เริ่ม UI บนเว็บของ ADK
ตรวจสอบว่าคุณอยู่ในbloggeragentรูทไดเรกทอรีของโปรเจ็กต์ในเทอร์มินัลและสภาพแวดล้อมเสมือนใช้งานอยู่ (source .venv/bin/activate) จากนั้นเริ่มอินเทอร์เฟซเว็บ
adk web
2. โต้ตอบกับ Agent
- เปิดเบราว์เซอร์ แล้วไปที่
http://127.0.0.1:8000(หรือพอร์ตที่คุณระบุ) - คุณควรเห็น ADK Web UI ที่มี
BloggerAgent โหลดอยู่และเลย์เอาต์ภาพ (แสดง Agent รูทของ Blogger ที่ชี้ไปยังเครื่องมือ RobustBlogPlanner และ RobustBlogWriter)
- พิมพ์หัวข้อทางเทคนิคในกล่องข้อความ แล้วกด Enter ตัวอย่างพรอมต์ทดสอบที่น่าสนใจซึ่งคุณใช้เพื่อประเมินเอเจนต์ได้มีดังนี้
How to build an AI agent using planning loopsExplain the difference between REST and gRPC in microservicesA guide to using Python's asyncio for backend concurrencyWhy developers should use Docker for local database setups
- ดูการติดตามการดำเนินการใน UI คุณจะเห็นว่า
BlogPlannerสร้างโครงร่างOutlineValidationCheckerตรวจสอบความถูกต้อง และBlogWriterเขียนฉบับร่างสุดท้ายตามโครงร่าง
8. ทำให้ใช้งานได้กับ Cloud Run
ตอนนี้คุณได้ยืนยันแล้วว่าเอเจนต์ทำงานในเครื่องได้แล้ว มาทำให้ใช้งานได้ใน Google Cloud Run เพื่อให้ผู้อื่นใช้ได้กันเลย
Google Cloud Run เป็นแพลตฟอร์มคำนวณที่มีการจัดการซึ่งทำให้คุณเรียกใช้คอนเทนเนอร์แบบไม่เก็บสถานะที่เรียกใช้ผ่านคำขอเว็บหรือเหตุการณ์ Pub/Sub ได้
1. ข้อกำหนดเบื้องต้นสำหรับการติดตั้งใช้งาน
หากต้องการติดตั้งใช้งานเอเจนต์เขียนบล็อกใน Cloud Run คุณจะต้องติดตั้งและตรวจสอบสิทธิ์ Google Cloud CLI (gcloud) ในเครื่องของคุณ
- ติดตั้ง Google Cloud CLI: หากยังไม่ได้ติดตั้ง ให้ทำตามคู่มือการติดตั้ง Google Cloud CLI สำหรับระบบปฏิบัติการของคุณ (macOS, Windows หรือ Linux)
- ตรวจสอบสิทธิ์เทอร์มินัลในเครื่อง: เมื่อติดตั้งแล้ว ให้เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อเข้าสู่ระบบบัญชี Google Cloud
gcloud auth login - ยืนยันการตรวจสอบสิทธิ์: ยืนยันว่าคุณเข้าสู่ระบบบัญชีเรียบร้อยแล้วและเข้าถึงทรัพยากร Google Cloud ได้โดยทำดังนี้
gcloud auth list
2. ตั้งค่าโปรเจ็กต์ Google Cloud
ตั้งค่าโปรเจ็กต์ที่ใช้งานอยู่ในเทอร์มินัล
gcloud config set project <YOUR_PROJECT_ID>
เปิดใช้บริการ Google Cloud ที่จำเป็นต่อการสร้างและติดตั้งใช้งานเอเจนต์ที่ทำงานในคอนเทนเนอร์
gcloud services enable \
run.googleapis.com \
artifactregistry.googleapis.com \
cloudbuild.googleapis.com
เนื่องจากคำสั่งการทำให้ ADK ใช้งานได้ใช้ Google Cloud Build เพื่อทำให้กระบวนการบิลด์เป็นอัตโนมัติ คุณจึงต้องให้สิทธิ์บัญชีบริการ Compute เริ่มต้นในการใช้ Cloud Build
ค้นหาหมายเลขโปรเจ็กต์โดยเรียกใช้คำสั่งต่อไปนี้
gcloud projects describe <YOUR_PROJECT_ID> --format="value(projectNumber)"
เรียกใช้คำสั่งต่อไปนี้เพื่อเชื่อมโยงบทบาท IAM ที่จำเป็น (แทนที่
- ให้สิทธิ์ Cloud Build ในการสร้างคอนเทนเนอร์
gcloud projects add-iam-policy-binding <YOUR_PROJECT_ID> \
--member="serviceAccount:<PROJECT_NUMBER>-compute@developer.gserviceaccount.com" \
--role="roles/cloudbuild.builds.builder"
- ให้สิทธิ์เข้าถึง Gemini Enterprise เพื่อให้ Agent ที่ติดตั้งใช้งานเรียกใช้โมเดล Gemini ได้โดยไม่ต้องใช้คีย์ API โดยทำดังนี้
gcloud projects add-iam-policy-binding <YOUR_PROJECT_ID> \
--member="serviceAccount:<PROJECT_NUMBER>-compute@developer.gserviceaccount.com" \
--role="roles/aiplatform.user"
3. ตั้งค่าตัวแปรสภาพแวดล้อมในเครื่อง
หากต้องการลดความซับซ้อนของคำสั่งการทำให้ใช้งานได้และป้องกันการพิมพ์ผิด ให้ตั้งค่ารหัสโปรเจ็กต์เป็นตัวแปรสภาพแวดล้อมในเซสชันเทอร์มินัล
export PROJECT_ID="<YOUR_PROJECT_ID>"
4. ทำให้ใช้งานได้โดยใช้ ADK CLI
ADK CLI มีคำสั่งที่ปรับปรุงแล้วเพื่อติดตั้งใช้งาน Agent ใน Cloud Run
ตรวจสอบว่าสภาพแวดล้อมเสมือนใช้งานอยู่และคุณอยู่ในไดเรกทอรีโปรเจ็กต์ bloggeragent จากนั้นเรียกใช้คำสั่งการติดตั้งใช้งาน
# Deploy using ADK
adk deploy cloud_run \
--project=$PROJECT_ID \
--region=us-east1 \
--service_name=bloggeragent \
--with_ui \
. \
-- \
--set-env-vars GOOGLE_GENAI_USE_VERTEXAI=TRUE,MODEL=gemini-3.5-flash,GOOGLE_CLOUD_LOCATION=global
ในระหว่างกระบวนการติดตั้งใช้งาน ระบบจะแจ้งให้คุณตอบคำถาม 2 ข้อต่อไปนี้ในเทอร์มินัล
- ยืนยันการสร้างที่เก็บ
Deploying from source requires an Artifact Registry Docker repository to store built containers. A repository named [cloud-run-source-deploy] in region [us-east1] will be created. Do you want to continue (Y/n)?
Yแล้วกด Enter - อนุญาตการเข้าถึงที่ไม่ผ่านการตรวจสอบสิทธิ์:
Allow unauthenticated invocations to [bloggeragent] (y/N)?
yแล้วกด Enter (การดำเนินการนี้จะช่วยให้คุณเข้าถึง ADK Web UI แบบสาธารณะในเบราว์เซอร์ได้)
5. เข้าถึง Agent ที่ติดตั้งใช้งาน
เมื่อการติดตั้งใช้งานเสร็จสมบูรณ์แล้ว คำสั่งจะแสดง URL เปิด URL นั้นในเบราว์เซอร์เพื่อเข้าถึง ADK Web UI ที่ใช้งานจริงและเข้าถึงได้แบบสาธารณะ
9. ล้างข้อมูล
โปรดลบทรัพยากรที่สร้างขึ้นระหว่างการทำ Codelab นี้เพื่อหลีกเลี่ยงการเรียกเก็บเงินอย่างต่อเนื่องกับบัญชี Google Cloud
1. ลบบริการ Cloud Run
ลบบริการ bloggeragent ที่ติดตั้งใช้งานแล้ว
gcloud run services delete bloggeragent --region=us-east1 --quiet
2. ลบที่เก็บ Artifact Registry
ลบที่เก็บ Docker ที่สร้างขึ้นเพื่อจัดเก็บอิมเมจคอนเทนเนอร์ที่สร้างแล้ว
gcloud artifacts repositories delete cloud-run-source-deploy --location=us-east1 --quiet
3. หยุดเซิร์ฟเวอร์ภายใน
หากต้องการหยุดเซิร์ฟเวอร์ ADK ในเครื่อง ให้กด CTRL+C ในเทอร์มินัลที่เซิร์ฟเวอร์ทำงานอยู่ แล้วปิดใช้งานสภาพแวดล้อมเสมือน
deactivate
10. ขอแสดงความยินดี
ยินดีด้วย คุณได้สร้าง AI Agent ตัวแรกโดยใช้ ADK ของ Google และ Gemini
สิ่งที่คุณได้เรียนรู้
- แนวคิดหลักของเอเจนต์ AI (การให้เหตุผลและการดำเนินการ)
- วิธีใช้ Google ADK เพื่อสร้างระบบแบบหลาย Agent
- วิธีเรียกใช้และทดสอบเอเจนต์โดยใช้เว็บ UI
ขั้นตอนถัดไป
- ลองเพิ่มเครื่องมือลงในเอเจนต์ (เช่น การค้นหาเว็บหรือการเรียก API)
- โปรดติดตามวิดีโอที่ 2 ซึ่งเราจะผสานรวมเซิร์ฟเวอร์ MCP