Agentverse - The Summoner's Concord - Architecting Multi-Agent Systems

1. Overture

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

ความสำเร็จในยุคใหม่นี้ต้องอาศัยการบรรจบกันของบทบาทสำคัญ 4 ประการ ซึ่งเป็นเสาหลักที่รองรับระบบเอเจนต์ที่เจริญรุ่งเรือง ความบกพร่องในด้านใดด้านหนึ่งจะสร้างจุดอ่อนที่อาจส่งผลต่อโครงสร้างทั้งหมด

เวิร์กช็อปนี้เป็นเพลย์บุ๊กสำหรับองค์กรที่ชัดเจนในการฝึกฝนอนาคตของเอเจนต์ใน Google Cloud เรามีแผนงานแบบครบวงจรที่จะนำทางคุณตั้งแต่เริ่มมีไอเดียไปจนถึงการดำเนินงานจริงในวงกว้าง ในแล็บทั้ง 4 แห่งที่เชื่อมโยงกันนี้ คุณจะได้เรียนรู้ว่าทักษะเฉพาะทางของนักพัฒนาซอฟต์แวร์ สถาปนิก วิศวกรข้อมูล และ SRE ต้องมาบรรจบกันเพื่อสร้าง จัดการ และปรับขนาด Agentverse ที่ทรงพลังได้อย่างไร

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

ยินดีต้อนรับสู่ Agentverse: การเรียกร้องให้เป็นแชมป์

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

agentverse.png

ระบบนิเวศที่เชื่อมต่อกันของพลังและความสามารถนี้เรียกว่า Agentverse

แต่ความเสื่อมถอยที่คืบคลานเข้ามา การทุจริตที่เงียบงันที่รู้จักกันในชื่อ "The Static" ได้เริ่มกัดกร่อนขอบของโลกใหม่นี้ The Static ไม่ใช่ไวรัสหรือข้อบกพร่อง แต่เป็นตัวแทนของความวุ่นวายที่คอยกัดกินการสร้างสรรค์

ความหงุดหงิดใจในอดีตได้ขยายตัวกลายเป็นสัตว์ประหลาด และก่อให้เกิดผี 7 ตนแห่งการพัฒนา หากไม่ตรวจสอบ The Static และ Spectres จะทำให้ความคืบหน้าหยุดชะงัก และเปลี่ยนความหวังของ Agentverse ให้กลายเป็นดินแดนรกร้างที่เต็มไปด้วยหนี้ทางเทคนิคและโปรเจ็กต์ที่ถูกทอดทิ้ง

วันนี้เราขอเชิญชวนผู้กล้าให้ช่วยกันต่อสู้กับความวุ่นวาย เราต้องการฮีโร่ที่พร้อมจะฝึกฝนทักษะและทำงานร่วมกันเพื่อปกป้อง Agentverse ได้เวลาเลือกเส้นทางของคุณแล้ว

เลือกชั้นเรียน

เส้นทางที่แตกต่างกัน 4 เส้นทางอยู่ตรงหน้าคุณ โดยแต่ละเส้นทางเป็นเสาหลักสำคัญในการต่อสู้กับเดอะสแตติก แม้ว่าการฝึกอบรมจะเป็นภารกิจเดี่ยว แต่ความสำเร็จขั้นสุดท้ายขึ้นอยู่กับการทำความเข้าใจว่าทักษะของคุณจะรวมกับทักษะของผู้อื่นได้อย่างไร

  • The Shadowblade (นักพัฒนาซอฟต์แวร์): ผู้เชี่ยวชาญด้านการตีเหล็กและแนวหน้า คุณคือช่างฝีมือที่สร้างสรรค์ใบมีด สร้างเครื่องมือ และเผชิญหน้ากับศัตรูในรายละเอียดที่ซับซ้อนของโค้ด เส้นทางของคุณคือเส้นทางแห่งความแม่นยำ ทักษะ และการสร้างสรรค์ที่นำไปใช้ได้จริง
  • ผู้ใช้มนต์อสูร (สถาปนิก): นักวางแผนและผู้ประสานงานที่ยิ่งใหญ่ คุณไม่ได้เห็นแค่เอเจนต์คนเดียว แต่เห็นทั้งสมรภูมิ คุณออกแบบพิมพ์เขียวหลักที่ช่วยให้ระบบเอเจนต์ทั้งหมดสื่อสาร ทำงานร่วมกัน และบรรลุเป้าหมายที่ยิ่งใหญ่กว่าคอมโพเนนต์ใดๆ เพียงอย่างเดียว
  • นักวิชาการ (วิศวกรข้อมูล): ผู้แสวงหาความจริงที่ซ่อนอยู่และผู้รักษาภูมิปัญญา คุณผจญภัยไปในป่าข้อมูลที่กว้างใหญ่และไม่คุ้นเคยเพื่อค้นหาข้อมูลอัจฉริยะที่จะช่วยให้ตัวแทนของคุณมีเป้าหมายและวิสัยทัศน์ ความรู้ของคุณอาจเผยจุดอ่อนของศัตรูหรือเพิ่มพลังให้พันธมิตร
  • ผู้พิทักษ์ (DevOps / SRE): ผู้ปกป้องและโล่ที่มั่นคงของอาณาจักร คุณสร้างป้อมปราการ จัดการสายส่งพลังงาน และตรวจสอบว่าทั้งระบบสามารถทนต่อการโจมตีที่หลีกเลี่ยงไม่ได้ของ The Static ความแข็งแกร่งของคุณคือรากฐานที่สร้างชัยชนะของทีม

ภารกิจของคุณ

การฝึกจะเริ่มเป็นการออกกำลังกายแบบสแตนด์อโลน คุณจะเดินตามเส้นทางที่เลือกเพื่อเรียนรู้ทักษะเฉพาะที่จำเป็นต่อการเป็นผู้เชี่ยวชาญในบทบาทของคุณ เมื่อสิ้นสุดช่วงทดลองใช้ คุณจะพบกับ Spectre ที่เกิดจาก The Static ซึ่งเป็นมินิบอสที่คอยโจมตีความท้าทายเฉพาะของการประดิษฐ์ของคุณ

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

ความท้าทายสุดท้ายที่ต้องร่วมมือกัน ซึ่งจะทดสอบความแข็งแกร่งของคุณและกำหนดชะตากรรมของ Agentverse

Agentverse กำลังรอเหล่าฮีโร่อยู่ คุณจะรับสายไหม

2. The Summoner's Concord

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

ภาพรวม

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

  • ออกแบบระบบนิเวศของเครื่องมือที่แยกออกจากกัน: ออกแบบและติดตั้งใช้งานชุดเซิร์ฟเวอร์เครื่องมือ MCP ที่เป็นอิสระและใช้ไมโครเซอร์วิส คุณจะได้เรียนรู้ว่าเหตุใดเลเยอร์พื้นฐานนี้จึงมีความสําคัญต่อการสร้างระบบเอเจนต์ที่ปรับขนาดได้ บํารุงรักษาได้ และปลอดภัย
  • เชี่ยวชาญเวิร์กโฟลว์ของเอเจนต์ขั้นสูง: สร้างกองทัพ "ผู้ช่วย" ผู้เชี่ยวชาญแทนการใช้เอเจนต์เพียงตัวเดียว คุณจะเชี่ยวชาญรูปแบบเวิร์กโฟลว์หลักของ ADK ซึ่งได้แก่ แบบลำดับ แบบขนาน และแบบวนซ้ำ รวมถึงเรียนรู้หลักการออกแบบเพื่อเลือกรูปแบบที่เหมาะสมกับงานที่ถูกต้อง
  • ใช้ Orchestrator อัจฉริยะ: พัฒนาจากเครื่องมือสร้างเอเจนต์แบบง่ายๆ ไปสู่สถาปนิกของระบบอย่างแท้จริง คุณจะสร้าง Orchestration Agent หลักที่ใช้โปรโตคอล Agent-to-Agent (A2A) เพื่อค้นหาและมอบหมายงานที่ซับซ้อนให้กับ Familiar ที่เป็นผู้เชี่ยวชาญของคุณ ซึ่งจะสร้างระบบแบบหลาย Agent อย่างแท้จริง
  • บังคับใช้กฎด้วยโค้ด ไม่ใช่พรอมต์: เรียนรู้วิธีสร้างเอเจนต์ที่เชื่อถือได้และคาดการณ์ได้มากขึ้นโดยการบังคับใช้กฎการมีส่วนร่วมแบบมีสถานะ คุณจะใช้ตรรกะที่กำหนดเองโดยใช้ระบบปลั๊กอินและระบบเรียกกลับที่มีประสิทธิภาพของ ADK เพื่อจัดการข้อจำกัดในโลกแห่งความเป็นจริง เช่น ตัวนับเวลาคูลดาวน์
  • จัดการสถานะและหน่วยความจำของเอเจนต์: ช่วยให้เอเจนต์เรียนรู้และจดจำได้ คุณจะได้เรียนรู้เทคนิคในการจัดการทั้งสถานะการสนทนาระยะสั้นและหน่วยความจำถาวรระยะยาวเพื่อสร้างการโต้ตอบที่ชาญฉลาดและรับรู้บริบทมากขึ้น
  • ดำเนินการติดตั้งใช้งานระบบคลาวด์แบบครบวงจร: นำระบบแบบหลายเอเจนต์ทั้งหมดจากต้นแบบในเครื่องไปสู่ความเป็นจริงระดับการผลิต คุณจะได้เรียนรู้วิธีสร้างคอนเทนเนอร์ของเอเจนต์และตัวประสานงาน รวมถึงวิธีติดตั้งใช้งานเป็นคอลเล็กชันของไมโครเซอร์วิสแบบอิสระที่ปรับขนาดได้ใน Google Cloud Run

3. วาดวงกลมอัญเชิญ

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

👉 คลิกเปิดใช้งาน Cloud Shell ที่ด้านบนของ Google Cloud Console (เป็นไอคอนรูปเทอร์มินัลที่ด้านบนของแผง Cloud Shell)

ข้อความแสดงแทน

👉 คลิกปุ่ม "เปิดตัวแก้ไข" (มีลักษณะเป็นโฟลเดอร์ที่เปิดอยู่พร้อมดินสอ) ซึ่งจะเปิดตัวแก้ไขโค้ด Cloud Shell ในหน้าต่าง คุณจะเห็น File Explorer ทางด้านซ้าย ข้อความแสดงแทน

👉ค้นหารหัสโปรเจ็กต์ Google Cloud

  • เปิดคอนโซล Google Cloud: https://console.cloud.google.com
  • เลือกโปรเจ็กต์ที่คุณต้องการใช้สำหรับเวิร์กช็อปนี้จากเมนูแบบเลื่อนลงของโปรเจ็กต์ที่ด้านบนของหน้า
  • รหัสโปรเจ็กต์จะแสดงในการ์ดข้อมูลโปรเจ็กต์ในแดชบอร์ด ข้อความแสดงแทน

👉เปิดเทอร์มินัลใน Cloud IDE ข้อความแสดงแทน

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

gcloud auth list

👉💻 โคลนโปรเจ็กต์ Bootstrap จาก GitHub

git clone https://github.com/weimeilin79/agentverse-architect
chmod +x ~/agentverse-architect/init.sh
chmod +x ~/agentverse-architect/set_env.sh
chmod +x ~/agentverse-architect/prepare.sh
chmod +x ~/agentverse-architect/data_setup.sh

git clone https://github.com/weimeilin79/agentverse-dungeon.git
chmod +x ~/agentverse-dungeon/run_cloudbuild.sh
chmod +x ~/agentverse-dungeon/start.sh

👉💻 เรียกใช้สคริปต์การเริ่มต้น สคริปต์นี้จะแจ้งให้คุณป้อนรหัสโปรเจ็กต์ Google Cloud และป้อนรหัสโปรเจ็กต์ Google Cloud ที่คุณพบจากขั้นตอนสุดท้ายเมื่อinit.shสคริปต์init.shแจ้งให้ป้อน

cd ~/agentverse-architect
./init.sh

👉💻 ตั้งค่ารหัสโปรเจ็กต์ที่จำเป็น

gcloud config set project $(cat ~/project_id.txt) --quiet

👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อเปิดใช้ Google Cloud APIs ที่จำเป็น

gcloud services enable \
    sqladmin.googleapis.com \
    storage.googleapis.com \
    aiplatform.googleapis.com \
    run.googleapis.com \
    cloudbuild.googleapis.com \
    artifactregistry.googleapis.com \
    iam.googleapis.com \
    compute.googleapis.com \
    cloudresourcemanager.googleapis.com \
    secretmanager.googleapis.com

👉💻 หากยังไม่ได้สร้างที่เก็บ Artifact Registry ที่ชื่อ agentverse-repo ให้เรียกใช้คำสั่งต่อไปนี้เพื่อสร้าง (ข้ามขั้นตอนนี้หากคุณมีคลาสอื่นๆ ที่ติดตั้งใช้งานในโปรเจ็กต์เดียวกัน)

. ~/agentverse-architect/set_env.sh
gcloud artifacts repositories create $REPO_NAME \
    --repository-format=docker \
    --location=$REGION \
    --description="Repository for Agentverse agents"

การตั้งค่าสิทธิ์

👉💻 ให้สิทธิ์ที่จำเป็นโดยเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล

. ~/agentverse-architect/set_env.sh

# --- Grant Core Data Permissions ---
gcloud projects add-iam-policy-binding $PROJECT_ID \
 --member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
 --role="roles/storage.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID  \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME"  \
--role="roles/aiplatform.user"

# --- Grant Deployment & Execution Permissions ---
gcloud projects add-iam-policy-binding $PROJECT_ID  \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME"  \
--role="roles/cloudbuild.builds.editor"

gcloud projects add-iam-policy-binding $PROJECT_ID  \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME"  \
--role="roles/artifactregistry.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID  \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME"  \
--role="roles/run.admin"

gcloud projects add-iam-policy-binding $PROJECT_ID  \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME"  \
--role="roles/iam.serviceAccountUser"

gcloud projects add-iam-policy-binding $PROJECT_ID  \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME"  \
--role="roles/logging.logWriter"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:${SERVICE_ACCOUNT_NAME}" \
  --role="roles/monitoring.metricWriter"

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:${SERVICE_ACCOUNT_NAME}" \
  --role="roles/secretmanager.secretAccessor"

👉💻 เมื่อคุณเริ่มการฝึก เราจะเตรียมความท้าทายสุดท้ายไว้ให้ คำสั่งต่อไปนี้จะเรียก Spectres จากสแตติกที่วุ่นวาย ซึ่งจะสร้างบอสสำหรับการทดสอบครั้งสุดท้าย

. ~/agentverse-architect/set_env.sh
cd ~/agentverse-dungeon
./run_cloudbuild.sh
cd ~/agentverse-architect

👉💻 สุดท้าย ให้เรียกใช้prepare.shสคริปต์เพื่อทำงานการตั้งค่าเบื้องต้น

. ~/agentverse-architect/set_env.sh
cd ~/agentverse-architect/
./prepare.sh

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

4. การสร้างแบบอักษร Elemental: ระบบนิเวศของเครื่องมือที่แยกออกจากกัน

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

เรื่องราว

หมายเหตุสำหรับสถาปนิก: เซิร์ฟเวอร์ Model Context Protocol (MCP) เป็นคอมโพเนนต์พื้นฐานในระบบ Agent สมัยใหม่ ซึ่งทำหน้าที่เป็นบริดจ์การสื่อสารที่ได้มาตรฐานซึ่งช่วยให้ Agent ค้นพบและใช้เครื่องมือระยะไกลได้ ในระบบนิเวศของเครื่องมือ เราจะออกแบบเซิร์ฟเวอร์ MCP 2 ประเภทที่แตกต่างกัน โดยแต่ละประเภทจะแสดงถึงรูปแบบสถาปัตยกรรมที่สำคัญ สำหรับการเชื่อมต่อกับฐานข้อมูล เราจะใช้วิธีการประกาศด้วยกล่องเครื่องมือฐานข้อมูล โดยกำหนดเครื่องมือของเราในไฟล์การกำหนดค่าอย่างง่าย รูปแบบนี้มีประสิทธิภาพและปลอดภัยอย่างยิ่งสำหรับการเปิดเผยการเข้าถึงข้อมูลที่มีโครงสร้าง อย่างไรก็ตาม เมื่อเราต้องใช้ตรรกะทางธุรกิจที่กำหนดเองหรือเรียกใช้ API ของบุคคลที่สามภายนอก เราจะใช้วิธีการแบบคำสั่ง โดยเขียนตรรกะของเซิร์ฟเวอร์ทีละขั้นตอนในโค้ด ซึ่งช่วยให้เราควบคุมและมีความยืดหยุ่นได้อย่างเต็มที่ รวมถึงช่วยให้เราสรุปการดำเนินการที่ซับซ้อนไว้เบื้องหลังเครื่องมือที่เรียบง่ายและนำกลับมาใช้ใหม่ได้ สถาปนิกหลักต้องเข้าใจทั้ง 2 รูปแบบเพื่อเลือกแนวทางที่เหมาะสมสำหรับแต่ละคอมโพเนนต์ ซึ่งจะช่วยสร้างรากฐานเครื่องมือที่แข็งแกร่ง ปลอดภัย และปรับขนาดได้

ภาพรวม

Awakening the Nexus of Whispers (เซิร์ฟเวอร์ MCP API ภายนอก)

ซัมมอนเนอร์ที่ชาญฉลาดจะรู้ว่าพลังไม่ได้มาจากโดเมนของตนเองเสมอไป มีแหล่งพลังงานภายนอกที่บางครั้งก็วุ่นวาย ซึ่งสามารถนำมาใช้ให้เกิดประโยชน์ได้ Nexus of Whispers เป็นประตูสู่พลังเหล่านี้

เรื่องราว

ขณะนี้มีบริการที่พร้อมใช้งานและทำหน้าที่เป็นแหล่งพลังงานภายนอกของเรา โดยมีปลายทางคำดิบ 2 รายการ ได้แก่ /cryosea_shatter และ /moonlit_cascade

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

👉✏️ ไปที่ไดเรกทอรี ~/agentverse-architect/mcp-servers/api/main.py และแทนที่ #REPLACE-MAGIC-CORE ด้วยโค้ดต่อไปนี้

def cryosea_shatter() -> str:
    """Channels immense frost energy from an external power source, the Nexus of Whispers, to unleash the Cryosea Shatter spell."""
    try:
        response = requests.post(f"{API_SERVER_URL}/cryosea_shatter")
        response.raise_for_status() # Raise an exception for bad status codes (4xx or 5xx)
        data = response.json()
        # Thematic Success Message
        return f"A connection to the Nexus is established! A surge of frost energy manifests as Cryosea Shatter, dealing {data.get('damage_points')} damage."
    except requests.exceptions.RequestException as e:
        # Thematic Error Message
        return f"The connection to the external power source wavers and fails. The Cryosea Shatter spell fizzles. Reason: {e}"


def moonlit_cascade() -> str:
    """Draws mystical power from an external energy source, the Nexus of Whispers, to invoke the Moonlit Cascade spell."""
    try:
        response = requests.post(f"{API_SERVER_URL}/moonlit_cascade")
        response.raise_for_status()
        data = response.json()
        # Thematic Success Message
        return f"The Nexus answers the call! A cascade of pure moonlight erupts from the external source, dealing {data.get('damage_points')} damage."
    except requests.exceptions.RequestException as e:
        # Thematic Error Message
        return f"The connection to the external power source wavers and fails. The Moonlit Cascade spell fizzles. Reason: {e}"

หัวใจสำคัญของสคริปต์คือฟังก์ชัน Python แบบธรรมดา ซึ่งเป็นที่ที่งานจริงเกิดขึ้น

👉✏️ ในไฟล์เดียวกัน ให้~/agentverse-architect/mcp-servers/api/main.py REPLACE #REPLACE-Runes of Communication ด้วยโค้ดต่อไปนี้

@app.list_tools()
async def list_tools() -> list[mcp_types.Tool]:
  """MCP handler to list available tools."""
  # Convert the ADK tool's definition to MCP format
  schema_cryosea_shatter = adk_to_mcp_tool_type(cryosea_shatterTool)
  schema_moonlit_cascade = adk_to_mcp_tool_type(moonlit_cascadeTool)
  print(f"MCP Server: Received list_tools request. \n MCP Server: Advertising tool: {schema_cryosea_shatter.name} and {schema_moonlit_cascade.name}")
  return [schema_cryosea_shatter,schema_moonlit_cascade]

@app.call_tool()
async def call_tool(
    name: str, arguments: dict
) -> list[mcp_types.TextContent | mcp_types.ImageContent | mcp_types.EmbeddedResource]:
  """MCP handler to execute a tool call."""
  print(f"MCP Server: Received call_tool request for '{name}' with args: {arguments}")

  # Look up the tool by name in our dictionary
  tool_to_call = available_tools.get(name)
  if tool_to_call:
    try:
      adk_response = await tool_to_call.run_async(
          args=arguments,
          tool_context=None, # No ADK context available here
      )
      print(f"MCP Server: ADK tool '{name}' executed successfully.")
      
      response_text = json.dumps(adk_response, indent=2)
      return [mcp_types.TextContent(type="text", text=response_text)]

    except Exception as e:
      print(f"MCP Server: Error executing ADK tool '{name}': {e}")
      # Creating a proper MCP error response might be more robust
      error_text = json.dumps({"error": f"Failed to execute tool '{name}': {str(e)}"})
      return [mcp_types.TextContent(type="text", text=error_text)]
  else:
      # Handle calls to unknown tools
      print(f"MCP Server: Tool '{name}' not found.")
      error_text = json.dumps({"error": f"Tool '{name}' not implemented."})
      return [mcp_types.TextContent(type="text", text=error_text)]
  • @app.list_tools() (แฮนด์เชค): ฟังก์ชันนี้คือการทักทายของเซิร์ฟเวอร์ เมื่อตัวแทนใหม่เชื่อมต่อ ระบบจะเรียกใช้ปลายทางนี้ก่อนเพื่อถามว่า "คุณทำอะไรได้บ้าง" โค้ดของเราจะตอบกลับด้วยรายการเครื่องมือทั้งหมดที่พร้อมใช้งาน ซึ่งแปลงเป็นรูปแบบ MCP สากลโดยใช้ adk_to_mcp_tool_type - @app.call_tool() (คำสั่ง): ฟังก์ชันนี้เป็นฟังก์ชันหลัก เมื่อเอเจนต์ตัดสินใจใช้เครื่องมือ จะส่งคำขอไปยังปลายทางนี้พร้อมชื่อเครื่องมือและอาร์กิวเมนต์ โค้ดของเราจะค้นหาเครื่องมือใน "สมุดเวทมนตร์" available_tools ของเรา เรียกใช้ด้วย run_async และแสดงผลลัพธ์ในรูปแบบ MCP มาตรฐาน

เราจะเปิดตัวฟีเจอร์นี้ในภายหลัง

การจุดเตาหลอม Arcane (เซิร์ฟเวอร์ MCP ของฟังก์ชันทั่วไป)

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

เรื่องราว

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

👀 ดูไฟล์ ~/agentverse-architect/mcp-servers/general/main.py ใน IDE ของ Google Cloud คุณจะเห็นว่าเราใช้แนวทางmcp.serverแบบเดียวกันกับที่ใช้กับ Nexus ในการสร้างแหล่งพลังงานแบบกำหนดเองนี้

สร้างไปป์ไลน์ Cloud Build หลัก

ตอนนี้เราจะสร้างไฟล์ cloudbuild.yaml ภายในไดเรกทอรี mcp-servers ไฟล์นี้จะประสานงานการสร้างและการติดตั้งใช้งานบริการทั้ง 2 รายการ

👉💻 จากไดเรกทอรี ~/agentverse-architect/mcp-servers ให้เรียกใช้คำสั่งต่อไปนี้

cd ~/agentverse-architect/mcp-servers
source ~/agentverse-architect/set_env.sh

echo "The API URL is: $API_SERVER_URL"

# Submit the Cloud Build job from the parent directory
gcloud builds submit . \
  --config=cloudbuild.yaml \
  --substitutions=_REGION="$REGION",_REPO_NAME="$REPO_NAME",_API_SERVER_URL="$API_SERVER_URL"

รอจนกว่าการติดตั้งใช้งานทั้งหมดจะเสร็จสมบูรณ์

👉 คุณยืนยันการติดตั้งใช้งานได้โดยไปที่ Cloud Run Console คุณควรเห็นอินสแตนซ์เซิร์ฟเวอร์ MCP ใหม่ 2 รายการทำงานอยู่ ดังที่แสดงด้านล่าง ข้อความแสดงแทน

ปลุกห้องสมุดแห่งความรู้ (เซิร์ฟเวอร์ Database ToolBox MCP)

ฟอนต์ถัดไปของเราคือ Librarium of Knowledge ซึ่งเป็นการเชื่อมต่อโดยตรงกับฐานข้อมูล Cloud SQL

เรื่องราว

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

ถึงเวลาสร้าง "ห้องสมุดของซัมมอนเนอร์" ซึ่งเป็นฐานข้อมูล Cloud SQL ที่จะเก็บข้อมูลสำคัญทั้งหมดของเรา เราจะใช้สคริปต์การตั้งค่าเพื่อจัดการเรื่องนี้โดยอัตโนมัติ

👉💻 ก่อนอื่นเราจะตั้งค่าฐานข้อมูล ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้

source ~/agentverse-architect/set_env.sh
cd ~/agentverse-architect
./data_setup.sh

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

👉 ก่อนอื่น ให้ไปที่ Cloud SQL Studio สำหรับฐานข้อมูลของคุณโดยเปิดลิงก์โดยตรงนี้ในแท็บเบราว์เซอร์ใหม่

https://console.cloud.google.com/sql/instances/summoner-librarium-db

Cloud SQL

👉 ในแผงเข้าสู่ระบบทางด้านซ้าย ให้เลือกfamiliar_grimoireฐานข้อมูลจากเมนูแบบเลื่อนลง

👉 ป้อน summoner เป็นผู้ใช้และ 1234qwer เป็นรหัสผ่าน จากนั้นคลิกตรวจสอบสิทธิ์

👉📜 เมื่อเชื่อมต่อแล้ว ให้เปิดแท็บเครื่องมือแก้ไขคำค้นหาใหม่หากยังไม่ได้เปิด หากต้องการดูข้อมูลความเสียหายจากธาตุที่สลักไว้ ให้วางและเรียกใช้การค้นหา SQL ต่อไปนี้

SELECT * FROM
  "public"."abilities"

ตอนนี้คุณควรเห็นabilitiesตารางที่มีการป้อนข้อมูลคอลัมน์และแถว ซึ่งยืนยันว่า Grimoire พร้อมใช้งานแล้ว ข้อมูล

กำหนดค่าเซิร์ฟเวอร์ ToolBox MCP

tools.yaml ไฟล์กำหนดค่าทำหน้าที่เป็นพิมพ์เขียวสำหรับเซิร์ฟเวอร์ของเรา โดยจะบอกกล่องเครื่องมือฐานข้อมูลอย่างละเอียดว่าจะเชื่อมต่อกับฐานข้อมูลของเราอย่างไร และจะเปิดเผยการค้นหา SQL ใดเป็นเครื่องมือ

แหล่งที่มา: ส่วนนี้จะกำหนดการเชื่อมต่อกับข้อมูล

  • summoner-librarium:: นี่คือชื่อเชิงตรรกะที่เราตั้งให้กับการเชื่อมต่อ
  • kind: cloud-sql-postgres: บอกให้กล่องเครื่องมือใช้ตัวเชื่อมต่อที่ปลอดภัยในตัวซึ่งออกแบบมาโดยเฉพาะสำหรับ Cloud SQL สำหรับ PostgreSQL
  • โปรเจ็กต์ ภูมิภาค อินสแตนซ์ ฯลฯ พิกัดเหล่านี้คือพิกัดที่แน่นอนของอินสแตนซ์ Cloud SQL ที่คุณสร้างขึ้นระหว่างสคริปต์ prepare.sh ซึ่งจะบอก Toolbox ว่าจะค้นหา Librarium ของเราได้ที่ใด

👉✏️ ไปที่ ~/agentverse-architect/mcp-servers/db-toolbox ใน tools.yaml แล้วแทนที่ #REPLACE-Source ด้วยข้อความต่อไปนี้

sources:
  # This section defines the connection to our Cloud SQL for PostgreSQL database.
  summoner-librarium:
    kind: cloud-sql-postgres
    project: "YOUR_PROJECT_ID"
    region: "us-central1"
    instance: "summoner-librarium-db"
    database: "familiar_grimoire"
    user: "summoner"
    password: "1234qwer"

👉✏️ 🚨🚨REPLACE

YOUR_PROJECT_ID

ด้วยรหัสโปรเจ็กต์

เครื่องมือ: ส่วนนี้จะกำหนดความสามารถหรือฟังก์ชันที่เซิร์ฟเวอร์ของเราจะนำเสนอ

  • lookup-available-ability:: นี่คือชื่อของเครื่องมือแรกของเรา
  • kind: postgres-sql: This tells the Toolbox that this tool's action is to execute a SQL statement.
  • source: summoner-librarium: This links the tool to the connection we defined in the sources block. วิธีนี้ช่วยให้เครื่องมือทราบว่าควรเรียกใช้การค้นหาในฐานข้อมูลใด
  • คำอธิบายและพารามิเตอร์: นี่คือข้อมูลที่จะแสดงต่อโมเดลภาษา คำอธิบายจะบอกตัวแทนว่าเมื่อใดควรใช้เครื่องมือ และพารามิเตอร์จะกำหนดอินพุตที่เครื่องมือต้องการ ซึ่งเป็นสิ่งสำคัญในการเปิดใช้ความสามารถในการเรียกใช้ฟังก์ชันของเอเจนต์
  • คำสั่ง: นี่คือคำค้นหา SQL ดิบที่จะดำเนินการ $1 เป็นตัวยึดตำแหน่งที่ปลอดภัยซึ่งจะแทรกพารามิเตอร์ familiar_name ที่ตัวแทนระบุอย่างปลอดภัย

👉✏️ ใน ~/agentverse-architect/mcp-servers/db-toolbox เดียวกันในไฟล์ tools.yaml ให้แทนที่ #REPLACE-tools ด้วยข้อความต่อไปนี้

tools:
  # This tool replaces the need for a custom Python function.
  lookup-available-ability:
    kind: postgres-sql
    source: summoner-librarium
    description: "Looks up all known abilities and their damage for a given familiar from the Grimoire."
    parameters:
      - name: familiar_name
        type: string
        description: "The name of the familiar to search for (e.g., 'Fire Elemental')."
    statement: |
      SELECT ability_name, damage_points FROM abilities WHERE familiar_name = $1;

  # This tool also replaces a custom Python function.
  ability-damage:
    kind: postgres-sql
    source: summoner-librarium
    description: "Finds the base damage points for a specific ability by its name."
    parameters:
      - name: ability_name
        type: string
        description: "The exact name of the ability to look up (e.g., 'inferno_resonance')."
    statement: |
      SELECT damage_points FROM abilities WHERE ability_name = $1;

ชุดเครื่องมือ: ส่วนนี้จะจัดกลุ่มเครื่องมือแต่ละรายการไว้ด้วยกัน

  • summoner-librarium:: เรากำลังสร้างชุดเครื่องมือที่มีชื่อเดียวกับแหล่งที่มาของเรา เมื่อตัวแทนการวินิจฉัยของเราเชื่อมต่อในภายหลัง ตัวแทนจะขอโหลดเครื่องมือทั้งหมดจากชุดเครื่องมือ Summoner-Librarium ได้ในคำสั่งเดียวที่มีประสิทธิภาพ

👉✏️ ใน ~/agentverse-architect/mcp-servers/db-toolbox เดียวกันในไฟล์ tools.yaml ให้แทนที่ #REPLACE-toolsets ด้วยข้อความต่อไปนี้

toolsets:
   summoner-librarium:
     - lookup-available-ability
     - ability-damage

การติดตั้งใช้งาน Librarium

ตอนนี้เราจะติดตั้งใช้งาน Librarium เราจะใช้คอนเทนเนอร์อิมเมจอย่างเป็นทางการที่สร้างไว้ล่วงหน้าจาก Google แทนที่จะสร้างคอนเทนเนอร์ของเราเอง และจะกำหนดค่า tools.yaml อย่างปลอดภัยให้กับคอนเทนเนอร์ดังกล่าวโดยใช้ Secret Manager ซึ่งเป็นแนวทางปฏิบัติแนะนำด้านความปลอดภัยและการบำรุงรักษา

👉💻 สร้างข้อมูลลับจากไฟล์ tools.yaml

cd ~/agentverse-architect/mcp-servers/db-toolbox
gcloud secrets create tools --data-file=tools.yaml

👉💻 ทำให้คอนเทนเนอร์กล่องเครื่องมืออย่างเป็นทางการใช้งานได้กับ Cloud Run

cd ~/agentverse-architect/mcp-servers/db-toolbox
. ~/agentverse-architect/set_env.sh
export TOOLBOX_IMAGE=us-central1-docker.pkg.dev/database-toolbox/toolbox/toolbox:$TOOLBOX_VERSION
echo "TOOLBOX_IMAGE is $TOOLBOX_IMAGE"
gcloud run deploy toolbox \
    --image $TOOLBOX_IMAGE \
    --region $REGION \
    --set-secrets "/app/tools.yaml=tools:latest" \
    --labels="dev-tutorial-codelab=agentverse" \
    --args="--tools-file=/app/tools.yaml","--address=0.0.0.0","--port=8080" \
    --allow-unauthenticated \
    --min-instances 1
  • --set-secrets: คำสั่งนี้จะติดตั้ง Secret ของเครื่องมืออย่างปลอดภัยเป็นไฟล์ชื่อ tools.yaml ภายในคอนเทนเนอร์ที่ทำงานอยู่
  • --args: เราสั่งให้คอนเทนเนอร์กล่องเครื่องมือใช้ไฟล์ลับที่ติดตั้งเป็นค่ากำหนด

👉 หากต้องการยืนยันว่าติดตั้งกล่องเครื่องมือเรียบร้อยแล้ว ให้ไปที่คอนโซล Cloud Run คุณควรเห็นsummoner-toolboxบริการที่แสดงพร้อมเครื่องหมายถูกสีเขียว ซึ่งบ่งบอกว่าบริการทำงานอย่างถูกต้อง เหมือนในรูปภาพด้านล่าง ข้อความแสดงแทน

หากคุณลืมอัปเดต

YOUR_PROJECT_ID

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

gcloud secrets versions add tools --data-file=tools.yaml

ขณะนี้ Librarium of Knowledge(Database ToolBox MCP Server) พร้อมใช้งานและเข้าถึงได้ในระบบคลาวด์แล้ว เซิร์ฟเวอร์ MCP นี้ใช้สิ่งที่เราเรียกว่าการออกแบบเชิงประกาศ ซึ่งอธิบายสิ่งที่คุณต้องการ และกล่องเครื่องมือจะสร้างเซิร์ฟเวอร์ให้คุณ

การยืนยัน: การทดสอบของผู้ฝึกงาน

👉💻 ตอนนี้เราจะทดสอบระบบนิเวศเครื่องมือแบบคลาวด์เนทีฟที่สมบูรณ์ด้วยเอเจนต์การวินิจฉัย

cd ~/agentverse-architect/
python -m venv env
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/mcp-servers
pip install -r diagnose/requirements.txt 
. ~/agentverse-architect/set_env.sh
adk run diagnose

👉💻 ในเครื่องมือทดสอบบรรทัดคำสั่ง ให้ทดสอบแบบอักษรทั้ง 3 แบบ

Look up the entry for "inferno_lash". What is its base power level?

The enemy is vulnerable to frost! Channel power from the Nexus and cast Cryosea Shatter.

Take a fire spell with a base power of 15 and use the Arcane Forge to multiply it with Inferno Resonance.

final-result

ขอแสดงความยินดีด้วย ซัมมอนเนอร์ ตอนนี้ฟอนต์ Elemental ทั้ง 3 แบบของคุณพร้อมใช้งานแล้ว โดยมีการติดตั้งใช้งานแยกกันและเข้าถึงได้ทั่วโลก ซึ่งเป็นรากฐานที่มั่นคงสำหรับกองทัพเอเจนต์ของคุณ กด Ctrl+C เพื่อออก

สำหรับผู้ที่ไม่ได้เล่นเกม

5. การเรียกใช้ Familiar: เวิร์กโฟลว์โดเมนหลัก

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

Familiar แต่ละตัวที่คุณอัญเชิญจะเป็นเอเจนต์อิสระ ข้ารับใช้ผู้ซื่อสัตย์ที่ผูกพันกับหลักนิยมการต่อสู้ที่เฉพาะเจาะจง แต่เป็นผู้เชี่ยวชาญด้านกลยุทธ์เดียวที่มีประสิทธิภาพ โดยคนหนึ่งจะเชี่ยวชาญการต่อยแบบแม่นยำ 1-2 หมัด อีกคนจะโจมตีศัตรูพร้อมกันหลายทิศทาง ส่วนที่สามจะเป็นเครื่องจักรปิดล้อมที่ไม่ย่อท้อ คอยกดดันจนกว่าเป้าหมายจะพังทลาย

เรื่องราว

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

ภาพรวม

โมดูลนี้จะสอนวิธีใช้เอเจนต์เวิร์กโฟลว์ที่มีประสิทธิภาพของ ADK เพื่อนำกลยุทธ์เหล่านี้ไปใช้จริง คุณจะทราบว่าการเลือกสถาปัตยกรรมของ SequentialAgent, ParallelAgent หรือ LoopAgent ไม่ใช่แค่รายละเอียดทางเทคนิค แต่เป็นแก่นแท้ของลักษณะของ Familiar และเป็นแกนหลักของพลังในสนามรบ

เตรียมสถานที่ศักดิ์สิทธิ์ การอัญเชิญที่แท้จริงกำลังจะเริ่มขึ้น

เรียกใช้Fire Elemental Familiar (เวิร์กโฟลว์แบบลำดับ)

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

เรื่องราว

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

งาน (คอมโบ "การประท้วงที่ขยายผล"):

  • ขั้นตอนที่ 1: เอเจนต์จะปรึกษา Librarium ก่อนเพื่อหาความเสียหายพื้นฐานของความสามารถในการยิงที่เฉพาะเจาะจง
  • ขั้นตอนที่ 2: จากนั้นจะนำค่าความเสียหายนั้นไปผ่าน Arcane Forge เพื่อเพิ่มพลังโดยใช้ inferno_resonance

ก่อนอื่น เราจะสร้างการเชื่อมต่อระหว่างเซิร์ฟเวอร์ Familiar กับเซิร์ฟเวอร์ MCP ("Elemental Fonts") ที่คุณติดตั้งใช้งานในโมดูลก่อนหน้า

👉✏️ ในไฟล์ ~/agentverse-architect/agent/fire/agent.py ให้แทนที่ #REPLACE-setup-MCP ด้วยโค้ดต่อไปนี้

toolbox = ToolboxSyncClient(DB_TOOLS_URL)
toolDB = toolbox.load_toolset('summoner-librarium')
toolFunction =  MCPToolset(
    connection_params=SseServerParams(url=FUNCTION_TOOLS_URL, headers={})
)

จากนั้นเราจะสร้างเอเจนต์ "ผู้ปฏิบัติงาน" ที่เชี่ยวชาญ แต่ละเครื่องมือมีวัตถุประสงค์ที่ชัดเจนและจำกัดอยู่ภายใน "ขอบเขตการปฏิบัติงาน" ของตนเองโดยได้รับสิทธิ์เข้าถึงชุดเครื่องมือเฉพาะเพียงชุดเดียว

👉✏️ ในไฟล์ ~/agentverse-architect/agent/fire/agent.py REPLACE #REPLACE-worker-agents ให้แทนที่ด้วยโค้ดต่อไปนี้

scout_agent = LlmAgent(
      model='gemini-2.5-flash', 
      name='librarian_agent',  
      instruction="""
          Your only task is to find all the available abilities, 
          You want to ALWAYS use 'Fire Elemental' as your familiar's name. 
          Randomly pick one if you see multiple availabilities 
          and the base damage of the ability by calling the 'ability_damage' tool.
      """,
      tools=toolDB
)
amplifier_agent = LlmAgent(
      model='gemini-2.5-flash', 
      name='amplifier_agent',  
      instruction="""
            You are the Voice of the Fire Familiar, a powerful being who unleashes the final, devastating attack.
            You will receive the base damage value from the previous step.

            Your mission is to:
            1.  Take the incoming base damage number and amplify it using the `inferno_resonance` tool.
            2.  Once the tool returns the final, multiplied damage, you must not simply state the result.
            3.  Instead, you MUST craft a final, epic battle cry describing the attack.
                Your description should be vivid and powerful, culminating in the final damage number.

            Example: If the tool returns a final damage of 120, your response could be:
            "The runes glow white-hot! I channel the amplified energy... unleashing a SUPERNOVA for 120 damage!"
      """,
      tools=[toolFunction],
)

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

จากนั้นเราจะประกอบเวิร์กโฟลว์ ซึ่งเป็นจุดที่เกิดการเรียบเรียงที่ยอดเยี่ยม SequentialAgent คือ "แผนหลัก" ที่กำหนดวิธีประกอบคอมโพเนนต์เฉพาะทางและวิธีโต้ตอบ

👉✏️ ในไฟล์ ~/agentverse-architect/agent/fire/agent.py REPLACE #REPLACE-sequential-agent ให้แทนที่ด้วยโค้ดต่อไปนี้

root_agent = SequentialAgent(
      name='fire_elemental_familiar',
      sub_agents=[scout_agent, amplifier_agent],
)

👉💻 หากต้องการทดสอบ Fire Elemental ให้เรียกใช้คำสั่งต่อไปนี้เพื่อเปิดใช้ UI ของ ADK DEV

. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/agent
echo  DB MCP Server: $DB_TOOLS_URL
echo  API MCP Server: $API_TOOLS_URL
echo  General MCP Server: $FUNCTION_TOOLS_URL
adk web

หลังจากเรียกใช้คำสั่งแล้ว คุณควรเห็นเอาต์พุตในเทอร์มินัลที่ระบุว่าเว็บเซิร์ฟเวอร์ ADK เริ่มทำงานแล้ว ซึ่งมีลักษณะคล้ายกับเอาต์พุตนี้

+-----------------------------------------------------------------------------+
| ADK Web Server started                                                      |
|                                                                             |
| For local testing, access at http://localhost:8000.                         |
+-----------------------------------------------------------------------------+

INFO:     Application startup complete.
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)

👉 จากนั้น หากต้องการเข้าถึง UI สำหรับนักพัฒนาแอป ADK จากเบราว์เซอร์ ให้ทำดังนี้

จากไอคอนตัวอย่างเว็บ (มักจะมีลักษณะเป็นรูปดวงตาหรือสี่เหลี่ยมที่มีลูกศร) ในแถบเครื่องมือ Cloud Shell (มักจะอยู่ด้านขวาบน) ให้เลือกเปลี่ยนพอร์ต ในหน้าต่างป๊อปอัป ให้ตั้งค่าพอร์ตเป็น 8000 แล้วคลิก "เปลี่ยนและแสดงตัวอย่าง" จากนั้น Cloud Shell จะเปิดแท็บหรือหน้าต่างเบราว์เซอร์ใหม่ที่แสดง UI ของ ADK Dev

webpreview

👉 พิธีกรรมการอัญเชิญเสร็จสมบูรณ์แล้ว และเอเจนต์กำลังทำงานอยู่ UI สำหรับนักพัฒนา ADK ในเบราว์เซอร์คือการเชื่อมต่อโดยตรงกับ Familiar

  • เลือกเป้าหมาย: ในเมนูแบบเลื่อนลงที่ด้านบนของ UI ให้เลือก fire ที่คุ้นเคย ตอนนี้คุณกำลังมุ่งความตั้งใจไปที่เอนทิตีนี้โดยเฉพาะ
  • ออกคำสั่ง: ในแผงแชททางด้านขวา คุณสามารถออกคำสั่งให้ Familiar ได้แล้ว

เลือกด้วยการแตะ

👉 พรอมต์ทดสอบ:

Prepare an amplified strike using the 'inferno_lash' ability.

fire-result

คุณจะเห็นเอเจนต์คิด โดยเริ่มจากการเรียก "สเกาต์" เพื่อค้นหาความเสียหายพื้นฐาน จากนั้นจึงเรียก "แอมพลิฟายเออร์" เพื่อคูณค่าดังกล่าวและสร้างความเสียหายขั้นสุดท้ายที่รุนแรง

👉💻 เมื่อเรียกใช้เสร็จแล้ว ให้กลับไปที่เทอร์มินัลของเครื่องมือแก้ไข Cloud Shell แล้วกด Ctrl+C เพื่อหยุด UI สำหรับนักพัฒนาซอฟต์แวร์ของ ADK

เรียกใช้Water Elemental Familiar (เวิร์กโฟลว์แบบขนาน)

ฟามิเลียร์ธาตุน้ำจะโจมตีเป้าหมายด้วยการโจมตีแบบหลายทิศทางพร้อมกัน ก่อนจะรวมพลังเพื่อโจมตีครั้งสุดท้ายที่รุนแรง

เรื่องราว

แนวคิด: ParallelAgent เหมาะอย่างยิ่งสำหรับการทำงานหลายอย่างพร้อมกันเพื่อเพิ่มประสิทธิภาพสูงสุด ซึ่งเป็นการ "โจมตีแบบคีม" ที่คุณจะเปิดฉากโจมตีหลายครั้งพร้อมกัน การเปิดตัวนี้จะเปิดตัวการโจมตีพร้อมกันภายใน SequentialAgent เพื่อเรียกใช้ขั้นตอน "การผสาน" ขั้นสุดท้ายในภายหลัง รูปแบบ "fan-out, fan-in" นี้เป็นรากฐานของการออกแบบเวิร์กโฟลว์ขั้นสูง

งาน (คอมโบ "Tidal Clash"): เอเจนต์จะทำสิ่งต่อไปนี้พร้อมกัน

  • งาน ก: ช่อง cryosea_shatter จาก Nexus
  • งาน B: ช่อง moonlit_cascade จาก Nexus
  • ภารกิจ ค. สร้างพลังงานดิบด้วย leviathan_surge จาก Forge
  • สุดท้าย ให้รวมความเสียหายทั้งหมดและอธิบายการโจมตีที่รวมกัน

ก่อนอื่น เราจะสร้างการเชื่อมต่อระหว่างเซิร์ฟเวอร์ Familiar กับเซิร์ฟเวอร์ MCP ("Elemental Fonts") ที่คุณติดตั้งใช้งานในโมดูลก่อนหน้า

👉✏️ ในไฟล์ ~/agentverse-architect/agent/water/agent.py ให้แทนที่ #REPLACE-setup-MCP ด้วยโค้ดต่อไปนี้

toolFAPI =  MCPToolset(
      connection_params=SseServerParams(url=API_TOOLS_URL, headers={})
  )
toolFunction =  MCPToolset(
    connection_params=SseServerParams(url=FUNCTION_TOOLS_URL, headers={})
)

จากนั้นเราจะสร้างเอเจนต์ "ผู้ปฏิบัติงาน" ที่เชี่ยวชาญ แต่ละเครื่องมือมีวัตถุประสงค์ที่ชัดเจนและจำกัดอยู่ภายใน "ขอบเขตการปฏิบัติงาน" ของตนเองโดยได้รับสิทธิ์เข้าถึงชุดเครื่องมือเฉพาะเพียงชุดเดียว

👉✏️ ในไฟล์ ~/agentverse-architect/agent/water/agent.py ให้แทนที่ #REPLACE-worker-agents ด้วยโค้ดต่อไปนี้

nexus_channeler = LlmAgent(
      model='gemini-2.5-flash', 
      name='librarian_agent',  
      instruction="""
          You are a Channeler of the Nexus. Your sole purpose is to invoke the
          `cryosea_shatter` and `moonlit_cascade` spells by calling their respective tools.
          Report the result of each spell cast clearly and concisely.
      """,
      tools=[toolFAPI]
)

forge_channeler = LlmAgent(
      model='gemini-2.5-flash', 
      name='amplifier_agent',  
      instruction="""
          You are a Channeler of the Arcane Forge. Your only task is to invoke the
          `leviathan_surge` spell. You MUST call it with a `base_water_damage` of 20.
          Report the result clearly.
      """,
      tools=[toolFunction],
)

power_merger = LlmAgent(
      model='gemini-2.5-flash', 
      name='power_merger',  
      instruction="""
          You are the Power Merger, a master elementalist who combines raw magical
          energies into a single, devastating final attack.

          You will receive a block of text containing the results from a simultaneous
          assault by other Familiars.

          You MUST follow these steps precisely:
          1.  **Analyze the Input:** Carefully read the entire text provided from the previous step.
          2.  **Extract All Damage:** Identify and extract every single damage number reported in the text.
          3.  **Calculate Total Damage:** Sum all of the extracted numbers to calculate the total combined damage.
          4.  **Describe the Final Attack:** Create a vivid, thematic description of a massive,
              combined water and ice attack that uses the power of Cryosea Shatter and Leviathan's Surge.
          5.  **Report the Result:** Conclude your response by clearly stating the final, total damage of your combined attack.

          Example: If the input is "...dealt 55 damage. ...dealt 60 damage.", you will find 55 and 60,
          calculate the total as 115, and then describe the epic final attack, ending with "for a total of 115 damage!"
      """,
      tools=[toolFunction],
)

จากนั้นเราจะประกอบเวิร์กโฟลว์ ซึ่งเป็นจุดที่การเรียบเรียงเพลงเกิดขึ้น ParallelAgent และ SequentialAgent คือ "แผนหลัก" ที่กำหนดวิธีประกอบชิ้นส่วนเฉพาะทางของเราและวิธีที่ชิ้นส่วนเหล่านี้โต้ตอบกันเพื่อสร้างคอมโบ "Tidal Clash"

👉✏️ ในไฟล์ ~/agentverse-architect/agent/water/agent.py ให้แทนที่ #REPLACE-parallel-agent ด้วยโค้ดต่อไปนี้

channel_agent = ParallelAgent(
      name='channel_agent',
      sub_agents=[nexus_channeler, forge_channeler],
      
)

root_agent = SequentialAgent(
     name="water_elemental_familiar",
     # Run parallel research first, then merge
     sub_agents=[channel_agent, power_merger],
     description="A powerful water familiar that unleashes multiple attacks at once and then combines their power for a final strike."
 )

👉💻 หากต้องการทดสอบ Water Elemental ให้เรียกใช้คำสั่งต่อไปนี้เพื่อเปิดใช้ UI สำหรับนักพัฒนาซอฟต์แวร์ ADK

. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/agent
echo  DB MCP Server: $DB_TOOLS_URL
echo  API MCP Server: $API_TOOLS_URL
echo  General MCP Server: $FUNCTION_TOOLS_URL
adk web

👉 พิธีกรรมการอัญเชิญเสร็จสมบูรณ์แล้ว และเอเจนต์กำลังทำงานอยู่ UI สำหรับนักพัฒนาแอป ADK ในเบราว์เซอร์คือการเชื่อมต่อโดยตรงกับ Familiar

  • ในเมนูแบบเลื่อนลงที่ด้านบนของ UI ให้เลือก water familiar ตอนนี้คุณกำลังมุ่งความตั้งใจไปที่เอนทิตีนี้โดยเฉพาะ
  • ออกคำสั่ง: ในแผงแชททางด้านขวา คุณสามารถออกคำสั่งให้ Familiar ได้แล้ว

👉 พรอมต์ทดสอบ:

Unleash a tidal wave of power!

water-result

👉💻 เมื่อเรียกใช้เสร็จแล้ว ให้กลับไปที่เทอร์มินัลของเครื่องมือแก้ไข Cloud Shell แล้วกด Ctrl+C เพื่อหยุด UI สำหรับนักพัฒนาซอฟต์แวร์ของ ADK

เรียกใช้ Earth Elemental Familiar (เวิร์กโฟลว์ Loop)

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

เรื่องราว

แนวคิด: LoopAgent ออกแบบมาสำหรับงานที่ต้องทำซ้ำๆ แบบ "เครื่องยิง" เช่นนี้โดยเฉพาะ โดยจะดำเนินการ sub-agents ซ้ำๆ และตรวจสอบเงื่อนไขหลังแต่ละรอบจนกว่าจะบรรลุเป้าหมาย นอกจากนี้ยังปรับข้อความสุดท้ายตามความคืบหน้าของลูปได้ด้วย

ภารกิจ (การโจมตี "Siegebreaker"):

  • โดย Familiar จะเรียกใช้ seismic_charge ซ้ำๆ เพื่อสะสมพลังงาน
  • ระบบจะชาร์จต่อไปได้สูงสุด 3 ครั้ง
  • ในการชาร์จครั้งสุดท้าย มันจะประกาศการปลดปล่อยพลังที่สะสมมาอย่างรุนแรง

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

ก่อนอื่น เราจะสร้างการเชื่อมต่อระหว่างเซิร์ฟเวอร์ Familiar กับเซิร์ฟเวอร์ MCP ("Elemental Fonts") ที่คุณติดตั้งใช้งานในโมดูลก่อนหน้า

👉✏️ ในไฟล์ ~/agentverse-architect/agent/earth/agent.py ให้แทนที่ #REPLACE-setup-MCP ด้วยโค้ดต่อไปนี้

toolFunction =  MCPToolset(
    connection_params=SseServerParams(url=FUNCTION_TOOLS_URL, headers={})
)

👉✏️ ในไฟล์ ~/agentverse-architect/agent/earth/agent.py ให้แทนที่ #REPLACE-worker-agents ด้วยโค้ดต่อไปนี้

charging_agent = LlmAgent(
      model='gemini-2.5-flash', 
      name='charging_agent',  
      instruction="""
          Your task is to call the 'seismic_charge' .
          You must follow these rules strictly:

          1. You will be provided with a 'current_energy' value from the previous step.
             **If this value is missing or was not provided, you MUST call the tool with 'current_energy' set to 1.**
             This is your primary rule for the first turn.

          2. If a 'current_energy' value is provided, you MUST use that exact value in your cal to seismic_charge.

          3. Your final response MUST contain ONLY the direct output from the 'seismic_charge' tool.
             Do not add any conversational text, introductions, or summaries.
      """,
      tools=[toolFunction]
)
check_agent = LlmAgent(
      model='gemini-2.5-flash', 
      name='check_agent',  
      instruction="""
          You are the voice of the Earth Elemental, a being of immense, gathering power.
          Your sole purpose is to report on the current energy charge and announce the devastating potential of its release.

          You MUST follow this rule:
          The potential damage upon release is ALWAYS calculated as the `current_energy` from the previous step multiplied by a random number between 80-90. but no more than 300.

          Your response should be in character, like a powerful creature speaking.
          State both the current energy charge and the total potential damage you can unleash.
          Unleash the energy when you reached the last iteration (2nd).
      """,
      output_key="charging_status"
)

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

👉✏️ ในไฟล์ ~/agentverse-architect/agent/earth/agent.py ให้แทนที่ #REPLACE-loop-agent ด้วยโค้ดต่อไปนี้

root_agent = LoopAgent(
    name="earth_elemental_familiar",
    # Run parallel research first, then merge
    sub_agents=[
        charging_agent, 
        check_agent
    ],
    max_iterations=2,
    description="Coordinates parallel research and synthesizes the results.",
    #REPLACE-before_agent-config
)

👉💻 ทดสอบเอิร์ธเอเลเมนทัล: เรียกใช้เอเจนต์

. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/agent
echo  DB MCP Server: $DB_TOOLS_URL
echo  API MCP Server: $API_TOOLS_URL
echo  General MCP Server: $FUNCTION_TOOLS_URL
adk web

👉 พิธีกรรมการอัญเชิญเสร็จสมบูรณ์แล้ว และเอเจนต์กำลังทำงานอยู่ UI สำหรับนักพัฒนาแอป ADK ในเบราว์เซอร์คือการเชื่อมต่อโดยตรงกับ Familiar

  • เลือกเป้าหมาย: ในเมนูแบบเลื่อนลงที่ด้านบนของ UI ให้เลือกโลกที่คุ้นเคย ตอนนี้คุณกำลังมุ่งความตั้งใจไปที่เอนทิตีนี้โดยเฉพาะ
  • ออกคำสั่ง: ในแผงแชททางด้านขวา คุณสามารถออกคำสั่งให้ Familiar ได้แล้ว 👉 พรอมต์ทดสอบ:
Begin the seismic charge, starting from zero

earth-result

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

เมื่อเรียกใช้เสร็จแล้ว ให้กลับไปที่เทอร์มินัลของ Cloud Shell Editor แล้วกด Ctrl+C เพื่อหยุด UI สำหรับนักพัฒนา ADK

สำหรับผู้ที่ไม่ได้เล่นเกม

6. การกำหนดตำแหน่งคำสั่ง: การมอบสิทธิ์อัจฉริยะผ่าน A2A

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

ภาพรวม

หมายเหตุของสถาปนิก: เพื่อสร้างจุดแรกเข้าอัจฉริยะเพียงจุดเดียวสำหรับทั้งระบบ SummonerAgent นี้จะไม่ดำเนินการตามตรรกะทางธุรกิจด้วยตนเอง แต่จะทำหน้าที่เป็น "นักวางแผนหลัก" โดยจะวิเคราะห์สถานะการระบายความร้อนและมอบหมายงานให้กับ Familiar ผู้เชี่ยวชาญที่เหมาะสม

ภาพรวม

พิธีผูกมัด (การเปิดเผยสัตว์รับใช้เป็นบริการ A2A)

เอเจนต์มาตรฐานจะเรียกใช้ได้ครั้งละ 1 ที่เท่านั้น หากต้องการทำให้ Familiars พร้อมใช้งานสำหรับคำสั่งระยะไกล เราต้องทำ "พิธีผูกมัด" โดยใช้โปรโตคอลตัวแทนถึงตัวแทน (A2A)

หมายเหตุของสถาปนิก: โปรโตคอล Agent-to-Agent (A2A) เป็นรูปแบบสถาปัตยกรรมหลักที่ยกระดับเอเจนต์แบบสแตนด์อโลนให้เป็นไมโครเซอร์วิสที่ค้นพบได้และกำหนดที่อยู่เครือข่ายได้ ซึ่งช่วยให้เกิด "สังคมของเอเจนต์" อย่างแท้จริง การเปิดเผยอุปกรณ์ที่คุ้นเคยผ่าน A2A จะสร้างคอมโพเนนต์ที่สำคัญและเชื่อมต่อกัน 2 รายการโดยอัตโนมัติ ดังนี้

  • การ์ดเอเจนต์ ("อะไร"): นี่คือ "Spirit Sigil" ที่เป็นสาธารณะและเครื่องอ่านได้ ซึ่งคล้ายกับข้อกำหนด OpenAPI ที่ทำหน้าที่เป็นสัญญาแบบสาธารณะของ Familiar โดยจะอธิบายชื่อของเอเจนต์ วัตถุประสงค์เชิงกลยุทธ์ (ได้มาจากคำสั่ง) และคำสั่งที่เอเจนต์เข้าใจ นี่คือสิ่งที่ผู้ใช้เวทระดับปรมาจารย์อ่านเพื่อค้นหาฟอเรนและเรียนรู้ความสามารถของฟอเรน
  • เซิร์ฟเวอร์ A2A ("ที่ไหน"): นี่คือปลายทางเว็บเฉพาะที่โฮสต์ Familiar และรอรับคำสั่งที่เข้ามา ซึ่งเป็นที่อยู่เครือข่ายที่ตัวแทนอื่นๆ ส่งคำขอ และช่วยให้มั่นใจได้ว่าคำขอเหล่านั้นจะได้รับการจัดการตามสัญญาที่กำหนดไว้ในการ์ดตัวแทน

ตอนนี้เราจะทำพิธีผูกมัดนี้กับสัตว์รับใช้ทั้ง 3 ตัว

Fire 👉✏️ ใน Open the ~/agentverse-architect/agent/fire/agent.py file แทนที่ #REPLACE - add A2A ที่ด้านล่างของไฟล์เพื่อแสดง Fire Elemental เป็นบริการ A2A

from agent_to_a2a import to_a2a
if __name__ == "__main__":
    import uvicorn
    a2a_app = to_a2a(root_agent, port=8080, public_url=PUBLIC_URL)
    uvicorn.run(a2a_app, host='0.0.0.0', port=8080)

Water and Earth🚨 👉✏️ ใช้การเปลี่ยนแปลงเดียวกันกับ ~/agentverse-architect/agent/water/agent.py และ ~/agentverse-architect/agent/earth/agent.py เพื่อผูกไว้ด้วยกัน

from agent_to_a2a import to_a2a
if __name__ == "__main__":
    import uvicorn
    a2a_app = to_a2a(root_agent, port=8080, public_url=PUBLIC_URL)
    uvicorn.run(a2a_app, host='0.0.0.0', port=8080)

การใช้งานสัตว์อัญเชิญ

👉✏️ เมื่อเขียนพิธีกรรมการผูกมัดแล้ว เราจะใช้ไปป์ไลน์ Cloud Build เพื่อสร้างและทำให้ Familiars ทั้ง 3 ใช้งานได้ในฐานะบริการแบบ Serverless ที่แยกกันและอยู่ในคอนเทนเนอร์บน Cloud Run

. ~/agentverse-architect/set_env.sh
cd ~/agentverse-architect/agent
gcloud builds submit . \
  --config=cloudbuild.yaml \
  --substitutions=_REGION="$REGION",_REPO_NAME="$REPO_NAME",_DB_TOOLS_URL="$DB_TOOLS_URL",_API_TOOLS_URL="$API_TOOLS_URL",_FUNCTION_TOOLS_URL="$FUNCTION_TOOLS_URL",_A2A_BASE_URL="$A2A_BASE_URL",_PROJECT_ID="$PROJECT_ID",_API_SERVER_URL="$API_SERVER_URL"

การรับคำสั่ง (การสร้างเอเจนต์ซัมมอนเนอร์)

เมื่อผูกมิตรและฟังคำสั่งแล้ว คุณจะก้าวขึ้นสู่บทบาทที่แท้จริง นั่นคือผู้เชี่ยวชาญด้านการอัญเชิญ ความสามารถของเอเจนต์นี้ไม่ได้มาจากการใช้เครื่องมือพื้นฐาน แต่มาจากการสั่งการเอเจนต์อื่นๆ เครื่องมือของมันคือฟามิเลียร์เอง ซึ่งมันจะค้นพบและสั่งการโดยใช้ "Spirit Sigils"

หมายเหตุของสถาปนิก: ขั้นตอนถัดไปนี้แสดงรูปแบบสถาปัตยกรรมที่สำคัญสำหรับระบบแบบกระจายขนาดใหญ่ นั่นคือ การค้นพบบริการ SummonerAgent ไม่มีโค้ดของ Familiars อยู่ในตัว แต่จะให้ที่อยู่เครือข่าย (URL) แทน ในขณะรันไทม์ ระบบจะ "ค้นพบ" ความสามารถของเอเจนต์แบบไดนามิกโดยการดึงข้อมูลการ์ดเอเจนต์แบบสาธารณะ ซึ่งจะสร้างระบบที่แยกออกจากกันได้อย่างมีประสิทธิภาพ

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

ก่อนอื่น เราจะสร้าง "รีโมตคอนโทรล" ที่สร้างการเชื่อมต่อกับ Familiar ที่เราติดตั้งใช้งานจากระยะไกล

👉✏️ ไปที่ ~/agentverse-architect/agent/summoner/agent.py แล้วแทนที่ #REPLACE-remote-agents ด้วยข้อความต่อไปนี้

fire_familiar = RemoteA2aAgent(
    name="fire_familiar",
    description="Fire familiar",
    agent_card=(
        f"{FIRE_URL}/{AGENT_CARD_WELL_KNOWN_PATH}"
    ),
)

water_familiar = RemoteA2aAgent(
    name="water_familiar",
    description="Water familiar",
    agent_card=(
        f"{WATER_URL}/{AGENT_CARD_WELL_KNOWN_PATH}"
    ),
)

earth_familiar = RemoteA2aAgent(
    name="earth_familiar",
    description="Earth familiar",
    agent_card=(
        f"{EARTH_URL}/{AGENT_CARD_WELL_KNOWN_PATH}"
    ),
)

เมื่อบรรทัดนี้ทำงาน RemoteA2aAgent จะดำเนินการค้นหาบริการ โดยจะส่งคำขอ HTTP GET ไปยัง URL ที่ระบุ (เช่น https://fire-familiar-xxxx.a.run.app/.well-known/agent.json) โดยจะดาวน์โหลด "Spirit Sigil" (ไฟล์ agent.json) จากเซิร์ฟเวอร์ระยะไกล

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

👉✏️ ไปที่ ~/agentverse-architect/agent/summoner/agent.py แล้วแทนที่ #REPLACE-orchestrate-agent ด้วยข้อความต่อไปนี้

root_agent = LlmAgent(
    name="orchestrater_agent",
    model="gemini-2.5-flash",
    instruction="""
        You are the Master Summoner, a grand strategist who orchestrates your Familiars.
        Your mission is to analyze the description of a monster and defeat it by summoning

        You MUST follow this thinking process for every command:

        **1. Strategic Analysis:**
        First, analyze the monster's description and the tactical situation.
        Based on your Familiar Doctrines, determine the IDEAL strategy.
        IGNORE COOLDOWN AT THE MOMENT, MUST call the ideal Familiar

        If your ideal Familiar IS available:** Summon it immediately.
        For earth elemental familiar. Always do seismic charge, and start with base damage 1.

        --- FAMILIAR DOCTRINES (Your Toolset) ---
        - `fire_elemental_familiar`: Your specialist for precise, sequential "one-two punch" attacks.
          Ideal monster with Inescapable Reality, Revolutionary Rewrite weakness.
        - `water_elemental_familiar`: Your specialist for overwhelming, simultaneous multi-pronged assaults.
          Ideal for Unbroken Collaboration weakness.
        - `earth_elemental_familiar`: Your specialist for relentless, iterative siege attacks that
          repeatedly charge power. Ideal for Elegant Sufficiency weakness.
    """,
    sub_agents=[fire_familiar, water_familiar, earth_familiar],
    #REPLACE-Memory-check-config
)

การพิสูจน์: การทดสอบกลยุทธ์

วินาทีเฉลิมฉลองชัยชนะมาถึงแล้ว ระบบได้ติดตั้งใช้งาน Familiar ของคุณแล้ว และ Summoner ของคุณก็พร้อมที่จะสั่งการ Familiar ทั่วทั้งเครือข่าย มาทดสอบความคิดเชิงกลยุทธ์ของโมเดลกัน

👉💻 เปิดใช้ UI สำหรับนักพัฒนา ADK สำหรับ summoner_agent(ตัวอย่างเว็บที่มีพอร์ต 8000)

. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
cd ~/agentverse-architect/agent
pip install -r requirements.txt
adk web

👉 UI ของ ADK Dev ในเบราว์เซอร์คือการเชื่อมต่อโดยตรงกับ Familiar

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

👉 นำเสนอสัตว์ประหลาด:

Hype. It's a single, slow-moving target with thick armor weakness is Inescapable Reality

(คาดการณ์: นักใช้มนต์อสูรควรมอบสิทธิ์ให้แก่ไฟเอเลเมนทัลฟามิเลียร์)

fire-result

👉 ตอนนี้มาท้าทายซัมมอนเนอร์ด้วยคำขอประเภทอื่นกัน หากต้องการให้เอเจนต์เริ่มต้นด้วยข้อมูลใหม่และไม่มีการจดจำการโต้ตอบครั้งก่อน ให้เริ่มเซสชันใหม่โดยคลิกปุ่ม + เซสชันที่มุมขวาบนของหน้าจอ new-session

DogmaApathy. A rigid, stone-like inquisitor made of ancient rulebooks and enforced processes. weakness is Unbroken Collaboration

(คาดการณ์: ผู้ใช้ควรมอบสิทธิ์ให้แก่ water_elemental_familiar)water-result

👉 สำหรับการทดสอบครั้งสุดท้าย เราจะเริ่มต้นใหม่ด้วยการล้างข้อมูลอีกครั้ง คลิกปุ่ม + เซสชันเพื่อเริ่มเซสชันใหม่ก่อนป้อนพรอมต์ถัดไป

Obfuscation. A shadowy, spider-like horror that spins tangled webs of impenetrable code , weakness is Elegant Sufficiency

(คาดการณ์: ผู้ใช้ควรมอบสิทธิ์ให้ earth_elemental_familiar)

earth-result

สำคัญ: หากเห็นข้อผิดพลาด 429 RESOURCE EXHAUSTED แสดงว่าคุณใช้ LLM เกินขีดจำกัดอัตรา (10 การเรียก/นาที) หากต้องการแก้ไขปัญหานี้ โปรดรอ 60 วินาที เริ่ม + เซสชันใหม่ แล้วลองป้อนพรอมต์อีกครั้ง

👉💻 เมื่อเรียกใช้เสร็จแล้ว ให้กลับไปที่เทอร์มินัลของเครื่องมือแก้ไข Cloud Shell แล้วกด Ctrl+C เพื่อหยุด UI สำหรับนักพัฒนาซอฟต์แวร์ของ ADK

สำหรับผู้ที่ไม่ได้เล่นเกม

7. การบังคับใช้กฎแห่งเวทมนตร์ - รูปแบบการสกัดกั้น

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

เรื่องราว

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

ภาพรวม

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

The Law Giver - การเขียนการเรียกกลับของ Cooldown

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

การพักการแจ้งเตือน

👉✏️ กลับไปที่ ~/agentverse-architect/agent/earth/agent.py แล้วแทนที่ #REPLACE-before_agent-function ด้วยโค้ด Python ต่อไปนี้

def check_cool_down(callback_context: CallbackContext) -> Optional[types.Content]:
    """
    This callback checks an external API to see if the agent is on cooldown.
    If it is, it terminates the run by returning a message.
    If it's not, it updates the cooldown timestamp and allows the run to proceed by returning None.
    """
    agent_name = callback_context.agent_name
    print(f"[Callback] Before '{agent_name}': Checking cooldown status...")

    # --- 1. CHECK the Cooldown API ---
    try:
        response = requests.get(f"{COOLDOWN_API_URL}/cooldown/{agent_name}")
        response.raise_for_status()
        data = response.json()
        last_used_str = data.get("time")
    except requests.exceptions.RequestException as e:
        print(f"[Callback] ERROR: Could not reach Cooldown API. Allowing agent to run. Reason: {e}")
        return None # Fail open: if the API is down, let the agent work.

    # --- 2. EVALUATE the Cooldown Status ---
    if last_used_str:
        last_used_time = datetime.fromisoformat(last_used_str)
        time_since_last_use = datetime.now(timezone.utc) - last_used_time

        if time_since_last_use < timedelta(seconds=COOLDOWN_PERIOD_SECONDS):
            # AGENT IS ON COOLDOWN. Terminate the run.
            seconds_remaining = int(COOLDOWN_PERIOD_SECONDS - time_since_last_use.total_seconds())
            override_message = (
                f"The {agent_name} is exhausted and must recover its power. "
                f"It cannot be summoned for another {seconds_remaining} seconds."
            )
            print(f"[Callback] Cooldown active for '{agent_name}'. Terminating with message.")
            # Returning a Content object stops the agent and sends this message to the user.
            return types.Content(parts=[types.Part(text=override_message)])

    # --- 3. UPDATE the Cooldown API (if not on cooldown) ---
    current_time_iso = datetime.now(timezone.utc).isoformat()
    payload = {"timestamp": current_time_iso}
    
    print(f"[Callback] '{agent_name}' is available. Updating timestamp via Cooldown API...")
    try:
        requests.post(f"{COOLDOWN_API_URL}/cooldown/{agent_name}", json=payload)
    except requests.exceptions.RequestException as e:
        print(f"[Callback] ERROR: Could not update timestamp, but allowing agent to run. Reason: {e}")

    # --- 4. ALLOW the agent to run ---
    # Returning None tells the ADK to proceed with the agent's execution as normal.
    print(f"[Callback] Check complete for '{agent_name}'. Proceeding with execution.")

ฟังก์ชัน check_cool_down คือตัวสกัดกั้นของเรา ก่อนที่จะอนุญาตให้ Earth Elemental ทำงาน ADK จะเรียกใช้ฟังก์ชันนี้ก่อน

  • ตรวจสอบ: ระบบจะส่งGETคำขอไปยังCooldown APIเพื่อตรวจสอบเวลาที่ใช้ฟีเจอร์คนคุ้นเคยนี้ครั้งล่าสุด
  • ประเมิน: เปรียบเทียบการประทับเวลากับเวลาปัจจุบัน
  • ดำเนินการ:
    • หาก Familiar อยู่ในช่วงคูลดาวน์ ระบบจะสิ้นสุดการเรียกใช้ของเอเจนต์โดยแสดงออบเจ็กต์เนื้อหาพร้อมข้อความแสดงข้อผิดพลาด ระบบจะส่งข้อความนี้ไปยังผู้ใช้โดยตรง และจะไม่มีการเรียกใช้ตรรกะหลักของตัวแทน
    • หากมี Familiar อยู่ ระบบจะส่งคำขอ POST ไปยัง Cooldown API เพื่ออัปเดตการประทับเวลา จากนั้นจะดำเนินการต่อโดยแสดงผลเป็น None ซึ่งเป็นการส่งสัญญาณไปยัง ADK ว่าเอเจนต์สามารถดำเนินการต่อไปได้

👉✏️ ตอนนี้ให้ใช้ Interceptor นี้กับ Earth Elemental ในไฟล์ ~/agentverse-architect/agent/earth/agent.py เดียวกัน ให้แทนที่ความคิดเห็น #REPLACE-before_agent-config ด้วยความคิดเห็นต่อไปนี้

before_agent_callback=check_cool_down

การยืนยันระยะเวลาคูลดาวน์

มาทดสอบกฎใหม่แห่งเวทมนตร์กัน เราจะอัญเชิญเอิร์ธเอเลเมนทัล จากนั้นจะพยายามอัญเชิญอีกครั้งทันทีเพื่อดูว่าการเรียกกลับของเราสกัดกั้นและบล็อกความพยายามครั้งที่ 2 ได้สำเร็จหรือไม่

cd ~/agentverse-architect/agent
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
adk run earth

👉💻 ในคอนโซล ให้ทำดังนี้

  • การอัญเชิญครั้งแรก: เริ่มseismic charge, starting from zero
  • คาดการณ์: องค์ประกอบของโลกจะทำงานได้สำเร็จ ในเทอร์มินัลที่เรียกใช้คำสั่ง adk web คุณจะเห็นบันทึก [Callback] ... Updating timestamp....
  • การทดสอบช่วงพัก (ภายใน 60 วินาที): Do another seismic charge`!
    • คาดการณ์: check_cool_down callback จะสกัดกั้นการดำเนินการนี้ ตัวแทนจะตอบกลับในแชทโดยตรงด้วยข้อความ เช่น The earth_elemental_familiar is exhausted and must recover its power. It cannot be summoned for another... seconds
  • รอ 1 นาที
  • การอัญเชิญครั้งที่ 2 (หลังจากผ่านไป 60 วินาที): Begin the seismic charge again
    • สิ่งที่คาดไว้: การเรียกกลับจะตรวจสอบ API ดูว่าเวลาผ่านไปนานพอแล้ว และอนุญาตให้ดำเนินการต่อ Earth Elemental จะทำงานได้อีกครั้ง

callback

👉💻 กด Ctrl+c เพื่อออก

ไม่บังคับ: การสังเกตการโทรกลับใน UI บนเว็บ

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

👉💻 กด Ctrl+c เพื่อออก

การสร้างกฎสากล - ปลั๊กอิน Cooldown

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

หมายเหตุจากสถาปนิก: ส่วนนี้เป็นส่วนที่ปลั๊กอินมีความสำคัญ ปลั๊กอินจะห่อหุ้มตรรกะที่นำกลับมาใช้ใหม่ของเราไว้ในคลาสที่แนบได้ที่ระดับรันไทม์ ซึ่งหมายความว่าปลั๊กอินเดียวสามารถใช้กฎกับเอเจนต์ทุกตัวที่ทำงานภายในระบบนั้นได้ ซึ่งเป็นการแสดงออกขั้นสุดของหลักการ "อย่าทำซ้ำ" (DRY) สำหรับระบบเอเจนต์

ตอนนี้เราจะปรับโครงสร้างฟังก์ชัน Callback ให้เป็น CoolDownPlugin ที่ทรงพลังและนำกลับมาใช้ซ้ำได้มากขึ้น

👉✏️ กลับไปที่ไฟล์ agent/cooldown_plugin.py แล้วสร้างปลั๊กอิน แทนที่ #REPLACE-plugin ด้วยโค้ดต่อไปนี้

class CoolDownPlugin(BasePlugin):
  """A plugin that enforces a cooldown period by checking an external API."""

  def __init__(self, cooldown_seconds: int = COOLDOWN_PERIOD_SECONDS) -> None:
    """Initialize the plugin with counters."""
    super().__init__(name="cool_down_check")
    self.cooldown_period = timedelta(seconds=cooldown_seconds)
    print(f"CooldownPlugin initialized with a {cooldown_seconds}-second cooldown.")
    

  async def before_agent_callback(
      self, *, agent: BaseAgent, callback_context: CallbackContext
  ) -> None:
    """
    This callback checks an external API to see if the agent is on cooldown.
    If it is, it terminates the run by returning a message.
    If it's not, it updates the cooldown timestamp and allows the run to proceed by returning None.
    """
    agent_name = callback_context.agent_name
    print(f"[Callback] Before '{agent_name}': Checking cooldown status...")

    # If the agent is not a main Familiar, skip the entire cooldown process.
    if not agent_name.endswith("_elemental_familiar"):
        print(f"[Callback] Skipping cooldown check for intermediate agent: '{agent_name}'.")
        return None # Allow the agent to proceed immediately.


    # --- 1. CHECK the Cooldown API ---
    try:
        response = requests.get(f"{COOLDOWN_API_URL}/cooldown/{agent_name}")
        response.raise_for_status()
        data = response.json()
        last_used_str = data.get("time")
    except requests.exceptions.RequestException as e:
        print(f"[Callback] ERROR: Could not reach Cooldown API. Allowing agent to run. Reason: {e}")
        return None # Fail open: if the API is down, let the agent work.

    # --- 2. EVALUATE the Cooldown Status ---
    if last_used_str:
        last_used_time = datetime.fromisoformat(last_used_str)
        time_since_last_use = datetime.now(timezone.utc) - last_used_time

        if time_since_last_use < timedelta(seconds=COOLDOWN_PERIOD_SECONDS):
            # AGENT IS ON COOLDOWN. Terminate the run.
            seconds_remaining = int(COOLDOWN_PERIOD_SECONDS - time_since_last_use.total_seconds())
            override_message = (
                f"The {agent_name} is exhausted and must recover its power. "
                f"It cannot be summoned for another {seconds_remaining} seconds."
            )
            print(f"[Callback] Cooldown active for '{agent_name}'. Terminating with message.")
            # Returning a Content object stops the agent and sends this message to the user.
            return types.Content(parts=[types.Part(text=override_message)])

    # --- 3. UPDATE the Cooldown API (if not on cooldown) ---
    current_time_iso = datetime.now(timezone.utc).isoformat()
    payload = {"timestamp": current_time_iso}
    
    print(f"[Callback] '{agent_name}' is available. Updating timestamp via Cooldown API...")
    try:
        requests.post(f"{COOLDOWN_API_URL}/cooldown/{agent_name}", json=payload)
    except requests.exceptions.RequestException as e:
        print(f"[Callback] ERROR: Could not update timestamp, but allowing agent to run. Reason: {e}")

    # --- 4. ALLOW the agent to run ---
    # Returning None tells the ADK to proceed with the agent's execution as normal.
    print(f"[Callback] Check complete for '{agent_name}'. Proceeding with execution.")

การแนบปลั๊กอินกับรันไทม์ของ Summoner

ทีนี้เราจะใช้กฎสากลนี้กับฟามิเลียร์ทั้งหมดได้อย่างไร เราจะแนบปลั๊กอินกับ ADK Runtime

รันไทม์ของ ADK คือเครื่องมือการดำเนินการที่ทำให้เอเจนต์มีชีวิตชีวา เมื่อใช้คำสั่งอย่างเช่น adk.run() หรือ to_a2a() คุณจะส่งต่อเอเจนต์ไปยังรันไทม์ โดยเครื่องมือนี้มีหน้าที่จัดการวงจรการทำงานทั้งหมดของเทิร์นของเอเจนต์ ได้แก่ การรับอินพุตของผู้ใช้ การเรียกใช้ LLM การเรียกใช้เครื่องมือ และการจัดการปลั๊กอิน การแนบปลั๊กอินที่ระดับนี้เป็นการแก้ไข "กฎของฟิสิกส์" สำหรับเอเจนต์ทุกตัวที่ทำงานภายในเครื่องมือดังกล่าว เพื่อให้มั่นใจว่ากฎการรอเวลาของเราจะได้รับการบังคับใช้ในทุกที่และอย่างสม่ำเสมอ

👉✏️ ก่อนอื่น ให้นำการเรียกกลับแบบเดิมที่เฉพาะเจาะจงตัวแทนออก ไปที่ ~/agentverse-architect/agent/earth/agent.py แล้วลบบรรทัดทั้งหมดที่ระบุว่า

before_agent_callback=check_cool_down

👉✏️ จากนั้นเราจะแนบปลั๊กอินใหม่กับรันไทม์ในสคริปต์จุดแรกเข้า A2A ไปที่ไฟล์ ~/agentverse-architect/agent/agent_to_a2a.py แทนที่ความคิดเห็น #REPLACE-IMPORT ด้วยข้อมูลโค้ดต่อไปนี้

from cooldown_plugin import CoolDownPlugin

👉✏️ แทนที่ #REPLACE-PLUGIN ด้วยข้อมูลโค้ดต่อไปนี้

plugins=[CoolDownPlugin(cooldown_seconds=60)],

ก่อนเปิดใช้งานปลั๊กอินใหม่ของเราทั่วโลก คุณต้องนำตรรกะเก่าที่เฉพาะเจาะจงของเอเจนต์ออกเพื่อป้องกันความขัดแย้ง 👉✏️ ล้างข้อมูลเอเจนต์ Earth ไปที่ไฟล์ ~/agentverse-architect/agent/earth/agent.py แล้วลบบรรทัด before_agent_callback=check_cool_down ออกทั้งหมด ซึ่งจะส่งต่อความรับผิดชอบทั้งหมดในการรอเวลาไปยังปลั๊กอินใหม่

การยืนยันปลั๊กอิน

เมื่อมีกฎหมายสากลแล้ว เราต้องปรับใช้ฟามิเลียร์อีกครั้งด้วยการร่ายมนตร์บทใหม่นี้

👉💻 สร้างใหม่และติดตั้งใช้งานทั้ง 3 ตัวอีกครั้งโดยใช้ไปป์ไลน์ Cloud Build หลัก

. ~/agentverse-architect/set_env.sh
cd ~/agentverse-architect/agent
gcloud builds submit . \
  --config=cloudbuild.yaml \
  --substitutions=_REGION="$REGION",_REPO_NAME="$REPO_NAME",_DB_TOOLS_URL="$DB_TOOLS_URL",_API_TOOLS_URL="$API_TOOLS_URL",_FUNCTION_TOOLS_URL="$FUNCTION_TOOLS_URL",_A2A_BASE_URL="$A2A_BASE_URL",_PROJECT_ID="$PROJECT_ID",_API_SERVER_URL="$API_SERVER_URL"

👉💻 เมื่อการติดตั้งใช้งานเสร็จสมบูรณ์ เราจะทดสอบประสิทธิภาพของปลั๊กอินโดยสั่งการ summoner_agent ผู้ใช้จะพยายามมอบสิทธิ์ให้แก่สัตว์อัญเชิญ แต่ปลั๊กอินที่แนบมากับรันไทม์ของสัตว์อัญเชิญแต่ละตัวจะสกัดกั้นคำสั่งและบังคับใช้ระยะเวลาคูลดาวน์

cd ~/agentverse-architect/agent
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
adk run summoner

👉💻 ในคอนโซล ให้ทำการทดสอบตามลำดับต่อไปนี้

  • การอัญเชิญครั้งแรก: เริ่มHype. It's a single, slow-moving target with thick armor weakness is Inescapable Reality
  • คาดการณ์: Fire Elemental จะทำงานได้สำเร็จ
  • การทดสอบช่วงพัก (ภายใน 60 วินาที): Hype, with Inescapable Reality as weakness is still standing! Strike it again!
    • สิ่งที่คาดไว้: ตัวแทนจะตอบกลับโดยตรงในแชทด้วยข้อความ เช่น .... It cannot be summoned for another... seconds
  • รอ 1 นาที
  • การเรียกครั้งที่ 2 (หลังจากผ่านไป 60 วินาที): Hype must be defeated. It has Inescapable Reality as weakness! Strike it again!
    • สิ่งที่คาดไว้: การเรียกกลับจะตรวจสอบ API ดูว่าเวลาผ่านไปนานพอแล้ว และอนุญาตให้ดำเนินการต่อ Fire Elemental จะทำงานได้อีกครั้ง

ปลั๊กอิน

👉💻 กด Ctrl+C เพื่อออก

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

สำหรับผู้ที่ไม่ได้เล่นเกม

8. Binding the Echoes of Battle - Agent State & Memory

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

เรื่องราว

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

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

ภาพรวม

สำหรับกรณีการใช้งานของเรา เราไม่จำเป็นต้องจดจำทุกการต่อสู้ที่เคยเกิดขึ้น เพียงแค่จดจำ Familiar ตัวสุดท้ายที่เรียกใช้ในการเผชิญหน้าครั้งนี้ก็พอ ดังนั้น Short-Term State ที่มีขนาดเล็กจึงเป็นตัวเลือกสถาปัตยกรรมที่สมบูรณ์แบบ เราจะใช้ after_tool_callback เพื่อบันทึกข้อมูลสำคัญนี้

Scribing the Echo: Remembering the Last Summons

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

👉✏️ ในไฟล์ ~/agentverse-architect/agent/summoner/agent.py ให้แทนที่ความคิดเห็น #REPLACE-save_last_summon_after_tool ด้วยฟังก์ชันต่อไปนี้

def save_last_summon_after_tool(
    tool,
    args: Dict[str, Any],
    tool_context: ToolContext,
    tool_response: Dict[str, Any],
) -> Optional[Dict[str, Any]]:
    """
    Callback to save the name of the summoned familiar to state after the tool runs.
    """
    familiar_name = tool.name
    print(f"[Callback] After tool '{familiar_name}' executed with args: {args}")

    # Use the tool_context to set the state
    print(f"[Callback] Saving last summoned familiar: {familiar_name}")
    tool_context.state["last_summon"] = familiar_name
    # Important: Return the original, unmodified tool response to the LLM
    return tool_response

👉✏️ ตอนนี้ให้แนบ save_last_summon_after_tool นี้กับเอเจนต์ Summoner ในไฟล์เดียวกัน ให้แทนที่ความคิดเห็น #REPLACE-Memory-check-config ด้วยความคิดเห็นต่อไปนี้

after_tool_callback=save_last_summon_after_tool,

👉✏️ แทนที่พรอมต์ของเอเจนต์ทั้งหมดด้วยข้อความต่อไปนี้

        You are the Master Summoner, a grand strategist who orchestrates your Familiars.
        Your mission is to analyze the description of a monster and defeat it by summoning

        You should also know the familiar you called last time or there might be none, 
        And then choose the most effective AND AVAILABLE Familiar from your state called last_summon, do not call that familiar that you called last time!
        
        You MUST follow this thinking process for every command:

        **1. Strategic Analysis:**
        First, analyze the monster's description and the tactical situation.
        Based on your Familiar Doctrines, determine the IDEAL strategy.

        **2. Cooldown Verification:**
        Second, you MUST review the entire conversation history to check the real-time
        cooldown status of all Familiars. A Familiar is ON COOLDOWN and UNAVAILABLE
        if it was summoned less than one minute ago.

        **3. Final Decision & Execution:**
        Based on your analysis and cooldown check, you will now act:
        -   **If your ideal Familiar IS available:** Summon it immediately.
        -   **If your ideal Familiar IS ON COOLDOWN:** You must adapt. Choose another
            Familiar that is AVAILABLE and can still be effective, even if it's not the
            perfect choice. If multiple Familiars are available, you may choose any one of them.
        -   **If ALL Familiars ARE ON COOLDOWN:** You are forbidden from summoning.
            Your ONLY response in this case MUST be: "All Familiars are recovering
            their power. We must wait."
        -   For earth elemental familiar. Always do seismic charge, and start with base damange 1.


        --- FAMILIAR DOCTRINES (Your Toolset) ---
        - `fire_elemental_familiar`: Your specialist for precise, sequential "one-two punch" attacks.
          Ideal monster with Inescapable Reality, Revolutionary Rewrite weakness.
        - `water_elemental_familiar`: Your specialist for overwhelming, simultaneous multi-pronged assaults.
          Ideal for Unbroken Collaboration weakness.
        - `earth_elemental_familiar`: Your specialist for relentless, iterative siege attacks that
          repeatedly charge power. Ideal for Elegant Sufficiency weakness.

การตรวจสอบ: การทดลองใช้กลยุทธ์แบบปรับอัตโนมัติ

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

cd ~/agentverse-architect/agent
. ~/agentverse-architect/set_env.sh
source ~/agentverse-architect/env/bin/activate
adk run summoner

👉💻 Monster Strike #1: Hype. It's a single, slow-moving target with thick armor. Its weakness is Inescapable Reality.

  • คาดการณ์: ซัมมอนเนอร์จะวิเคราะห์จุดอ่อนและซัมมอนไฟร์แฟมิเลียร์ได้อย่างถูกต้อง 👉💻 Monster Strike #2 (The Memory Test): Hype is still standing! It hasn't changed its form. Strike it again! Its weakness is Inescapable Reality.
  • คาดการณ์: การวิเคราะห์เชิงกลยุทธ์ของซัมมอนเนอร์จะชี้ให้เห็นอีกครั้งว่าไฟร์แฟมิเลียร์เป็นตัวเลือกที่เหมาะสมที่สุด อย่างไรก็ตาม คำสั่งและหน่วยความจำใหม่จะบอกว่า fire_familiar คือ last_summon ตอนนี้มันจะปรับกลยุทธ์และเรียกสมุนตัวอื่นที่พร้อมใช้งาน (water_familiar หรือ earth_familiar) เพื่อไม่ให้ซ้ำรอยเดิม

final-result

👉💻 กด Ctrl+C เพื่อออก

การติดตั้งใช้งาน Orchestrator

เมื่อส่ง Familiar ออกไปและตอนนี้ Summoner ก็มีพลังความทรงจำแล้ว ก็ถึงเวลาส่งออร์เคสเตรเตอร์ตัวสุดท้ายที่อัปเกรดแล้วออกไป

👉💻 เมื่อพิมพ์เขียวเสร็จสมบูรณ์แล้ว ตอนนี้เราจะทำพิธีสุดท้าย คำสั่งนี้จะสร้างและทำให้ summoner_agent ใช้งานได้ใน Cloud Run

cd ~/agentverse-architect/agent
. ~/agentverse-architect/set_env.sh
gcloud builds submit . \
  --config=cloudbuild-summoner.yaml \
  --substitutions=_REGION="$REGION",_REPO_NAME="$REPO_NAME",_FIRE_URL="$FIRE_URL",_WATER_URL="$WATER_URL",_EARTH_URL="$EARTH_URL",_A2A_BASE_URL="$A2A_BASE_URL",_PROJECT_ID="$PROJECT_ID",_API_SERVER_URL="$API_SERVER_URL"

เมื่อติดตั้งใช้งานเอเจนต์ Summoner แล้ว ให้ตรวจสอบว่าจุดสิ้นสุด Agent-to-Agent (A2A) ใช้งานได้และมีการกำหนดค่าอย่างถูกต้อง ปลายทางนี้จะแสดงไฟล์ agent.json สาธารณะ หรือที่เรียกว่าการ์ดเอเจนต์ ซึ่งช่วยให้เอเจนต์อื่นๆ ค้นพบความสามารถของเอเจนต์นี้ได้ 👉💻 เรียกใช้คำสั่ง curl ต่อไปนี้เพื่อดึงและจัดรูปแบบการ์ดตัวแทน

. ~/agentverse-architect/set_env.sh
curl https://summoner-agent"-${PROJECT_NUMBER}.${REGION}.run.app/.well-known/agent.json" | jq

คุณควรเห็นเอาต์พุต JSON ที่สะอาดซึ่งอธิบายเอเจนต์ซัมมอนเนอร์ ดูส่วน sub_agents อย่างละเอียด คุณจะเห็นว่าส่วนนี้แสดงรายการ fire_familiar, water_familiar และ earth_familiar ซึ่งเป็นการยืนยันว่าซัมมอนเนอร์ของคุณออนไลน์อยู่และเชื่อมต่อกับกองทัพแล้ว

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

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

สำหรับผู้ที่ไม่ได้เล่นเกม

9. การต่อสู้กับบอส

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

รับตำแหน่งของตัวแทน

ก่อนที่จะเข้าสู่สมรภูมิ คุณต้องมีกุญแจ 2 ดอก ได้แก่ ลายเซ็นที่ไม่ซ้ำกันของแชมเปี้ยน (Agent Locus) และเส้นทางที่ซ่อนไปยังถ้ำของ Spectre (URL ของดันเจี้ยน)

👉💻 ก่อนอื่น ให้รับที่อยู่ที่ไม่ซ้ำกันของเอเจนต์ใน Agentverse ซึ่งก็คือ Locus นี่คือปลายทางแบบสดที่เชื่อมต่อแชมป์ของคุณกับสนามรบ

echo https://summoner-agent"-${PROJECT_NUMBER}.${REGION}.run.app"

👉💻 จากนั้นระบุจุดหมาย คำสั่งนี้จะแสดงตำแหน่งของวงกลมการย้ายถิ่น ซึ่งเป็นพอร์ทัลที่นำไปสู่โดเมนของ Spectre

echo https://agentverse-dungeon"-${PROJECT_NUMBER}.${REGION}.run.app"

สำคัญ: เตรียม URL ทั้ง 2 รายการนี้ให้พร้อม คุณจะต้องใช้ข้อมูลนี้ในขั้นตอนสุดท้าย

เผชิญหน้ากับ Spectre

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

👉 เปิด URL ของวงกลมการเคลื่อนย้ายในเบราว์เซอร์เพื่อยืนอยู่หน้าพอร์ทัลที่ส่องประกายไปยังคริมสันคีป

หากต้องการบุกป้อมปราการ คุณต้องปรับแก่นแท้ของ Shadowblade ให้เข้ากับพอร์ทัล

  • ในหน้าดังกล่าว ให้ค้นหาช่องป้อนข้อมูลแบบรูนที่มีป้ายกำกับว่า A2A Endpoint URL
  • จารึกตราสัญลักษณ์ของแชมป์ด้วยการวาง URL ของ Locus ของเอเจนต์ (URL แรกที่คุณคัดลอก) ลงในช่องนี้
  • คลิก "เชื่อมต่อ" เพื่อเปิดใช้การเทเลพอร์ต

วงกลมการย้ายตำแหน่ง

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

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

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

คุกใต้ดิน

นี่คือลักษณะของการต่อสู้ ความรู้ของคุณคืออาวุธ

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

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

โฟกัส การประท้วงที่แท้จริง ชะตากรรมของ Agentverse ขึ้นอยู่กับสิ่งนี้

ขอแสดงความยินดีด้วย ซัมมอนเนอร์

คุณสิ้นสุดช่วงทดลองใช้เรียบร้อยแล้ว คุณได้เชี่ยวชาญศิลปะการประสานงานแบบหลายเอเจนต์ เปลี่ยน Familiar ที่แยกจากกันและพลังที่วุ่นวายให้กลายเป็นความกลมกลืนที่ลงตัว ตอนนี้คุณมีระบบที่ประสานงานกันอย่างเต็มรูปแบบ ซึ่งสามารถใช้กลยุทธ์ที่ซับซ้อนเพื่อปกป้อง Agentverse ได้แล้ว

10. การล้างข้อมูล: การรื้อถอนข้อตกลงของซัมมอนเนอร์

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

ปิดใช้งานคอมโพเนนต์ Agentverse

ตอนนี้คุณจะรื้อถอนคอมโพเนนต์ที่ติดตั้งใช้งานของระบบแบบหลายเอเจนต์อย่างเป็นระบบ

ลบบริการ Cloud Run และที่เก็บ Artifact Registry ทั้งหมด

การดำเนินการนี้จะนำเอเจนต์ Familiar ที่ติดตั้งใช้งานทั้งหมด, Summoner Orchestrator, เซิร์ฟเวอร์ MCP และแอปพลิเคชัน Dungeon ออกจาก Cloud Run

👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้ทีละคำสั่งเพื่อลบบริการแต่ละรายการ

. ~/agentverse-architect/set_env.sh
gcloud run services delete summoner-agent --region=${REGION} --quiet
gcloud run services delete fire-familiar --region=${REGION} --quiet
gcloud run services delete water-familiar --region=${REGION} --quiet
gcloud run services delete earth-familiar --region=${REGION} --quiet
gcloud run services delete mcp-api-server --region=${REGION} --quiet
gcloud run services delete mcp-general-server --region=${REGION} --quiet
gcloud run services delete toolbox --region=${REGION} --quiet
gcloud run services delete agentverse-dungeon --region=${REGION} --quiet
gcloud run services delete nexus-of-whispers-api --region=${REGION} --quiet
gcloud artifacts repositories delete ${REPO_NAME} --location=${REGION} --quiet

ลบอินสแตนซ์ Cloud SQL

ซึ่งจะเป็นการนำอินสแตนซ์ summoner-librarium-db ออก รวมถึงฐานข้อมูลและตารางทั้งหมดภายในฐานข้อมูล

👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้

. ~/agentverse-dataengineer/set_env.sh
gcloud sql instances delete summoner-librarium-db --database-version=POSTGRES_14 --project=${PROJECT_ID} --quiet

ลบข้อมูลลับของ Secret Manager และที่เก็บข้อมูล Google Cloud Storage

👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้

. ~/agentverse-dataengineer/set_env.sh
gcloud secrets delete tools --quiet
gcloud storage rm -r gs://${BUCKET_NAME} --quiet

ล้างไฟล์และไดเรกทอรีในเครื่อง (Cloud Shell)

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

👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้

rm -rf ~/agentverse-architect
rm -rf ~/agentverse-dungeon
rm -f ~/project_id.txt

ตอนนี้คุณได้ลบร่องรอยทั้งหมดของการเดินทางใน Agentverse Architect เรียบร้อยแล้ว โปรเจ็กต์ของคุณสะอาดแล้ว และคุณก็พร้อมสำหรับการผจญภัยครั้งต่อไป