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

1. บทนำ

ภาพรวม

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

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

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

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

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

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

ข้อกำหนดเบื้องต้น

  • มีความคุ้นเคยกับ Python และอินเทอร์เฟซบรรทัดคำสั่ง
  • สิทธิ์เข้าถึงโปรเจ็กต์ Google Cloud ที่เปิดใช้การเรียกเก็บเงิน
  • เครื่องมือ CLI ที่ติดตั้ง: gcloud, uv

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

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

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

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

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

โครงสร้างแบบต้นไม้ที่แสดง Agent แบบลำดับชั้น

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

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

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

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

บัญชี Google

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

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

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

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

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

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

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

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

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

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

ข้อควรทราบ

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

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

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

4. เปิดโปรแกรมแก้ไข Cloud Shell

  1. คลิกลิงก์นี้เพื่อไปยังโปรแกรมแก้ไข Cloud Shell โดยตรง
  2. หากระบบแจ้งให้ให้สิทธิ์ในวันนี้ ให้คลิกให้สิทธิ์เพื่อดำเนินการต่อ คลิกเพื่อให้สิทธิ์ Cloud Shell
  3. หากเทอร์มินัลไม่ปรากฏที่ด้านล่างของหน้าจอ ให้เปิดโดยทำดังนี้
    • คลิกดู
    • คลิก Terminalเปิดเทอร์มินัลใหม่ใน Cloud Shell Editor
  4. ในเทอร์มินัล ให้ตั้งค่าโปรเจ็กต์ด้วยคำสั่งนี้
    gcloud config set project [PROJECT_ID]
    • ตัวอย่าง
      gcloud config set project lab-project-id-example
    • หากจำรหัสโปรเจ็กต์ไม่ได้ คุณสามารถแสดงรหัสโปรเจ็กต์ทั้งหมดได้โดยใช้คำสั่งต่อไปนี้
      gcloud projects list
      ตั้งค่ารหัสโปรเจ็กต์ในเทอร์มินัล Cloud Shell Editor
  5. คุณควรเห็นข้อความต่อไปนี้
    Updated property [core/project].

5. เปิดใช้ API

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

  1. เปิดใช้ API ในเทอร์มินัลโดยทำดังนี้
    gcloud services enable aiplatform.googleapis.com

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

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

คุณดูเอกสารประกอบที่ครอบคลุมสำหรับ Google GenAI SDK สำหรับ Python ได้ที่นี่: เอกสารประกอบของ Google GenAI SDK

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. ในเทอร์มินัล ให้ไปที่ไดเรกทอรีการทำงานที่ถูกต้องสำหรับ Lab นี้ (adk_multiagent_systems)
    cd ~/adk_multiagent_systems

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

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

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

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

  1. ในเทอร์มินัล ให้สร้างและเปิดใช้งานสภาพแวดล้อมเสมือนโดยใช้ uv ซึ่งจะช่วยให้มั่นใจว่าการขึ้นต่อกันของโปรเจ็กต์จะไม่ขัดแย้งกับ Python ของระบบหรือโปรเจ็กต์อื่นๆ
    uv venv
source .venv/bin/activate
  2. ในเทอร์มินัล ให้ติดตั้ง google-adk และทรัพยากร Dependency อื่นๆ จากไฟล์ requirements.txt โดยใช้คำสั่งต่อไปนี้
    uv pip install -r requirements.txt

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

  1. คุณอยู่ในไดเรกทอรี adk_multiagent_systems อยู่แล้ว ในเทอร์มินัล ให้สร้างไฟล์ .env เพื่อจัดเก็บตัวแปรสภาพแวดล้อม
    cloudshell edit .env
  2. วางข้อความต่อไปนี้ลงในไฟล์ .env ที่เปิดในเครื่องมือแก้ไข
    GOOGLE_GENAI_USE_ENTERPRISE=true
GOOGLE_CLOUD_PROJECT="[YOUR-PROJECT-ID]"
GOOGLE_CLOUD_LOCATION=global
MODEL="gemini-3.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
    ตอนนี้โครงสร้างไฟล์ควรมีลักษณะดังนี้
    แผง Explorer แสดงโฟลเดอร์ adk_multiagent_systems ที่เปิดอยู่

7. สำรวจการโอนระหว่าง Agent หลัก, Agent ย่อย และ Agent ที่เป็นเพียร์

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

มาทดสอบกัน

  1. เปิด adk_multiagent_systems/parent_and_subagents/agent.py ใน Cloud Shell Editor โปรดสังเกตเอเจนต์ 3 รายในไฟล์ agent.py
    • root_agent (ชื่อ steering): ถามคำถามกับผู้ใช้เพื่อตัดสินใจว่าจะโอนไปยัง Agent ย่อย ใด ในขั้นต้น ระบบจะอาศัยเพียง description ของตัวแทนย่อยเท่านั้น
    • travel_brainstormer: ช่วยผู้ใช้ระดมความคิดเกี่ยวกับจุดหมายปลายทาง
    • attractions_planner: ช่วยให้ผู้ใช้ดูรายการกิจกรรมน่าสนใจในประเทศที่เฉพาะเจาะจง
  2. สร้าง travel_brainstormer และ attractions_planner ให้เป็นตัวแทนย่อยของ root_agent โดยเพิ่มบรรทัดต่อไปนี้ในการสร้าง root_agent
        sub_agents=[travel_brainstormer, attractions_planner]
  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. ตอนนี้ให้บอกตัวแทนในเทอร์มินัลว่า
    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 โดยค่าเริ่มต้น ระบบจะอนุญาต
  12. ที่พรอมต์ผู้ใช้ ให้พิมพ์ exit เพื่อสิ้นสุดเซสชัน

สรุป

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

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

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.
  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)
  6. ในเทอร์มินัล Cloud Shell ให้คลิกปุ่มตัวอย่างเว็บ แล้วเลือกเปลี่ยนพอร์ตเพื่อดูอินเทอร์เฟซเว็บในแท็บใหม่
    เมนูตัวอย่างเว็บ
  7. ป้อนหมายเลขพอร์ต 8000 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง แท็บเบราว์เซอร์ใหม่จะเปิดขึ้นพร้อม UI สำหรับนักพัฒนา ADK
    เปลี่ยนช่องป๊อปอัปพอร์ตโดยป้อน 8000 ในกล่องข้อความ
  8. จากเมนูแบบเลื่อนลงเลือกตัวแทนทางด้านซ้าย ให้เลือก parent_and_subagents
  9. เริ่มการสนทนาด้วย hello
  10. หลังจากตัวแทนทักทายคุณแล้ว ให้ตอบกลับด้วยข้อความต่อไปนี้
    I'd like to go to Egypt.
    ระบบจะโอนสายไปยัง attractions_planner และแสดงรายการสถานที่ท่องเที่ยวให้คุณ
  11. เลือกสถานที่ท่องเที่ยว เช่น
    I'll go to the Sphinx
  12. คุณควรได้รับคำตอบเช่น โอเค ฉันบันทึก The Sphinx ลงในรายการของคุณแล้ว...
  13. คลิกกล่องเครื่องมือตอบกลับ (ทำเครื่องหมายด้วยเครื่องหมายถูก) เพื่อดูกิจกรรมที่สร้างขึ้นจากการตอบกลับของเครื่องมือ
    โปรดทราบว่ามีฟิลด์ actions ซึ่งมี stateDelta ที่อธิบายการเปลี่ยนแปลงสถานะ
  14. ตอบกลับด้วยสถานที่ท่องเที่ยวอื่นจากรายการของเอเจนต์
  15. ในเมนูการนำทางด้านซ้ายมือ ให้คลิก "X" เพื่อออกจากโฟกัสที่เหตุการณ์ที่คุณตรวจสอบก่อนหน้านี้
  16. คลิกแท็บสถานะในแถบด้านข้างทางซ้าย ตอนนี้คุณจะเห็นอาร์เรย์ attractions ในสถานะของเซสชัน ซึ่งควรมีทั้ง 2 รายการที่คุณเลือกตัวอย่างสถานะเซสชันใน UI บนเว็บ
  17. ส่งข้อความนี้ถึงตัวแทน
    What is on my list?
    ตอนนี้ตัวแทนควรอ่านจากสถานะและแสดงรายการของคุณ
  18. เมื่อทดสอบเอเจนต์เสร็จแล้ว ให้ปิดแท็บเว็บเบราว์เซอร์ แล้วกด CTRL + C ในเทอร์มินัล Cloud Shell เพื่อหยุดเซิร์ฟเวอร์

สรุปส่วน

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

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

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

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

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

  • SequentialAgent
  • LoopAgent
  • ParallelAgent

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

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

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

แผนภาพระบบ Multi-Agent ของทีมแนวคิดภาพยนตร์

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

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

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

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

Film_concept_team multi-agent system step 1

  • 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
    อ่านไฟล์คำจำกัดความของเอเจนต์นี้ เนื่องจากต้องกำหนดตัวแทนย่อยก่อนจึงจะกำหนดให้กับตัวแทนหลักได้ หากต้องการอ่านไฟล์ตามลำดับของโฟลว์การสนทนา ให้อ่านตัวแทนจากด้านล่างของไฟล์ขึ้นไปด้านบน
  2. สังเกตเครื่องมือ append_to_state ฟังก์ชันตัวช่วยนี้ช่วยให้ตัวแทนสามารถผนวกข้อมูลลงในรายการในสถานะเซสชัน ซึ่งเป็นวิธีที่ researcher และ screenwriter จะส่งต่องานของตน
  3. ลองใช้ Agent ในเทอร์มินัล ให้เปิดอินเทอร์เฟซเว็บโดยเปิดใช้การโหลดซ้ำแบบเรียลไทม์
    cd ~/adk_multiagent_systems
adk web --reload_agents
  4. ในเทอร์มินัล Cloud Shell ให้คลิกปุ่มตัวอย่างเว็บ แล้วเลือกเปลี่ยนพอร์ตเพื่อดูอินเทอร์เฟซเว็บในแท็บใหม่
    เมนูตัวอย่างเว็บ
  5. ป้อนหมายเลขพอร์ต 8000 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง แท็บเบราว์เซอร์ใหม่จะเปิดขึ้นพร้อม UI สำหรับนักพัฒนา ADK
    เปลี่ยนช่องป๊อปอัปพอร์ตโดยป้อน 8000 ในกล่องข้อความ
  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. มุมมองเหตุการณ์จะแสดงกราฟภาพของแผนผังตัวแทน คุณจะเห็นว่า greeter เรียก film_concept_team ซึ่งจะเรียกเอเจนต์ย่อยแต่ละตัวตามลำดับกราฟเว็บ ADK
  13. คุณสามารถคลิกแท็บคำขอและการตอบกลับสำหรับเอเจนต์ใดก็ได้ในกราฟเพื่อตรวจสอบข้อมูลที่ส่งผ่านอย่างละเอียด รวมถึงสถานะเซสชัน

สรุปส่วน

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

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

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

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

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

Film_concept_team multi-agent system step 2

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

  1. ใน adk_multiagent_systems/workflow_agents/agent.py ให้เพิ่มการนำเข้าสำหรับ exit_loop (ใกล้กับการนำเข้า google.adk อื่นๆ) ดังนี้
    from google.adk.tools import exit_loop
  2. เพิ่มเอเจนต์ critic ใหม่ ตัวแทนจะตรวจสอบเนื้อเรื่อง หากเป็นค่าที่ถูกต้อง ฟังก์ชันจะเรียกใช้ exit_loop หากไม่ ระบบจะเพิ่มความคิดเห็นลงในสถานะสำหรับลูปถัดไป
    วางคำจำกัดความของเอเจนต์ต่อไปนี้ในส่วน # 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,
)
  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 Dev แล้วคลิก + เซสชันใหม่ที่ด้านขวาบน
  6. เริ่มการสนทนาใหม่กับ hello
  7. เมื่อได้รับข้อความแจ้ง ให้ระบุหัวข้อที่กว้างขึ้นแก่ตัวแทนในครั้งนี้ ตัวอย่างไอเดีย
    • นักออกแบบอุตสาหกรรมที่สร้างผลิตภัณฑ์สำหรับมวลชน
    • นักเขียนแผนที่
    • ชายคนนั้นที่ทำให้พืชผลผลิตอาหารได้มากขึ้น
    ตอนนี้ Agent จะทำงานผ่านลูป ใน UI ของ ADK Dev คุณจะเห็นบันทึกเมื่อเอเจนต์ทํางานหลายครั้ง (เช่น "[นักวิจัย]" "[นักเขียนบท]" "[นักวิจารณ์]" "[นักวิจัย]" "[นักเขียนบท]" "[นักวิจารณ์]...")
  8. เมื่อลูปเสร็จสมบูรณ์ เอเจนต์จะเขียนไฟล์ ตรวจสอบไฟล์ที่สร้างขึ้นในไดเรกทอรี adk_multiagent_systems/movie_pitches
  9. ตรวจสอบกราฟเหตุการณ์ใน UI สำหรับนักพัฒนาซอฟต์แวร์เพื่อดูโครงสร้างลูป

สรุปส่วน

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

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

12. ใช้ ParallelAgent สำหรับ "Fan Out and Gather"

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

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

Film_concept_team multi-agent system step 3

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

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

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

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