หน้านี้ได้รับการแปลโดย Cloud Translation API

สร้างระบบหลายเอเจนต์ด้วย ADK, ทำให้ใช้งานได้ใน Agent Engine และเริ่มต้นใช้งานโปรโตคอล A2A

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

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

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

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

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

หากยังไม่มีโปรเจ็กต์ที่ใช้ได้ คุณจะต้องสร้างโปรเจ็กต์ใหม่ในคอนโซล GCP
ในแล็บนี้ เราจะใช้ 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>

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

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

3. ข้อมูลเบื้องต้นเกี่ยวกับชุดพัฒนาเอเจนต์

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

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

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

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

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

4. ความรู้เบื้องต้นเกี่ยวกับ Vertex AI Agent Engine

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

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

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

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

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

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

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

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

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

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

6. สถาปัตยกรรมของ 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 (Sub-agent ของ image_scoring)	เอเจนต์นี้มีหน้าที่รับผิดชอบตรรกะหลักในการสร้างและให้คะแนนรูปภาพ โดยจะเรียกใช้ลำดับของ Agent ย่อย 3 รายการเพื่อให้บรรลุเป้าหมายนี้	image_generation_prompt_agent image_generation_agent scoring_images_prompt
checker_agent_instance (Sub-agent ของ image_scoring)	เอเจนต์นี้จะตรวจสอบว่าควรดำเนินการกระบวนการให้คะแนนรูปภาพต่อหรือสิ้นสุด โดยจะใช้เครื่องมือ check_tool_condition เพื่อประเมินเงื่อนไขการสิ้นสุด	-
checker_agent_instance (Sub-agent ของ image_scoring)	ตัวแทนนี้เป็นผู้เชี่ยวชาญในการสร้างพรอมต์สำหรับการสร้างรูปภาพ โดยจะรับข้อความอินพุตและสร้างพรอมต์แบบละเอียดที่เหมาะกับโมเดลการสร้างรูปภาพ	-
image_generation_prompt_agent (Sub-agent ของ image_generation_scoring_agent)	ตัวแทนนี้เป็นผู้เชี่ยวชาญในการสร้างพรอมต์สำหรับการสร้างรูปภาพ โดยจะรับข้อความอินพุตและสร้างพรอมต์แบบละเอียดที่เหมาะกับโมเดลการสร้างรูปภาพ	-
scoring_images_prompt (Sub-agent ของ image_generation_scoring_agent):	เอเจนต์นี้เป็นผู้เชี่ยวชาญในการประเมินและให้คะแนนรูปภาพตามเกณฑ์ต่างๆ โดยจะนำรูปภาพที่สร้างขึ้นมาให้คะแนน	-

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

เครื่องมือ	คำอธิบาย	User Agent
check_tool_condition	เครื่องมือนี้จะตรวจสอบว่าตรงตามเงื่อนไขการสิ้นสุดลูปหรือไม่ หรือมีการวนซ้ำถึงจำนวนสูงสุดแล้วหรือไม่ หากข้อใดข้อหนึ่งเป็นจริง ระบบจะหยุดลูป	checker_agent_instance
generate_images	เครื่องมือนี้สร้างรูปภาพโดยใช้โมเดล Imagen 3 นอกจากนี้ยังบันทึกรูปภาพที่สร้างขึ้นไปยังที่เก็บข้อมูล 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

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

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

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

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

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

เรียกใช้คำสั่งต่อไปนี้เพื่อโคลนแหล่งที่มาที่จำเป็นจาก 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

เราจะใช้ 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

หากไม่มีที่เก็บข้อมูลในระบบคลาวด์ ให้สร้างที่เก็บข้อมูลใหม่ใน Google Cloud Storage นอกจากนี้ คุณยังสร้างที่เก็บข้อมูลโดยใช้คำสั่ง gsutil ได้ด้วย ให้สิทธิ์เข้าถึง Google Cloud Storage แก่ Agent Engine (เรียกใช้ในเทอร์มินัลของ 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 Engine 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 Engine 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

ในโปรแกรมแก้ไข ให้ไปที่มุมมอง -> สลับไฟล์ที่ซ่อนอยู่ และในโฟลเดอร์ 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

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

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

รูปที่ 4

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

เลือก image_scoring ในเมนูแบบเลื่อนลงที่ด้านซ้ายบน (ดูรูปที่ 5) ตอนนี้มาสร้างรูปภาพกันเลย คุณควรเห็นรูปภาพในที่เก็บข้อมูล Google Cloud Storage ด้วย ลองใช้พรอมต์ต่อไปนี้หรือพรอมต์ของคุณเอง
ภูมิทัศน์ภูเขาอันเงียบสงบยามพระอาทิตย์ตก
แมวขี่จักรยาน

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

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

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

สร้างไฟล์ 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

สร้างแพ็กเกจ เราต้องรวมแอปของเราไว้ในแพ็กเกจ 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

ตอนนี้เราจะเตรียมสคริปต์การติดตั้งใช้งาน สคริปต์การติดตั้งใช้งานจะติดตั้งใช้งานเอเจนต์การให้คะแนนรูปภาพหรือบริการเครื่องมือเอเจนต์ โปรดยืนยันเนื้อหาของ deploy.py ในโฟลเดอร์ deploy ดังที่แสดงด้านล่าง (ใช้แผงด้านข้างของ 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.")

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

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

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

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

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

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

#go to multiagenthandson folder
cd ~/imagescoring/multiagenthandson

#execute remote_test.py
python3 -m testclient.remote_test

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

9. สร้างเอเจนต์ 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 โดยควรมีเนื้อหาต่อไปนี้

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. เรียกใช้ตัวแทน 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 ที่ระบุ

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

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

ลบเซิร์ฟเวอร์ Vertex AI Agent Engine ที่เราเพิ่งสร้าง ไปที่ Vertex AI โดยพิมพ์ Vertex AI ในแถบค้นหาของ Google Cloud Console คลิกเครื่องมือ Agent ทางด้านซ้าย คุณลบ Agent ได้โดยคลิกลบ

รูปที่ 8

ลบไฟล์ใน Cloud Shell

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

ลบที่เก็บข้อมูล คุณไปที่คอนโซล GCP->Cloud Storage เลือกและลบที่เก็บข้อมูลได้

รูปที่ 9: การลบที่เก็บข้อมูล

11. บทสรุป

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

สรุป

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

สร้างแอปพลิเคชันแบบหลายเอเจนต์โดยใช้ ADK (Agent Development Kit)
ทําให้แอปพลิเคชันใช้งานได้ใน Vertex AI Agent Engine
สร้าง Agent ที่สื่อสารได้โดยใช้โปรโตคอล A2A

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