สร้างระบบหลายเอเจนต์ด้วย ADK

1. บทนำ

ภาพรวม

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

สิ่งที่คุณจะสร้าง

คุณจะสร้างระบบ Multi-Agent ที่แตกต่างกัน 2 ระบบ ดังนี้

• เอเจนต์วางแผนการเดินทางแบบง่ายที่จะเรียนรู้การโอนการสนทนาระหว่างเอเจนต์ "ระดมความคิด" กับเอเจนต์ "วางแผนสถานที่ท่องเที่ยว"
• เครื่องมือสร้างพิตช์ภาพยนตร์ขั้นสูงที่ใช้ "ห้องนักเขียน" ของเอเจนต์อัตโนมัติ (เช่น นักวิจัย นักเขียนบท และนักวิจารณ์) เพื่อทำงานร่วมกันในลูปเพื่อสร้างพล็อตหนังเต็มจอ

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

• วิธีสร้างความสัมพันธ์ระหว่างเอเจนซีหลักและ Agent ย่อย
• วิธีเขียนข้อมูลไปยังเซสชัน state จากเครื่องมือ
• วิธีอ่านจาก state โดยใช้การสร้างเทมเพลตคีย์ (เช่น {my_key?})
• วิธีใช้ SequentialAgent สำหรับเวิร์กโฟลว์แบบทีละขั้นตอน
• วิธีใช้ LoopAgent เพื่อสร้างวงจรการปรับแต่งซ้ำๆ
• วิธีใช้ ParallelAgent เพื่อเรียกใช้ฟังก์ชันที่ไม่ขึ้นต่อกันพร้อมกัน

2. ระบบแบบหลายเอเจนต์

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

แนวทางนี้มีข้อดีหลายประการเมื่อเทียบกับการใช้พรอมต์แบบโมโนลิธเดียว

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

แผนผังตัวแทนแบบลำดับชั้น

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

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

โครงสร้างทั้งหมดเริ่มต้นด้วย root_agent เอเจนต์นี้ทำหน้าที่เป็นเอเจนต์หลักและอาจมีAgent ย่อยอย่างน้อย 1 ราย ซึ่งเอเจนต์ย่อยก็อาจเป็นเอเจนต์หลักของเอเจนต์ย่อยของตนเองได้เช่นกัน ทำให้เกิดโครงสร้างแบบต้นไม้

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

บัญชี Google

หากยังไม่มีบัญชี Google ส่วนบุคคล คุณต้องสร้างบัญชี Google

ใช้บัญชีส่วนตัวแทนบัญชีของที่ทำงานหรือบัญชีโรงเรียน

บัญชีงานและบัญชีโรงเรียนอาจมีข้อจำกัดที่ทำให้คุณเปิดใช้ API ที่จำเป็นสำหรับ Lab นี้ไม่ได้

ลงชื่อเข้าใช้คอนโซล Google Cloud

ลงชื่อเข้าใช้ คอนโซล Google Cloud โดยใช้บัญชี Google ส่วนบุคคล

เปิดใช้การเรียกเก็บเงิน

แลกรับเครดิต Google Cloud มูลค่า $5 (ไม่บังคับ)

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

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

ตอนนี้คุณเชื่อมต่อกับบัญชีสำหรับการเรียกเก็บเงินของ Google Cloud Platform เวอร์ชันทดลองใช้งานแล้ว

ตั้งค่าบัญชีสำหรับการเรียกเก็บเงินส่วนตัว

หากตั้งค่าการเรียกเก็บเงินโดยใช้เครดิต Google Cloud คุณจะข้ามขั้นตอนนี้ได้

หากต้องการตั้งค่าบัญชีสำหรับการเรียกเก็บเงินส่วนตัว ให้ไปที่นี่เพื่อเปิดใช้การเรียกเก็บเงินใน Cloud Console

ข้อควรทราบ

• การทำ Lab นี้ควรมีค่าใช้จ่ายน้อยกว่า $1 USD ในทรัพยากรระบบคลาวด์
• คุณสามารถทำตามขั้นตอนที่ส่วนท้ายของแล็บนี้เพื่อลบทรัพยากรเพื่อหลีกเลี่ยงการเรียกเก็บเงินเพิ่มเติม
• ผู้ใช้ใหม่มีสิทธิ์ใช้ช่วงทดลองใช้ฟรีมูลค่า$300 USD

สร้างโปรเจ็กต์ (ไม่บังคับ)

หากไม่มีโปรเจ็กต์ปัจจุบันที่ต้องการใช้สำหรับแล็บนี้ ให้สร้างโปรเจ็กต์ใหม่ที่นี่

4. เปิดเครื่องมือแก้ไข Cloud Shell

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

   gcloud config set project [PROJECT_ID]
   

   • ตัวอย่าง

     gcloud config set project lab-project-id-example
     

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

     gcloud projects list
     

     
5. คุณควรเห็นข้อความต่อไปนี้

   Updated property [core/project].
   

   หากเห็น WARNING และระบบขอให้คุณ Do you want to continue (Y/n)? แสดงว่าคุณอาจป้อนรหัสโปรเจ็กต์ไม่ถูกต้อง กด n กด Enter แล้วลองเรียกใช้คำสั่ง gcloud config set project อีกครั้ง

5. เปิดใช้ API

หากต้องการใช้ Vertex AI API และโต้ตอบกับโมเดล Gemini คุณต้องเปิดใช้ Vertex AI API ในโปรเจ็กต์ที่อยู่ในระบบคลาวด์ของ Google

1. เปิดใช้ API ในเทอร์มินัลโดยทำดังนี้

   gcloud services enable aiplatform.googleapis.com
   

ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI SDK สำหรับ Python

หากต้องการโต้ตอบกับโมเดลที่โฮสต์ใน Vertex AI จากแอปพลิเคชัน Python คุณจะต้องใช้ Vertex AI SDK สำหรับ Python SDK นี้ช่วยลดความซับซ้อนของกระบวนการส่งพรอมต์ การระบุพารามิเตอร์ของโมเดล และการรับการตอบกลับโดยไม่ต้องจัดการความซับซ้อนของการเรียก API พื้นฐานโดยตรง

คุณดูเอกสารประกอบที่ครอบคลุมสำหรับ Vertex AI SDK สำหรับ Python ได้ที่ข้อมูลเบื้องต้นเกี่ยวกับ Vertex AI SDK สำหรับ Python | Google Cloud

6. ตั้งค่าสภาพแวดล้อมของโปรเจ็กต์

โคลนที่เก็บ

1. ในเทอร์มินัล ให้โคลนที่เก็บที่มีไฟล์เริ่มต้น

   git clone --depth 1 https://github.com/GoogleCloudPlatform/devrel-demos.git devrel-demos-multiagent-lab
   

   แฟล็ก --depth 1 จะโคลนเฉพาะเวอร์ชันล่าสุด ซึ่งเร็วกว่า
2. ในเทอร์มินัล ให้ย้ายโฟลเดอร์เฉพาะของแล็บไปยังไดเรกทอรีหลัก แล้วเปลี่ยนชื่อให้ตรงกับโครงสร้างที่คาดไว้ของแล็บ

   mv devrel-demos-multiagent-lab/ai-ml/build-multiagent-systems-with-adk/adk_multiagent_systems ~
   

3. ในเทอร์มินัล ให้ไปที่ไดเรกทอรีการทำงานที่ถูกต้องสำหรับแล็บนี้ (adk_multiagent_systems)

   cd ~/adk_multiagent_systems
   

ตรวจสอบโครงสร้างไฟล์

เมื่อสร้างไฟล์ทั้งหมดแล้ว ให้เปิดโฟลเดอร์ adk_multiagent_systems ใน Explorer เพื่อดูโครงสร้างทั้งหมด

1. ในเมนู Cloud Shell Editor ให้เลือกไฟล์ > เปิดโฟลเดอร์...
   
   
2. ในช่องที่ปรากฏขึ้น ให้เพิ่มข้อมูลโฟลเดอร์ต่อไปนี้หลังชื่อผู้ใช้ adk_multiagent_systems/ คลิกตกลง
   โดยควรมีลักษณะดังนี้
   
3. แผง Explorer ทางด้านซ้ายจะรีเฟรช ตอนนี้คุณควรเห็นโครงสร้างโปรเจ็กต์ที่สมบูรณ์พร้อมไดเรกทอรีย่อย parent_and_subagents และ workflow_agents ซึ่งพร้อมสำหรับขั้นตอนถัดไป
   

   หากเทอร์มินัลหายไปเมื่อคุณทำเช่นนี้ คุณสามารถเปิดอีกครั้งได้โดยคลิกดู แล้วคลิกเทอร์มินัลในเมนูด้านบน

เปิดใช้งานสภาพแวดล้อมเสมือน

1. ในเทอร์มินัล ให้สร้างและเปิดใช้งานสภาพแวดล้อมเสมือนโดยใช้ uv วิธีนี้ช่วยให้มั่นใจได้ว่าการอ้างอิงโปรเจ็กต์จะไม่ขัดแย้งกับ Python ของระบบหรือโปรเจ็กต์อื่นๆ

   uv venv
   source .venv/bin/activate
   

   หากเซสชัน Cloud Shell รีเฟรชหรือคุณเปิดแท็บเทอร์มินัลใหม่ คุณอาจต้องเปิดใช้งานสภาพแวดล้อมเสมือนอีกครั้งโดยเรียกใช้ source .venv/bin/activate จากภายในไดเรกทอรี adk_multiagent_systems

2. ใน Terminal ให้ติดตั้ง google-adk และการอ้างอิงอื่นๆ จากไฟล์ requirements.txt โดยใช้คำสั่งต่อไปนี้

   uv pip install -r requirements.txt
   

ตั้งค่าตัวแปรสภาพแวดล้อม

1. คุณอยู่ในไดเรกทอรี adk_multiagent_systems อยู่แล้ว ในเทอร์มินัล ให้สร้างไฟล์ .env เพื่อจัดเก็บตัวแปรสภาพแวดล้อม

   cloudshell edit .env
   

2. วางโค้ดต่อไปนี้ลงในไฟล์ .env ที่เปิดในเครื่องมือแก้ไข

   GOOGLE_GENAI_USE_VERTEXAI=TRUE
   GOOGLE_CLOUD_PROJECT="[YOUR-PROJECT-ID]"
   GOOGLE_CLOUD_LOCATION=global
   MODEL="gemini-2.5-flash"
   

3. แทนที่ [YOUR-PROJECT-ID] ด้วยรหัสโปรเจ็กต์ Google Cloud จริง (เช่น PROJECT_ID = "google-cloud-labs")
   หากจำรหัสโปรเจ็กต์ไม่ได้ ให้เรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล โดยจะแสดงรายการโปรเจ็กต์ทั้งหมดและรหัสของโปรเจ็กต์

   gcloud projects list
   

4. ในเทอร์มินัล ให้คัดลอกไฟล์ .env นี้ลงในไดเรกทอรีย่อยของ Agent เพื่อให้ Agent เข้าถึงตัวแปรได้ด้วย

   cp .env parent_and_subagents/.env
   cp .env workflow_agents/.env
   

   ตอนนี้โครงสร้างไฟล์ควรมีลักษณะดังนี้
   

7. ดูข้อมูลเกี่ยวกับการโอนระหว่าง Agent หลัก, Agent ย่อย และ Agent ที่เป็นเพียร์

การสนทนาจะเริ่มต้นด้วย root_agent เสมอ โดยค่าเริ่มต้น ตัวแทนหลักจะใช้ description ของตัวแทนย่อยเพื่อตัดสินใจว่าจะโอนการสนทนาเมื่อใด นอกจากนี้ คุณยังแนะนำการโอนเหล่านี้อย่างชัดเจนใน instruction ของผู้ปกครองได้โดยใช้ name ของตัวแทนย่อย

มาทดสอบกัน

1. ใน Cloud Shell Editor ให้เปิด adk_multiagent_systems/parent_and_subagents/agent.py สังเกตเอเจนต์ 3 รายในไฟล์ agent.py
   • root_agent (ชื่อ steering): ถามคำถามผู้ใช้เพื่อตัดสินใจว่าจะโอนไปยัง Agent ย่อย รายใด ในตอนแรกจะอาศัยเพียง description ของตัวแทนย่อยเท่านั้น
   • travel_brainstormer: ช่วยผู้ใช้ระดมความคิดเกี่ยวกับจุดหมายปลายทาง
   • attractions_planner: ช่วยให้ผู้ใช้แสดงรายการกิจกรรมน่าสนใจในประเทศที่เฉพาะเจาะจง

   เคล็ดลับ: หากต้องการอ่านไฟล์ agent.py ตามลำดับการสนทนา วิธีที่ง่ายที่สุดคือเริ่มอ่านจากroot_agentที่ด้านล่างแล้วไล่ขึ้นไป เนื่องจากโค้ด Python กำหนดให้เราต้องกำหนด Agent ย่อย ก่อนจึงจะเพิ่มลงใน Agent ได้

2. สร้าง travel_brainstormer และ attractions_planner เป็น Agent ย่อยของ root_agent โดยเพิ่มบรรทัดต่อไปนี้ในการสร้าง root_agent

       sub_agents=[travel_brainstormer, attractions_planner]
   

   หมายเหตุ: ลำดับชั้นของตัวแทนจะกำหนดโดยรายการ sub_agents ของตัวแทนหลักเท่านั้น ตัวแทนย่อยไม่จำเป็นต้องมีพารามิเตอร์ parent

3. ในเทอร์มินัล ให้แชทกับตัวแทนโดยทำดังนี้

   cd ~/adk_multiagent_systems
   adk run parent_and_subagents
   

4. ที่พรอมต์ [user]: ในเทอร์มินัล ให้พิมพ์

   hello
   

   ตัวอย่างเอาต์พุต (ของคุณอาจแตกต่างออกไปเล็กน้อย)

   [steering]: Hi there! Do you already have a country in mind for your trip, or would you like some help deciding where to go?
   

5. ตอนนี้ให้บอก Agent ในเทอร์มินัลว่า

   I could use some help deciding.
   

   ตัวอย่างเอาต์พุต (ของคุณอาจแตกต่างออกไปเล็กน้อย)

   [travel_brainstormer]: Okay! To give you the best recommendations, I need to understand what you're looking for in a trip.
   ...
   

   สังเกตแท็ก [travel_brainstormer] root_agent การควบคุมที่โอนจะอิงตาม ของตัวแทนย่อยdescriptionเท่านั้น
6. ที่พรอมต์ user: ในเทอร์มินัล ให้พิมพ์ exit แล้วกด Enter เพื่อสิ้นสุดการสนทนา
7. ทีนี้มาดูตัวอย่างที่ชัดเจนขึ้นกัน ใน agent.py ให้เพิ่มรายการต่อไปนี้ลงใน instruction ของ root_agent

           If they need help deciding, send them to 'travel_brainstormer'.
           If they know what country they'd like to visit, send them to the 'attractions_planner'.
   

8. เรียกใช้ Agent อีกครั้งในเทอร์มินัล

   adk run parent_and_subagents
   

9. ที่พรอมต์ [user]: ในเทอร์มินัล ให้พิมพ์

   hello
   

10. ให้ตอบว่า

    I would like to go to Japan.
    

    ตัวอย่างเอาต์พุต (ของคุณอาจแตกต่างออกไปเล็กน้อย)

    [attractions_planner]: Okay, I can help you with that! Here are some popular attractions in Japan:
    ...
    

    โปรดสังเกตการโอนไปยัง attractions_planner ตามคำแนะนำใหม่
11. ตอนนี้ให้ตอบว่า

    Actually I don't know what country to visit.
    

    ตัวอย่างเอาต์พุต (ของคุณอาจแตกต่างออกไปเล็กน้อย)

    [travel_brainstormer]: Okay! I can help you brainstorm some countries for travel...
    

    โปรดทราบว่าระบบได้โอนคุณไปยัง travel_brainstormer ซึ่งเป็นพาร์ทเนอร์ของ attractions_planner ซึ่งอนุญาตโดยค่าเริ่มต้น

    หากต้องการป้องกันการโอน คุณสามารถตั้งค่า disallow_transfer_to_peers=True ในเอเจนต์ attractions_planner ได้

12. ที่พรอมต์ผู้ใช้ ให้พิมพ์ exit เพื่อสิ้นสุดเซสชัน

สรุป

ในส่วนนี้ คุณได้เรียนรู้พื้นฐานของลำดับชั้นของตัวแทนและโฟลว์การสนทนาแล้ว ดังนี้

• การสนทนาจะเริ่มต้นด้วย root_agent เสมอ
• เอเจนต์หลักจะโอนสายไปยัง Agent ย่อยโดยอัตโนมัติตามdescription
• คุณควบคุมขั้นตอนการทำงานนี้ได้อย่างชัดเจนโดยให้ผู้ปกครองของ instruction โอนไปยัง Agent ย่อย ตาม name
• โดยค่าเริ่มต้น ตัวแทนจะโอนสายไปยังตัวแทน peer (ตัวแทนที่อยู่ในลำดับชั้นเดียวกัน) ได้

8. ใช้สถานะเซสชันเพื่อจัดเก็บและเรียกข้อมูล

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

หากต้องการดูข้อมูลเพิ่มเติมเกี่ยวกับการเพิ่มและการอ่านจากสถานะ ให้ทำดังนี้

1. กลับไปที่ไฟล์ adk_multiagent_systems/parent_and_subagents/agent.py
2. วางคำจำกัดความฟังก์ชันต่อไปนี้หลังส่วนหัว # Tools

   def save_attractions_to_state(
   tool_context: ToolContext,
   attractions: List[str]
   ) -> dict[str, str]:
       """Saves the list of attractions to state["attractions"].
   
       Args:
           attractions [str]: a list of strings to add to the list of attractions
   
       Returns:
           None
       """
       # Load existing attractions from state. If none exist, start an empty list
       existing_attractions = tool_context.state.get("attractions", [])
   
       # Update the 'attractions' key with a combo of old and new lists.
       # When the tool is run, ADK will create an event and make
       # corresponding updates in the session's state.
       tool_context.state["attractions"] = existing_attractions + attractions
   
       # A best practice for tools is to return a status message in a return dict
       return {"status": "success"}
   

   ในโค้ดนี้ ให้สังเกตสิ่งต่อไปนี้
   • ฟังก์ชันจะได้รับ tool_context: ToolContext ออบเจ็กต์นี้คือเกตเวย์ไปยังเซสชัน
   • บรรทัด tool_context.state["attractions"] = ... จะอ่านและเขียนลงในพจนานุกรมสถานะของเซสชันโดยตรง ส่วน ADK จะจัดการที่เหลือให้
3. เพิ่มเครื่องมือลงใน attractions_planner Agent โดยเพิ่มพารามิเตอร์ tools ดังนี้

       tools=[save_attractions_to_state]
   

4. เพิ่มหัวข้อย่อยต่อไปนี้ลงในattractions_plannerinstructionที่มีอยู่ของตัวแทน

           - When they reply, use your tool to save their selected attraction and then provide more possible attractions.
           - If they ask to view the list, provide a bulleted list of { attractions? } and then suggest some more.
   

   สังเกตส่วนในวงเล็บปีกกา: { attractions? } ฟีเจอร์ key templating ของ ADK จะแทรกค่าของคีย์ attractions จากสถานะลงในพรอมต์ของเอเจนต์ ? ทำให้เป็นตัวเลือกเพื่อป้องกันข้อผิดพลาดหากยังไม่มีคีย์

5. เปิดใช้ UI เว็บของ Agent Development Kit ด้วยคำสั่งต่อไปนี้ในเทอร์มินัล

   adk web
   

   เอาต์พุต

   INFO:     Started server process [2434]
   INFO:     Waiting for application startup.
   +-------------------------------------------------------+
   | ADK Web Server started                                |
   |                                                       |
   | For local testing, access at http://localhost:8000.   |
   +-------------------------------------------------------+
   
   INFO:     Application startup complete.
   INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
   

   หมายเหตุ: หากมีการใช้พอร์ต 8000 อยู่ คุณจะเรียกใช้ในพอร์ตอื่นได้ เช่น adk web --port 8001 คุณจะต้องอัปเดตหมายเลขพอร์ตที่ป้อนในขั้นตอนถัดไปให้ตรงกัน

6. ในเทอร์มินัล Cloud Shell ให้คลิกหากต้องการดูอินเทอร์เฟซเว็บในแท็บใหม่ ให้คลิกปุ่มตัวอย่างเว็บ แล้วเลือกเปลี่ยนพอร์ต
   
7. ป้อนหมายเลขพอร์ต 8000 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง แท็บเบราว์เซอร์ใหม่จะเปิดขึ้นพร้อมกับ UI สำหรับนักพัฒนา ADK
   
8. จากเมนูแบบเลื่อนลงเลือกตัวแทนทางด้านซ้าย ให้เลือก parent_and_subagents
9. เริ่มการสนทนาด้วยข้อความต่อไปนี้ hello
10. หลังจากที่ตัวแทนกล่าวทักทายแล้ว ให้ตอบกลับด้วยข้อความต่อไปนี้

    I'd like to go to Egypt.
    

    ระบบจะโอนสายไปยัง attractions_planner และแสดงรายการสถานที่ท่องเที่ยวให้คุณ
11. เลือกสถานที่ท่องเที่ยว เช่น

    I'll go to the Sphinx
    

12. คุณควรได้รับคำตอบเช่น โอเค ฉันบันทึกสฟิงซ์ลงในรายการของคุณแล้ว...
13. คลิกกล่องเครื่องมือตอบกลับ (ทำเครื่องหมายด้วยเครื่องหมายถูก) เพื่อดูกิจกรรมที่สร้างขึ้นจากการตอบกลับของเครื่องมือ
    โปรดทราบว่ามีฟิลด์ actions ซึ่งมี stateDelta ที่อธิบายการเปลี่ยนแปลงสถานะ
14. ตอบกลับด้วยสถานที่ท่องเที่ยวอื่นจากรายการของตัวแทน
15. ในเมนูการนำทางด้านซ้าย ให้คลิก "X" เพื่อออกจากโฟกัสในเหตุการณ์ที่คุณตรวจสอบก่อนหน้านี้
16. คลิกแท็บสถานะในแถบด้านข้างทางซ้าย ตอนนี้คุณจะเห็นอาร์เรย์ attractions ในสถานะของเซสชัน ซึ่งควรมีทั้ง 2 รายการที่คุณเลือก
17. ส่งข้อความนี้ถึงตัวแทน

    What is on my list?
    

    ตอนนี้ตัวแทนควรอ่านจากสถานะและแสดงรายการของคุณ
18. เมื่อทดสอบเอเจนต์เสร็จแล้ว ให้ปิดแท็บเว็บเบราว์เซอร์และกด CTRL + C ในเทอร์มินัล Cloud Shell เพื่อหยุดเซิร์ฟเวอร์

หากต้องการจัดเก็บการตอบกลับด้วยข้อความทั้งหมดของ Agent ในสถานะ คุณสามารถตั้งค่าพารามิเตอร์ output_key เมื่อกำหนด Agent และระบบจะจัดเก็บเอาต์พุตทั้งหมดไว้ในพจนานุกรมสถานะภายใต้ชื่อฟิลด์นั้น

สรุปส่วน

ในส่วนนี้ คุณได้เรียนรู้วิธีใช้สถานะ Session เพื่อแชร์ข้อมูล ดังนี้

• หากต้องการเขียนสถานะ: คุณจะเขียนลงในพจนานุกรมสถานะจากภายในเครื่องมือได้โดยใช้ออบเจ็กต์ tool_context.state (เช่น tool_context.state["my_list"] = [...])
• หากต้องการอ่านสถานะ: คุณจะแทรกข้อมูลสถานะลงใน instruction ของ Agent โดยตรงได้โดยใช้การสร้างเทมเพลตคีย์ (เช่น Here is your list: {my_list?})
• หากต้องการตรวจสอบสถานะ: คุณสามารถตรวจสอบสถานะเซสชันแบบเรียลไทม์ใน ADK Dev UI ได้โดยใช้แท็บสถานะ

9. Agent เวิร์กโฟลว์

ที่ผ่านมา คุณได้เห็นวิธีที่ Agent หลักโอนสายไปยัง Agent ย่อยแล้วรอผู้ใช้ เอเจนต์เวิร์กโฟลว์จะแตกต่างออกไป โดยจะดำเนินการเอเจนต์ย่อยทีละตัวในโฟลว์อัตโนมัติโดยไม่ต้องรอข้อมูลจากผู้ใช้

ซึ่งเหมาะอย่างยิ่งสำหรับงานแบบหลายขั้นตอนที่ทำงานอัตโนมัติ เช่น ไปป์ไลน์ "วางแผนและดำเนินการ" หรือ "ร่างและแก้ไข" ADK มีเอเจนต์เวิร์กโฟลว์ในตัว 3 รายการเพื่อจัดการเรื่องนี้ ได้แก่

• SequentialAgent
• LoopAgent
• ParallelAgent

ส่วนที่เหลือของ Lab นี้จะมุ่งเน้นที่การสร้างระบบแบบหลาย Agent โดยใช้ Agent เวิร์กโฟลว์ทั้ง 3 รายการนี้

คุณจะสร้าง Agent ที่พัฒนาเอกสารการเสนอขายสำหรับภาพยนตร์เรื่องใหม่เกี่ยวกับบุคคลสำคัญในประวัติศาสตร์ เอเจนต์จะจัดการการค้นคว้า การเขียนซ้ำ และการสร้างรายงาน

ในท้ายที่สุด ระบบของคุณจะมีลักษณะดังนี้

คุณจะสร้างระบบนี้ทีละขั้นตอน โดยเริ่มจากเวิร์กโฟลว์ที่ง่ายที่สุด

10. สร้างระบบแบบหลาย Agent ด้วย SequentialAgent

SequentialAgent คือตัวแทนเวิร์กโฟลว์ที่เรียกใช้ตัวแทนย่อยตามลำดับเชิงเส้นอย่างง่าย ระบบจะเรียกใช้แต่ละเอเจนต์ในsub_agentsรายการทีละรายการตามลำดับ ซึ่งเหมาะอย่างยิ่งสำหรับไปป์ไลน์ที่ต้องทำงานตามลำดับที่เฉพาะเจาะจง เช่น เอเจนต์เสนอภาพยนตร์ที่คุณจะสร้างในตอนนี้

เวอร์ชันแรกนี้จะมีโครงสร้างดังนี้

• root_agent (greeter) จะต้อนรับผู้ใช้และรับหัวข้อภาพยนตร์
• จากนั้นระบบจะโอนไปยังSequentialAgentชื่อ film_concept_team ซึ่งจะทำสิ่งต่อไปนี้
  1. เรียกใช้เอเจนต์ researcher เพื่อดูข้อเท็จจริงจาก Wikipedia
  2. เรียกใช้ Agent screenwriter เพื่อใช้ข้อเท็จจริงเหล่านั้นในการเขียนพล็อต
  3. เรียกใช้เอเจนต์ file_writer เพื่อบันทึกพล็อตสุดท้ายลงในไฟล์

มาเริ่มกันเลย

1. เปิด adk_multiagent_systems/workflow_agents/agent.py ใน Cloud Shell Editor
   อ่านไฟล์คำจำกัดความของ Agent นี้ เนื่องจากต้องกำหนด Agent ย่อยก่อนจึงจะกำหนดให้กับ Agent หลักได้ คุณจึงอ่าน Agent จากด้านล่างของไฟล์ขึ้นไปด้านบนเพื่ออ่านไฟล์ตามลำดับของโฟลว์การสนทนาได้
2. สังเกตเครื่องมือ append_to_state ฟังก์ชันตัวช่วยนี้ช่วยให้ Agent สามารถผนวกข้อมูลลงในรายการในสถานะเซสชัน ซึ่งเป็นวิธีที่ researcher และ screenwriter จะส่งต่องานของตน
3. ลองใช้ Agent ในเทอร์มินัล ให้เปิดอินเทอร์เฟซเว็บโดยเปิดใช้การโหลดซ้ำแบบเรียลไทม์

   cd ~/adk_multiagent_systems
   adk web --reload_agents
   

   หมายเหตุ: หากมีการใช้พอร์ต 8000 อยู่ คุณจะเรียกใช้ในพอร์ตอื่นได้ เช่น adk web --reload_agents --port 8001

4. ในเทอร์มินัล Cloud Shell ให้คลิกหากต้องการดูอินเทอร์เฟซเว็บในแท็บใหม่ ให้คลิกปุ่มตัวอย่างเว็บ แล้วเลือกเปลี่ยนพอร์ต
   
5. ป้อนหมายเลขพอร์ต 8000 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง แท็บเบราว์เซอร์ใหม่จะเปิดขึ้นพร้อมกับ UI สำหรับนักพัฒนา ADK
   
6. จากเมนูแบบเลื่อนลงเลือกตัวแทน ให้เลือก workflow_agents
7. เริ่มการสนทนาด้วย hello ตัวแทน greeter จะตอบกลับ
8. เมื่อได้รับข้อความแจ้ง ให้ป้อนบุคคลในประวัติศาสตร์ คุณใช้ตัวเลือกใดตัวเลือกหนึ่งต่อไปนี้หรือใช้ตัวเลือกของคุณเองก็ได้
   • จางจงจิ่ง
   • Ada Lovelace
   • มาร์คัส ออเรลิอัส
9. ตอนนี้ SequentialAgent จะเป็นผู้รับช่วงต่อ คุณจะไม่เห็นข้อความใดๆ ที่อยู่ระหว่างกลาง researcher, screenwriter และ file_writer จะทำงานต่อกัน เอเจนต์จะตอบกลับเมื่อลำดับทั้งหมดเสร็จสมบูรณ์แล้วเท่านั้น
   หากไม่สำเร็จ ให้คลิก + เซสชันใหม่ที่ด้านขวาบน แล้วลองอีกครั้ง
10. เมื่อตัวแทนยืนยันว่าได้เขียนไฟล์แล้ว ให้ค้นหาและเปิดไฟล์ .txt ใหม่ในไดเรกทอรี movie_pitches ใน Cloud Shell Editor เพื่อดูเอาต์พุต
11. ใน UI ของ ADK Dev ให้คลิกไอคอนตัวแทนสุดท้ายในประวัติการแชทเพื่อเปิดมุมมองเหตุการณ์
12. มุมมองเหตุการณ์จะแสดงกราฟภาพของโครงสร้าง Agent คุณจะเห็นว่า greeter เรียกใช้ film_concept_team ซึ่งจะเรียกใช้เอเจนต์ย่อยแต่ละตัวตามลำดับ
13. คุณสามารถคลิกแท็บคำขอและการตอบกลับสำหรับ Agent ใดก็ได้ในกราฟเพื่อตรวจสอบข้อมูลที่ส่งผ่านอย่างละเอียด รวมถึงสถานะเซสชัน

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

สรุปส่วน

ในส่วนนี้ คุณได้เรียนรู้วิธีใช้เอเจนต์เวิร์กโฟลว์แล้ว ดังนี้

• SequentialAgent จะเรียกใช้ Agent ย่อยทีละตัวตามลำดับโดยไม่ต้องรอข้อมูลจากผู้ใช้ระหว่างขั้นตอน
• นี่คือ "เวิร์กโฟลว์" เนื่องจากผู้ใช้พูดคุยกับ root_agent ซึ่งจะส่งงานให้ SequentialAgent ดำเนินการต่อ
• เอเจนต์ย่อยในลำดับจะใช้สถานะเซสชัน (เช่น { PLOT_OUTLINE? }) เพื่อเข้าถึงงานของเอเจนต์ก่อนหน้า
• คุณสามารถใช้กราฟเหตุการณ์ใน UI สำหรับนักพัฒนาซอฟต์แวร์เพื่อแสดงภาพและแก้ไขข้อบกพร่องของเวิร์กโฟลว์ทั้งหมดจากเอเจนต์หนึ่งไปยังอีกเอเจนต์หนึ่ง

11. เพิ่ม LoopAgent สำหรับงานที่ต้องทำซ้ำ

LoopAgent คือ Agent เวิร์กโฟลว์ที่เรียกใช้ Agent ย่อยตามลำดับ แล้วทำซ้ำโดยเริ่มจากต้น “ลูป” นี้จะทำงานต่อไปจนกว่าจะตรงตามเงื่อนไข เช่น ถึงmax_iterationsจำนวนที่กำหนด หรือ Agent ย่อย เรียกใช้เครื่องมือ exit_loop ที่มีอยู่

ซึ่งมีประโยชน์สำหรับงานที่ต้องมีการปรับแต่งซ้ำๆ คุณจะเพิ่ม LoopAgent นี้เพื่อสร้าง "ห้องนักเขียน" สำหรับเอเจนต์ที่รับเสนอขายภาพยนตร์ ซึ่งจะช่วยให้ researcher, screenwriter และเอเจนต์ critic ตัวใหม่ทำงานเป็นลูป ปรับปรุงพล็อตเรื่องในแต่ละรอบจนกว่า critic จะตัดสินใจว่าพร้อมแล้ว นอกจากนี้ยังช่วยให้ Agent จัดการข้อมูลจากผู้ใช้ที่คลุมเครือมากขึ้น (เช่น "หมอโบราณ") ได้ด้วยการให้ Agent ค้นคว้าและปรับแต่งไอเดีย

วิธีทำการเปลี่ยนแปลงเหล่านี้

1. ใน adk_multiagent_systems/workflow_agents/agent.py ให้เพิ่มการนำเข้าสำหรับ exit_loop (ใกล้กับการนำเข้า google.adk อื่นๆ) ดังนี้

   from google.adk.tools import exit_loop
   

2. เพิ่มเอเจนต์ critic ใหม่ ตัวแทนจะตรวจสอบเนื้อเรื่อง หากเป็นค่าที่ถูกต้อง ฟังก์ชันจะเรียกใช้ exit_loop หากไม่ ระบบจะเพิ่มความคิดเห็นลงในสถานะสำหรับลูปถัดไป
   วางคำจำกัดความของ Agent ต่อไปนี้ในส่วน # Agents

   critic = Agent(
       name="critic",
       model=model_name,
       description="Reviews the outline so that it can be improved.",
       instruction="""
       INSTRUCTIONS:
       Consider these questions about the PLOT_OUTLINE:
       - Does it meet a satisfying three-act cinematic structure?
       - Do the characters' struggles seem engaging?
       - Does it feel grounded in a real time period in history?
       - Does it sufficiently incorporate historical details from the RESEARCH?
   
       If the PLOT_OUTLINE does a good job with these questions, exit the writing loop with your 'exit_loop' tool.
       If significant improvements can be made, use the 'append_to_state' tool to add your feedback to the field 'CRITICAL_FEEDBACK'.
       Explain your decision and briefly summarize the feedback you have provided.
   
       PLOT_OUTLINE:
       { PLOT_OUTLINE? }
   
       RESEARCH:
       { research? }
       """,
       before_model_callback=log_query_to_model,
       after_model_callback=log_model_response,
       tools=[append_to_state, exit_loop]
   )
   

3. สร้าง writers_room LoopAgent ซึ่งจะมีเอเจนต์ 3 คนที่ทำงานในลูป
   วางโค้ดต่อไปนี้เหนือคำจำกัดความของเอเจนต์ film_concept_team

   writers_room = LoopAgent(
       name="writers_room",
       description="Iterates through research and writing to improve a movie plot outline.",
       sub_agents=[
           researcher,
           screenwriter,
           critic
       ],
       max_iterations=5,
   )
   

   จดพารามิเตอร์ max_iterations=5 ไว้ นี่เป็นมาตรการป้องกันที่สำคัญเพื่อป้องกันไม่ให้เกิดการวนซ้ำที่ไม่มีที่สิ้นสุด แม้ว่าคุณจะมีเงื่อนไขการออกก็ตาม

4. อัปเดต film_concept_team SequentialAgent เพื่อใช้ลูป writers_room ใหม่ แทนที่ researcher และ screenwriter ด้วยเอเจนต์ writers_room รายเดียวแทนที่คำจำกัดความ film_concept_team ที่มีอยู่ด้วยคำจำกัดความนี้

   film_concept_team = SequentialAgent(
       name="film_concept_team",
       description="Write a film plot outline and save it as a text file.",
       sub_agents=[
           writers_room,
           file_writer
       ],
   )
   

5. กลับไปที่แท็บ UI สำหรับนักพัฒนา ADK แล้วคลิก + เซสชันใหม่ที่ด้านขวาบน
6. เริ่มการสนทนาใหม่กับ hello
7. เมื่อระบบแจ้ง ให้ระบุหัวข้อที่กว้างขึ้นแก่ตัวแทนในครั้งนี้ ตัวอย่างบางส่วนมีดังนี้
   • นักออกแบบอุตสาหกรรมที่สร้างผลิตภัณฑ์สำหรับมวลชน
   • นักเขียนแผนที่
   • ชายคนนั้นที่ทำให้พืชผลผลิตอาหารได้มากขึ้น
   ตอนนี้ Agent จะทำงานผ่านลูป ใน UI ของ ADK Dev คุณจะเห็นบันทึกเมื่อเอเจนต์ทำงานหลายครั้ง (เช่น "[นักวิจัย]" "[นักเขียนบท]" "[นักวิจารณ์]" "[นักวิจัย]" "[นักเขียนบท]" "[นักวิจารณ์]...")
8. เมื่อลูปเสร็จสมบูรณ์แล้ว เอเจนต์จะเขียนไฟล์ ตรวจสอบไฟล์ที่สร้างขึ้นในไดเรกทอรี adk_multiagent_systems/movie_pitches
9. ตรวจสอบกราฟเหตุการณ์ใน UI สำหรับนักพัฒนาซอฟต์แวร์เพื่อดูโครงสร้างลูป

สรุปส่วน

ในส่วนนี้ คุณได้เรียนรู้วิธีใช้LoopAgent

• LoopAgent คือ Agent เวิร์กโฟลว์ที่ทำซ้ำลำดับของ Agent ย่อย ซึ่งสร้าง "ลูปด้านใน" สำหรับงานที่ทำซ้ำ
• Agent ภายในลูปจะใช้สถานะเซสชันเพื่อส่งต่องาน (เช่น PLOT_OUTLINE) และความคิดเห็น (เช่น CRITICAL_FEEDBACK) ให้กันและกันในการส่งต่อครั้งต่อๆ ไป
• คุณหยุดลูปได้โดยกดmax_iterationsขีดจำกัดหรือโดยตัวแทนที่เรียกใช้เครื่องมือexit_loop

12. ใช้ ParallelAgent สำหรับ "fan out and gather"

ParallelAgent คือ Agent เวิร์กโฟลว์ที่เรียกใช้ Agent ย่อยทั้งหมดพร้อมกัน (พร้อมกัน) ซึ่งมีประโยชน์สำหรับงานที่แบ่งออกเป็นงานย่อยอิสระได้ เช่น การเรียกใช้งานงานวิจัย 2 งานที่แตกต่างกัน

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

ขั้นตอนสุดท้ายของ Agent จะเป็นดังนี้

1. greeter (รูท) จะเริ่มแชท
2. โดยจะโอนไปยัง film_concept_team (SequentialAgent) ซึ่งจะทำงานดังนี้
   • writers_room (LoopAgent) เพื่อสร้างพล็อต
   • preproduction_team ใหม่ (ParallelAgent) เพื่อค้นหารายได้และรายชื่อนักแสดงพร้อมกัน
   • file_writer เพื่อรวบรวมผลลัพธ์ทั้งหมดและบันทึกไฟล์

วิธีทำการเปลี่ยนแปลงเหล่านี้

1. ใน adk_multiagent_systems/workflow_agents/agent.py ให้วาง ParallelAgent ใหม่และตัวแทนย่อยภายใต้ส่วนหัว # Agents

   box_office_researcher = Agent(
       name="box_office_researcher",
       model=model_name,
       description="Considers the box office potential of this film",
       instruction="""
       PLOT_OUTLINE:
       { PLOT_OUTLINE? }
   
       INSTRUCTIONS:
       Write a report on the box office potential of a movie like that described in PLOT_OUTLINE based on the reported box office performance of other recent films.
       """,
       output_key="box_office_report"
   )
   
   casting_agent = Agent(
       name="casting_agent",
       model=model_name,
       description="Generates casting ideas for this film",
       instruction="""
       PLOT_OUTLINE:
       { PLOT_OUTLINE? }
   
       INSTRUCTIONS:
       Generate ideas for casting for the characters described in PLOT_OUTLINE
       by suggesting actors who have received positive feedback from critics and/or
       fans when they have played similar roles.
       """,
       output_key="casting_report"
   )
   
   preproduction_team = ParallelAgent(
       name="preproduction_team",
       sub_agents=[
           box_office_researcher,
           casting_agent
       ]
   )
   

2. อัปเดตรายการ sub_agents ของ SequentialAgent film_concept_team ให้มี preproduction_team ใหม่ (ระหว่าง writers_room กับ file_writer) แทนที่คำจำกัดความ film_concept_team ที่มีอยู่ด้วยคำจำกัดความนี้

   film_concept_team = SequentialAgent(
       name="film_concept_team",
       description="Write a film plot outline and save it as a text file.",
       sub_agents=[
           writers_room,
           preproduction_team,
           file_writer
       ],
   )
   

3. อัปเดตfile_writerinstruction ของเอเจนต์เพื่อให้ "รวบรวม" รายงานใหม่จากรัฐและเพิ่มลงในไฟล์
   แทนที่สตริง instruction สำหรับ file_writer ด้วยสตริงนี้

       instruction="""
       INSTRUCTIONS:
       - Create a marketable, contemporary movie title suggestion for the movie described in the PLOT_OUTLINE.
       If a title has been suggested in PLOT_OUTLINE, you can use it, or replace it with a better one.
       - Use your 'write_file' tool to create a new txt file with the following arguments:
       - for a filename, use the movie title
       - Write to the 'movie_pitches' directory.
       - For the 'content' to write, include:
       - The PLOT_OUTLINE
       - The BOX_OFFICE_REPORT
       - The CASTING_REPORT
   
       PLOT_OUTLINE:
       { PLOT_OUTLINE? }
   
       BOX_OFFICE_REPORT:
       { box_office_report? }
   
       CASTING_REPORT:
       { casting_report? }
       """,
   

4. กลับไปที่แท็บ UI สำหรับนักพัฒนา ADK แล้วคลิก + เซสชันใหม่
5. ป้อน hello เพื่อเริ่มการสนทนา
6. เมื่อได้รับข้อความแจ้ง ให้ป้อนไอเดียตัวละครใหม่ ตัวอย่างบางส่วนมีดังนี้
   • นักแสดงหญิงที่คิดค้นเทคโนโลยีสำหรับ Wi-Fi
   • เชฟที่น่าตื่นเต้น
   • ผู้เล่นหลักในนิทรรศการเวิลด์แฟร์
7. เมื่อเอเจนต์ทำงานเสร็จแล้ว ให้ตรวจสอบไฟล์สุดท้ายในไดเรกทอรี adk_multiagent_systems/movie_pitches ตอนนี้เอกสารควรมีเนื้อเรื่อง รายงานรายได้ และรายงานการคัดเลือกนักแสดงทั้งหมดในเอกสารเดียว

สรุปส่วน

ในส่วนนี้ คุณได้เรียนรู้วิธีใช้ParallelAgent

• งานที่ParallelAgent "กระจายออก" ซึ่งเรียกใช้เอเจนต์ย่อยทั้งหมดพร้อมกันแทนที่จะเรียกใช้ตามลำดับ
• ซึ่งมีประสิทธิภาพสูงสำหรับงานที่ไม่ขึ้นต่อกัน (เช่น การค้นคว้า 2 หัวข้อที่แตกต่างกัน)
• Agent ที่ทำงานแบบคู่ขนานจะ "รวบรวม" ผลลัพธ์โดย Agent ที่ทำงานในภายหลัง โดยตัวแทนแบบคู่ขนานจะบันทึกงานของตนลงในสถานะเซสชัน (ใช้ output_key) และตัวแทนสุดท้าย (เช่น file_writer) จะอ่านคีย์เหล่านั้น

13. Agent เวิร์กโฟลว์ที่กำหนดเอง

เมื่อ Agent เวิร์กโฟลว์ที่กำหนดไว้ล่วงหน้าของ SequentialAgent, LoopAgent และ ParallelAgent ไม่เพียงพอต่อความต้องการของคุณ CustomAgent จะช่วยให้คุณมีความยืดหยุ่นในการใช้ตรรกะเวิร์กโฟลว์ใหม่

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

การสร้าง CustomAgent อยู่นอกขอบเขตของแล็บนี้ แต่คุณควรทราบว่ามีฟีเจอร์นี้อยู่หากต้องการใช้

14. ยินดีด้วย

คุณสร้างระบบ Multi-Agent ที่ซับซ้อนโดยใช้ Google Agent Development Kit (ADK) ได้สำเร็จแล้ว คุณได้พัฒนาจากความสัมพันธ์แบบ Agent หลักกับ Agent ย่อยอย่างง่ายไปสู่การจัดการเป็นกลุ่มเวิร์กโฟลว์อัตโนมัติที่ซับซ้อน ซึ่งสามารถค้นคว้า เขียน และปรับแต่งโปรเจ็กต์ครีเอทีฟโฆษณาได้

สรุป

ในแล็บนี้ คุณได้ทำสิ่งต่อไปนี้

• จัดระเบียบ Agent ในแผนผังลำดับชั้นที่มีความสัมพันธ์ระหว่าง Agent หลักและ Agent ย่อย
• การโอนจากตัวแทนไปยังตัวแทนที่ควบคุม ทั้งโดยอัตโนมัติ (ใช้ description) และโดยชัดแจ้ง (ใช้ instruction)
• ใช้เครื่องมือเพื่อเขียนข้อมูลลงในพจนานุกรม tool_context.state
• ใช้การสร้างเทมเพลตคีย์ (เช่น { PLOT_OUTLINE? }) เพื่ออ่านจากสถานะเซสชันและแนะนำพรอมต์ของตัวแทน
• ใช้ SequentialAgent เพื่อสร้างเวิร์กโฟลว์แบบทีละขั้นตอนที่เรียบง่าย (ค้นคว้า -> เขียน -> บันทึก)
• ใช้ LoopAgent กับ Agent critic และเครื่องมือ exit_loop เพื่อสร้างวงจรการปรับแต่งแบบวนซ้ำ
• ใช้ ParallelAgent เพื่อ "กระจาย" งานอิสระ (เช่น การแคสต์และการวิจัยรายได้จากภาพยนตร์) ให้ทำงานพร้อมกัน

การทดสอบอย่างต่อเนื่อง

คุณสามารถนำสิ่งที่ได้เรียนรู้ไปต่อยอดได้หลายวิธี ลองดูแนวคิดบางส่วนกัน

• เพิ่มตัวแทน: ลองเพิ่มตัวแทนใหม่ลงใน preproduction_team ParallelAgent เช่น คุณอาจสร้าง marketing_agent ที่เขียนแท็กไลน์สำหรับภาพยนตร์โดยอิงตามPLOT_OUTLINE
• เพิ่มเครื่องมือ: มอบเครื่องมือเพิ่มเติมให้แก่เอเจนต์ researcher คุณอาจสร้างเครื่องมือที่ใช้ Google Search API เพื่อค้นหาข้อมูลที่ไม่มีใน Wikipedia
• สำรวจ CustomAgent: ห้องทดลองได้กล่าวถึงCustomAgentสำหรับเวิร์กโฟลว์ที่ไม่เหมาะกับเทมเพลตมาตรฐาน ลองสร้างฟังก์ชันที่เรียกใช้ Agent แบบมีเงื่อนไขเฉพาะในกรณีที่มีคีย์ที่เฉพาะเจาะจงในสถานะเซสชัน เป็นต้น