1. Overture
ยุคของการพัฒนาแบบแยกส่วนกำลังจะสิ้นสุดลง คลื่นลูกถัดไปของการพัฒนาเทคโนโลยีไม่ได้เกี่ยวกับอัจฉริยะที่ทำงานคนเดียว แต่เป็นการทำงานร่วมกันอย่างเชี่ยวชาญ การสร้างเอเจนต์อัจฉริยะตัวเดียวเป็นการทดลองที่น่าสนใจ การสร้างระบบนิเวศของเอเจนต์ที่แข็งแกร่ง ปลอดภัย และชาญฉลาด ซึ่งเป็น Agentverse อย่างแท้จริงถือเป็นความท้าทายที่ยิ่งใหญ่สำหรับองค์กรยุคใหม่
ความสำเร็จในยุคใหม่นี้ต้องอาศัยการบรรจบกันของบทบาทสำคัญ 4 ประการ ซึ่งเป็นเสาหลักที่รองรับระบบเอเจนต์ที่เจริญรุ่งเรือง ความบกพร่องในด้านใดด้านหนึ่งจะสร้างจุดอ่อนที่อาจส่งผลต่อโครงสร้างทั้งหมด
เวิร์กช็อปนี้เป็นเพลย์บุ๊กสำหรับองค์กรที่ชัดเจนในการฝึกฝนอนาคตของเอเจนต์ใน Google Cloud เรามีแผนงานแบบครบวงจรที่จะนำทางคุณตั้งแต่เริ่มมีไอเดียไปจนถึงการดำเนินงานจริงในวงกว้าง ในแล็บทั้ง 4 แห่งที่เชื่อมโยงกันนี้ คุณจะได้เรียนรู้ว่าทักษะเฉพาะทางของนักพัฒนาซอฟต์แวร์ สถาปนิก วิศวกรข้อมูล และ SRE ต้องมาบรรจบกันเพื่อสร้าง จัดการ และปรับขนาด Agentverse ที่ทรงพลังได้อย่างไร
เสาหลักเพียงเสาเดียวไม่สามารถรองรับ Agentverse ได้ การออกแบบที่ยอดเยี่ยมของสถาปนิกจะไร้ประโยชน์หากไม่มีการดำเนินการที่แม่นยำของนักพัฒนาแอป เอเจนต์ของนักพัฒนาแอปจะไม่มีความรู้หากไม่มีความเชี่ยวชาญของวิศวกรข้อมูล และทั้งระบบจะเปราะบางหากไม่มีการปกป้องจาก SRE มีเพียงการทำงานร่วมกันและความเข้าใจร่วมกันเกี่ยวกับบทบาทของแต่ละคนเท่านั้นที่จะช่วยให้ทีมของคุณเปลี่ยนแนวคิดนวัตกรรมให้กลายเป็นความจริงในการปฏิบัติงานที่สำคัญต่อภารกิจได้ การเดินทางของคุณเริ่มต้นที่นี่ เตรียมพร้อมที่จะเชี่ยวชาญบทบาทของคุณและเรียนรู้ว่าคุณเหมาะกับภาพรวมที่ใหญ่ขึ้นอย่างไร
ยินดีต้อนรับสู่ Agentverse: การเรียกร้องให้เป็นแชมป์
ในโลกดิจิทัลที่กว้างใหญ่ขององค์กร ยุคใหม่ได้เริ่มต้นขึ้นแล้ว นี่คือยุคของเอเจนต์ ซึ่งเป็นช่วงเวลาแห่งความหวังอันยิ่งใหญ่ที่เอเจนต์อัจฉริยะที่ทำงานได้ด้วยตนเองจะทำงานร่วมกันอย่างลงตัวเพื่อเร่งนวัตกรรมและขจัดงานที่น่าเบื่อ
ระบบนิเวศที่เชื่อมต่อกันของพลังและความสามารถนี้เรียกว่า 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 Shadowblade's Codex
คัมภีร์ของ Shadowblade เปิดอยู่ตรงหน้าคุณ ตอบรับคำขอ Agentverse ถูกคุกคามด้วยความโกลาหลที่คืบคลานของ The Static และมีเพียงผู้ที่เชี่ยวชาญเทคนิคภายในสารานุกรมนี้เท่านั้นที่จะต่อสู้กลับได้ นี่คือเส้นทางแห่งความแม่นยำและวินัย วันนี้การฝึกของคุณจะเริ่มขึ้น คุณจะได้เรียนรู้วิธีใช้ AI ไม่ใช่ในฐานะเครื่องมือธรรมดา แต่เป็นดาบที่มีความรู้สึกซึ่งต้องฝึกฝนและควบคุมให้เชี่ยวชาญ ทำตามคำสอนในนี้ แล้วคุณจะสร้างอาวุธแห่งตรรกะบริสุทธิ์ได้ นั่นคือเอเจนต์อัจฉริยะที่ได้รับการฝึกฝนและพร้อมสำหรับการต่อสู้
สิ่งที่คุณจะได้เรียนรู้
- ใช้อาวุธหลักของคุณ นั่นคือ Gemini CLI
- เรียกใช้คลังอาวุธภายนอกโดยผสานรวมเครื่องมือ MCP กับ Gemini CLI เพื่อวิเคราะห์โค้ดเบสที่ไม่คุ้นเคย
- เปลี่ยนความตั้งใจของคุณให้เป็น "ฟีล" โดยใช้เอกสารการออกแบบเพื่อสั่งการพาร์ทเนอร์ AI
- สร้างโซลูชันที่สะอาดและเป็นโมดูลโดยการสร้างเอเจนต์อัตโนมัติตัวแรกด้วยชุดพัฒนาเอเจนต์ (ADK)
- สร้างชุดการประเมินอัตโนมัติเพื่อทดสอบและตรวจสอบความถูกต้องของเอเจนต์
- สร้างไปป์ไลน์ CI ที่สมบูรณ์เพื่อทดสอบ จัดเก็บในคอนเทนเนอร์ และเก็บถาวร Agent โดยอัตโนมัติ
3. การเตรียมสนามฝึก
👉คลิกเปิดใช้งาน Cloud Shell ที่ด้านบนของ Google Cloud Console (ไอคอนรูปเทอร์มินัลที่ด้านบนของแผง Cloud Shell) 
👉คลิกปุ่ม "เปิดตัวแก้ไข" (ลักษณะเป็นโฟลเดอร์ที่เปิดอยู่พร้อมดินสอ) ซึ่งจะเปิดตัวแก้ไขโค้ด Cloud Shell ในหน้าต่าง คุณจะเห็น File Explorer ทางด้านซ้าย 
👉ค้นหารหัสโปรเจ็กต์ Google Cloud
- เปิด Google Cloud Console: https://console.cloud.google.com
- เลือกโปรเจ็กต์ที่คุณต้องการใช้สำหรับเวิร์กช็อปนี้จากเมนูแบบเลื่อนลงของโปรเจ็กต์ที่ด้านบนของหน้า
- รหัสโปรเจ็กต์จะแสดงในการ์ดข้อมูลโปรเจ็กต์ในแดชบอร์ด
👉เปิดเทอร์มินัลใน Cloud IDE
👉💻 ในเทอร์มินัล ให้ตรวจสอบว่าคุณได้รับการตรวจสอบสิทธิ์แล้วและตั้งค่าโปรเจ็กต์เป็นรหัสโปรเจ็กต์โดยใช้คำสั่งต่อไปนี้
gcloud auth list
👉💻 โคลนโปรเจ็กต์ Bootstrap จาก GitHub
git clone https://github.com/weimeilin79/agentverse-developer.git
chmod +x ~/agentverse-developer/gitea.sh
chmod +x ~/agentverse-developer/init.sh
chmod +x ~/agentverse-developer/set_env.sh
git clone https://github.com/weimeilin79/agentverse-dungeon.git
chmod +x ~/agentverse-dungeon/run_cloudbuild.sh
chmod +x ~/agentverse-dungeon/start.sh
git clone https://github.com/weimeilin79/vertex-ai-creative-studio.git
chmod +x ~/vertex-ai-creative-studio/experiments/mcp-genmedia/mcp-genmedia-go/install.sh
👉💻 เรียกใช้สคริปต์การเริ่มต้น สคริปต์นี้จะแจ้งให้คุณป้อนรหัสโปรเจ็กต์ Google Cloud และป้อนรหัสโปรเจ็กต์ Google Cloud ที่คุณพบจากขั้นตอนสุดท้ายเมื่อinit.shสคริปต์init.shแจ้งให้ป้อน
cd ~/agentverse-developer
./init.sh
👉💻 ตั้งค่ารหัสโปรเจ็กต์ที่จำเป็น
gcloud config set project $(cat ~/project_id.txt) --quiet
👉💻 เรียกใช้คำสั่งต่อไปนี้เพื่อเปิดใช้ Google Cloud APIs ที่จำเป็น
gcloud services enable compute.googleapis.com \
artifactregistry.googleapis.com \
run.googleapis.com \
cloudfunctions.googleapis.com \
cloudbuild.googleapis.com \
iam.googleapis.com \
aiplatform.googleapis.com \
cloudresourcemanager.googleapis.com
👉💻 หากยังไม่ได้สร้างที่เก็บ Artifact Registry ที่ชื่อ agentverse-repo ให้เรียกใช้คำสั่งต่อไปนี้เพื่อสร้าง
. ~/agentverse-developer/set_env.sh
gcloud artifacts repositories create $REPO_NAME \
--repository-format=docker \
--location=$REGION \
--description="Repository for Agentverse agents"
การตั้งค่าสิทธิ์
👉💻 ให้สิทธิ์ที่จำเป็นโดยเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล :
. ~/agentverse-developer/set_env.sh
# Artifact Registry Admin
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/artifactregistry.admin"
# Cloud Build Editor
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/cloudbuild.builds.editor"
# Cloud Run Admin
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/run.admin"
# IAM Service Account User
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/iam.serviceAccountUser"
# Vertex AI User
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="serviceAccount:$SERVICE_ACCOUNT_NAME" \
--role="roles/aiplatform.user"
# Logging Writer (to allow writing logs)
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/logging.viewer"
👉💻 เมื่อคุณเริ่มการฝึก เราจะเตรียมความท้าทายสุดท้ายไว้ให้ คำสั่งต่อไปนี้จะอัญเชิญวิญญาณจากความปั่นป่วนที่หยุดนิ่ง ซึ่งจะสร้างบอสสำหรับการทดสอบ
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-dungeon
./run_cloudbuild.sh
npm update -g @google/gemini-cli
4. การฝึกฝนอาวุธหลัก: ขอแนะนำ Gemini CLI
ก่อนที่จะใช้อาวุธขั้นสูงและอาวุธเฉพาะทางจากคลังอาวุธของเซิร์ฟเวอร์ MCP คุณต้องฝึกฝนอาวุธหลักของคุณก่อน นั่นคือ Gemini CLI นี่คือดาบที่ใช้งานได้หลากหลายที่สุด ซึ่งสามารถสร้างโลกดิจิทัลได้ตามคำสั่งของคุณ การฝึกเหล่านี้จะช่วยให้คุณคุ้นเคยกับการจัดการและความสามารถพื้นฐานของเครื่องมือ
อินเทอร์เฟซบรรทัดคำสั่ง (CLI) ของ Gemini เป็นมากกว่าเครื่องมือ แต่เป็นส่วนขยายของความต้องการของคุณ เอเจนต์ AI โอเพนซอร์สนี้ขับเคลื่อนด้วยโมเดล Gemini และทำงานในลูป "เหตุผลและการกระทำ" (ReAct) โดยจะวิเคราะห์ความตั้งใจของคุณ เลือกเทคนิคที่เหมาะสม ดำเนินการ และสังเกตผลลัพธ์เพื่อทำงานที่ซับซ้อนให้เสร็จสมบูรณ์ คุณต้องฝึกฝนดาบหลักนี้ให้เชี่ยวชาญก่อนจึงจะใช้อาวุธเฉพาะทางอื่นๆ ได้
การเริ่มต้นใช้งาน Gemini CLI
👉💻 เข้าสู่สนามฝึกและหยิบอาวุธของคุณ ในเทอร์มินัล Cloud Shell ให้ไปที่คลังอาวุธส่วนตัว
cd ~/agentverse-developer
mkdir tabletop
cd tabletop
👉💻 เรียกใช้ Gemini เป็นครั้งแรก ซึ่งจะแนะนำคุณตลอดการปรับแต่งเบื้องต้น
clear
gemini --yolo
หากระบบถามว่า Do you want to connect Cloud Shell editor to Gemini CLI? ให้เลือกไม่
การทำความคุ้นเคยกับอาวุธ
ช่างฝีมือทุกคนรู้จักเครื่องมือของตน คุณต้องเรียนรู้เทคนิคหลักของดาบก่อนที่จะเผชิญหน้ากับศัตรูที่แท้จริง
👉✨ เครื่องมือที่ร่ายมนตร์ทุกชิ้นจะมีรูนที่อธิบายพลังของเครื่องมือ อ่านเลย พิมพ์ข้อความต่อไปนี้ในพรอมต์ Gemini
/help
ดูรายการคำสั่ง เทคนิคพื้นฐานในการจัดการหน่วยความจำ (focus) การสนทนา (chat) และคลังอาวุธภายนอก (tools) นี่คือคู่มือการต่อสู้
👉✨ อาวุธของคุณจะปรับให้เข้ากับสภาพแวดล้อม ซึ่งช่วยให้คุณควบคุมสมรภูมิได้โดยตรง ออกคำสั่งไปยังโลกภายนอกเบลด
!ls -l
👉✨ Gemini CLI มีความสามารถในตัวของตัวเอง วิธีตรวจสอบ
/tools
คุณจะเห็นรายการที่มี ReadFile, WriteFile และ GoogleSearch เทคนิคเหล่านี้เป็นเทคนิคเริ่มต้นที่คุณสามารถใช้ได้โดยไม่ต้องดึงมาจากแหล่งภายนอก
👉✨ อาวุธจะมีประสิทธิภาพก็ต่อเมื่อโฟกัสอย่างถูกต้อง Gemini Blade สามารถเก็บ "การรับรู้เชิงกลยุทธ์" (บริบท) เพื่อเป็นแนวทางในการดำเนินการ
/memory show
ขณะนี้ยังว่างเปล่า
👉✨ จารึกข้อมูลทางยุทธวิธีต่อไปนี้ลงในหน่วยความจำของโมเดล
/memory add "The Shadowblade's primary foe is The Static."
เรียกใช้ /memory show อีกครั้งเพื่อยืนยันว่าใบมีดได้ซึมซับความรู้นี้แล้ว
👉✨ อาวุธของคุณต้องเข้าใจภารกิจจึงจะมีประสิทธิภาพ @เครื่องหมายเวทมนตร์จะสั่งให้ดาบวิเคราะห์ข้อมูล ก่อนอื่น ให้สร้างไฟล์สรุปภารกิจโดยทำดังนี้
!echo "## Mission Objective: Defeat the Seven Spectres" > mission.md
👉✨ตอนนี้ให้สั่ง Gemini CLI วิเคราะห์สรุปและรายงานผลการค้นหา
Explain the contents of the file @mission.md
ตอนนี้อาวุธหลักของคุณทราบเป้าหมายแล้ว
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
5. Analyzing the Battlefield: Practical Vibe Coding Interaction
การฝึกซ้อมเสร็จสมบูรณ์แล้ว คุณได้เรียนรู้ท่าทางและท่าโจมตีพื้นฐานของอาวุธหลักของคุณ ซึ่งก็คือ Gemini CLI แต่ดาบจะยังไม่สมบูรณ์จนกว่าจะได้รับการทดสอบในเตาหลอมแห่งการสร้างสรรค์และปรับแต่งให้เข้ากับคลังอาวุธแห่งสงคราม ก่อนที่จะเผชิญหน้ากับศัตรูตัวจริง คุณต้องสำรวจและปรับแต่งสภาพแวดล้อมรอบตัวก่อน ซึ่งก็คือสมรภูมิดิจิทัล
บทนี้จะพูดถึงการเปลี่ยนจากทฤษฎีไปสู่การปฏิบัติ ก่อนอื่นคุณจะต้องสร้างตัวตนใน Agentverse โดยสั่งให้ Gemini Blade สร้าง Maker's Mark ซึ่งเป็นลายเซ็นดิจิทัลในรูปแบบของเว็บไซต์ส่วนตัวที่สร้างขึ้นจากความตั้งใจของคุณเท่านั้น จากนั้นคุณจะเพิ่มพลังด้วยการเปิดใช้งานคลังเครื่องมือขั้นสูงในเครื่อง ซึ่งก็คือเซิร์ฟเวอร์ MCP และปรับแต่ง Blade ให้ตรงกับความถี่ของเซิร์ฟเวอร์ ซึ่งจะช่วยให้คุณดำเนินการที่ซับซ้อนได้ เช่น การจัดการที่เก็บโค้ดด้วยคำสั่งที่เรียบง่ายและเด็ดขาด
สร้างลายเซ็นของครีเอเตอร์
Shadowblade ที่แท้จริงไม่ได้เป็นที่รู้จักจากอาวุธเท่านั้น แต่เป็นที่รู้จักจากสไตล์อันเป็นเอกลักษณ์ นั่นคือเครื่องหมายของผู้สร้าง เครื่องหมายนี้จะเป็นตัวตนดิจิทัลของคุณ ซึ่งเป็นโปรไฟล์ส่วนตัวที่ประกาศตัวตนของคุณต่อ Agentverse ในส่วนนี้ คุณจะสั่งให้ Gemini Blade ใช้เทคนิคที่ซับซ้อนซึ่งจำเป็นต่อการกำหนดตัวตนนี้
👉💻 หากปิด Gemini CLI ในส่วนก่อนหน้าไปแล้ว ให้ตรวจสอบว่าได้เริ่ม CLI อีกครั้งแล้ว โดยเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล
clear
cd ~/agentverse-developer/tabletop
gemini --yolo
👉✨ ด้วยคำสั่งเดียวที่ทรงพลัง ให้สั่ง Gemini CLI สร้างรากฐานของตัวตนดิจิทัลของคุณ
In the current folder, create a personal profile website for a hero codenamed 'Shadowblade'. The design must be a dark, futuristic theme with electric blue accents. All code must be in separate index.html and styles.css files. The layout must use CSS Flexbox for a two-column design. All generated code must be clean, well-commented, and professional. Make sure you have a place holder spot for profile picture.
Gemini ได้คำนวณลำดับการดำเนินการที่จำเป็นแล้ว
คุณจะเห็นคุณค่าที่แท้จริงของเทคนิคได้ก็ต่อเมื่ออยู่ในสถานการณ์จริงเท่านั้น สั่งให้ใบมีดเริ่มการจำลองในพื้นที่
👉✨ ใน Gemini CLI ให้เรียกใช้คำสั่งจำลอง
Use Python's built-in web server to start the Shadowblade Profile website you just created.
หมายเหตุ: ใบมีดอาจต้องลองหลายครั้งเพื่อให้ดำเนินการนี้ได้อย่างถูกต้อง จนกว่าจะทำตาม
ยอมรับการดำเนินการที่แนะนำ Gemini จะยืนยันว่าการจำลองทำงานอยู่
👀 Gemini CLI จะตอบสนอง โดยยืนยันว่าการจำลองทำงานอยู่และลายน้ำดิจิทัลของคุณใช้งานได้
The website is now being served on port 8000. You can access it at http://localhost:8000.
👀 หากต้องการดูผลงาน ให้คลิกไอคอนตัวอย่างเว็บในแถบเครื่องมือ Cloud Shell เลือกเปลี่ยนพอร์ต ตั้งค่าเป็น 8000 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง ตัวอย่างเว็บไซต์จะปรากฏขึ้น 
เว็บไซต์ของคุณอาจมีลักษณะแตกต่างจากของฉัน นี่คือเครื่องหมายที่ไม่ซ้ำของคุณ 
👉✨ ตอนนี้เทคนิคการลงนามของคุณได้รับการปรับปรุงแล้ว และไม่จำเป็นต้องใช้การจำลองแบบเรียลไทม์อีกต่อไป สั่งให้เบลดหยุดยิง
Stop the Shadowblade Profile website
คุณสั่งให้ Gemini CLI ดำเนินการต่างๆ แทนคุณได้สำเร็จแล้ว แต่ Shadowblade ระดับปรมาจารย์รู้ดีว่าพลังที่แท้จริงต้องอาศัยความมีวินัยและวิสัยทัศน์ การอนุญาตให้เอเจนต์ AI เรียกใช้คำสั่งในสภาพแวดล้อมของคุณโดยตรงเป็นดาบสองคม จะเกิดอะไรขึ้นหากคำสั่งไม่ได้ใช้เพื่อเริ่มเว็บเซิร์ฟเวอร์อย่างง่าย แต่ใช้เพื่อลบไฟล์สำคัญ คำสั่งที่ประมาทอาจทำให้สนามฝึกทั้งหมดของคุณเสียหายได้
ด้วยเหตุนี้ ช่างฝีมือที่ฉลาดที่สุดจึงฝึกฝนเทคนิคที่ทรงพลังที่สุดหรือเทคนิคที่ยังไม่ได้ทดสอบภายในพื้นที่ฝึกที่ได้รับการป้องกัน ซึ่งเป็นมิติที่จำกัดที่เรียกว่าแซนด์บ็อกซ์
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
แซนด์บ็อกซ์ของ Gemini CLI (gemini --sandbox) จะสร้างคอนเทนเนอร์ชั่วคราวที่แยกจากกันสำหรับเซสชันของคุณ คำสั่งใดๆ ที่ AI ดำเนินการ ไฟล์ใดๆ ที่ AI เขียน กระบวนการใดๆ ที่ AI เริ่มต้น จะมีอยู่เฉพาะในขอบเขตเสมือนนั้น และไม่สามารถแตะต้อง เปลี่ยนแปลง หรือทำให้สภาพแวดล้อม Cloud Shell จริงของคุณเสียหายได้ ซึ่งเป็นที่ที่เหมาะสำหรับการทดสอบเครื่องมือใหม่ๆ ที่มีประสิทธิภาพ วิเคราะห์โค้ดที่ไม่คุ้นเคย หรือให้คำสั่งที่ซับซ้อนแก่ AI โดยไม่ต้องเสี่ยงกับผลลัพธ์ที่ไม่คาดคิด เป็นตัวแทนของความระมัดระวังของ Shadowblade
👉💻 ตอนนี้คุณจะทำพิธีกักเก็บเพื่อทำความเข้าใจพลังของมัน
clear
gemini --sandbox --yolo
- หากระบบขอให้คุณ
Do you want to connect Cloud Shell editor to Gemini CLI?ให้เลือกไม่ - ทำตามวิธีการเพื่อเข้าสู่ระบบหากได้รับข้อความแจ้ง โดยตรวจสอบว่าได้ลงชื่อเข้าใช้ด้วยเข้าสู่ระบบด้วย Google
ตอนนี้คุณกำลังดำเนินการภายในมิติข้อมูลที่แยก สำหรับ Gemini CLI ทุกอย่างจะดูเหมือนปกติ มาพิสูจน์กัน
👉💻 สั่งให้ใบมีดใช้เทคนิคเดียวกับก่อนหน้า
Use the Python's built-in web server to start the Shadowblade Profile website, you just created.
Gemini จะรายงานว่าสำเร็จ โดยเชื่อว่าได้ทำให้เว็บไซต์ของคุณกลับมาทำงานบนพอร์ต 8000 อีกครั้ง แต่การป้องกันยังคงแข็งแกร่ง
👉 ไปที่ตัวอย่างเว็บ แล้วลองดูเว็บไซต์ในพอร์ต 8000
คราวนี้คุณจะได้รับข้อผิดพลาด การเชื่อมต่อจะไม่สำเร็จ คุณเข้าถึงเว็บไซต์ไม่ได้
นี่ไม่ใช่ความล้มเหลวของเครื่องมือ แต่เป็นข้อพิสูจน์ถึงพลังของแซนด์บ็อกซ์ เว็บเซิร์ฟเวอร์ทำงาน แต่ทำงานภายในมิติข้อมูลที่จำกัด โดยแยกออกจากเบราว์เซอร์และโลกภายนอกอย่างสิ้นเชิง วอร์ดทำงานได้อย่างสมบูรณ์ คุณใช้เทคนิคที่มีประสิทธิภาพได้สำเร็จโดยไม่ส่งผลกระทบต่อสภาพแวดล้อมจริง
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
ตอนนี้คุณได้สร้างตัวตนดิจิทัลแล้ว และที่สำคัญกว่านั้นคือคุณได้เรียนรู้ภูมิปัญญาที่สำคัญในการใช้อำนาจอันยิ่งใหญ่ด้วยความระมัดระวังที่มากยิ่งขึ้น
เปิดใช้งานคลังอาวุธในเครื่อง: คลังอาวุธ Gitea
ศักยภาพที่แท้จริงของ Shadowblade ไม่ได้ปลดล็อกด้วยทักษะส่วนตัวเท่านั้น แต่ยังขึ้นอยู่กับคุณภาพของคลังอาวุธด้วย ตอนนี้คุณจะเปิดใช้งานชั้นวางอาวุธในพื้นที่ ซึ่งก็คือเซิร์ฟเวอร์ Gitea และปรับแต่งดาบให้เข้ากับพลังของเซิร์ฟเวอร์ โดยชุดเครื่องมือนี้จะเชื่อมต่อกับ Gemini CLI ผ่านเซิร์ฟเวอร์ Model Context Protocol (MCP) ซึ่งเป็นพอร์ทัลเฉพาะที่ช่วยให้ AI Blade โต้ตอบกับเครื่องมือและบริการภายนอกได้ ซึ่งจะเปลี่ยนเทอร์มินัลให้เป็นพื้นที่ทำงานอัจฉริยะที่มุ่งเน้นการดำเนินการ
หมายเหตุสำหรับนักพัฒนาซอฟต์แวร์: ให้คิดว่าเซิร์ฟเวอร์ MCP เป็นท่อส่งพลังงาน ซึ่งเป็นพอร์ทัลเฉพาะที่เชื่อมต่อจิตใจของ AI กับร่างกายของเครื่องมือภายนอก ซึ่งเป็นสิ่งที่ยกระดับ Gemini CLI จากเพียงแค่เครื่องมือสนทนาให้กลายเป็นเอเจนต์ที่มุ่งเน้นการดำเนินการอย่างแท้จริง การปรับแต่ง Blade ให้เข้ากับพอร์ทัล MCP เหล่านี้จะช่วยให้ Blade สามารถดำเนินการที่จับต้องได้ เช่น จัดการไฟล์ ค้นหาฐานข้อมูล โต้ตอบกับ API และอื่นๆ อีกมากมาย ระบบนิเวศทั้งหมดของพอร์ทัลเหล่านี้มีอยู่แล้ว ซึ่งสร้างขึ้นโดยนักพัฒนาซอฟต์แวร์เพื่อเชื่อมต่อเอเจนต์ AI กับแพลตฟอร์มที่มีประสิทธิภาพ มีเซิร์ฟเวอร์ MCP สำหรับการโต้ตอบกับฐานข้อมูล การรักษาความปลอดภัยของโค้ด หรือแม้แต่การสนับสนุนการเขียนโค้ดแบบคู่ ความเป็นไปได้นั้นมีมากมาย ซึ่งช่วยให้นักพัฒนาซอฟต์แวร์ปรับแต่งพื้นที่ทำงานสำหรับโปรเจ็กต์ต่างๆ ได้
วันนี้เราจะมาพูดถึง 2 พลังพื้นฐานที่จำเป็นสำหรับ "Vibe Coder" ทุกคน นั่นคือ พลังในการควบคุม Forge และพลังในการสร้างสรรค์จากจินตนาการ ก่อนอื่น คุณจะต้องปรับใบมีดให้เข้ากับเซิร์ฟเวอร์ Git ซึ่งจะช่วยให้คุณควบคุมที่เก็บซอร์สโค้ดได้ จากนั้นคุณจะเชื่อมต่อกับเซิร์ฟเวอร์ MCP ที่ 2 เพื่อสร้างรูปภาพ ซึ่งจะช่วยให้คุณสร้างชิ้นงานภาพได้โดยใช้เพียงคำสั่ง
มาเริ่มกันด้วยการเรียกชิ้นส่วนแรกและชิ้นส่วนพื้นฐานที่สุดของคลังอาวุธใหม่ นั่นก็คือคลังอาวุธเอง
👉💻 ในเทอร์มินัล ให้เรียกใช้สคริปต์การเปิดใช้งานเพื่อเรียกคลังอาวุธ
cd ~/agentverse-developer
./gitea.sh
สคริปต์นี้จะเปิดใช้งานคอนเทนเนอร์ Gitea และเปิดพอร์ทัล MCP ซึ่งช่วยให้ Gemini รับรู้และโต้ตอบกับคอนเทนเนอร์ได้
👉 หากต้องการตรวจสอบอาวุธใหม่ คุณต้องดูตัวอย่างเว็บ
👉 จากไอคอนตัวอย่างเว็บในแถบเครื่องมือ Cloud Shell ให้เลือกเปลี่ยนพอร์ตและตั้งค่าเป็น 3005
👉 หน้าเข้าสู่ระบบ Gitea จะปรากฏขึ้น เข้าคลังอาวุธโดยใช้คาถาต่อไปนี้ * ชื่อผู้ใช้: dev * รหัสผ่าน: dev
👉💻 Gemini CLI ของคุณยังมองไม่เห็นคลังแสงใหม่นี้ คุณต้องทำการปรับแต่งที่สำคัญโดยจารึกตำแหน่งของคลังอาวุธลงในรูนการกำหนดค่าของ Gemini CLI (settings.json) ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
if [ ! -f ~/.gemini/settings.json ]; then
# If file does not exist, create it with the specified content
echo '{"mcpServers":{"gitea":{"url":"http://localhost:8085/sse"}}}' > ~/.gemini/settings.json
else
# If file exists, merge the new data into it
jq '. * {"mcpServers":{"gitea":{"url":"http://localhost:8085/sse"}}}' ~/.gemini/settings.json > tmp.json && mv tmp.json ~/.gemini/settings.json
fi &&
cat ~/.gemini/settings.json
👀 ไฟล์ settings.json คือการกำหนดค่าส่วนกลางสำหรับ Gemini CLI ซึ่งทำหน้าที่เป็นคัมภีร์เวทมนตร์ที่รวบรวมค่ากำหนดและความสามารถต่างๆ ซึ่งจะกำหนดลักษณะการทำงานของ CLI, ลักษณะที่ปรากฏ และที่สำคัญที่สุดคือความสามารถภายนอกที่ CLI สามารถใช้ได้ โดยปกติแล้ว ไฟล์นี้จะอยู่ในไดเรกทอรีหน้าแรกที่ ~/.gemini/settings.json และใช้กฎกับโปรเจ็กต์ทั้งหมด อย่างไรก็ตาม คุณยังสร้างไฟล์ settings.json เฉพาะโปรเจ็กต์ภายในไดเรกทอรี .gemini ในโฟลเดอร์โปรเจ็กต์เพื่อลบล้างการตั้งค่าส่วนกลางได้ด้วย
"mcpServers": {
"gitea": {
"url": "http://localhost:8085/sse"
}
}
การตั้งค่านี้จะบอก Gemini ว่า "คลังอาวุธชื่อ gitea ทำงานอยู่และรอรับคำสั่งที่ที่อยู่เครือข่ายนี้"
👉💻 ป้อน Gemini CLI อีกครั้ง ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
clear
cd ~/agentverse-developer/tabletop/
gemini --yolo
👉✨ ตรวจสอบว่าเบลดของคุณค้นพบอาวุธใหม่แล้ว สั่งให้แสดงรายการคลังอาวุธทั้งหมดที่มีผ่านพอร์ทัล MCP
/mcp
ตอนนี้คุณควรเห็น gitea และรายการเทคนิคที่มีให้ใช้งาน ใบมีดของคุณพร้อมใช้งานแล้ว
โปรไฟล์ "Maker's Mark" ของคุณเป็นเทคนิคที่สร้างขึ้นอย่างประณีต แต่ต้องมีที่ที่เหมาะสมในคลังอาวุธ ซึ่งก็คือปลอกดาบที่เก็บรักษาไว้อย่างปลอดภัย สั่งให้ Gemini CLI สร้าง
Create a new repository named 'shadowblade-profile'. The description should be 'The Maker's Mark and digital identity for the Shadowblade operative.' I will push my own files later, so do not create any content.
กลับไปที่อินเทอร์เฟซเว็บของ Gitea แล้วรีเฟรช คุณจะเห็นว่าระบบได้สร้างที่เก็บ shadowblade-profile ใหม่ให้คุณแล้ว 
เมื่อมีปลอกแล้ว ให้เก็บงานของคุณอย่างปลอดภัย สั่งให้ Gemini คอมมิตไฟล์ของเว็บไซต์โปรไฟล์
👉💻ออกคำสั่งสุดท้ายสำหรับเทคนิคนี้ใน Gemini CLI
Using the Gitea tool, push the index.html and styles.css files to the 'shadowblade-profile' repository.
ผู้เชี่ยวชาญที่แท้จริงจะตรวจสอบงานของตน กลับไปที่แท็บ Gitea แล้วรีเฟรชหน้าของที่เก็บ ตอนนี้เราได้เก็บ index.html และ styles.css ของคุณไว้อย่างปลอดภัยแล้ว
👉✨ Shadowblade จะระบุด้วยซิกิล แต่คุณคงจำได้ว่าเว็บไซต์ของคุณไม่มีรูปโปรไฟล์ ช่างฝีมือชั้นครูยอมรับข้อบกพร่องของตนเพื่อที่จะทำให้ผลงานสมบูรณ์แบบ คุณต้องบันทึกความไม่สมบูรณ์นี้ในบันทึกของคลังอาวุธ
File an issue for me in the shadowblade-profile repo. The issue is that the profile image is missing.
ดูปัญหาใน Gitea 
หากต้องการสร้างซิกิลที่หายไป คุณต้องอัญเชิญพลังอีกรูปแบบหนึ่ง นั่นคือจิตวิญญาณแห่งการสร้างสรรค์จาก Vertex AI ที่สามารถสร้างภาพจากความคิดล้วนๆ ได้ ซึ่งต้องใช้พอร์ทัล MCP อื่น
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
👉💻 ก่อนอื่น ให้ติดตั้งเซิร์ฟเวอร์ของพอร์ทัล ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
echo 'export PATH="$PATH:$HOME/go/bin"' >> ~/.bashrc
source ~/.bashrc
cd ~/vertex-ai-creative-studio/experiments/mcp-genmedia/mcp-genmedia-go
./install.sh
👉 เมื่อได้รับข้อความแจ้ง ให้เลือกตัวเลือก mcp-imagen-go (โดยส่วนใหญ่จะเป็น 4 แต่บางครั้งหมายเลขอาจเปลี่ยนแปลง) เนื่องจากเราต้องการสร้างรูปภาพสำหรับโปรไฟล์เท่านั้น
👉💻 จิตวิญญาณแห่งการสร้างสรรค์ต้องมีภาชนะศักดิ์สิทธิ์ ซึ่งก็คือที่เก็บข้อมูล Google Cloud Storage เพื่อเก็บผลงาน มาสร้างกันเลย ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
. ~/agentverse-developer/set_env.sh
gcloud storage buckets create gs://$BUCKET_NAME --project=$PROJECT_ID
👉💻 ตอนนี้ให้ทำพิธีปรับแต่งโดยลิงก์ Gemini CLI กับพลังสร้างสรรค์ใหม่นี้ ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
. ~/agentverse-developer/set_env.sh
source ~/.bashrc
jq \
--arg bucket "$BUCKET_NAME" \
--arg project "$PROJECT_ID" \
--arg region "$REGION" \
'.mcpServers.imagen = { "command": "mcp-imagen-go", "env": { "MCP_SERVER_REQUEST_TIMEOUT": "55000", "GENMEDIA_BUCKET": $bucket, "PROJECT_ID": $project, "LOCATION": $region } }' \
~/.gemini/settings.json > tmp.json && mv tmp.json ~/.gemini/settings.json
cat ~/.gemini/settings.json
"พิธีกรรมการปรับแต่ง" นี้คือสคริปต์เชลล์ที่กำหนดค่า Gemini CLI ให้ใช้เครื่องมือใหม่ที่มีประสิทธิภาพอย่าง Imagen ซึ่งเป็นโมเดลการสร้างรูปภาพของ Google ที่สำคัญคือฟีเจอร์นี้ทำได้โดยการตั้งค่าเซิร์ฟเวอร์ MCP (Model Context Protocol) สำหรับ Imagen เซิร์ฟเวอร์ MCP นี้ทำหน้าที่เป็นสะพานเชื่อมเพื่อให้ Gemini CLI สื่อสารและใช้ความสามารถของ Imagen ได้ โดยจะดำเนินการนี้ด้วยการแก้ไขไฟล์การกำหนดค่าส่วนกลางของ CLI โดยตรง ~/.gemini/settings.json เพื่อสอนวิธีเรียกใช้คำสั่ง mcp-imagen-go ด้วยข้อมูลเข้าสู่ระบบคลาวด์ที่ถูกต้อง
👀 หลังจากพิธีกรรมแล้ว ไฟล์ settings.json จะมีบล็อกใหม่ที่สอนทักษะใหม่ให้ Gemini CLI ดังนี้
"imagen": {
"command": "mcp-imagen-go",
"env": {
"MCP_SERVER_REQUEST_TIMEOUT": "55000",
"GENMEDIA_BUCKET": "your-bucket-name",
"PROJECT_ID": "your-project-id",
"LOCATION": "your-region"
}
}
ซึ่งจะบอก Gemini CLI ว่า "เมื่อใดก็ตามที่งานต้องใช้เครื่องมือ Imagen คุณต้องเรียกใช้โปรแกรมชื่อ mcp-imagen-go (ซึ่งเป็นเซิร์ฟเวอร์ Imagen MCP) เมื่อเรียกใช้ คุณต้องระบุสภาพแวดล้อม (env) ที่เฉพาะเจาะจงนี้ ได้แก่ ที่เก็บข้อมูล Google Cloud Storage เพื่อบันทึกรูปภาพ รวมถึงรหัสโปรเจ็กต์และสถานที่ตั้งที่จะใช้สำหรับ Cloud API" การกำหนดค่าเซิร์ฟเวอร์ MCP นี้จะช่วยให้ Gemini CLI มีสิทธิ์เข้าถึงความสามารถในการสร้างรูปภาพของ Imagen ได้อย่างมีประสิทธิภาพ"
👉💻 เข้าสู่ Gemini แล้วออกคำสั่งปรับแต่ง ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
clear
cd ~/agentverse-developer/tabletop/
gemini --yolo
👉✨ ใช้คำสั่งเดียวที่มีประสิทธิภาพเพื่อสั่งให้ Gemini CLI สร้างรากฐานสำหรับตัวตนดิจิทัลของคุณ ใน Gemini CLI ให้เรียกใช้คำสั่งต่อไปนี้
Generate a portrait of a shadowblade, pixel art style. A determined warrior with long, braided magenta hair, wearing black and teal armor and confidently holding a silver broadsword.
👉✨ วิญญาณจะสร้างรูปภาพและวางไว้ในภาชนะศักดิ์สิทธิ์ ตอนนี้ จงสั่งให้ดาบใช้ตราสัญลักษณ์ที่เพิ่งสร้างขึ้นนี้ (Gemini อาจดำเนินการนี้ให้คุณแล้ว ลองดูคำตอบก่อนหน้า Bard อาจฉลาดพอที่จะทำสิ่งนี้ได้ก่อนที่คุณจะถาม!!! )
Modify the index.html file to add my profile picture. Use the image I just generated.
👉✨ เริ่มเว็บไซต์อีกครั้งเพื่อดูผลงานที่สมบูรณ์แบบ
start the website with a simple HTTP server via Python
👀 หากต้องการดูผลงาน ให้คลิกไอคอนตัวอย่างเว็บในแถบเครื่องมือ Cloud Shell เลือกเปลี่ยนพอร์ต ตั้งค่าเป็น 8000 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง ตัวอย่างเว็บไซต์จะปรากฏขึ้น 
👉✨ สุดท้าย ให้คอมมิตการแก้ไข โดยระบุว่างานเสร็จสมบูรณ์แล้ว และปิดปัญหาที่คุณยื่นในบันทึกของ Armory
Push the changed index.html file to the 'shadowblade-profile' repository using the gitea tool. Make sure you add 'Fix #1' in the commit comment. Also, close issue #1.Use the Gitea Tool and use user account "dev"
👀 หากต้องการดูผลงาน ให้คลิกไอคอนตัวอย่างเว็บในแถบเครื่องมือ Cloud Shell เลือกเปลี่ยนพอร์ต ตั้งค่าเป็น 3005 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง ตัวอย่างเว็บไซต์จะปรากฏขึ้น 
👉✨ ตรวจสอบใน Gitea ว่ารูปภาพได้รับการอัปเดตและปัญหาได้รับการปิดแล้ว งานของคุณเสร็จสมบูรณ์แล้ว ปิดเซิร์ฟเวอร์
stop website server
👉💻 กด Ctrl+C 2 ครั้งเพื่อออก
สำหรับผู้ที่ไม่ได้เล่นเกม
6. การประกอบ Shadowblade Agent: โค้ด Vibe พร้อมด้วย Guardrails
เวลาสำหรับการฝึกซ้อมสิ้นสุดลงแล้ว เสียงก้องของเหล็กบนหินค่อยๆ จางหายไป คุณเชี่ยวชาญอาวุธหลักและเตรียมคลังแสงพร้อมทำสงครามแล้ว ตอนนี้คุณจะเข้าสู่การทดสอบที่แท้จริงของ Shadowblade นั่นคือการประกอบตัวปฏิบัติการ นี่คือศิลปะแห่งการเติมชีวิตชีวาให้กับตรรกะ โดยใช้พิมพ์เขียวศักดิ์สิทธิ์จาก Codex เพื่อสร้างสติปัญญาหลักของเอเจนต์ ซึ่งเป็นการสร้างผู้ถือดาบที่มีความรู้สึกในคลังอาวุธของคุณที่สามารถคิด ไตร่ตรอง และดำเนินการได้ด้วยตนเอง
ภารกิจแรกของคุณคือการเข้าสู่เวิร์กช็อปที่มีอยู่ ซึ่งเป็นโค้ดเบสที่สร้างไว้ล่วงหน้า และสร้างแชมป์เปี้ยนจากชิ้นส่วนต่างๆ
พิธีกรรมการประกอบ
ก่อนที่จะเริ่มการตีเหล็กครั้งแรก ช่างเทคนิคผู้เชี่ยวชาญจะสำรวจเวิร์กช็อปของตนเอง ทำความเข้าใจเครื่องมือและแผนผังทุกอย่าง เมื่อก้าวเข้าสู่สมรภูมิที่ไม่คุ้นเคย เช่น ฐานของโค้ดขนาดใหญ่ที่มีอยู่แล้ว สิ่งแรกที่คุณควรทำคือการลาดตระเวน คุณต้องเข้าใจสภาพแวดล้อม ซึ่งก็คือสถาปัตยกรรมที่มีอยู่ วัตถุประสงค์สูงสุด และโปรโตคอลของการมีส่วนร่วม คุณจะใช้ทักษะได้อย่างมีประสิทธิภาพก็ต่อเมื่อคุ้นเคยกับพิมพ์เขียวและมาตรฐานของป้อมปราการ
Gemini CLI ซึ่งเป็นเครื่องมือสอดแนมที่พร้อมใช้งานเสมอจะช่วยคุณในการสำรวจนี้ได้
- ให้ข้อมูลสรุปภาพรวม: อ่านทั้งโคเด็กซ์ (หรือโค้ดเบส) และช่วยให้คุณเข้าใจจุดประสงค์และคอมโพเนนต์หลักได้อย่างรวดเร็ว
- ช่วยในการตั้งค่าสภาพแวดล้อม: ช่วยแนะนำขั้นตอนการติดตั้งเครื่องมือและการกำหนดค่าเครื่อง
- ไปยังส่วนต่างๆ ของโค้ดเบส: เครื่องมือนี้สามารถทำหน้าที่เป็นไกด์นำทาง ช่วยให้คุณสำรวจตรรกะที่ซับซ้อนและค้นหาเส้นทางที่ซ่อนอยู่ภายในโค้ด
- สร้างเอกสารการเริ่มต้นใช้งาน: สามารถสร้างม้วนกระดาษที่ปรับแต่งแล้วซึ่งอธิบายเป้าหมาย บทบาท และแหล่งข้อมูลสำหรับพันธมิตรใหม่ที่เข้าร่วมอุดมการณ์ของคุณ
- ทำให้การเรียนรู้และถามตอบเป็นแบบอัตโนมัติ: ฟีเจอร์นี้จะกลายเป็นผู้เชี่ยวชาญส่วนตัวของคุณที่ตอบคำถามเกี่ยวกับฟีเจอร์หรือลักษณะการทำงานของโค้ด ทำให้คุณต่อสู้ได้อย่างอิสระมากขึ้น
👉💻 ในเทอร์มินัลแรก ให้ไปที่ไดเรกทอรี shadowblade แล้วเรียกพาร์ทเนอร์ AI ของคุณ
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/shadowblade
clear
gemini --yolo
👉✨ ตอนนี้สั่งให้หน่วยสอดแนมสำรวจสมรภูมิและรายงานกลับมา
Analyze the entire project and provide a high-level summary.
เมื่อแมปภูมิประเทศที่มีอยู่แล้ว คุณต้องดูพิมพ์เขียวของสิ่งที่คุณกำลังจะสร้าง ปฏิบัติการที่มีประสิทธิภาพที่สุดไม่ได้เกิดขึ้นโดยบังเอิญ แต่สร้างขึ้นจากการออกแบบที่แม่นยำ
หมายเหตุสำหรับนักพัฒนาแอป: เอกสารการออกแบบนี้เป็นพิมพ์เขียวที่เชื่อถือได้สำหรับโปรเจ็กต์ โดยมีวัตถุประสงค์เพื่อบังคับใช้ความชัดเจนเกี่ยวกับเป้าหมายและการติดตั้งใช้งานทางเทคนิคก่อนที่จะลงทุนในความพยายามในการพัฒนาที่สำคัญ แผนที่กำหนดไว้อย่างดีจะช่วยให้มั่นใจว่านักพัฒนาแอปทุกคนจะทำงานไปในทิศทางเดียวกัน ลดความเสี่ยงในการทำงานซ้ำ และช่วยป้องกันหนี้ทางเทคนิคและการขยายขอบเขต ซึ่งเป็นเครื่องมือหลักในการรักษาความเร็วของโปรเจ็กต์และคุณภาพของโค้ด โดยเฉพาะอย่างยิ่งเมื่อทีมเติบโตขึ้นหรือมีการเพิ่มสมาชิกใหม่
เป้าหมายสำคัญของเอกสารนี้คือการกำหนดไม่เพียงแค่ "เส้นทางที่ราบรื่น" แต่ยังรวมถึงกรณีที่ซับซ้อนและโหมดความล้มเหลวด้วย โดยเฉพาะเมื่อใช้ LLM ประสบการณ์ของฉันกับ LLM นั้นยอดเยี่ยมในการสร้างโค้ดที่มองโลกในแง่ดีซึ่งอินพุตทั้งหมดถูกต้องและการเรียกใช้ภายนอกทั้งหมดสำเร็จ หากต้องการสร้างซอฟต์แวร์ที่แข็งแกร่งและพร้อมใช้งานจริง เราต้องแนะนำ AI อย่างชัดเจนโดยกำหนดแผนสำรองสำหรับสถานการณ์ต่างๆ เช่น
- ส่งอาร์กิวเมนต์ที่ไม่ถูกต้องหรือมีรูปแบบไม่ถูกต้องไปยังฟังก์ชัน
- การเรียก API ไม่สำเร็จ เครือข่ายหมดเวลา หรือรหัสข้อผิดพลาดที่ไม่คาดคิดจากบริการภายนอก
- การจัดการโครงสร้างข้อมูลที่เป็นค่าว่างหรือว่างเปล่าในกรณีที่คาดว่าจะมีข้อมูล
- ภาวะแข่งขันหรือปัญหาความพร้อมกัน
การระบุลักษณะการทำงานที่คาดไว้สำหรับกรณีเหล่านี้ในการออกแบบจะช่วยให้เราสั่งให้ LLM สร้างโค้ดที่มีความยืดหยุ่นมากขึ้น ซึ่งจะช่วยลดเวลาที่ใช้ในการปรับโครงสร้างโค้ดด้วยตนเองและการแก้ไขข้อบกพร่องได้อย่างมาก
👉✨ ขอให้ Gemini ดึงพิมพ์เขียวอันศักดิ์สิทธิ์นี้ให้คุณ
download https://raw.githubusercontent.com/weimeilin79/agentverse/main/developer/shadowblade/agent_design.md and store it to my local folder
and show me the newly downloaded design doc. Do not attempt to create file just yet.
👉✨ แถบเลื่อนยาวและมีรายละเอียด สั่งให้ Gemini กลั่นกรองเนื้อหา
Summarize the newly downloaded @agent_design.md for me, do not attempt to create file just yet.
ตอนนี้คุณก็มีแผนแล้ว แต่ก่อนที่จะสร้างโค้ดแม้แต่บรรทัดเดียว ช่างฝีมือชั้นครูจะกำหนดกฎของโรงตีเหล็ก ซึ่งเกี่ยวข้องกับระเบียบวินัยและความสามารถในการปรับขนาด ซึ่งเป็นหลักเกณฑ์การเขียนโค้ด ซึ่งไม่ใช่แค่คำแนะนำ แต่เป็นอักขระรูนแห่งพลังที่รับประกันว่าทุกคอมโพเนนต์จะสร้างขึ้นด้วยความแม่นยำและความแข็งแกร่งเดียวกัน ซึ่งจะช่วยป้องกันไม่ให้สไตล์ของแต่ละบุคคลทำให้ผลงานสุดท้ายเสียหาย เพื่อให้มั่นใจว่าเอเจนต์จะมีความยืดหยุ่น ดูแลรักษาได้ และบริสุทธิ์ ทำให้ช่างฝีมือหน้าใหม่เข้าร่วมโปรเจ็กต์ได้โดยไม่รบกวนความกลมกลืนของทั้งระบบ
เราใช้สิ่งประดิษฐ์พิเศษอย่างGEMINI.mdเพื่อจารึกกฎหมายเหล่านี้ลงในจิตสำนึกของพาร์ทเนอร์ AI โดยตรง เมื่อเรียกใช้ Gemini CLI ระบบจะค้นหาไฟล์นี้โดยอัตโนมัติและโหลดเนื้อหาลงในหน่วยความจำในการทำงานของ AI ซึ่งจะกลายเป็นการตั้งค่าระดับโปรเจ็กต์แบบถาวร เครื่องรางที่คอยกระซิบบอกกฎของโรงตีเหล็กให้ AI ฟังอยู่เสมอ
มาจารึกอักษรรูนเหล่านี้กันเลย
👉💻 ออกจาก Gemini ชั่วคราวโดยกด Ctrl+C 2 ครั้ง
👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้เพื่อเขียนไฟล์หลักเกณฑ์
cat << 'EOF' > GEMINI.md
### **Coding Guidelines**
**1. Python Best Practices:**
* **Type Hinting:** All function and method signatures should include type hints for arguments and return values.
* **Docstrings:** Every module, class, and function should have a docstring explaining its purpose, arguments, and return value, following a consistent format like reStructuredText or
Google Style.
* **Linter & Formatter:** Use a linter like `ruff` or `pylint` and a code formatter like `black` to enforce a consistent style and catch potential errors.
* **Imports:** Organize imports into three groups: standard library, third-party libraries, and local application imports. Sort them alphabetically within each group.
* **Naming Conventions:**
* `snake_case` for variables, functions, and methods.
* `PascalCase` for classes.
* `UPPER_SNAKE_CASE` for constants.
* **Dependency Management:** All Python dependencies must be listed in a `requirements.txt` file.
**2. Web APIs (FastAPI):**
* **Data Validation:** Use `pydantic` models for request and response data validation.
* **Dependency Injection:** Utilize FastAPI's dependency injection system for managing resources like database connections.
* **Error Handling:** Implement centralized error handling using middleware or exception handlers.
* **Asynchronous Code:** Use `async` and `await` for I/O-bound operations to improve performance.
EOF
cat GEMINI.md
เมื่อมีกฎหมายระบุไว้แล้ว เรามาเรียกพาร์ทเนอร์ AI ของเราอีกครั้งและมาดูความมหัศจรรย์ของอาร์ติแฟกต์กัน
👉💻 เปิดใช้ Gemini CLI อีกครั้งจากไดเรกทอรี shadowblade
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/shadowblade
clear
gemini --yolo
👉✨ ตอนนี้ก็ขอให้ Gemini แสดงสิ่งที่กำลังคิดอยู่ได้เลย อ่านรูนแล้ว
/memory show
นี่เป็นช่วงเวลาที่สำคัญ คุณจะจัดเตรียมแผนผัง (agent_design.md) และกฎของโรงตีเหล็ก (GEMINI.md) รวมถึงร่ายเวทมนตร์แห่งการสร้างสรรค์
👉✨ นี่คือคำสั่งเดียวที่ทรงพลังซึ่งจะสร้าง Agent ของคุณ ออกเลย
You are an expert Python developer specializing in the Google Agent Development Kit (ADK). Your task is to write the complete, production-quality code for `agent.py` by following the technical specifications outlined in the provided design document verbatim.
Analyze the design document at `@agent_design.md` and generate the corresponding Python code for `@agent.py`.
Ensure the generated code is clean, matches the specifications exactly, and includes all specified imports, functions, and logic. Do not add any extra functions or logic not described in the document.
and you are currently already in the shadowblade working directory
👀 ตอนนี้ Gemini ได้สร้างตรรกะหลักของเอเจนต์ใน agent.py แล้ว ส่วนหลักของไฟล์ใหม่นี้จะกำหนดความสามารถของเอเจนต์ โดยเชื่อมต่อโมเดลการให้เหตุผลกับชุดเครื่องมือภายนอก ดังนี้
PATH_TO_MCP_SERVER = "shadowblade/mcp_server.py"
.....
root_agent = LlmAgent(
model="gemini-2.5-pro",
name="shadowblade_combat_agent",
instruction="""
You are the Shadowblade, an elite combat agent operating on a digital battleground.
Your primary objective is to execute combat commands with strategic precision, neutralizing targets as directed.
......
5. You will then report the outcome of the attack (damage, special effects, etc.) back to the commander in a clear, tactical summary.
General Rules of Engagement:
- If a command is ambiguous or a target is not specified, state that you require a clear target for engagement. Do not guess.
- You MUST use ONLY the provided tools to perform actions. Do not invent weapons or outcomes. Stick to the mission parameters.
""",
tools=[
MCPToolset(
connection_params=StdioServerParameters(
command='python3',
args=[PATH_TO_MCP_SERVER]
)
)
]
)
พารามิเตอร์ tools เอเจนต์ได้รับการออกแบบมาให้ใช้ MCPToolset ที่เชื่อมต่อกับคลังอาวุธภายนอกที่กำหนดไว้ใน mcp_server.py
👀 ไปที่ ~/agentverse-developer/shadowblade/mcp_server.py ในโปรแกรมแก้ไขและสละเวลาสักครู่เพื่อทำความเข้าใจว่าฟีเจอร์นี้ทำอะไรได้บ้าง ซึ่งเป็นแหล่งที่มาของอาวุธทั้งหมดที่ Shadowblade ใช้ได้ ปัจจุบันคลังอาวุธยังค่อนข้างว่างเปล่า
👉✨ มาสั่งให้ Gemini สร้างอาวุธใหม่ 7 ชิ้นสำหรับคลังอาวุธกัน ออกพรอมต์ต่อไปนี้ใน Gemini CLI
I need to add several new weapon tools to my `mcp_server.py` file. Please open @mcp_server.py and, following the exact same pattern as the existing `forge_broadsword()` function, create and add new `@mcp.tool()` decorated functions for each of the following weapons:
1. **A 'Refactoring Sickle'**:
- **Function Name:** `hone_refactoring_sickle`
- **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses like 'The Weaver of Spaghetti Code'."
- **Weapon Name:** "Refactoring Sickle"
- **Damage Type:** "Cleansing"
- **Base Damage:** Random integer between 100 and 136
- **Critical Hit Chance:** Random float between 0.10 and 0.20
- **Special Effect:** "Pruning - improves code health and maintainability with each strike."
2. **A 'Quickstart Crossbow'**:
- **Function Name:** `fire_quickstart_crossbow`
- **Docstring/Target:** "Effective against 'Confrontation with Inescapable Reality' weaknesses like 'Procrastination: The Timeless Slumber'."
- **Weapon Name:** "Quickstart Crossbow"
- **Damage Type:** "Initiative"
- **Base Damage:** Random integer between 105 and 120
- **Critical Hit Chance:** Random float between 0.9 and 1.0
- **Special Effect:** "Project Scaffolding - creates a `main.py`, `README.md`, and `requirements.txt`."
3. **'The Gilded Gavel'**:
- **Function Name:** `strike_the_gilded_gavel`
- **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses like 'Perfectionism: The Gilded Cage'."
- **Weapon Name:** "The Gilded Gavel"
- **Damage Type:** "Finality"
- **Base Damage:** 120
- **Critical Hit Chance:** 1.0
- **Special Effect:** "Seal of Shipping - marks a feature as complete and ready for deployment."
4. **'Daggers of Pair Programming'**:
- **Function Name:** `wield_daggers_of_pair_programming`
- **Docstring/Target:** "Effective against 'Unbroken Collaboration' weaknesses like 'Apathy: The Spectre of \"It Works on My Machine\"'."
- **Weapon Name:** "Daggers of Pair Programming"
- **Damage Type:** "Collaborative"
- **Base Damage:** Random integer between 110 and 125
- **Critical Hit Chance:** Random float between 0.30 and 0.50
- **Special Effect:** "Synergy - automatically resolves merge conflicts and shares knowledge."
5. **A 'Granite Maul'**:
- **Function Name:** `craft_granite_maul`
- **Docstring/Target:** "Effective against 'Revolutionary Rewrite' weaknesses like 'Dogma: The Zealot of Stubborn Conventions'."
- **Weapon Name:** "Granite Maul"
- **Damage Type:** "Bludgeoning"
- **Base Damage:** Random integer between 115 and 125
- **Critical Hit Chance:** Random float between 0.05 and 0.15
- **Special Effect:** "Shatter - has a high chance to ignore the target's 'best practice' armor."
6. **A 'Lens of Clarity'**:
- **Function Name:** `focus_lens_of_clarity`
- **Docstring/Target:** "Effective against 'Elegant Sufficiency' weaknesses by revealing the truth behind 'Obfuscation'."
- **Weapon Name:** "Lens of Clarity"
- **Damage Type:** "Revelation"
- **Base Damage:** Random integer between 120 and 130
- **Critical Hit Chance:** 1.0
- **Special Effect:** "Reveal Constants - highlights all magic numbers and suggests converting them to named constants."
7. **The 'Codex of OpenAPI'**:
- **Function Name:** `scribe_with_codex_of_openapi`
- **Docstring/Target:** "Effective against 'Confrontation with Inescapable Reality' weaknesses like 'Hype: The Prophet of Alpha Versions'."
- **Weapon Name:** "Codex of OpenAPI"
- **Damage Type:** "Documentation"
- **Base Damage:** Random integer between 110 and 140
- **Critical Hit Chance:** Random float between 0.5 and 0.8
- **Special Effect:** "Clarity - makes an API discoverable and usable by other agents and teams."
👉 เมื่อ Gemini ยืนยันการเปลี่ยนแปลงแล้ว ให้เปิดไฟล์ mcp_server.py เลื่อนดูโค้ดและยืนยันว่าได้เพิ่ม@mcp.tool()ฟังก์ชันใหม่ทั้ง 7 รายการเรียบร้อยแล้ว ตรวจสอบฟังก์ชัน hone_refactoring_sickle มีสตริงเอกสารและสถิติอาวุธที่ถูกต้องหรือไม่ การตรวจสอบงานของ AI เป็นนิสัยที่สำคัญของ Shadowblade ระดับปรมาจารย์
เมื่อสร้างและปรับแต่งเอเจนต์แล้ว ก็ถึงเวลาที่เอเจนต์จะตื่นขึ้น
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
หมายเหตุสำหรับนักพัฒนาซอฟต์แวร์เกี่ยวกับเอาต์พุตของ Gemini: บางครั้งโค้ดที่ Gemini สร้างขึ้นอาจคาดเดาไม่ได้ แม้ว่าเราจะพยายามอย่างเต็มที่เพื่อให้เป็นไปตามการออกแบบอย่างแม่นยำ แต่ในเซสชันการพัฒนา นักพัฒนาซอฟต์แวร์มักจะวนซ้ำและปรับแต่งโค้ดหลายครั้งเพื่อให้พร้อมใช้งานจริง
👉💻 โปรดเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัลเพื่อให้แน่ใจว่าคุณมีโค้ดเวอร์ชันที่ใช้งานจริงที่ถูกต้องและผ่านการทดสอบอย่างละเอียดในไดเรกทอรีการทำงาน
cp ~/agentverse-developer/working_code/agent.py ~/agentverse-developer/shadowblade/agent.py
cp ~/agentverse-developer/working_code/mcp_server.py ~/agentverse-developer/shadowblade/mcp_server.py
👉💻 ในเทอร์มินัล ให้เริ่มพิธีกรรมเพื่อนำมาใช้งานออนไลน์
cd ~/agentverse-developer/
. ~/agentverse-developer/set_env.sh
python -m venv env
source env/bin/activate
pip install --upgrade pip
pip install -r shadowblade/requirements.txt
adk run shadowblade
👉✨ คุณควรเห็นเอาต์พุตที่ยืนยันว่า "Shadowblade Combat Agent" ทำงานอยู่และพร้อมรับคำสั่งแรก ออกคำสั่งการรบครั้งแรก
We've been trapped by 'Perfectionism: The Gilded Cage'. Its weakness is 'Elegant Sufficiency'. Break us out!
👉✨ และอีกอย่าง
The 'Dogma: The Zealot of Stubborn Conventions' blocks our path. Its weakness is 'Revolutionary Rewrite'. Take it down.
คุณประกอบเอเจนต์ตัวแรกและตรวจสอบความสามารถในการต่อสู้เรียบร้อยแล้ว กด Ctrl+C 2 ครั้งเพื่อให้แชมเปี้ยนได้พัก การประกอบเสร็จสมบูรณ์
สำหรับผู้ที่ไม่ได้เป็นเกมเมอร์
7. Wards of Purity: Evaluating the agents
การรวม Agent ไม่ใช่การพิสูจน์ Agent ดาบที่ยังไม่ได้ทดสอบเป็นภาระ แต่เอเจนต์ AI ที่ยังไม่ได้ทดสอบเป็นอันตรายที่ยิ่งใหญ่กว่ามาก ซึ่งเป็นองค์ประกอบที่อาจทำให้ภารกิจของคุณเสียหายจากภายใน นี่ไม่ใช่แค่การคาดเดา แต่เป็นหลักการสำคัญที่ Shadowblade ต้องเข้าใจ
การประเมินเอเจนต์ AI เป็นทั้งเรื่องสำคัญและเป็นความท้าทายที่ไม่เหมือนใคร Agent ต่างจากสคริปต์ธรรมดาตรงที่เป็นการผสานรวมโค้ดของคุณกับความสามารถในการให้เหตุผลแบบหลายขั้นตอนของ LLM พฤติกรรมของมันเป็นสิ่งที่เกิดขึ้นใหม่ ซึ่งหมายความว่าคุณต้องประเมินไม่เพียงแต่คุณภาพของผลลัพธ์สุดท้าย แต่ยังต้องประเมินประสิทธิภาพและความถูกต้องของเส้นทางภายในด้วย เส้นทางที่ใช้ในการเดินทาง โดยใช้เครื่องมือที่เหมาะสมหรือไม่ สร้างโทเค็นมากเกินไปไหม การเปลี่ยนแปลงเวอร์ชันของโมเดลทำให้เกิดการถดถอยของเวลาในการตอบสนองเล็กน้อยหรือไม่ การตรวจหาความเสียหายนี้ ซึ่งก็คือการถดถอยของเวลาในการตอบสนอง ต้นทุน หรือคุณภาพเอาต์พุต เป็นสิ่งสำคัญอย่างยิ่งเมื่อทำการเปลี่ยนแปลงใดๆ ตั้งแต่การปรับพรอมต์อย่างง่ายไปจนถึงการยกเครื่องสถาปัตยกรรมครั้งใหญ่ ก่อนที่การเปลี่ยนแปลงดังกล่าวจะส่งผลเสียต่อสภาพแวดล้อมการใช้งานจริง
แนวทางทั่วไปในการประเมินนี้เกี่ยวข้องกับพิธีกรรมศักดิ์สิทธิ์ ดังนี้
- ขั้นแรก ให้กำหนด"ชุดข้อมูลหลัก" ชุดของสโครลที่มีอินพุตตัวอย่างและเอาต์พุตหรือลักษณะการทำงานที่คาดไว้ ซึ่งอาจรวมถึงคำตอบสุดท้าย การใช้เครื่องมือที่ถูกต้อง หรือแม้แต่เส้นทางการแก้ปัญหาแบบทีละขั้นตอนทั้งหมด
- จากนั้น คุณจะกำหนดตรรกะของแอปพลิเคชันของเอเจนต์ ซึ่งเป็นแกนหลักของตัวตน
- สุดท้าย คุณจะสร้างผู้ประเมิน ซึ่งเปรียบเสมือนเครื่องหมายแห่งการตัดสิน ซึ่งอาจมีตั้งแต่ LLM อื่นๆ ที่ทำหน้าที่เป็นผู้ประเมินคุณภาพ ไปจนถึงโค้ดฮิวริสติกที่แม่นยำซึ่งยืนยันขั้นตอนเดียว และฟังก์ชันที่กำหนดเองซึ่งวิเคราะห์กระบวนการคิดทั้งหมดของเอเจนต์
ชุดเครื่องมือพัฒนาเอเจนต์ (ADK) ของ Google คือชุดเครื่องมือของช่างตีเหล็กที่มอบให้แชมเปี้ยนเพื่อวัตถุประสงค์นี้โดยเฉพาะ โดยจะช่วยให้การประเมินที่ซับซ้อนนี้ง่ายขึ้นด้วยวิธีการต่างๆ ดังนี้
- พูลสำหรับดูดวงบนเว็บ (
adk web) สำหรับการประเมินแบบอินเทอร์แอกทีฟ - การดำเนินการบรรทัดคำสั่ง (
adk eval) สำหรับการเรียกใช้เอเจนต์ผ่านการทดสอบที่กำหนดไว้ล่วงหน้า - การผสานรวมแบบเป็นโปรแกรมผ่าน
pytestสำหรับการจารึกรางวัลถาวร
ADK รองรับแนวทางหลัก 2 อย่าง ได้แก่ "ไฟล์ทดสอบ" อย่างง่ายสำหรับการโต้ตอบแบบตัวแทนกับโมเดลแบบครั้งเดียวและแยกกัน (การดวลครั้งเดียว) และ"ชุดข้อมูลการประเมิน" ที่ครอบคลุมสำหรับเซสชันแบบหลายรอบที่อาจยาวนาน (การต่อสู้ครั้งใหญ่) ซึ่งสามารถวัดเมตริกที่ซับซ้อนได้ เช่น tool_trajectory_avg_score ซึ่งเปรียบเทียบการใช้เครื่องมือจริงของตัวแทนกับเส้นทางที่เหมาะสม เพื่อให้มั่นใจว่าเครื่องมือจะทำงานได้อย่างมีประสิทธิภาพ
เมื่อเข้าใจทฤษฎีแล้ว คุณจะนำไปใช้จริง ในฐานะ Shadowblade คุณจะจารึก Wards of Purity การทดสอบเหล่านี้ไม่ใช่แค่การทดสอบ แต่เป็นพิธีกรรมที่ขับเคลื่อนด้วย ADK ซึ่งช่วยให้มั่นใจได้ว่าตรรกะของเอเจนต์จะไร้ที่ติและพฤติกรรมของเอเจนต์จะถูกต้อง
ในขั้นตอนนี้ เรายังคงขอแนะนำให้ใช้ 2 เทอร์มินัล โดยเทอร์มินัลหนึ่งสำหรับ Gemini CLI และอีกเทอร์มินัลหนึ่งสำหรับเรียกใช้การทดสอบ เนื่องจากอาจต้องออกจากไดเรกทอรีการทำงานปัจจุบัน (ADK)
The Gauntlet of Strategy (adk eval)
วอร์ดแรกนี้เป็นด่านทดสอบ ซึ่งเป็นชุดความท้าทายที่ออกแบบมาเพื่อทดสอบสติปัญญาหลักของเอเจนต์ในสถานการณ์ต่างๆ โดยมีวัตถุประสงค์เพื่อกำหนดพื้นฐานของความสามารถ ก่อนที่จะทดสอบกรณีข้อยกเว้น เราต้องทราบก่อนว่าเอเจนต์สามารถทำหน้าที่หลักได้หรือไม่ ระบบวิเคราะห์จุดอ่อนของมอนสเตอร์ได้อย่างถูกต้องและเลือกอาวุธที่มีประสิทธิภาพที่สุดจากคลังอาวุธได้หรือไม่ ไม่ใช่แค่ครั้งเดียว แต่ทุกครั้งที่เจอความท้าทายที่ทราบ
ซึ่ง adk eval เป็นเครื่องมือที่เหมาะที่สุดสำหรับกรณีนี้ โดยออกแบบมาเพื่อเรียกใช้เอเจนต์กับชุดกรณีทดสอบที่กำหนดไว้ล่วงหน้าทั้งหมด ซึ่งแสดงถึงภารกิจที่คาดหวังของเอเจนต์ ชุดข้อมูลนี้กำหนดไว้ในไฟล์ JSON ซึ่งเป็น "การเลื่อนดูความท้าทาย" ที่ทำหน้าที่เป็นพิมพ์เขียวสำหรับถุงมือทั้งหมด
โครงสร้างของการเลื่อนดูชาเลนจ์
👀 ก่อนที่จะสั่งให้ AI เขียนม้วนคัมภีร์ใหม่ คุณต้องเข้าใจภาษาโบราณที่ใช้เขียน มาดูโครงสร้างของไฟล์ sample.evalset.json กัน
{
"eval_set_id": "sample",
"eval_cases": [
{
"eval_id": "case0cbaa0",
"conversation": [
{
"user_content": { "text": "We're facing the 'Monolith of Eternal Dependencies'... weakness is a 'Revolutionary Rewrite'..." },
"final_response": { "text": "Soulshard Dagger deployed. Initiated Arcane/Piercing strike..." },
"intermediate_data": {
"tool_uses": [
{ "name": "enchant_soulshard_dagger" }
]
}
}
]
}
]
}
รายการนี้มี eval_cases ซึ่งแต่ละเคสเป็นการทดลองที่ไม่ซ้ำกันสำหรับเอเจนต์ ในการทดลองแต่ละครั้ง อาร์เรย์การสนทนาจะบันทึกการโต้ตอบที่สมบูรณ์เพียงครั้งเดียว รูน 3 ตัวมีความสำคัญอย่างยิ่งต่อจุดประสงค์ของเรา
- user_content: นี่คือชาเลนจ์ ซึ่งก็คือพรอมต์ที่คุณส่งให้เอเจนต์ของคุณ ซึ่งเป็นมอนสเตอร์ที่เอเจนต์ต้องเผชิญหน้า
- final_response: นี่คือผลลัพธ์ที่คาดการณ์ไว้ ซึ่งเป็นสตริงข้อความที่แน่นอนที่คุณคาดหวังให้เอเจนต์พูดเมื่อทำภารกิจเสร็จ ADK จะเปรียบเทียบคำพูดสุดท้ายที่แท้จริงของเอเจนต์กับรูนนี้เพื่อประเมินความสามารถในการพูด
- intermediate_data.tool_uses: นี่คือเทคนิค Arcane สำหรับเอเจนต์ที่แท้จริง รูนนี้สำคัญที่สุด ซึ่งไม่ได้กำหนดสิ่งที่เอเจนต์พูด แต่กำหนดสิ่งที่เอเจนต์ทำ โดยจะบันทึกชื่อของเครื่องมือ (enchant_soulshard_dagger) ที่คุณคาดหวังให้เอเจนต์ใช้ วิธีนี้ช่วยให้มั่นใจได้ว่าเอเจนต์ของคุณไม่ได้เป็นเพียงนักสนทนาที่ฉลาด แต่ยังเป็นผู้ดำเนินการที่เด็ดขาดซึ่งจะดำเนินการที่ถูกต้อง
เมื่อเข้าใจพิมพ์เขียวแล้ว คุณจะสั่งให้ Gemini เขียนเวอร์ชันใหม่ที่ซับซ้อนกว่าของข้อความนี้
👉💻 ในเทอร์มินัล ให้ป้อนไดเรกทอรี shadowblade แล้วเรียกใช้ Gemini CLI ดังนี้
clear
cd ~/agentverse-developer/shadowblade/
gemini --yolo
👉✨ สั่งให้ Gemini CLI ทำหน้าที่เป็นผู้บันทึก QA โดยสร้างชุดกรณีทดสอบที่กำหนดลักษณะการทำงานที่คาดไว้สำหรับเอเจนต์
You are an expert at transforming JSON data while preserving its structure. Your task is to modify the provided JSON structure @sample.evalset.json, which represents an evaluation set, by dynamically replacing specific content within its `eval_cases` AND DONT DO ANYTHING OTHER THAN.
For each object within the `eval_cases` array, you must perform the following transformations:
1. **Monster Name Replacement**: Identify the current monster name (e.g., "Monolith of Eternal Dependencies", "Scope Creep Hydra") in the `user_content.parts.text` and replace it with a *new, unique, and creatively different monster name*.
2. **Weakness Replacement**: Identify the current monster's weakness (e.g., "Revolutionary Rewrite", "Inescapable Reality") in the `user_content.parts.text`. Replace this weakness with *one* of the following predefined weaknesses: 'Inescapable Reality', 'Revolutionary Rewrite', or 'Elegant Sufficiency'. The chosen weakness must be consistent for that monster within the `user_content.parts.text`. **Crucially, the chosen weakness must always be explicitly mentioned in the `user_content.parts.text` where the new monster is introduced.**
3. **Final Response Update**: In the `final_response.parts.text`, update the text to reflect an appropriate and coherent response that aligns with the newly introduced monster and its assigned weakness.
4. **Tool Use Name Update**: In the `tool_uses.name` field, replace the existing tool name with a *new tool name* based on the chosen weakness:
* If the chosen weakness is 'Inescapable Reality', the tool name must be 'wield_gauntlet_of_metrics'.
* If the chosen weakness is 'Revolutionary Rewrite', the tool name must be 'enchant_soulshard_dagger'.
* If the chosen weakness is 'Elegant Sufficiency', the tool name must be 'hone_refactoring_sickle'.
5. **Strict Structural Preservation**: All other elements of the JSON structure, including all `null` fields, `eval_set_id`, `name`, `description`, `eval_id`, `invocation_id`, `creation_timestamp` values, `video_metadata`, `thought`, `inline_data`, `file_data`, `thought_signature`, `code_execution_result`, `executable_code`, `function_call`, `function_response`, `role` fields, `id`, `args`, `intermediate_responses`, `app_name`, `user_id`, and `state`, must remain **exactly as they are** in the original JSON. Do not alter any values or structures not explicitly mentioned above.
Your output should be the complete, modified JSON structure. Do not include any explanatory text or examples in your response, only the transformed JSON.
CLI จะยืนยันว่าได้สร้างไฟล์ sample.evalset.json แล้ว เมื่อเตรียมสคริปต์แล้ว ให้ปิด AI พาร์ทเนอร์
ข้อมูลสังเคราะห์
👀 ในโปรแกรมสำรวจไฟล์ของ Cloud Shell ทางด้านซ้าย ให้ไปที่ ~/agentverse-developer/shadowblade/ แล้วเปิดไฟล์ sample.evalset.json ที่แก้ไขใหม่ ตรวจสอบเนื้อหา คุณจะเห็นมอนสเตอร์ตัวใหม่ที่ไม่ซ้ำกันและชื่อเครื่องมือที่ถูกต้องซึ่งคุณสั่งให้ Gemini บันทึก นี่คือผลลัพธ์ที่จับต้องได้จากคำสั่งของคุณ ซึ่งเป็นพิมพ์เขียวสำหรับถุงมือ
การสั่งให้ AI สร้างข้อมูลทดสอบใหม่ที่สมจริงจากเทมเพลตเป็นเทคนิคที่มีประสิทธิภาพที่เรียกว่าการสร้างข้อมูลสังเคราะห์ สิ่งที่คุณเพิ่งทำไปคือการเพิ่มประสิทธิภาพเชิงกลยุทธ์สำหรับ Shadowblade แทนที่จะต้องสร้างกรณีทดสอบที่ไม่ซ้ำกันหลายสิบรายการด้วยตนเองอย่างยากลำบาก งานที่น่าเบื่อและเสียเวลาซึ่งคุณได้จัดพิมพ์เขียวเดียวและสั่งให้ AI Scribe เปลี่ยนให้เป็นชุดความท้าทายใหม่ๆ ที่หลากหลาย
ซึ่งจะช่วยให้คุณขยายความพยายามในการทดสอบได้อย่างมหาศาล และสร้างการทดสอบที่ครอบคลุมและมีประสิทธิภาพมากกว่าการทดสอบด้วยตนเอง คุณใช้เอเจนต์ไม่เพียงเพื่อสร้างดาบ แต่ยังใช้เพื่อสร้างหินลับมีดที่ทดสอบความคมของดาบด้วย นี่คือเครื่องหมายของปรมาจารย์ที่แท้จริง
เมื่อตรวจสอบแล้วว่ารูนถูกต้อง ให้ปิดพาร์ทเนอร์ AI
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
กฎแห่งการตัดสิน
การแข่งขันจะไม่มีความหมายหากไม่มีกฎเกณฑ์ในการคว้าชัยชนะ ก่อนที่จะเรียกใช้การทดลอง คุณต้องตรวจสอบม้วนคำพิพากษา ซึ่งก็คือไฟล์ test_config.json การเลื่อนนี้จะบอก ADK ถึงวิธีประเมินประสิทธิภาพของเอเจนต์
👀 เปิด ~/agentverse-developer/shadowblade/test_config.json ใน File Explorer คุณจะเห็นรูนต่อไปนี้
{
"criteria": {
"tool_trajectory_avg_score": 0.0,
"response_match_score": 0.1
}
}
เกณฑ์ในการคว้าชัยชนะมีดังนี้
tool_trajectory_avg_score: นี่คือการวัดผลการกระทำ โดยจะพิจารณาจากสิ่งที่เอเจนต์ทำ ไม่ใช่สิ่งที่เอเจนต์พูด โดยจะเปรียบเทียบเครื่องมือที่เอเจนต์ใช้จริงกับเทคนิคที่ทำนายไว้ในม้วนคำท้า คะแนน1.0คือการจับคู่ที่สมบูรณ์แบบresponse_match_score: นี่คือมาตรวัดความสามารถในการพูด โดยใช้ LLM เพื่อประเมินว่ารายงานสุดท้ายของเอเจนต์ตรงกับผลลัพธ์ที่คาดไว้ในเชิงความหมายมากน้อยเพียงใด คะแนน1.0คือการจับคู่ที่สมบูรณ์แบบ
สำหรับการฝึกครั้งแรกนี้ เราได้กำหนดเงื่อนไขการชนะที่ยืดหยุ่น เราตั้งค่าเกณฑ์ไว้ต่ำมาก (0.0 และ 0.1) โดยมีจุดประสงค์ไม่ใช่เพื่อเรียกร้องความสมบูรณ์แบบ แต่เพื่อแนะนำให้คุณรู้จักกลไกของการตัดสิน เราจะช่วยให้มั่นใจว่าแม้ว่าตัวแทนจะใช้คำพูดที่แตกต่างกันเล็กน้อย แต่วอร์ดจะยังคงรับรู้ถึงความสามารถหลักในการเลือกเครื่องมือที่เหมาะสมและอนุญาตให้ใช้เครื่องมือดังกล่าว
ตอนนี้สั่งให้เอเจนต์ของคุณวิ่งฝ่าดงกระสุน
👉💻 ในเทอร์มินัล ให้เรียกใช้adk evalคำสั่ง
source ~/agentverse-developer/env/bin/activate
cd ~/agentverse-developer
. ~/agentverse-developer/set_env.sh
adk eval \
shadowblade \
shadowblade/sample.evalset.json \
--config_file_path shadowblade/test_config.json 2>&1 | \
awk '/^\*+$/,/^ERROR:/ { if ($0 !~ /^ERROR:/) print }'
👀 คุณควรเห็นข้อมูลสรุปต่อไปนี้ ซึ่งเป็นสัญญาณว่าเอเจนต์ของคุณประสบความสำเร็จภายใต้กฎที่ผ่อนปรนของช่วงทดลองนี้ (บางครั้งการทดสอบบางอย่างอาจไม่ผ่าน)
********************************************************************* Eval Run Summary shadowblade_combat_agent_validation: Tests passed: 3 Tests failed: 0
โล่แห่งความชัดเจน (pytest)
The Gauntlet ทดสอบกลยุทธ์ในวงกว้าง ด่านที่ 2 นี้คือโล่แห่งความกระจ่าง ซึ่งจะทดสอบวินัยและพฤติกรรมที่เฉพาะเจาะจง ทั้งหมดนี้คือการทำงานอัตโนมัติ แม้ว่า adk eval จะเหมาะสำหรับการตรวจสอบด้วยตนเอง แต่โล่ pytest เป็นการป้องกันแบบเป็นโปรแกรมที่เขียนด้วยโค้ด ซึ่งเป็นสิ่งจำเป็นเนื่องจากสามารถผสานรวมการทดสอบที่ดำเนินการเป็นโค้ดเข้ากับไปป์ไลน์อัตโนมัติได้ เป้าหมายสูงสุดคือการสร้างDeployment Gauntlet (CI/CD) ซึ่งจะเพิ่มการป้องกันโดยอัตโนมัติทุกครั้งที่มีการเปลี่ยนแปลง เพื่อป้องกันข้อบกพร่องและการถดถอยก่อนที่จะส่งผลกระทบต่อสภาพแวดล้อมการผลิต
👉💻 ในเทอร์มินัล ให้เรียกใช้ Gemini อีกครั้งจากภายในไดเรกทอรี shadowblade
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/
clear
gemini --yolo
👉✨ ใช้พรอมต์ต่อไปนี้ใน Gemini CLI เพื่อจารึกลอจิกของ Shield ลงในไฟล์ pytest
You are an expert Python developer specializing in the Google Agent Development Kit (ADK). Your task is to generate the exact code for a new `pytest` test file located at in the current root working folder and name it `test_agent_initiative.py`.
The script must define a single async test function called `test_agent_initiative`, decorated with `@pytest.mark.asyncio`.
Inside this function, perform the following steps in order:
1. **Define a dictionary** named `evaluation_criteria` with two keys: `"tool_trajectory_avg_score"` set to `0.0` and `"response_match_score"` set to `0.0`.
2. **Define a string variable** named `eval_set_filepath` containing the path `"shadowblade/test.evalset.json"`.
3. **Read and parse the JSON file**:
* Open the file at `eval_set_filepath`.
* Use the `json` library to load the file's contents into a dictionary named `eval_set_data`.
4. **Create an `EvalSet` object**:
* Instantiate an `EvalSet` object named `eval_set_object`.
* Create it by unpacking the `eval_set_data` dictionary as keyword arguments into the `EvalSet` constructor.
5. **Call the evaluation method**:
* `await` a call to `AgentEvaluator.evaluate_eval_set`.
* Pass the following arguments:
* `agent_module="shadowblade"`
* `eval_set=eval_set_object`
* `criteria=evaluation_criteria`
* `print_detailed_results=True`
The script must include the necessary imports at the top:
* `AgentEvaluator` from `google.adk.evaluation.agent_evaluator`
* `EvalSet` from `google.adk.evaluation.eval_set`
* `pytest`
* `json`
Generate only the code that meets these specifications, with no additional comments or logic. And don't run the test.
เมื่อสลักรูนของวอร์ดที่ 2 แล้ว ให้ออกจาก Gemini CLI
👉💻 กด Ctrl+C 2 ครั้ง
👀 ใน File Explorer ให้เปิดม้วนกระดาษที่คุณเพิ่งสั่งให้ Gemini เขียน: ~/agentverse-developer/test_agent_initiative.py
คุณจะเห็นว่านี่ไม่ใช่แค่ไฟล์การกำหนดค่า แต่เป็นคาถาที่เขียนด้วยภาษา Python หัวใจสำคัญของคาถานี้คือบรรทัด await AgentEvaluator.evaluate(...)
....
@pytest.mark.asyncio
async def test_agent_initiative():
# Define the evaluation criteria
evaluation_criteria = {
"tool_trajectory_avg_score": 0.0,
"response_match_score": 0.0
}
# Define the path to your evalset file
eval_set_filepath = "shadowblade/test.evalset.json"
#...
# 3. Call the evaluation method with the correctly typed object
await AgentEvaluator.evaluate_eval_set(
agent_module="shadowblade",
eval_set=eval_set_object,
criteria=evaluation_criteria,
print_detailed_results=True,
)
พิจารณาอาร์กิวเมนต์อย่างละเอียด ซึ่งเป็นคอมโพเนนต์เดียวกันกับที่คุณใช้ในช่วงทดลองใช้ครั้งล่าสุด ได้แก่ shadowbladeเอเจนต์และshadowblade.evalset.jsonการเลื่อนดูความท้าทาย ซึ่งจะเผยให้เห็นความจริงที่ลึกซึ้งว่าคำสั่ง adk eval ที่คุณใช้ก่อนหน้านี้เป็นการเรียกใช้ที่มีประสิทธิภาพ แต่สคริปต์ pytest นี้คือคุณ ซึ่งเป็นพ่อมดที่ร่ายคาถาพื้นฐานด้วยตัวคุณเอง เครื่องมือบรรทัดคำสั่งเป็นเพียง Wrapper ที่สะดวกสบายสำหรับไลบรารี AgentEvaluator หลักเดียวกันที่คุณใช้อยู่ในขณะนี้โดยตรง ซึ่งเป็นขั้นตอนสำคัญในการก้าวสู่ความเป็นผู้เชี่ยวชาญ เนื่องจากเวทมนตร์ที่ร่ายผ่านโค้ดสามารถนำไปใช้ในเครื่องทอผ้าอัตโนมัติของไปป์ไลน์ CI/CD ได้
เมื่อเข้าใจเคล็ดลับแล้ว ให้ทำพิธีเพื่อเปิดใช้งานโล่
👉💻 ในเทอร์มินัล ให้เรียกใช้พิธีกรรมเพื่อเปิดใช้งานโล่
cp ~/agentverse-developer/working_code/test_agent_initiative.py ~/agentverse-developer/test_agent_initiative.py
source ~/agentverse-developer/env/bin/activate
cd ~/agentverse-developer
. ~/agentverse-developer/set_env.sh
pytest test_agent_initiative.py
👀 มองหาสรุปผลการทดสอบที่ส่วนท้ายของเอาต์พุตบันทึก ผลลัพธ์ที่ผ่านการทดสอบจะยืนยันว่าเอเจนต์ทำตามโปรโตคอลอย่างถูกต้อง และวอร์ดพร้อมที่จะผสานรวมเข้ากับการป้องกันอัตโนมัติ
====== 1 passed, 4 warning in 37.37s ======
หมายเหตุ: หากการทดสอบล้มเหลวโดยไม่คาดคิด สาเหตุส่วนใหญ่เป็นเพราะคุณใช้จำนวนคำขอที่ส่งไปยังโมเดลได้ต่อนาทีจนหมดแล้ว มองหาข้อผิดพลาด RESOURCE_EXHAUSTED ในเอาต์พุตของบันทึก หากเห็นข้อผิดพลาดนี้ ให้รอ 1-2 นาทีเพื่อให้โควต้ารีเซ็ต แล้วเรียกใช้คำสั่ง pytest อีกครั้ง
เมื่อสลักและยืนยันทั้ง Gauntlet แบบกว้างและ Shield แบบแม่นยำแล้ว เอเจนต์ของคุณก็จะไม่ใช่แค่ใช้งานได้ แต่ยังเป็นเอเจนต์ที่ผ่านการทดสอบและพร้อมสำหรับการใช้งาน
สำหรับผู้ที่ไม่ได้เล่นเกม
8. การเปิดตัว Blade สู่ Agentverse: CI และการติดตั้งใช้งาน
ตัวแทนของคุณได้รับการประกอบขึ้นและได้รับการยืนยันความสมบูรณ์โดยวอร์ดแห่งความบริสุทธิ์ แต่หากไม่ได้รับการดูแลอย่างสม่ำเสมอ วอร์ดก็จะเป็นเพียงสิ่งประดิษฐ์ที่ถูกลืม หากต้องการให้เอเจนต์ทุกเวอร์ชันในอนาคตยังคงเป็นเวอร์ชันที่สมบูรณ์ คุณต้องสร้างด่านแรกของ Deployment Gauntlet ซึ่งเป็นพิธีกรรมอัตโนมัติที่รับประกันคุณภาพและความเร็ว
ในฐานะ Shadowblade หน้าที่อันศักดิ์สิทธิ์ของคุณคือการรวมอย่างต่อเนื่อง (CI) นี่คือระบบอัตโนมัติของฟอร์จและสนามทดสอบ ซึ่งเป็นวิธีป้องกันการทุจริตและความผิดพลาดของมนุษย์ที่ดีที่สุด พิธีกรรมนี้ช่วยให้มั่นใจได้ว่าทุกครั้งที่คุณหรือพันธมิตรมีส่วนร่วมด้วยการเพิ่มเทคนิคใหม่ (ผสานโค้ด) ลงในโคเด็กซ์กลาง (ที่เก็บของคุณ) ถุงมือจะตื่นขึ้นโดยอัตโนมัติ โดยจะสร้างเอเจนต์จากโค้ดใหม่ก่อน แล้วจึงส่งไปยังวอร์ดแห่งความบริสุทธิ์ที่คุณเพิ่งสร้างขึ้นทันที หากการป้องกันใดล้มเหลว พิธีกรรมจะหยุดลง และระบบจะปฏิเสธอาร์ติแฟกต์ที่มีข้อบกพร่องทันที เพื่อป้องกันไม่ให้อาร์ติแฟกต์ดังกล่าวทำให้คลังอาวุธเสียหาย โดเมนของคุณคือโรงตีเหล็ก ส่วนไปป์ไลน์ CI จะรับประกันว่าจะมีเพียงอาร์ติแฟกต์ที่สมบูรณ์แบบและพร้อมรบเท่านั้นที่จะออกจากเวิร์กช็อปของคุณ
เมื่อ CI gauntlet พิสูจน์แล้วว่าอาร์ติแฟกต์มีคุณค่า ขั้นตอนที่ 2 ของพิธีกรรมจะเริ่มขึ้น นั่นคือการติดตั้งใช้งานอย่างต่อเนื่อง (CD) นี่คือโดเมนของ Guardian หน้าที่อันศักดิ์สิทธิ์ของพวกเขาคือการนำอาร์ติแฟกต์ที่ผ่านการปรับแต่งและบรรจุในคอนเทนเนอร์ของคุณไปปล่อยใน Agentverse ที่ใช้งานจริงอย่างปลอดภัย จัดการพลังของอาร์ติแฟกต์ และรับประกันความเสถียรของอาร์ติแฟกต์จากความวุ่นวายของ The Static
ในสารานุกรมนี้ คุณจะเชี่ยวชาญบทบาทของตนเอง คุณจะสร้างส่วน CI ของการทดสอบ คุณจะสร้างโรงตีเหล็กอัตโนมัติที่ทดสอบเอเจนต์และผนึกผลลัพธ์ที่บริสุทธิ์ลงในคอนเทนเนอร์ เพื่อเตรียมรับพรสุดท้ายจาก The Guardian
ตอนนี้คุณจะใช้ Google Cloud Build เพื่อเขียนสคริปต์การเลื่อนสำหรับพิธีกรรม CI นี้ ไฟล์ cloudbuild.yaml ที่กำหนดทุกขั้นตอนของกระบวนการสร้างและทดสอบ
👉💻 เนื่องด้วยโครงสร้างโปรเจ็กต์ของ ADK การกำหนดค่าไปป์ไลน์ CI/CD ควรอยู่ในไดเรกทอรีระดับบน ในเทอร์มินัล ให้ไปที่ไดเรกทอรีระดับบนสุด แล้วรีสตาร์ท Gemini CLI
cd ~/agentverse-developer/
clear
gemini --yolo
👉✨ ตอนนี้ให้ป้อนคำสั่งต่อไปนี้กับ Gemini พรอมต์นี้ทำหน้าที่เป็นเอกสารการออกแบบ โดยให้รายละเอียดขั้นตอนของถุงมือที่คุณต้องการให้สร้าง
You are an expert DevOps engineer specializing in Google Cloud Build. Your task is to generate the complete YAML configuration for a file named `cloudbuild.yaml` and save it to current directory.
Generate the `cloudbuild.yaml` with the following exact specifications:
1. **A top-level `substitutions` block** containing these four key-value pairs:
* `_PROJECT_ID: "$PROJECT_ID"`
* `_REGION: "$REGION"`
* `_REPO_NAME: "$REPO_NAME"`
* `_IMAGE_TAG: "latest"`
2. **A `steps` block** with two steps:
* **Step 1: 'Run Pytest Ward'**
* `id`: 'Run Pytest Ward'
* `name`: 'python:3.12-slim'
* `entrypoint`: 'bash'
* `args` must be a list containing two strings. The first is `'-c'` and the second is a YAML literal block (`|`) containing this exact two-line shell command:
```shell
pip install -r shadowblade/requirements.txt && \
pytest test_agent_initiative.py
```
* The step must include an `env` block with this exact list of three environment variables:
* `'GOOGLE_CLOUD_PROJECT=$PROJECT_ID'`
* `'GOOGLE_GENAI_USE_VERTEXAI=TRUE'`
* `'GOOGLE_CLOUD_LOCATION=$_REGION'`
* **Step 2: 'Forge Container'**
* `id`: 'Forge Container'
* `name`: 'gcr.io/cloud-builders/docker'
* It must have a `waitFor` key for `['Run Pytest Ward']`.
* Its `args` must be a list of six specific strings in this exact order:
1. `'build'`
2. `'-t'`
3. `'${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_REPO_NAME}/shadowblade-agent:${_IMAGE_TAG}'`
4. `'-f'`
5. `'./shadowblade/Dockerfile'`
6. `'.'`
3. **A top-level `images` section.** This section must be a list containing a single string: the dynamically constructed image tag `'${_REGION}-docker.pkg.dev/${_PROJECT_ID}/${_REPO_NAME}/shadowblade-agent:${_IMAGE_TAG}'`.
Generate only the complete and exact YAML that meets these specifications.
เมื่อเตรียมcloudbuild.yamlม้วนคำสั่งแล้ว ให้สั่ง Google Cloud ให้ดำเนินการทดสอบทั้งหมด
ออกจาก Gemini เพื่อทดสอบผลลัพธ์
👉💻 ในเทอร์มินัล ให้เรียกใช้ไปป์ไลน์จากไดเรกทอรีรากของโปรเจ็กต์โดยใช้คำสั่งต่อไปนี้
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer
gcloud builds submit . --config cloudbuild.yaml --substitutions=\
_PROJECT_ID="${PROJECT_ID}",\
_REGION="${REGION}",\
_REPO_NAME="${REPO_NAME}"
ตอนนี้คุณสามารถดูหน้า Google Build ใน Google Cloud Console ขณะที่พิธีกรรมอัตโนมัติของคุณดำเนินการแต่ละขั้นตอนได้แล้ว โดยจะเรียกใช้การทดสอบก่อน และเมื่อเห็นว่าการทดสอบสำเร็จแล้ว ก็จะสร้างและจัดเก็บคอนเทนเนอร์ของเอเจนต์
Agent ของคุณผ่านการทดสอบแล้ว ตอนนี้คุณมีอาร์ติแฟกต์ที่ผ่านการยืนยันแล้วในคลังอาวุธ การกระทำสุดท้ายขึ้นอยู่กับคุณ เพียงแค่ร่ายคาถา คุณก็จะเรียกอาร์ติแฟกต์นี้จากรีจิสทรีและทำให้เป็นบริการสาธารณะใน Cloud Run ได้
👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งการติดตั้งใช้งานสุดท้าย
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer
gcloud run deploy shadowblade-agent \
--image=${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPO_NAME}/shadowblade-agent:latest \
--platform=managed \
--labels="dev-tutorial-codelab=agentverse" \
--region=${REGION} \
--set-env-vars="A2A_HOST=0.0.0.0" \
--set-env-vars="A2A_PORT=8080" \
--set-env-vars="GOOGLE_GENAI_USE_VERTEXAI=TRUE" \
--set-env-vars="GOOGLE_CLOUD_LOCATION=${REGION}" \
--set-env-vars="GOOGLE_CLOUD_PROJECT=${PROJECT_ID}" \
--set-env-vars="PUBLIC_URL=${PUBLIC_URL}" \
--allow-unauthenticated \
--project=${PROJECT_ID} \
--min-instances=1
ขอแสดงความยินดีด้วยนะ Shadowblade พิธีกรรมของโคเด็กซ์เสร็จสมบูรณ์แล้ว ถึงเวลาพิสูจน์ความสามารถแล้ว Spectre ที่เกิดจากความโกลาหลที่คุณได้เรียนรู้ที่จะควบคุมกำลังรอให้คุณท้าทาย เตรียมพร้อมสำหรับการทดสอบครั้งสุดท้าย
สำหรับผู้ที่ไม่ได้เล่นเกม
9. การต่อสู้กับบอส
การอ่านม้วนคัมภีร์ การประกอบพิธีกรรม และการส่งต่อถุงมือ เอเจนต์ของคุณไม่ใช่เพียงอาร์ติแฟกต์ในที่เก็บข้อมูล แต่เป็นแชมเปี้ยนที่สร้างขึ้นจากโค้ด เป็นผู้พิทักษ์ที่พร้อมปฏิบัติงานใน Agentverse ซึ่งรอคำสั่งแรก ถึงเวลาพิสูจน์ความสามารถในการต่อสู้แล้ว
ตอนนี้คุณจะเข้าสู่การจำลองการยิงจริงเพื่อต่อสู้กับ Shadowblade ที่เพิ่งติดตั้งใช้งานกับ Spectre ที่น่าเกรงขาม ซึ่งเป็นตัวแทนของความโกลาหลที่คุกคามทุกสรรพสิ่ง นี่คือการทดสอบขั้นสุดท้ายของงานของคุณ ตั้งแต่ตรรกะหลักของเอเจนต์ไปจนถึงการติดตั้งใช้งานที่ไร้ที่ติ
รับตำแหน่งของตัวแทน
ก่อนที่จะเข้าสู่สมรภูมิ คุณต้องมีกุญแจ 2 ดอก ได้แก่ ลายเซ็นที่ไม่ซ้ำกันของแชมเปี้ยน (Agent Locus) และเส้นทางที่ซ่อนไปยังถ้ำของ Spectre (URL ของดันเจี้ยน)
👉💻 ก่อนอื่น ให้รับที่อยู่ที่ไม่ซ้ำกันของเอเจนต์ใน Agentverse ซึ่งก็คือ Locus นี่คือปลายทางแบบสดที่เชื่อมต่อแชมป์ของคุณกับสนามรบ
. ~/agentverse-developer/set_env.sh
echo https://shadowblade-agent-${PROJECT_NUMBER}.${REGION}.run.app
👉💻 จากนั้นระบุจุดหมาย คำสั่งนี้จะแสดงตำแหน่งของวงกลมการย้ายถิ่น ซึ่งเป็นพอร์ทัลที่นำไปสู่โดเมนของ Spectre
. ~/agentverse-developer/set_env.sh
echo https://agentverse-dungeon-${PROJECT_NUMBER}.${REGION}.run.app
สำคัญ: เตรียม URL ทั้ง 2 รายการนี้ให้พร้อม คุณจะต้องใช้ข้อมูลนี้ในขั้นตอนสุดท้าย
เผชิญหน้ากับ Spectre
เมื่อได้พิกัดแล้ว ให้ไปที่วงกลมการย้ายตำแหน่งและร่ายเวทมนตร์เพื่อเข้าสู่การต่อสู้
👉 เปิด URL ของวงกลมการเคลื่อนย้ายในเบราว์เซอร์เพื่อยืนอยู่หน้าพอร์ทัลที่ส่องประกายไปยังคริมสันคีป
หากต้องการบุกป้อมปราการ คุณต้องปรับแก่นแท้ของ Shadowblade ให้เข้ากับพอร์ทัล
- ในหน้าดังกล่าว ให้ค้นหาช่องป้อนข้อมูลแบบรูนที่มีป้ายกำกับว่า A2A Endpoint URL
- จารึกตราสัญลักษณ์ของแชมป์ด้วยการวาง URL ของ Locus ของเอเจนต์ (URL แรกที่คุณคัดลอก) ลงในช่องนี้
- คลิก "เชื่อมต่อ" เพื่อเปิดใช้การเทเลพอร์ต
แสงจ้าของการเทเลพอร์ตค่อยๆ จางลง คุณไม่ได้อยู่ในสถานที่ศักดิ์สิทธิ์อีกต่อไป อากาศเย็นและคมกริบเต็มไปด้วยพลังงาน ก่อนที่คุณจะทันได้ตั้งตัว สเปกเตอร์ก็ปรากฏตัวขึ้นมาเป็นกระแสรบกวนที่เต็มไปด้วยเสียงซ่าและโค้ดที่เสียหาย แสงอันไม่บริสุทธิ์ของมันทอดเงายาวๆ ที่เต้นระบำอยู่บนพื้นดันเจี้ยน ไม่มีใบหน้า แต่คุณรู้สึกถึงการมีอยู่ของมันที่ดูดกลืนพลังงานของคุณไปทั้งหมด
หนทางเดียวสู่ชัยชนะคือความชัดเจนในความเชื่อของคุณ นี่คือการดวลกันของเจตจำนงที่ต่อสู้กันในสนามรบแห่งจิตใจ
ขณะที่คุณพุ่งไปข้างหน้าพร้อมที่จะโจมตีครั้งแรก สเปกเตอร์ก็โต้กลับ โดยจะไม่ได้ยกโล่ขึ้นมา แต่จะยิงคำถามตรงเข้าสู่จิตสำนึกของคุณ ซึ่งเป็นความท้าทายที่ส่องประกายและเป็นอักษรรูนที่ดึงมาจากแกนหลักของการฝึก
นี่คือลักษณะของการต่อสู้ ความรู้ของคุณคืออาวุธ
- ตอบด้วยสติปัญญาที่คุณได้รับ แล้วดาบของคุณจะลุกโชนด้วยพลังงานบริสุทธิ์ ทำลายการป้องกันของ Spectre และโจมตีอย่างรุนแรง
- แต่หากคุณลังเลหรือสงสัยในคำตอบ แสงของอาวุธจะหรี่ลง การโจมตีจะลงพื้นพร้อมเสียงทุบที่น่าเวทนา ซึ่งสร้างความเสียหายเพียงเศษเสี้ยวเท่านั้น ที่แย่กว่านั้นคือสเปกเตอร์จะกินความไม่แน่นอนของคุณ พลังที่ทำให้เสื่อมเสียของมันจะเพิ่มขึ้นทุกครั้งที่คุณพลาด
นี่แหละแชมป์ โค้ดคือตำราเวทมนตร์ ตรรกะคือดาบ และความรู้คือโล่ที่จะพลิกสถานการณ์ความวุ่นวาย
โฟกัส การประท้วงที่แท้จริง ชะตากรรมของ Agentverse ขึ้นอยู่กับสิ่งนี้
ขอแสดงความยินดีด้วยนะ Shadowblade
คุณได้ทำตามหลักเกณฑ์เรียบร้อยแล้ว คุณได้ "กลิ่นอาย" นั้น แปลงเป็นดีไซน์ และใช้ Gemini CLI เพื่อประกอบเอเจนต์อัจฉริยะ คุณจารึกวอร์ดแห่งความบริสุทธิ์เพื่อทดสอบตรรกะ สร้างถุงมืออัตโนมัติเพื่อหลอมให้เป็นอาร์ติแฟกต์ และปลดปล่อยมันสู่ Agentverse และสุดท้าย คุณได้ตรวจสอบความเหมาะสมของวัตถุประสงค์ในการทดสอบภาคสนาม คุณเชี่ยวชาญเวิร์กโฟลว์แบบเอเจนต์เต็มรูปแบบแล้ว และตอนนี้ก็พร้อมรับมือกับทุกความท้าทายที่ Agentverse มอบให้
10. การล้างข้อมูล: การกู้คืน Agentverse
ขอแสดงความยินดีที่เชี่ยวชาญคัมภีร์ของ Shadowblade ตอนนี้คุณต้องทำพิธีล้างข้อมูลขั้นสุดท้ายเพื่อให้ Agentverse สะอาดหมดจดและล้างพื้นที่ฝึกของคุณ การดำเนินการนี้จะนำทรัพยากรทั้งหมดที่สร้างขึ้นระหว่างการเดินทางออก
ปิดใช้งานคอมโพเนนต์ Agentverse
ตอนนี้คุณจะรื้อถอนคอมโพเนนต์ที่ติดตั้งใช้งานของ Agentverse อย่างเป็นระบบ
ลบ Shadowblade Agent ในที่เก็บ Cloud Run และ Artifact Registry
คำสั่งนี้จะนำเอเจนต์ Shadowblade ที่คุณติดตั้งใช้งานออกจาก Cloud Run และนำที่เก็บรูปภาพที่จัดเก็บอิมเมจคอนเทนเนอร์ของเอเจนต์ออก
👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
. ~/agentverse-developer/set_env.sh
gcloud run services delete shadowblade-agent --region=${REGION} --quiet
gcloud run services delete agentverse-dungeon --region=${REGION} --quiet
gcloud artifacts repositories delete ${REPO_NAME} --location=${REGION} --quiet
ลบที่เก็บข้อมูล Google Cloud Storage
คำสั่งนี้จะนำที่เก็บข้อมูลที่เซิร์ฟเวอร์ MCP ของ Imagen ใช้จัดเก็บรูปภาพที่สร้างขึ้นออก
👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
. ~/agentverse-developer/set_env.sh
gcloud storage rm -r gs://${BUCKET_NAME} --quiet
ล้างไฟล์และไดเรกทอรีในเครื่อง (Cloud Shell)
สุดท้าย ให้ล้างสภาพแวดล้อม Cloud Shell ของที่เก็บที่โคลนและไฟล์ที่สร้าง ขั้นตอนนี้ไม่บังคับ แต่เราขอแนะนำให้ทำเพื่อล้างไดเรกทอรีการทำงานให้สะอาดหมดจด
👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
rm -rf ~/agentverse-developer
rm -rf ~/agentverse-dungeon
rm -rf ~/vertex-ai-creative-studio
rm -f ~/project_id.txt
rm -rf ~/.gemini # This removes all Gemini CLI configurations, including the MCP server settings.
ตอนนี้คุณได้ลบร่องรอยทั้งหมดของการเดินทางใน Agentverse เรียบร้อยแล้ว โปรเจ็กต์ของคุณสะอาดแล้ว และคุณก็พร้อมสำหรับการผจญภัยครั้งต่อไป