สร้างระบบแบบหลาย Agent ด้วย ADK, ติดตั้งใช้งานใน Agent Runtime และเริ่มต้นใช้งานโปรโตคอล A2A

1. วัตถุประสงค์ของห้องทดลองนี้

ในแล็บเชิงปฏิบัตินี้ คุณจะได้สร้างแอปพลิเคชันแบบหลายเอเจนต์ โดยใช้ ADK (Agent Development Kit) ที่สร้างรูปภาพตามพรอมต์ของคุณและประเมินรูปภาพนั้นเทียบกับพรอมต์ของคุณ หากรูปภาพไม่เป็นไปตามข้อกำหนดที่อธิบายไว้ในพรอมต์อย่างน่าพอใจ เอเจนต์จะสร้างรูปภาพต่อไปเรื่อยๆ จนกว่าจะสร้างรูปภาพที่เป็นไปตามข้อกำหนดของคุณ เอเจนต์แต่ละตัวในแบบฝึกหัดนี้มีจุดประสงค์เดียว และเอเจนต์จะทำงานร่วมกันเพื่อให้บรรลุเป้าหมายโดยรวม คุณจะได้เรียนรู้วิธีทดสอบแอปพลิเคชันในเครื่องและทำให้ใช้งานได้ใน Agent Runtime

สิ่งที่คุณจะได้เรียนรู้

• ทำความเข้าใจพื้นฐานของ ADK (Agent Development Kit) และดูวิธีสร้างระบบแบบหลาย Agent
• ดูวิธีติดตั้งใช้งานและใช้ Agent ใน Agent Runtime ได้อย่างง่ายดาย
• ทำความเข้าใจพื้นฐานของโปรโตคอล A2A
• ดูวิธีใช้ A2A Protocol และ ADK (Agent Development Kit) ร่วมกันเพื่อสร้าง Open Agent

2. การตั้งค่าโปรเจ็กต์

คุณรับเครดิต Google Cloud เพื่อเรียกใช้ Lab นี้ได้ คลิกที่นี่เพื่อรับเครดิต โปรดดูที่นี่เพื่อตรวจสอบวิธีอ้างสิทธิ์รับเครดิต Google Cloud

• หากยังไม่มีโปรเจ็กต์ที่ใช้ได้ คุณจะต้องสร้างโปรเจ็กต์ใหม่ในคอนโซล GCP
• ใน Lab นี้ เราจะใช้ GCP Cloud Shell เพื่อทำงาน เปิด Cloud Shell แล้วตั้งค่าโปรเจ็กต์โดยใช้ Cloud Shell
• เปิด GCP Cloud Shell โดยคลิกที่นี่ Cloud Shell หากเห็นป๊อปอัป "ให้สิทธิ์ Shell" ให้คลิกเพื่อให้สิทธิ์ Cloud Shell Editor
• คุณตรวจสอบได้ว่าโปรเจ็กต์ได้รับการตรวจสอบสิทธิ์แล้วหรือไม่โดยใช้คำสั่งต่อไปนี้ในเทอร์มินัล Cloud Shell

gcloud auth list

• เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell เพื่อยืนยันโปรเจ็กต์

gcloud config list project

• คัดลอกรหัสโปรเจ็กต์และใช้คำสั่งต่อไปนี้เพื่อตั้งค่า

gcloud config set project <YOUR_PROJECT_ID>

• หากจำรหัสโปรเจ็กต์ไม่ได้ คุณสามารถแสดงรหัสโปรเจ็กต์ทั้งหมดได้โดยใช้คำสั่งต่อไปนี้

gcloud projects list

3. เปิดใช้ API

เราต้องเปิดใช้บริการ API บางอย่างเพื่อเรียกใช้แล็บนี้ เรียกใช้คำสั่งต่อไปนี้ใน Cloud Shell

gcloud services enable aiplatform.googleapis.com
gcloud services enable cloudresourcemanager.googleapis.com

ขอแนะนำ API

• API แพลตฟอร์ม Agent ของ Gemini Enterprise (aiplatform.googleapis.com) ช่วยให้เข้าถึงแพลตฟอร์ม Agent ของ Gemini Enterprise ได้ ซึ่งจะช่วยให้แอปพลิเคชันของคุณโต้ตอบกับโมเดล Gemini เพื่อการสร้างข้อความ เซสชันแชท และการเรียกใช้ฟังก์ชันได้
• Cloud Resource Manager API (cloudresourcemanager.googleapis.com) ช่วยให้คุณจัดการข้อมูลเมตาสำหรับโปรเจ็กต์ Google Cloud แบบเป็นโปรแกรมได้ เช่น รหัสและชื่อโปรเจ็กต์ ซึ่งมักจะต้องใช้ในเครื่องมือและ SDK อื่นๆ เพื่อยืนยันข้อมูลประจำตัวและสิทธิ์ของโปรเจ็กต์

4. ข้อมูลเบื้องต้นเกี่ยวกับ Agent Development Kit

Agent Development Kit มีข้อดีหลักๆ หลายประการสำหรับนักพัฒนาแอปที่สร้างแอปพลิเคชันแบบเอเจนต์

1. ระบบ Multi-Agent: สร้างแอปพลิเคชันแบบแยกส่วนและรองรับการปรับขนาดได้โดยการรวม Agent ที่เชี่ยวชาญหลายรายไว้ในลำดับชั้น เปิดใช้การประสานงานและการมอบหมายที่ซับซ้อน
2. ระบบนิเวศของเครื่องมือที่หลากหลาย: ติดตั้งความสามารถที่หลากหลายให้กับ Agent: ใช้เครื่องมือที่สร้างไว้ล่วงหน้า (ค้นหา, การดำเนินการโค้ด ฯลฯ) สร้างฟังก์ชันที่กำหนดเอง ผสานรวมเครื่องมือจากเฟรมเวิร์ก Agent ของบุคคลที่สาม (LangChain, CrewAI) หรือแม้แต่ใช้ Agent อื่นๆ เป็นเครื่องมือ
3. การจัดการเป็นกลุ่มที่ยืดหยุ่น: กำหนดเวิร์กโฟลว์โดยใช้ Agent เวิร์กโฟลว์ (SequentialAgent, ParallelAgent และ LoopAgent) สำหรับไปป์ไลน์ที่คาดการณ์ได้ หรือใช้ประโยชน์จากการกำหนดเส้นทางแบบไดนามิกที่ขับเคลื่อนด้วย LLM (การโอน LlmAgent) เพื่อให้มีลักษณะการทำงานที่ปรับเปลี่ยนได้
4. ประสบการณ์ของนักพัฒนาซอฟต์แวร์แบบบูรณาการ: พัฒนา ทดสอบ และแก้ไขข้อบกพร่องในเครื่องด้วย CLI ที่มีประสิทธิภาพและ UI สำหรับนักพัฒนาซอฟต์แวร์แบบอินเทอร์แอกทีฟ ตรวจสอบเหตุการณ์ สถานะ และขั้นตอนการดำเนินการของ Agent ทีละขั้นตอน
5. การประเมินในตัว: ประเมินประสิทธิภาพของเอเจนต์อย่างเป็นระบบโดยการประเมินทั้งคุณภาพของคำตอบสุดท้ายและเส้นทางการดำเนินการแบบทีละขั้นตอนเทียบกับกรณีทดสอบที่กำหนดไว้ล่วงหน้า
6. พร้อมใช้งาน: สร้างคอนเทนเนอร์และติดตั้งใช้งาน Agent ได้ทุกที่ ไม่ว่าจะเรียกใช้ในเครื่อง ปรับขนาดด้วย Agent Runtime หรือผสานรวมเข้ากับโครงสร้างพื้นฐานที่กำหนดเองโดยใช้ Cloud Run หรือ Docker

แม้ว่า SDK หรือเฟรมเวิร์กเอเจนต์ Gen AI อื่นๆ จะช่วยให้คุณค้นหาโมเดลและแม้กระทั่งเพิ่มประสิทธิภาพด้วยเครื่องมือต่างๆ ได้ แต่การประสานงานแบบไดนามิกระหว่างโมเดลหลายๆ โมเดลนั้นต้องใช้ความพยายามอย่างมากในฝั่งของคุณ

Agent Development Kit มีเฟรมเวิร์กระดับสูงกว่าเครื่องมือเหล่านี้ ซึ่งช่วยให้คุณเชื่อมต่อ Agent หลายตัวเข้าด้วยกันได้อย่างง่ายดายเพื่อเวิร์กโฟลว์ที่ซับซ้อนแต่ดูแลรักษาง่าย

รูปที่ 1: ตำแหน่งของ ADK (Agent Development Kit)

5. ข้อมูลเบื้องต้นเกี่ยวกับ Agent Runtime

Agent Runtime เป็นบริการที่มีการจัดการครบวงจรสำหรับการติดตั้งใช้งาน Agent ใน Google Cloud Agent Runtime ช่วยให้นักพัฒนาซอฟต์แวร์สามารถพัฒนา ปรับแต่ง ติดตั้งใช้งาน ให้บริการ และจัดการเอเจนต์ AI แบบโอเพนซอร์ส( ADK (Agent Development Kit) , LangChain, LangGraph, CrewAI, AutoGen และอื่นๆ) ใน Gemini Enterprise Agent Platform

นอกจากนี้ รันไทม์ของเอเจนต์ยังมีบริการจัดการข้อมูลผู้ใช้หรือที่เรียกว่าหน่วยความจำของเอเจนต์ด้วย ปัจจุบันมีบริการหน่วยความจำ 2 ประเภท

• หน่วยความจำระยะสั้น: เซสชันของเครื่องมือ Agent ช่วยให้คุณจัดเก็บ จัดการ และดึงประวัติการสนทนาที่กำลังดำเนินอยู่ (สถานะ) ภายในเซสชันเดียวเป็นหน่วยความจำระยะสั้นได้
• ความจำระยะยาว: Agent Engine Memory Bank ช่วยจัดเก็บ เปลี่ยนรูป และดึงความทรงจำ (สถานะ) โดยเฉพาะอย่างยิ่งในหลายๆ เซสชันเป็นความจำระยะยาว

คุณยังติดตั้งใช้งานเอเจนต์ในบริการอื่นๆ ของ Google Cloud เช่น Cloud Run หรือ GKE ได้ด้วย โดยควรพิจารณาใช้รันไทม์ของเอเจนต์สำหรับกรณีการใช้งานต่อไปนี้

• รันไทม์ที่มีการจัดการแบบมีสถานะ: หากต้องการรันไทม์ที่มีการจัดการแบบมีสถานะและมีการจัดการอย่างเต็มรูปแบบสำหรับการติดตั้งใช้งานเอเจนต์ Agent Runtime เป็นตัวเลือกที่ดีเนื่องจากจะแยกงานทั่วไป เช่น การจัดการเซสชัน ความคงทนสำหรับเอเจนต์ AI ออกไป
• การเรียกใช้โค้ด: หาก Agent ต้องเรียกใช้โค้ดที่สร้างขึ้นแบบไดนามิกระหว่างเซสชันของผู้ใช้ รันไทม์ของ Agent จะมีแซนด์บ็อกซ์ที่ปลอดภัยซึ่งคุณสามารถเรียกใช้โค้ดได้
• หน่วยความจำระยะยาวที่ยืดหยุ่น: หากต้องการหน่วยความจำระยะยาวที่ยืดหยุ่นสำหรับเอเจนต์ของคุณ Gemini Enterprise Agent Platform Memory Bank ซึ่งใช้กับ Agent Runtime ได้จะช่วยให้คุณจดจำข้อมูลเกี่ยวกับผู้ใช้ที่ใช้ได้ในเซสชันต่างๆ ได้อย่างยืดหยุ่น

นอกจากนี้ คุณยังรวม Agent Runtime กับรันไทม์อื่นๆ เช่น Cloud Run เพื่อสร้างสถาปัตยกรรมแอปพลิเคชันที่ยืดหยุ่นได้ด้วย ด้านล่างนี้คือตัวอย่างสถาปัตยกรรมอ้างอิงที่ใช้บริการต่างๆ เพื่อสร้างเอเจนต์

รูปที่ 2: สถาปัตยกรรมอ้างอิงตัวอย่างสำหรับการสร้าง Agent โดยใช้บริการหลายอย่าง

6. ข้อมูลเบื้องต้นเกี่ยวกับ A2A

โปรโตคอล Agent2Agent (A2A) เป็นมาตรฐานแบบเปิดที่ออกแบบมาเพื่อเปิดใช้การสื่อสารและการทำงานร่วมกันที่ราบรื่นและปลอดภัยระหว่าง AI Agent แบบอัตโนมัติจากเฟรมเวิร์ก ผู้ให้บริการ และโดเมนต่างๆ

1. ความสามารถในการทำงานร่วมกันแบบสากล: A2A ช่วยให้เอเจนต์ทำงานร่วมกันได้โดยไม่คำนึงถึงเทคโนโลยีพื้นฐาน ซึ่งส่งเสริมระบบนิเวศแบบหลายเอเจนต์อย่างแท้จริง ซึ่งหมายความว่าเอเจนต์ที่สร้างโดยบริษัทต่างๆ บนแพลตฟอร์มที่แตกต่างกันจะสื่อสารและประสานงานกันได้
2. การค้นพบความสามารถ: เอเจนต์สามารถโฆษณาความสามารถของตนเองได้โดยใช้ "การ์ดเอเจนต์" (เอกสาร JSON) ซึ่งอธิบายตัวตน ฟีเจอร์ A2A ที่รองรับ ทักษะ และข้อกำหนดในการตรวจสอบสิทธิ์ ซึ่งจะช่วยให้เอเจนต์อื่นๆ ค้นพบและเลือกเอเจนต์ที่เหมาะสมที่สุดสำหรับงานที่กำหนดได้
3. ปลอดภัยโดยค่าเริ่มต้น: ความปลอดภัยเป็นหลักการสำคัญ A2A มีกลไกการตรวจสอบสิทธิ์และการให้สิทธิ์ระดับองค์กร โดยใช้มาตรฐานต่างๆ เช่น HTTPS/TLS, JWT, OIDC และคีย์ API เพื่อให้มั่นใจถึงการโต้ตอบที่ปลอดภัยและปกป้องข้อมูลที่ละเอียดอ่อน
4. ไม่ขึ้นอยู่กับรูปแบบ: โปรโตคอลรองรับรูปแบบการสื่อสารต่างๆ รวมถึงการสตรีมข้อความ เสียง และวิดีโอ ตลอดจนแบบฟอร์มแบบอินเทอร์แอกทีฟและ iframe ที่ฝัง ความยืดหยุ่นนี้ช่วยให้เอเจนต์แลกเปลี่ยนข้อมูลในรูปแบบที่เหมาะสมที่สุดสำหรับงานและผู้ใช้
5. การจัดการงานที่มีโครงสร้าง: A2A กำหนดโปรโตคอลที่ชัดเจนสำหรับการมอบหมายงาน การตรวจสอบ และการทำงานให้เสร็จสมบูรณ์ โดยจะรองรับการจัดกลุ่มงานที่เกี่ยวข้องและการจัดการงานเหล่านั้นในตัวแทนต่างๆ โดยใช้รหัสงานที่ไม่ซ้ำกัน งานสามารถเปลี่ยนสถานะผ่านวงจรที่กำหนดไว้ (เช่น ส่งแล้ว กำลังดำเนินการ เสร็จแล้ว)
6. การดำเนินการแบบทึบแสง: ฟีเจอร์สำคัญคือเอเจนต์ไม่จำเป็นต้องเปิดเผยกระบวนการให้เหตุผลภายใน หน่วยความจำ หรือเครื่องมือเฉพาะต่อเอเจนต์อื่นๆ โดยจะแสดงเฉพาะบริการที่เรียกใช้ได้เท่านั้น ซึ่งจะช่วยส่งเสริมการทำงานแบบแยกส่วนและความเป็นส่วนตัว
7. สร้างขึ้นตามมาตรฐานที่มีอยู่: A2A ใช้ประโยชน์จากเทคโนโลยีเว็บที่มีอยู่ เช่น HTTP, เหตุการณ์ที่เซิร์ฟเวอร์ส่ง (SSE) สำหรับการสตรีมแบบเรียลไทม์ และ JSON-RPC สำหรับการแลกเปลี่ยนข้อมูลที่มีโครงสร้าง ซึ่งช่วยให้ผสานรวมกับโครงสร้างพื้นฐานด้านไอทีที่มีอยู่ได้ง่ายขึ้น
8. การสื่อสารแบบอะซิงโครนัส: โปรโตคอลนี้ออกแบบมาโดยคำนึงถึงการสื่อสารแบบอะซิงโครนัสเป็นหลัก ซึ่งช่วยให้การดำเนินงานมีความยืดหยุ่นและเปิดใช้การแจ้งเตือนแบบพุชสำหรับการอัปเดตได้แม้ว่าจะไม่ได้รักษาการเชื่อมต่อไว้อย่างต่อเนื่อง

7. สถาปัตยกรรมของ Agent

ใน Lab นี้ คุณจะได้สร้างแอปพลิเคชันแบบหลาย Agent ที่สร้างรูปภาพตามข้อกำหนดของคุณและประเมินรูปภาพก่อนที่จะนำเสนอให้คุณ

ระบบนี้มีโครงสร้างที่มีเอเจนต์หลักชื่อ image_scoring ซึ่งประสานงานกระบวนการทั้งหมด Agent หลักนี้มี Agent ย่อยชื่อ image_generation_scoring_agent ซึ่งมี Agent ย่อยของตัวเองสำหรับงานที่เฉพาะเจาะจงมากขึ้น ซึ่งจะสร้างความสัมพันธ์แบบลำดับชั้นที่ตัวแทนหลักมอบหมายงานให้กับตัวแทนย่อย

รูปที่ 3: Agent Flow โดยรวม

รายชื่อตัวแทนทั้งหมด

Agent	Purpose	ตัวแทนย่อย
การให้คะแนนรูปภาพ (เอเจนต์หลัก)	นี่คือเอเจนต์รูทที่จัดการเวิร์กโฟลว์โดยรวม โดยจะเรียกใช้ image_generation_scoring_agent และ checker_agent ซ้ำๆ ในลูปจนกว่าจะตรงตามเงื่อนไขการสิ้นสุด	image_generation_scoring_agent checker_agent_instance
image_generation_scoring_agent (Agent ย่อย ของ image_scoring)	ซึ่งทำหน้าที่รับผิดชอบตรรกะหลักในการสร้างและให้คะแนนรูปภาพ โดยจะเรียกใช้ลำดับของ Agent ย่อย 3 รายการเพื่อให้บรรลุเป้าหมายนี้	image_generation_prompt_agent image_generation_agent scoring_images_prompt
checker_agent_instance (Agent ย่อย ของ image_scoring)	เอเจนต์นี้จะตรวจสอบว่าควรดำเนินการกระบวนการให้คะแนนรูปภาพต่อหรือสิ้นสุด โดยจะใช้เครื่องมือ check_tool_condition เพื่อประเมินเงื่อนไขการสิ้นสุด	-
checker_agent_instance (Agent ย่อย ของ image_scoring)	ตัวแทนนี้เป็นผู้เชี่ยวชาญในการสร้างพรอมต์สำหรับการสร้างรูปภาพ โดยจะรับข้อความอินพุตและสร้างพรอมต์แบบละเอียดที่เหมาะกับโมเดลการสร้างรูปภาพ	-
image_generation_prompt_agent (Agent ย่อย ของ image_generation_scoring_agent)	ตัวแทนนี้เป็นผู้เชี่ยวชาญในการสร้างพรอมต์สำหรับการสร้างรูปภาพ โดยจะรับข้อความอินพุตและสร้างพรอมต์แบบละเอียดที่เหมาะกับโมเดลการสร้างรูปภาพ	-
scoring_images_prompt (Agent ย่อย ของ image_generation_scoring_agent):	เอเจนต์นี้เป็นผู้เชี่ยวชาญในการประเมินและให้คะแนนรูปภาพตามเกณฑ์ต่างๆ โดยจะนำรูปภาพที่สร้างขึ้นมาให้คะแนน	-

รายการเครื่องมือทั้งหมดที่ใช้

เครื่องมือ	คำอธิบาย	User Agent
check_tool_condition	เครื่องมือนี้จะตรวจสอบว่าตรงตามเงื่อนไขการสิ้นสุดลูปหรือไม่ หรือมีการวนซ้ำถึงจำนวนสูงสุดแล้วหรือไม่ หากข้อใดข้อหนึ่งเป็นจริง ระบบจะหยุดลูป	checker_agent_instance
generate_images	เครื่องมือนี้สร้างรูปภาพโดยใช้โมเดล Imagen 3 นอกจากนี้ยังบันทึกรูปภาพที่สร้างขึ้นไปยัง Bucket ของ Google Cloud Storage ได้ด้วย	image_generation_agent
get_policy	เครื่องมือนี้จะดึงนโยบายจากไฟล์ JSON image_generation_prompt_agent ใช้เพื่อสร้างพรอมต์การสร้างรูปภาพ และ scoring_images_prompt ใช้เพื่อให้คะแนนรูปภาพ	image_generation_agent
get_image	เครื่องมือนี้จะโหลดอาร์ติแฟกต์รูปภาพที่สร้างขึ้นเพื่อให้สามารถให้คะแนนได้	scoring_images_prompt
set_score	เครื่องมือนี้จะตั้งคะแนนรวมของรูปภาพที่สร้างขึ้นในสถานะเซสชัน	scoring_images_prompt

8. ติดตั้ง ADK และตั้งค่าสภาพแวดล้อม

ในแบบฝึกหัดนี้ เราจะใช้ Cloud Shell เพื่อทำงาน

เตรียมแท็บ Cloud Shell Editor

1. คลิกลิงก์นี้เพื่อไปยัง Cloud Shell Editor โดยตรง
2. คลิกต่อไป
3. เมื่อได้รับข้อความแจ้งให้ให้สิทธิ์ Cloud Shell ให้คลิกให้สิทธิ์
4. ตลอดช่วงที่เหลือของแล็บนี้ คุณสามารถทำงานในหน้าต่างนี้เป็น IDE ด้วย Cloud Shell Editor และเทอร์มินัล Cloud Shell
5. เปิดเทอร์มินัลใหม่โดยใช้เทอร์มินัล>เทอร์มินัลใหม่ใน Cloud Shell Editor คำสั่งทั้งหมดด้านล่างจะทำงานในเทอร์มินัลนี้

ดาวน์โหลดและติดตั้ง ADK และตัวอย่างโค้ดสำหรับแล็บนี้

1. เรียกใช้คำสั่งต่อไปนี้เพื่อโคลนแหล่งข้อมูลที่จำเป็นจาก GitHub และติดตั้งไลบรารีที่จำเป็น เรียกใช้คำสั่งในเทอร์มินัลที่เปิดใน Cloud Shell Editor

#create the project directory
mkdir ~/imagescoring
cd ~/imagescoring
#clone the code in the local directory
git clone https://github.com/haren-bh/multiagenthandson.git

2. เราจะใช้ uv เพื่อสร้างสภาพแวดล้อม Python (เรียกใช้ในเทอร์มินัลของ Cloud Shell Editor)

#Install uv if you do not have installed yet
pip install uv

#Create the virtual environment
uv venv .adkvenv

source .adkvenv/bin/activate

#go to the project directory
cd ~/imagescoring/multiagenthandson

#install dependencies
uv pip install -r pyproject.toml

3. หากไม่มี Bucket พื้นที่เก็บข้อมูลระบบคลาวด์ ให้สร้างใหม่ใน Google Cloud Storage นอกจากนี้ คุณยังสร้าง Bucket โดยใช้คำสั่ง gsutil ได้ด้วย ให้สิทธิ์เข้าถึงรันไทม์ของ Agent ใน Google Cloud Storage (เรียกใช้ในเทอร์มินัลของ Cloud Shell Editor)

# First, make sure your PROJECT_ID variable is set
PROJECT_ID=$(gcloud config get-value project)

# Now, create the bucket with a unique name
# We'll use the project ID to help ensure uniqueness
gsutil mb gs://${PROJECT_ID}-imagescoring-bucket

#Now lets give Agent Runtime the permission to access Cloud Storage
# 1. Get the current Project ID (text) and Project Number (numeric)
PROJECT_ID=$(gcloud config get-value project)
PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")

# 2. Construct the Reasoning Engine Service Account email
SA_EMAIL="service-${PROJECT_NUMBER}@gcp-sa-aiplatform-re.iam.gserviceaccount.com"
# 3. Create Agent Runtime Service account if not already created
gcloud beta services identity create --service=aiplatform.googleapis.com --project=${PROJECT_NUMBER}

# 3. Grant GCS Access
gcloud projects add-iam-policy-binding $PROJECT_ID --member="serviceAccount:$SA_EMAIL" --role="roles/storage.objectUser" --condition=None

4. ในโปรแกรมแก้ไข ให้ไปที่มุมมอง -> สลับไฟล์ที่ซ่อนอยู่ และในโฟลเดอร์ image_scoring ให้สร้างไฟล์ .env ที่มีเนื้อหาต่อไปนี้ เพิ่มรายละเอียดที่จำเป็น เช่น ชื่อโปรเจ็กต์และที่เก็บข้อมูล Cloud Storage (เรียกใช้ในเทอร์มินัล Cloud Shell Editor)

#go to image_scoring folder
cd ~/imagescoring/multiagenthandson/image_scoring

cat <<EOF>> .env
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=$(gcloud config get-value project)
GOOGLE_CLOUD_LOCATION=us-central1
GOOGLE_CLOUD_STORAGE_BUCKET=$(gcloud config get-value project)-imagescoring-bucket
GCS_BUCKET_NAME=$(gcloud config get-value project)-imagescoring-bucket
SCORE_THRESHOLD=40
IMAGEN_MODEL="imagen-3.0-generate-002"
GENAI_MODEL="gemini-2.5-flash"
EOF

5. ในเมนู Cloud Shell Editor ให้เลือกไฟล์ > เปิดโฟลเดอร์
6. ในช่องที่ปรากฏขึ้น ให้เพิ่มข้อมูลโฟลเดอร์ต่อไปนี้หลังชื่อผู้ใช้ imagescoring/ คลิกตกลง ตอนนี้คุณควรเห็นโครงสร้างโปรเจ็กต์ทั้งหมดในแผง Explorer ทางด้านซ้าย
7. ไปที่โฟลเดอร์ image_scoring ในแผงด้านข้างของ Explorer คลิกไฟล์ agent.py เพื่อเปิดและดูโครงสร้างของเอเจนต์ Agent นี้มี Agent รูทที่จะเชื่อมต่อกับ Agent ย่อยอื่นๆ

รูปที่ 4: โครงสร้างโฟลเดอร์ที่ดูได้จากแผงด้านข้างของ Explorer คุณเพียงแค่คลิกไฟล์เพื่อดูเนื้อหาของไฟล์

8. กลับไปที่ไดเรกทอรีระดับบนสุด multiagenthandson ในเทอร์มินัล แล้วเรียกใช้คำสั่งต่อไปนี้เพื่อเรียกใช้ Agent ในเครื่อง (เรียกใช้ในเทอร์มินัลของ Cloud Shell Editor)

#go to the directory multiagenthandson
cd ~/imagescoring/multiagenthandson
# Run the following command to run agents locally
adk web

รูปที่ 5: การเริ่มต้นแอปพลิเคชัน ADK

9. Ctrl+คลิก (CMD+คลิกสำหรับ MacOS) ที่ URL http:// ที่แสดงในเทอร์มินัลเพื่อเปิดไคลเอ็นต์ GUI ที่อิงตามเบราว์เซอร์ของ ADK โดยควรมีลักษณะดังรูปที่ 5
10. เลือก image_scoring ในเมนูแบบเลื่อนลงที่ด้านซ้ายบน (ดูรูปที่ 5) ตอนนี้มาสร้างรูปภาพกันเลย คุณควรเห็นรูปภาพใน Bucket ของ Google Cloud Storage ด้วย ลองใช้พรอมต์ต่อไปนี้หรือพรอมต์ของคุณเอง

• ภูมิทัศน์ภูเขาอันเงียบสงบยามพระอาทิตย์ตก
• แมวขี่จักรยาน

รูปที่ 6: เอาต์พุตตัวอย่าง

9. ทำให้ใช้งานได้กับ Agent Runtime

ตอนนี้เราจะติดตั้งใช้งานเอเจนต์ใน Agent Engine Agent Engine เป็นบริการที่มีการจัดการครบวงจรสำหรับการติดตั้งใช้งานเอเจนต์ใน GCP Agent Engine ใช้ได้กับ ADK (Agent Development Kit) ดังนั้นจึงติดตั้งใช้งาน Agent ที่สร้างด้วย ADK (Agent Development Kit) ใน Agent Engine ได้

1. ก่อนไปยังขั้นตอนด้านล่างในเทอร์มินัล Cloud Shell Editor ให้ปิดเซิร์ฟเวอร์ ADK ด้วย Ctrl+C
2. สร้างไฟล์ requirements.txt โดยใช้ Poetry Poetry จะใช้ pyproject.toml เพื่อสร้างไฟล์ requirements.txt หลังจากเรียกใช้คำสั่ง ให้ตรวจสอบว่าได้สร้างไฟล์ requirements.txt แล้ว (เรียกใช้ในเทอร์มินัลของ Cloud Shell Editor)

# Go to the parent folder containing pyproject.toml file
cd ~/imagescoring/multiagenthandson

# install poetry-plugin-export
uv pip install poetry-plugin-export

#Create requirements.txt file
python3 -m poetry export -f requirements.txt --output requirements.txt --without-hashes

3. สร้างแพ็กเกจ เราต้องรวมแอปของเราไว้ในแพ็กเกจ Python .whl เราจะใช้บทกวีเพื่อทำสิ่งนั้น เมื่อเรียกใช้คำสั่งแล้ว ให้ตรวจสอบว่าได้สร้างโฟลเดอร์ dist และมีไฟล์ .whl (เรียกใช้ในเทอร์มินัลของ Cloud Shell Editor)

# Go to the parent folder containing pyproject.toml file
cd ~/imagescoring/multiagenthandson

#Create python package, to create whl file
python3 -m poetry build

4. ตอนนี้เราจะเตรียมสคริปต์ที่ทำให้ Agent การให้คะแนนรูปภาพใช้งานได้ในบริการ Agent Engine ในไดเรกทอรี deploy ให้ค้นหา deploy.py ในแผงด้านข้างของ Cloud Shell Editor แล้วคลิกเพื่อเปิด ยืนยันเนื้อหาดังนี้

import vertexai
from image_scoring.agent import root_agent
import os
import glob # To easily find the wheel file
from dotenv import load_dotenv

# Load environment variables from image_scoring/.env
env_path = os.path.join(os.path.dirname(__file__), "..", "image_scoring", ".env")
load_dotenv(env_path)

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
LOCATION = os.getenv("GOOGLE_CLOUD_LOCATION", "us-central1")
STAGING_BUCKET = f"gs://{os.getenv('GOOGLE_CLOUD_STORAGE_BUCKET')}"

from vertexai import agent_engines

client=vertexai.Client(
    project=PROJECT_ID,
    location=LOCATION,
)
remote_app = client.agent_engines.create(
    agent=root_agent,
    config={
        "display_name": "image-scoring",
        "staging_bucket": STAGING_BUCKET,
        "requirements": open(os.path.join(os.getcwd(), "requirements.txt")).readlines() + ["./dist/image_scoring-0.1.0-py3-none-any.whl"],
        "extra_packages": [
            "./dist/image_scoring-0.1.0-py3-none-any.whl",
        ],     "env_vars":{"GCS_BUCKET_NAME":os.getenv('GOOGLE_CLOUD_STORAGE_BUCKET')}
    }
)
print(f"DEBUG: AgentEngine attributes: {dir(remote_app)}")
try:
    print(remote_app.api_resource.name)
except AttributeError:
    print("Could not find resource_name, check DEBUG output above.")

5. ตอนนี้เราสามารถเรียกใช้สคริปต์การติดตั้งใช้งานได้แล้ว ก่อนอื่น ให้ไปที่โฟลเดอร์ระดับบนสุด multiagenthandson (เรียกใช้ในเทอร์มินัล Cloud Shell Editor)

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#run deploy script from the parent folder containing deploy.py
python3 -m deploy.deploy

หลังจากที่ติดตั้งใช้งานแล้ว คุณควรเห็นข้อความคล้ายกับด้านล่าง

รูปที่ 7: เอาต์พุตตัวอย่าง

6. ตอนนี้เรามาทดสอบเอเจนต์ที่ใช้งานจริงกัน หากต้องการทดสอบเครื่องมือ Agent ที่ติดตั้งใช้งานจากระยะไกล ให้คัดลอกตำแหน่งของ Agent จากเอาต์พุตการติดตั้งใช้งานในเทอร์มินัลก่อน ซึ่งควรมีลักษณะดังนี้ projects/85469421903/locations/us-central1/reasoningEngines/7369674597261639680
   ไปที่โฟลเดอร์ testclient ในแผงด้านข้างของ Cloud Shell Editor คลิก remote_test.py เพื่อเปิด แล้วแก้ไขบรรทัดต่อไปนี้

REASONING_ENGINE_ID = "projects/xxx/locations/us-central1/reasoningEngines/xxx"  # TODO: Change this

7. จากไดเรกทอรีราก multiagenthandson ให้เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลของ Cloud Shell Editor เอาต์พุตของคุณควรตรงกับรูปที่ 8

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#execute remote_test.py
python3 -m testclient.remote_test

รูปที่ 8: เอาต์พุตตัวอย่าง

10. สร้างเอเจนต์ A2A

ในขั้นตอนนี้ เราจะสร้างเอเจนต์ A2A อย่างง่ายโดยอิงตามเอเจนต์ที่เราสร้างไว้ในขั้นตอนก่อนหน้า คุณสามารถเผยแพร่ Agent ADK (Agent Development Kit) ที่มีอยู่ภายใต้โปรโตคอล A2A สิ่งสำคัญที่คุณจะได้เรียนรู้ในขั้นตอนนี้มีดังนี้

• ดูข้อมูลพื้นฐานเกี่ยวกับโปรโตคอล A2A
• ดูวิธีที่โปรโตคอล ADK และ A2A ทำงานร่วมกัน
• ดูวิธีโต้ตอบกับโปรโตคอล A2A

ในแบบฝึกหัดนี้ เราจะใช้โค้ดในโฟลเดอร์ image_scoring_adk_a2a_server ก่อนเริ่มงาน โปรดเปลี่ยนไดเรกทอรีเป็นโฟลเดอร์นี้ (เรียกใช้ในเทอร์มินัลของ Cloud Shell Editor)

#change directory to image_scoring_adk_a2a_server
cd ~/imagescoring/multiagenthandson/image_scoring_adk_a2a_server

#copy the env file
cp ~/imagescoring/multiagenthandson/image_scoring/.env remote_a2a/image_scoring

1. สร้างการ์ดตัวแทน A2A

โปรโตคอล A2A ต้องใช้การ์ดเอเจนต์ที่มีข้อมูลทั้งหมดเกี่ยวกับเอเจนต์ เช่น ความสามารถของเอเจนต์ คู่มือการใช้งานเอเจนต์ เป็นต้น เมื่อมีการติดตั้งใช้งานเอเจนต์ A2A แล้ว คุณจะดูการ์ดเอเจนต์ได้โดยใช้ลิงก์ ".well-known/agent-card.json" ลูกค้าสามารถดูข้อมูลนี้เพื่อส่งคำขอไปยังตัวแทน

ไปที่ไดเรกทอรี remote_a2a/image_scoring แล้วค้นหา agents.json ในแผงด้านข้างของ Cloud Shell Editor คลิกไฟล์เพื่อเปิดและตรวจสอบว่าเนื้อหาตรงกับข้อมูลต่อไปนี้

{
 "name": "image_scoring",
 "description": "Agent that generates images based on user prompts and scores their adherence to the prompt.",
 "url": "http://localhost:8001/a2a/image_scoring",
 "version": "1.0.0",
 "defaultInputModes": ["text/plain"],
 "defaultOutputModes": ["image/png", "text/plain"],
 "capabilities": {
   "streaming": true,
   "functions": true
 },
 "skills": [
   {
     "id": "generate_and_score_image",
     "name": "Generate and Score Image",
     "description": "Generates an image from a given text prompt and then evaluates how well the generated image adheres to the original prompt, providing a score.",
     "tags": ["image generation", "image scoring", "evaluation", "AI art"],
     "examples": [
       "Generate an image of a futuristic city at sunset",
       "Create an image of a cat playing a piano",
       "Show me an image of a serene forest with a hidden waterfall"
     ]
   }
 ]
}

2. สร้างเอเจนต์ A2A ในไดเรกทอรีรูท image_scoring_adk_a2a_server ให้ตรวจสอบว่ามีไฟล์ a2a_agent.py คุณเปิดไฟล์ได้โดยคลิกชื่อไฟล์ในแผงด้านข้างของ Cloud Shell Editor ไฟล์นี้ทำหน้าที่เป็นจุดแรกเข้าสำหรับตัวแทน A2A และควรมีเนื้อหาต่อไปนี้

#change directory to image_scoring_adk_a2a_server
cd ~/imagescoring/multiagenthandson/image_scoring_adk_a2a_server

from google.adk.agents.remote_a2a_agent import RemoteA2aAgent

root_agent = RemoteA2aAgent(
   name="image_scoring",
   description="Agent to give interesting facts.",
   agent_card="http://localhost:8001/a2a/image_scoring/.well-known/agent.json",
  
   # Optional configurations
   timeout=300.0,          # HTTP timeout (seconds)
   httpx_client=None,      # Custom HTTP client
)

3. เรียกใช้ Agent A2A

ตอนนี้เราก็พร้อมที่จะเรียกใช้ Agent แล้ว หากต้องการเรียกใช้เอเจนต์ ให้เรียกใช้คำสั่งต่อไปนี้จากภายในโฟลเดอร์บนสุด image_scoring_adk_a2a_server (เรียกใช้ในเทอร์มินัลของ Cloud Shell Editor)

#following command runs the ADK agent as a2a agent
adk api_server --a2a --port 8001 remote_a2a

4. ทดสอบตัวแทน A2A

เมื่อตัวแทนทำงานแล้ว เราก็ไปทดสอบตัวแทนได้เลย ก่อนอื่น เรามาดูบัตรตัวแทนกัน เปิดเทอร์มินัลใหม่โดยใช้เทอร์มินัล>เทอร์มินัลใหม่ แล้วเรียกใช้คำสั่งต่อไปนี้ (เรียกใช้ในเทอร์มินัล Cloud Shell Editor ที่เพิ่งเปิด)

#Execute the following 
curl http://localhost:8001/a2a/image_scoring/.well-known/agent.json

การดำเนินการข้างต้นควรแสดงการ์ดเอเจนต์สำหรับเอเจนต์ A2A ซึ่งส่วนใหญ่เป็นเนื้อหาของ agent.json ที่เราสร้างขึ้นในขั้นตอนก่อนหน้า

ตอนนี้เราจะส่งคำขอไปยังตัวแทน เราใช้ curl เพื่อส่งคำขอไปยังเอเจนต์ได้ (เรียกใช้ในเทอร์มินัลของ Cloud Shell Editor ที่เปิดใหม่)

curl -X POST   http://localhost:8001/a2a/image_scoring   -H 'Content-Type: application/json'   -d '{
    "id": "uuid-123",
    "params": {
      "message": {
        "messageId": "msg-456",
        "parts": [{"text": "Create an image of a cat"}],
        "role": "user"
      }
    }
  }'

ในคำขอข้างต้น คุณสามารถเปลี่ยนพรอมต์ได้โดยเปลี่ยนบรรทัด "สร้างรูปภาพแมว" เมื่อเรียกใช้คำสั่งแล้ว คุณจะตรวจสอบรูปภาพเอาต์พุตได้ใน Google Cloud Storage ที่ระบุ

11. ล้างข้อมูล

ตอนนี้มาล้างข้อมูลที่เราเพิ่งสร้างกัน

1. ลบเซิร์ฟเวอร์ Agent Runtime ที่เราเพิ่งสร้าง ไปที่แพลตฟอร์ม Agent ของ Gemini Enterprise โดยพิมพ์ "แพลตฟอร์ม Agent ของ Gemini Enterprise" ในแถบค้นหาของ Google Cloud Console คลิกเครื่องมือ Agent ทางด้านซ้าย คุณลบ Agent ได้โดยคลิกลบ

รูปที่ 9: คุณลบอินสแตนซ์ Agent Runtime จากคอนโซล Google Cloud ได้

2. ลบไฟล์ใน Cloud Shell

#Execute the following to delete the files
cd ~
rm -R ~/imagescoring

3. ลบ Bucket คุณไปที่คอนโซล GCP->Cloud Storage เลือกและลบ Bucket ได้

รูปที่ 10: การลบ Bucket

12. บทสรุป

ยินดีด้วย คุณทำให้แอปพลิเคชัน ADK (Agent Development Kit) แบบหลาย Agent ใช้งานได้ใน Agent Runtime เรียบร้อยแล้ว นี่เป็นความสำเร็จที่สำคัญซึ่งครอบคลุมวงจรหลักของแอปพลิเคชันสมัยใหม่ที่ดำเนินการบนระบบคลาวด์ ซึ่งจะช่วยให้คุณมีรากฐานที่มั่นคงสำหรับการทำให้ระบบเอเจนต์ที่ซับซ้อนของคุณเองใช้งานได้

สรุป

ในแล็บนี้ คุณได้เรียนรู้สิ่งต่อไปนี้

• สร้างแอปพลิเคชันแบบหลาย Agent โดยใช้ ADK (Agent Development Kit)
• ทำให้แอปพลิเคชันใช้งานได้กับ Agent Runtime
• สร้าง Agent ที่สื่อสารได้โดยใช้โปรโตคอล A2A

แหล่งข้อมูลที่เป็นประโยชน์

• เอกสารประกอบ ADK อย่างเป็นทางการ
• รันไทม์ของ Agent
• โปรโตคอล A2A
• Cloud Run

จากต้นแบบสู่เวอร์ชันที่ใช้งานจริง

แล็บนี้เป็นส่วนหนึ่งของเส้นทางการเรียนรู้ AI พร้อมใช้งานจริงด้วย Google Cloud

• สำรวจหลักสูตรทั้งหมดเพื่อเชื่อมช่องว่างจากต้นแบบไปสู่การผลิต
• แชร์ความคืบหน้าของคุณด้วยแฮชแท็ก #ProductionReadyAI