1. Overture
ยุคของการพัฒนาแบบแยกส่วนกำลังจะสิ้นสุดลง การพัฒนาเทคโนโลยีในยุคถัดไปไม่ได้ขึ้นอยู่กับอัจฉริยะเพียงคนเดียว แต่เป็นการทำงานร่วมกันเพื่อความเชี่ยวชาญ การสร้างเอเจนต์อัจฉริยะเพียงตัวเดียวเป็นการทดลองที่น่าสนใจ การสร้างระบบนิเวศของเอเจนต์ที่แข็งแกร่ง ปลอดภัย และชาญฉลาด ซึ่งเป็น Agentverse อย่างแท้จริงถือเป็นความท้าทายที่ยิ่งใหญ่สำหรับองค์กรยุคใหม่
ความสำเร็จในยุคใหม่นี้ต้องอาศัยการบรรจบกันของบทบาทสำคัญ 4 ประการ ซึ่งเป็นเสาหลักที่รองรับระบบเอเจนต์ที่เจริญรุ่งเรือง ความบกพร่องในด้านใดด้านหนึ่งจะสร้างจุดอ่อนที่อาจส่งผลต่อโครงสร้างทั้งหมด
เวิร์กช็อปนี้เป็นเพลย์บุ๊กสำหรับองค์กรที่ชัดเจนในการฝึกฝนอนาคตของ Agentic บน 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
- ขยายคลังเครื่องมือด้วยส่วนขยาย Gemini CLI และทักษะของ Agent
- เรียกใช้คลังอาวุธภายนอกโดยผสานรวมเครื่องมือ MCP กับ Gemini CLI
- เปลี่ยนความตั้งใจของคุณให้เป็น "ฟีล" โดยใช้เอกสารการออกแบบเพื่อสั่งการพาร์ทเนอร์ AI
- สร้างโซลูชันที่สะอาดและเป็นโมดูลโดยการสร้าง Agent แบบอัตโนมัติตัวแรกด้วย Agent Development Kit (ADK)
- เขียนฮุกเพื่อสกัดกั้นและป้องกันพฤติกรรมของเอเจนต์
- สร้างชุดการประเมินอัตโนมัติเพื่อทดสอบและตรวจสอบความถูกต้องของเอเจนต์
- สร้างไปป์ไลน์ CI ที่สมบูรณ์เพื่อทดสอบ จัดเก็บในคอนเทนเนอร์ และเก็บถาวร Agent โดยอัตโนมัติ
3. การเตรียมสนามฝึก
รับเครดิต Google Cloud
⚠️ ข้อกำหนดเบื้องต้นที่สำคัญ:
- ใช้ Gmail ส่วนตัว: คุณต้องใช้บัญชีส่วนตัว (เช่น
name@gmail.com) บัญชีที่บริษัทหรือโรงเรียนจัดการจะใช้ไม่ได้
👉 ขั้นตอน
- ไปที่เว็บไซต์อ้างสิทธิ์เครดิต: คลิกที่นี่
- ลงชื่อเข้าใช้: วางลิงก์ลงในแถบที่อยู่ แล้วลงชื่อเข้าใช้ด้วย Gmail ส่วนตัว
- ยอมรับข้อกำหนด: ยอมรับข้อกำหนดในการให้บริการของ Google Cloud Platform
- ยืนยันเครดิต: มองหาข้อความที่ยืนยันว่ามีการใช้เครดิตแล้ว
- *หมายเหตุ: หากระบบแจ้งให้ป้อนข้อมูลบัตรเครดิต คุณก็ไม่ต้องสนใจและปิดหน้าต่างได้
แค่นี้ก็เรียบร้อย คุณปิดหน้าต่างนี้ได้เลย
ตั้งค่าสภาพแวดล้อมการทำงาน
👉คลิกเปิดใช้งาน Cloud Shell ที่ด้านบนของคอนโซล Google Cloud (ไอคอนรูปเทอร์มินัลที่ด้านบนของแผง Cloud Shell) 
👉คลิกปุ่ม "เปิดตัวแก้ไข" (ลักษณะเป็นโฟลเดอร์ที่เปิดอยู่พร้อมดินสอ) ซึ่งจะเปิดตัวแก้ไขโค้ด Cloud Shell ในหน้าต่าง คุณจะเห็น File Explorer ทางด้านซ้าย 
👉เปิดเทอร์มินัลใน 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
👉💻 เรียกใช้สคริปต์การตั้งค่าจากไดเรกทอรีโปรเจ็กต์
⚠️ หมายเหตุเกี่ยวกับรหัสโปรเจ็กต์: สคริปต์จะแนะนำรหัสโปรเจ็กต์เริ่มต้นที่สร้างขึ้นแบบสุ่ม คุณกด Enter เพื่อยอมรับค่าเริ่มต้นนี้ได้
อย่างไรก็ตาม หากต้องการสร้างโปรเจ็กต์ใหม่ที่เฉพาะเจาะจง คุณสามารถพิมพ์รหัสโปรเจ็กต์ที่ต้องการเมื่อสคริปต์แจ้ง
cd ~/agentverse-developer
./init.sh
สคริปต์จะจัดการขั้นตอนการตั้งค่าที่เหลือโดยอัตโนมัติ
👉 ขั้นตอนสำคัญหลังจากเสร็จสิ้น: เมื่อสคริปต์ทำงานเสร็จแล้ว คุณต้องตรวจสอบว่า คอนโซล Google Cloud กำลังดูโปรเจ็กต์ที่ถูกต้อง
- ไปที่ console.cloud.google.com
- คลิกเมนูแบบเลื่อนลงของตัวเลือกโปรเจ็กต์ที่ด้านบนของหน้า
- คลิกแท็บ "ทั้งหมด" (เนื่องจากโปรเจ็กต์ใหม่อาจยังไม่ปรากฏใน "ล่าสุด")
- เลือกรหัสโปรเจ็กต์ที่คุณเพิ่งกำหนดค่าใน
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 Agent แบบโอเพนซอร์สนี้ขับเคลื่อนด้วยโมเดล Gemini และทำงานในลูป "ให้เหตุผลและดำเนินการ" (ReAct) โดยจะวิเคราะห์ความตั้งใจของคุณ เลือกเทคนิคที่เหมาะสม ดำเนินการ และสังเกตผลลัพธ์เพื่อทำงานที่ซับซ้อนให้เสร็จสมบูรณ์ คุณต้องฝึกฝนดาบหลักนี้ให้เชี่ยวชาญก่อนจึงจะใช้อาวุธเฉพาะทางอื่นๆ ได้
เริ่มต้นใช้งาน Gemini CLI
👉💻 เข้าสู่สนามฝึกและหยิบอาวุธของคุณ ในเทอร์มินัล Cloud Shell ให้ไปที่คลังอาวุธส่วนตัว
cd ~/agentverse-developer
mkdir tabletop
cd tabletop
👉💻 เรียกใช้ Gemini เป็นครั้งแรก ซึ่งจะแนะนำคุณตลอดการปรับแต่งเบื้องต้น
clear
gemini
หากระบบถามว่า Do you want to connect Cloud Shell editor to Gemini CLI? ให้เลือกไม่
การทำความคุ้นเคยกับอาวุธ
ช่างฝีมือทุกคนรู้จักเครื่องมือของตน คุณต้องเรียนรู้เทคนิคหลักของดาบก่อนที่จะเผชิญหน้ากับศัตรูตัวจริง
👉✨ เครื่องมือที่ร่ายมนตร์ทุกชิ้นจะมีรูนที่อธิบายพลังของมัน อ่านเลย ในพรอมต์ Gemini ให้พิมพ์ดังนี้
/help
ดูรายการคำสั่ง เทคนิคพื้นฐานในการจัดการหน่วยความจำ (focus) การสนทนา (chat) และคลังอาวุธภายนอก (tools) นี่คือคู่มือการต่อสู้
👉✨ อาวุธของคุณจะปรับให้เข้ากับสภาพแวดล้อม ซึ่งช่วยให้คุณควบคุมสมรภูมิได้โดยตรง ออกคำสั่งไปยังโลกภายนอกเบลด
!ls -l
👉✨ Gemini CLI มีความสามารถในตัวของตัวเอง วิธีตรวจสอบ
/tools
คุณจะเห็นรายการที่มี ReadFile, WriteFile และ GoogleSearch เทคนิคเหล่านี้เป็นเทคนิคเริ่มต้นที่คุณเรียกใช้ได้โดยไม่ต้องดึงมาจากคลังภายนอก
👉✨ คุณยังสามารถปรับปรุงดาบด้วยส่วนขยาย ซึ่งเป็นการเสริมพลังที่สร้างไว้ล่วงหน้าโดยผู้เชี่ยวชาญคนอื่นๆ ที่รวมเครื่องมือ คำสั่ง และบริบทไว้ในหน่วยเดียวที่ติดตั้งได้ ตรวจสอบว่าส่วนขยายใดที่ปรับให้เข้ากับใบมีดของคุณในปัจจุบัน
/extensions list
ขณะนี้รายการอาจว่างเปล่าเนื่องจากคุณยังไม่ได้ติดตั้งส่วนขยายใดๆ คุณจะเรียกใช้ส่วนขยายแรกในภายหลังเมื่อการฝึกของคุณต้องการพลังของการสร้างรูปภาพ
👉✨ นอกจากส่วนขยายแล้ว ผู้เชี่ยวชาญที่มีทักษะยังได้รวบรวมความเชี่ยวชาญของตนไว้ในทักษะ Agent ซึ่งเป็นม้วนความรู้เฉพาะทางตามความต้องการ ดูว่าใบมีดของคุณค้นพบทักษะใดได้บ้าง
/skills list
ระบบจะไม่โหลดทักษะลงในหน่วยความจำโดยค่าเริ่มต้น แต่จะเปิดใช้งานเมื่อจำเป็นเท่านั้น เพื่อให้ใบมีดของคุณทำงานได้อย่างรวดเร็วและไม่ติดขัด คุณจะได้เรียนรู้วิธีใช้ทักษะในภายหลังระหว่างการฝึก
👉✨ อาวุธจะมีประสิทธิภาพก็ต่อเมื่อโฟกัสอย่างถูกต้อง 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. การวิเคราะห์สมรภูมิ: การโต้ตอบด้วย Vibe Coding ในทางปฏิบัติ
การฝึกซ้อมเสร็จสมบูรณ์แล้ว คุณได้เรียนรู้ท่าทางและท่าโจมตีพื้นฐานของอาวุธหลักของคุณแล้ว นั่นคือ Gemini CLI แต่ดาบจะยังไม่สมบูรณ์จนกว่าจะได้รับการทดสอบในเตาหลอมแห่งการสร้างสรรค์และปรับแต่งให้เข้ากับคลังอาวุธแห่งสงคราม ก่อนที่จะเผชิญหน้ากับศัตรูตัวจริง คุณต้องสำรวจและปรับแต่งสภาพแวดล้อมรอบตัวก่อน ซึ่งก็คือสมรภูมิดิจิทัล
บทนี้จะพูดถึงการเปลี่ยนจากทฤษฎีไปสู่การปฏิบัติ ก่อนอื่นคุณจะต้องสร้างตัวตนใน Agentverse โดยสั่งให้ใบมีด Gemini สร้าง Maker's Mark ซึ่งเป็นลายเซ็นดิจิทัลในรูปแบบของเว็บไซต์ส่วนตัวที่สร้างขึ้นจากความตั้งใจของคุณเท่านั้น จากนั้นคุณจะขยายขีดความสามารถด้วยการเปิดใช้งานคลังเครื่องมือขั้นสูงในเครื่อง ซึ่งก็คือเซิร์ฟเวอร์ MCP และปรับแต่ง Blade ให้ตรงกับความถี่ของเซิร์ฟเวอร์ ซึ่งจะช่วยให้คุณดำเนินการที่ซับซ้อนได้ เช่น การจัดการที่เก็บโค้ดด้วยคำสั่งที่ง่ายและเด็ดขาด
สร้างลายเซ็นของคุณ
ผู้ใช้ Shadowblade ที่แท้จริงไม่ได้เป็นที่รู้จักจากอาวุธเท่านั้น แต่ยังเป็นที่รู้จักจากสไตล์ที่เป็นเอกลักษณ์ของตนเองด้วย นั่นคือร่องรอยของช่างฝีมือ เครื่องหมายนี้จะเป็นตัวตนดิจิทัลของคุณ ซึ่งเป็นโปรไฟล์ส่วนตัวที่ประกาศตัวตนของคุณต่อ Agentverse ในส่วนนี้ คุณจะสั่งให้ Gemini Blade ใช้เทคนิคที่ซับซ้อนซึ่งจำเป็นต่อการกำหนดตัวตนนี้
👉💻 หากปิด Gemini CLI ในส่วนก่อนหน้าไปแล้ว ให้เริ่มอีกครั้งโดยเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล
clear
cd ~/agentverse-developer/tabletop
gemini
👉✨ ใช้คำสั่งเดียวที่มีประสิทธิภาพเพื่อสั่งให้ 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 placeholder spot for profile picture. Do not attempt to start the server.
Gemini ได้คำนวณลำดับการดำเนินการที่จำเป็นแล้ว
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI แล้วเรียกใช้คำสั่งต่อไปนี้ในเทอร์มินัล*
python -m http.server
👀 หากต้องการดูผลงาน ให้คลิกไอคอนตัวอย่างเว็บในแถบเครื่องมือ Cloud Shell เลือกเปลี่ยนพอร์ต ตั้งค่าเป็น 8000 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง ตัวอย่างเว็บไซต์จะปรากฏขึ้น 
เว็บไซต์ของคุณอาจมีลักษณะแตกต่างจากของฉัน นี่คือเครื่องหมายที่ไม่ซ้ำกันของคุณ 
ตอนนี้เทคนิคการสร้างลายเซ็นของคุณได้รับการปรับปรุงแล้ว และคุณไม่จำเป็นต้องใช้การจำลองแบบเรียลไทม์อีกต่อไป สั่งให้เบลดหยุดยิง
👉💻 กด Ctrl+C เพื่อออกจากเซิร์ฟเวอร์ http
ตอนนี้คุณได้สร้างตัวตนดิจิทัลแล้ว และที่สำคัญกว่านั้นคือคุณได้เรียนรู้ภูมิปัญญาที่สำคัญในการใช้อำนาจอันยิ่งใหญ่ด้วยความระมัดระวังที่มากยิ่งขึ้น
เปิดใช้งานคลังอาวุธในเครื่อง: คลังอาวุธ 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
👉✨ ตรวจสอบว่าเบลดของคุณค้นพบอาวุธใหม่แล้ว สั่งให้แสดงรายการคลังอาวุธทั้งหมดที่มีผ่านพอร์ทัล 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 
หากต้องการสร้างซิกิลที่ขาดหายไป คุณต้องอัญเชิญพลังอีกรูปแบบหนึ่ง นั่นคือจิตวิญญาณแห่งการสร้างสรรค์ที่สามารถสร้างภาพจากความคิดบริสุทธิ์ได้ ในส่วน Gitea คุณได้แก้ไขรันการกำหนดค่าด้วยตนเองเพื่อปรับใบมีดให้เข้ากับเซิร์ฟเวอร์ MCP ซึ่งเป็นแนวทาง "ดิบ" ตอนนี้คุณจะได้เรียนรู้เทคนิคที่ทันสมัย นั่นคือส่วนขยาย Gemini CLI
ส่วนขยายคือการเสริมพลังที่สร้างไว้ล่วงหน้าซึ่งรวมเซิร์ฟเวอร์ MCP, คำสั่งที่กำหนดเอง, บริบท และการตั้งค่าไว้ในหน่วยที่ติดตั้งได้หน่วยเดียว คำสั่งเดียวแทนที่การกำหนดค่าด้วยตนเองหลายสิบบรรทัด
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
ก่อนที่จะอัญเชิญวิญญาณแห่งการสร้างสรรค์ คุณต้องปลดล็อกพลังของวิญญาณในอาณาจักรของคุณก่อน ส่วนขยาย Nano Banana ใช้ Generative Language API ซึ่งเป็นเกตเวย์แยกต่างหากจากบริการ Vertex AI ที่คุณใช้อยู่ คุณต้องเปิดใช้เกตเวย์นี้และสร้างคีย์ที่ไม่ซ้ำกันเพื่ออนุญาตให้เข้าถึง Spirit
👉💻 เปิดใช้ API ในเทอร์มินัลโดยทำดังนี้
gcloud services enable generativelanguage.googleapis.com
👉💻 ตอนนี้ให้สร้างคีย์ API ซึ่งเป็นโทเค็นเพื่อการเข้าถึงส่วนบุคคลของวิญญาณ
- ไปที่หน้าข้อมูลเข้าสู่ระบบของคอนโซล Google Cloud
- คลิก + สร้างข้อมูลเข้าสู่ระบบที่ด้านบน แล้วเลือกคีย์ API
- ตั้งชื่อคีย์ API ให้จดจำง่าย เช่น คีย์ API ของ Generative Language
- ในเมนูแบบเลื่อนลงของการจำกัด API ให้เลือก Generative Language API
- สร้างและคัดลอกคีย์ - คุณจะต้องใช้คีย์นี้ในขั้นตอนถัดไป
👉💻 ติดตั้งส่วนขยาย Nano Banana ซึ่งเป็นจิตวิญญาณแห่งการสร้างสรรค์ที่ขับเคลื่อนโดยโมเดลการเปลี่ยนข้อความเป็นรูปภาพ Gemini เฉพาะทางของ Google ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
gemini extensions install https://github.com/gemini-cli-extensions/nanobanana
เมื่อได้รับข้อความแจ้งให้ใส่คีย์ API ให้วางคีย์ที่เพิ่งสร้างขึ้น แล้วกด Enter
👉💻 คุณต้องปรับแต่งอีกครั้ง สภาพแวดล้อมของ Cloud Shell จะกำหนดเส้นทางคำขอ AI ทั้งหมดผ่าน Vertex AI โดยค่าเริ่มต้น แต่จิตวิญญาณแห่งการสร้างสรรค์จะสื่อสารผ่านเกตเวย์อื่น เรียกใช้คำสั่งนี้เพื่อกำหนดค่าพอร์ทัลของส่วนขยายอย่างถูกต้อง
NANO_CONFIG=$(find ~/.gemini/extensions -name "gemini-extension.json" -path "*nanobanana*" 2>/dev/null | head -1) && \
jq '.mcpServers.nanobanana.env.GOOGLE_GENAI_USE_VERTEXAI = ""' "$NANO_CONFIG" > /tmp/nb_tmp.json && \
mv /tmp/nb_tmp.json "$NANO_CONFIG"
คำสั่งเดียวนี้จะทำทุกอย่างให้คุณ ได้แก่ ดาวน์โหลดเซิร์ฟเวอร์ MCP, ลงทะเบียนเครื่องมือ และติดตั้งคำสั่ง Slash ที่กำหนดเอง โดยที่คุณไม่ต้องทำอะไรเลยsettings.json
👀 หมายเหตุสำหรับนักพัฒนาซอฟต์แวร์: ส่วนขยายเทียบกับเซิร์ฟเวอร์ MCP ดิบ เปรียบเทียบกับการตั้งค่า Gitea ในส่วนนั้น คุณได้เรียกใช้คำสั่ง jq เพื่อแทรก URL ของเซิร์ฟเวอร์ MCP ลงใน settings.json ด้วยตนเอง แนวทาง "ดิบ" นั้นมีประโยชน์ในการทำความเข้าใจกลไก แต่สำหรับการใช้งานจริงส่วนใหญ่ เราขอแนะนำให้ใช้ส่วนขยาย โดยจะรวมเซิร์ฟเวอร์ MCP, คำสั่งที่กำหนดเอง (เช่น /generate, /edit, /story), การกำหนดค่าสภาพแวดล้อม และแม้แต่คำสั่งตามบริบท (ผ่าน GEMINI.md ที่รวมไว้) ไว้ในแพ็กเกจเดียวที่แชร์ได้ คุณสามารถดูระบบนิเวศทั้งหมดของส่วนขยายได้ที่แกลเลอรีส่วนขยายของ Gemini CLI
👉💻 ป้อน Gemini CLI อีกครั้งและยืนยันว่าส่วนขยายทำงานอยู่
clear
cd ~/agentverse-developer/tabletop/
gemini
👉✨ ยืนยันว่าส่วนขยายได้รับการปรับแต่งแล้ว
/extensions list
ตอนนี้คุณควรเห็น nanobanana แสดงพร้อมเครื่องมือและคำสั่ง
👉✨ ใช้คำสั่งเดียวที่ทรงพลังเพื่อสั่งให้ส่วนขยาย Nano Banana สร้างซิกิลของคุณ ใน 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.
👉💻 เริ่มเซิร์ฟเวอร์ HTTP ในเทอร์มินัลใหม่
cd ~/agentverse-developer/tabletop/
python -m http.server
👀 หากต้องการดูผลงาน ให้คลิกไอคอนตัวอย่างเว็บในแถบเครื่องมือ Cloud Shell เลือกเปลี่ยนพอร์ต ตั้งค่าเป็น 8000 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง ตัวอย่างเว็บไซต์จะปรากฏขึ้น 
👉✨ กลับไปที่เทอร์มินัลที่เรียกใช้ Gemini CLI ให้คอมมิตการแก้ไข โดยระบุว่างานเสร็จสมบูรณ์แล้ว และปิดปัญหาที่คุณยื่นในบันทึกของ 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"
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
👀 หากต้องการดูผลงาน ให้คลิกไอคอนตัวอย่างเว็บในแถบเครื่องมือ Cloud Shell เลือกเปลี่ยนพอร์ต ตั้งค่าเป็น 3005 แล้วคลิกเปลี่ยนและแสดงตัวอย่าง ตัวอย่างเว็บไซต์จะปรากฏขึ้น 
👉💻 ในเทอร์มินัลที่เรียกใช้เซิร์ฟเวอร์ HTTP ให้กด Ctrl+C เพื่อออกจากเซิร์ฟเวอร์ HTTP
สำหรับผู้ที่ไม่ได้เล่นเกม
6. การประกอบ Shadowblade Agent: Vibe Code พร้อมขอบเขต
เวลาสำหรับการฝึกซ้อมสิ้นสุดลงแล้ว เสียงก้องของเหล็กบนหินค่อยๆ จางหายไป คุณเชี่ยวชาญอาวุธหลักและเตรียมคลังแสงสำหรับสงครามแล้ว ตอนนี้คุณจะเข้าสู่การทดสอบที่แท้จริงของ Shadowblade นั่นคือการประกอบตัวปฏิบัติการ นี่คือศิลปะแห่งการเติมชีวิตให้กับตรรกะ โดยใช้พิมพ์เขียวศักดิ์สิทธิ์จาก Codex เพื่อสร้างสติปัญญาหลักของเอเจนต์ ซึ่งเป็นการสร้างผู้ถือดาบที่มีสติสัมปชัญญะสำหรับดาบในคลังแสงของคุณที่สามารถคิด ไตร่ตรอง และดำเนินการได้ด้วยตนเอง
ภารกิจแรกของคุณคือการเข้าสู่เวิร์กช็อปที่มีอยู่ ซึ่งเป็นฐานของโค้ดที่สร้างไว้ล่วงหน้า และสร้างแชมป์เปี้ยนจากชิ้นส่วนต่างๆ
พิธีกรรมการประกอบ
ก่อนที่จะเริ่มการตีเหล็กครั้งแรก ช่างเทคนิคผู้เชี่ยวชาญจะสำรวจเวิร์กช็อปของตนเองเพื่อทำความเข้าใจเครื่องมือและแผนผังทุกอย่าง เมื่อก้าวเข้าสู่สมรภูมิที่ไม่คุ้นเคย เช่น ฐานของโค้ดขนาดใหญ่ที่มีอยู่แล้ว สิ่งแรกที่คุณควรทำคือการลาดตระเวน คุณต้องเข้าใจสภาพแวดล้อม ซึ่งก็คือสถาปัตยกรรมที่มีอยู่ วัตถุประสงค์สูงสุด และโปรโตคอลของการมีส่วนร่วม คุณจะใช้ทักษะได้อย่างมีประสิทธิภาพก็ต่อเมื่อทำความคุ้นเคยกับพิมพ์เขียวและมาตรฐานของป้อมปราการ
Gemini CLI ซึ่งเป็นเครื่องมือสอดแนมที่พร้อมใช้งานเสมอจะช่วยคุณในการสำรวจนี้ได้
- ให้ข้อมูลสรุประดับสูง: โมเดลนี้สามารถอ่านทั้งโคเด็กซ์ (หรือฐานของโค้ด) และช่วยให้คุณเข้าใจจุดประสงค์และคอมโพเนนต์หลักได้อย่างรวดเร็ว
- ช่วยในการตั้งค่าสภาพแวดล้อม: ช่วยแนะนำขั้นตอนการติดตั้งเครื่องมือและการกำหนดค่าเครื่อง
- ไปยังส่วนต่างๆ ของโค้ดเบส: Gemini สามารถทำหน้าที่เป็นไกด์ที่ช่วยให้คุณสำรวจตรรกะที่ซับซ้อนและค้นหาเส้นทางที่ซ่อนอยู่ภายในโค้ดได้
- สร้างเอกสารการเริ่มต้นใช้งาน: สร้างม้วนกระดาษที่ปรับแต่งแล้วซึ่งอธิบายเป้าหมาย บทบาท และแหล่งข้อมูลสำหรับพันธมิตรใหม่ที่เข้าร่วมอุดมการณ์ของคุณ
- การเรียนรู้และถามตอบอัตโนมัติ: กลายเป็นผู้เชี่ยวชาญส่วนตัวที่ตอบคำถามเกี่ยวกับฟีเจอร์หรือลักษณะการทำงานของโค้ด ช่วยให้คุณต่อสู้ได้อย่างอิสระมากขึ้น
👉💻 ในเทอร์มินัลแรก ให้ไปที่ไดเรกทอรี shadowblade แล้วเรียกพาร์ทเนอร์ AI ของคุณ
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/shadowblade
clear
gemini
👉✨ ตอนนี้สั่งให้หน่วยสอดแนมสำรวจสมรภูมิและรายงานกลับมา
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, store it as an agent_design.md file in my local folder, and show me the newly downloaded design doc. Do not attempt to create the file just yet.
👉✨ แถบเลื่อนยาวและมีรายละเอียด สั่งให้ Gemini กลั่นกรองเนื้อหา
Summarize the newly downloaded @agent_design.md for me, do not attempt to create file just yet.
ตอนนี้คุณมีแพ็กเกจแล้ว แต่ก่อนที่จะสร้างโค้ดแม้แต่บรรทัดเดียว ช่างฝีมือชั้นครูจะกำหนดกฎของโรงตีเหล็ก ซึ่งเกี่ยวข้องกับความมีวินัยและความสามารถในการปรับขนาด หลักเกณฑ์การเขียนโค้ดมีดังนี้ ซึ่งไม่ใช่แค่คำแนะนำ แต่เป็นรูนแห่งพลังที่ช่วยให้มั่นใจว่าทุกคอมโพเนนต์สร้างขึ้นด้วยความแม่นยำและความแข็งแกร่งในระดับเดียวกัน ซึ่งจะป้องกันไม่ให้จัดรูปแบบแต่ละรายการทำให้ผลงานสุดท้ายเสียหาย เพื่อให้มั่นใจว่า Agent จะมีความยืดหยุ่น ดูแลรักษาได้ และบริสุทธิ์ ทำให้ช่างฝีมือใหม่ๆ สามารถเข้าร่วมโปรเจ็กต์ได้โดยไม่รบกวนความกลมกลืนของทั้งระบบ
เราใช้สิ่งประดิษฐ์พิเศษอย่าง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
👉✨ ตอนนี้ก็ขอความช่วยเหลือจาก Gemini ให้แสดงสิ่งที่กำลังคิดอยู่ได้เลย อ่านรูนแล้ว
/memory show
การเสริมความเชี่ยวชาญเฉพาะทาง: ทักษะของเอเจนต์
รูนGEMINI.mdที่คุณจารึกไว้จะเหมือนเวทมนตร์ถาวรที่ทำงานอยู่เสมอและนำทางดาบของคุณ แต่ผู้เชี่ยวชาญที่แท้จริงไม่ได้พกม้วนคัมภีร์ทุกม้วนไปทุกการต่อสู้ ความเชี่ยวชาญบางอย่างมีความเฉพาะเจาะจงมากเกินไปหรือมีขนาดใหญ่เกินไปที่จะโหลดไว้ตลอดเวลา ทักษะของเอเจนต์จึงเข้ามามีบทบาทในจุดนี้
ให้คิดว่าทักษะของเอเจนต์เป็นเหมือนม้วนคัมภีร์ที่ปิดผนึกไว้ในแพ็ก โดยมีข้อมูลความเชี่ยวชาญเฉพาะทาง เช่น คำสั่งโดยละเอียด สคริปต์ หรือแม้แต่ข้อมูลอ้างอิง แต่จะยังคงไม่ได้ใช้งานจนกว่าคุณจะต้องการ เฉพาะเมื่อคุณเผชิญกับความท้าทายที่ตรงกับโดเมนของม้วนกระดาษเท่านั้น ใบมีดของคุณจึงจะดึงม้วนกระดาษออกมาและดูดซับความรู้จากม้วนกระดาษ เราเรียกวิธีนี้ว่าการเปิดเผยข้อมูลแบบตามลำดับขั้น ซึ่งจะช่วยให้ใบมีดของคุณทำงานได้อย่างรวดเร็วและไม่หนักเกินไป โดยจะเปิดใช้งานความสามารถเฉพาะเมื่อมีการร้องขอเท่านั้น
👀 หมายเหตุสำหรับนักพัฒนาซอฟต์แวร์: ทักษะของเอเจนต์เป็นเลเยอร์ที่ 3 ของลำดับชั้นการออกแบบบริบทของ Gemini CLI
- การตั้งค่าผู้ใช้ (
~/.gemini/settings.json) - การกำหนดค่าส่วนกลาง - GEMINI.md - บริบทระดับโปรเจ็กต์แบบถาวร (โหลดเสมอ)
- ทักษะของตัวแทน (
.gemini/skills/) - ความเชี่ยวชาญตามความต้องการ (โหลดเมื่อจำเป็น)
โมเดลการเปิดเผยข้อมูลแบบค่อยเป็นค่อยไปนี้มีความสําคัญอย่างยิ่งสําหรับการใช้งานในองค์กร โดยที่คลังอาจมีทักษะเฉพาะทางหลายสิบอย่าง (การตรวจสอบความปลอดภัย การย้ายข้อมูลฐานข้อมูล การตรวจสอบการปฏิบัติตามข้อกําหนด) แต่ AI จะเปิดใช้งานเฉพาะทักษะที่เกี่ยวข้องกับงานปัจจุบันเท่านั้น ซึ่งจะช่วยประหยัดโทเค็นบริบทที่มีค่า
มาสร้างทักษะแรกกันเลย นั่นคือม้วนกระดาษที่บันทึกความเชี่ยวชาญด้าน ADK ซึ่งดาบของคุณจะนำมาใช้ได้เมื่อสร้างเอเจนต์
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI จากนั้นสร้างไดเรกทอรีทักษะและจารึกม้วนกระดาษ
mkdir -p ~/.gemini/skills/adk-agent-design
cat << 'EOF' > ~/.gemini/skills/adk-agent-design/SKILL.md
---
name: adk-agent-design
description: Expert guidance for designing and building agents with the Google Agent Development Kit (ADK). Activate when the user asks about agent architecture, tool design, callback patterns, or ADK best practices.
---
# ADK Agent Design Expertise
When designing an ADK agent, follow these principles:
## Agent Architecture
- Define agents using `LlmAgent` with a clear `name`, `model`, `instruction`, and `tools` list.
- Keep instructions specific and action-oriented. Tell the agent what it IS, not what it should try to be.
- Use `before_model_callback` and `after_model_callback` for guardrails and validation.
## Tool Design
- Each tool should do ONE thing well. Prefer small, focused tools over large, multi-purpose ones.
- Always include descriptive docstrings — the LLM uses these to decide when to call each tool.
- Return structured data (dicts) from tools so the LLM can reason about the results.
## Testing Strategy
- Use `adk eval` with evalset JSON files for broad strategy testing.
- Use `pytest` with `AgentEvaluator` for programmatic, CI-ready tests.
- Define both `tool_trajectory_avg_score` and `response_match_score` criteria.
EOF
👉💻 ป้อน Gemini CLI อีกครั้งเพื่อดูทักษะที่สร้างขึ้นใหม่
cd ~/agentverse-developer/shadowblade
gemini
👉✨ ตรวจสอบว่าทักษะอยู่ในแพ็กของคุณ
/skills list
คุณควรเห็น adk-agent-design แสดงอยู่ ซึ่งเป็นม้วนกระดาษที่ปิดผนึกไว้และรอการเปิดใช้งาน
👉✨ ตอนนี้ขอความช่วยเหลือจาก Gemini ในสิ่งที่ควรจะเปิดใช้งานทักษะ
What are the best practices for designing tools in an ADK agent?
สังเกตว่าตอนนี้คำตอบอิงตามความรู้เฉพาะทางที่คุณเขียนไว้ในทักษะ โดยเบลดไม่ได้เก็บความเชี่ยวชาญนี้ไว้ในหน่วยความจำพื้นฐาน แต่ค้นพบการเลื่อนที่เกี่ยวข้องและดึงออกมาเมื่อคำถามตรงกันเท่านั้น นี่คือการเปิดเผยข้อมูลแบบค่อยเป็นค่อยไป
คุณสามารถสร้างทักษะสำหรับโดเมนใดก็ได้ ไม่ว่าจะเป็นการตรวจสอบความปลอดภัย การย้ายข้อมูลฐานข้อมูล การตรวจสอบการปฏิบัติตามข้อกำหนด และแชร์ทักษะดังกล่าวกับทีมได้โดยการคอมมิตไปยังการควบคุมเวอร์ชัน ใบมีดของสมาชิกในทีมแต่ละคนจะได้รับความเชี่ยวชาญเดียวกันและนำไปใช้ได้อย่างสม่ำเสมอ
นี่คือช่วงเวลาสำคัญ คุณจะจัดเตรียมแผนผัง (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 แล้ว ส่วนหลักของไฟล์ใหม่นี้จะกำหนดความสามารถของ Agent โดยเชื่อมต่อโมเดลการให้เหตุผลกับชุดเครื่องมือภายนอก ดังนี้
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 เลื่อนดูโค้ดและยืนยันว่าได้เพิ่มฟังก์ชันใหม่ 7 รายการ @mcp.tool() เรียบร้อยแล้ว ตรวจสอบฟังก์ชัน 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 Agent ที่ยังไม่ได้ทดสอบเป็นอันตรายที่ร้ายแรงกว่ามาก ซึ่งเป็นองค์ประกอบที่อาจทำให้ภารกิจของคุณเสียหายจากภายใน นี่ไม่ใช่แค่การคาดเดา แต่เป็นหลักการสำคัญที่ Shadowblade ต้องเข้าใจ
การประเมินเอเจนต์ AI เป็นทั้งเรื่องสำคัญและมีความท้าทายเฉพาะตัว Agent ต่างจากสคริปต์ธรรมดาตรงที่เป็นการผสานรวมโค้ดของคุณแบบไดนามิกเข้ากับจิตใจที่ใช้เหตุผลแบบหลายขั้นตอนของ LLM พฤติกรรมของมันเป็นสิ่งที่เกิดขึ้นใหม่ ซึ่งหมายความว่าคุณต้องประเมินไม่เพียงแต่คุณภาพของผลลัพธ์สุดท้าย แต่ยังต้องประเมินประสิทธิภาพและความถูกต้องของเส้นทางภายในด้วย เส้นทางที่ใช้ในการเดินทาง โดยใช้เครื่องมือที่เหมาะสมหรือไม่ สร้างโทเค็นมากเกินไปไหม การเปลี่ยนแปลงเวอร์ชันของโมเดลทำให้เกิดการถดถอยของเวลาในการตอบสนองเล็กน้อยหรือไม่ การตรวจหาความเสียหายนี้ ซึ่งก็คือความเสื่อมถอยในด้านเวลาในการตอบสนอง ต้นทุน หรือคุณภาพเอาต์พุต เป็นสิ่งสำคัญอย่างยิ่งเมื่อทำการเปลี่ยนแปลงใดๆ ตั้งแต่การปรับพรอมต์อย่างง่ายไปจนถึงการยกเครื่องสถาปัตยกรรมครั้งใหญ่ ก่อนที่การเปลี่ยนแปลงดังกล่าวจะส่งผลเสียต่อสภาพแวดล้อมการผลิต
แนวทางทั่วไปในการประเมินนี้เกี่ยวข้องกับพิธีกรรมศักดิ์สิทธิ์ ดังนี้
- ก่อนอื่นให้กำหนด"ชุดข้อมูลที่สมบูรณ์" ซึ่งเป็นชุดของสคริปต์ที่มีอินพุตตัวอย่างและเอาต์พุตหรือลักษณะการทำงานที่คาดไว้ ซึ่งอาจรวมถึงคำตอบสุดท้าย การใช้เครื่องมือที่ถูกต้อง หรือแม้แต่เส้นทางการแก้ปัญหาแบบทีละขั้นตอนทั้งหมด
- จากนั้น คุณจะกำหนดตรรกะของแอปพลิเคชันของเอเจนต์ ซึ่งเป็นหัวใจสำคัญของเอเจนต์
- สุดท้าย คุณจะสร้างผู้ประเมิน ซึ่งเปรียบเสมือนเครื่องหมายแห่งการตัดสิน ซึ่งอาจมีตั้งแต่ LLM อื่นๆ ที่ทำหน้าที่เป็นผู้ประเมินคุณภาพ ไปจนถึงโค้ดฮิวริสติกที่แม่นยำซึ่งยืนยันขั้นตอนเดียว ไปจนถึงฟังก์ชันที่กำหนดเองซึ่งวิเคราะห์กระบวนการคิดทั้งหมดของเอเจนต์
Agent Development Kit (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: นี่คือผลลัพธ์ที่คาดการณ์ไว้ ซึ่งเป็นสตริงข้อความที่แน่นอนที่คุณคาดหวังให้ Agent พูดเมื่อทำภารกิจเสร็จ ADK จะเปรียบเทียบคำพูดสุดท้ายที่แท้จริงของเอเจนต์กับรูนนี้เพื่อประเมินความสามารถในการพูด
- intermediate_data.tool_uses: นี่คือเทคนิค Arcane สำหรับเอเจนต์ที่แท้จริง รูนนี้สำคัญที่สุดในบรรดารูนทั้งหมด ซึ่งไม่ได้กำหนดสิ่งที่เอเจนต์พูด แต่กำหนดสิ่งที่เอเจนต์ทำ โดยจะบันทึกชื่อของเครื่องมือ (enchant_soulshard_dagger) ที่คุณคาดหวังให้เอเจนต์ใช้ วิธีนี้ช่วยให้มั่นใจได้ว่าเอเจนต์ของคุณไม่ได้เป็นเพียงนักสนทนาที่ฉลาด แต่ยังเป็นผู้ดำเนินการที่เด็ดขาดซึ่งจะดำเนินการที่ถูกต้อง
เมื่อเข้าใจพิมพ์เขียวแล้ว คุณจะสั่งให้ Gemini คัดลอกเวอร์ชันใหม่ที่ซับซ้อนกว่าของภาพเลื่อนนี้
👉💻 ในเทอร์มินัล ให้ไปที่ไดเรกทอรี shadowblade แล้วเรียกใช้ Gemini CLI ดังนี้
clear
cd ~/agentverse-developer/shadowblade/
gemini
👉✨ สั่งให้ Gemini CLI ทำหน้าที่เป็นผู้บันทึก QA โดยสร้างชุดกรณีทดสอบที่กำหนดลักษณะการทำงานที่คาดไว้สำหรับ Agent
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: นี่คือการวัดผลการกระทำ โดยจะพิจารณาจากสิ่งที่เอเจนต์ทำ ไม่ใช่สิ่งที่พูด โดยจะเปรียบเทียบเครื่องมือที่ Agent ใช้จริงกับเทคนิคที่ทำนายไว้ในม้วนคำท้า คะแนน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 }'
👀 คุณควรเห็นข้อมูลสรุปต่อไปนี้ ซึ่งเป็นสัญญาณว่า Agent ของคุณประสบความสำเร็จภายใต้กฎที่ผ่อนปรนของช่วงทดลองนี้ (บางครั้งการทดสอบบางอย่างอาจไม่ผ่าน)
********************************************************************* Eval Run Summary shadowblade_combat_agent_validation: Tests passed: 3 Tests failed: 0
The Shield of Clarity (pytest)
The Gauntlet ทดสอบกลยุทธ์ในวงกว้าง วอร์ดที่ 2 ซึ่งก็คือโล่แห่งความชัดเจนจะทดสอบวินัยและพฤติกรรมที่เฉพาะเจาะจง ทั้งหมดนี้คือการทำงานอัตโนมัติ แม้ว่า adk eval จะเหมาะสำหรับการตรวจสอบด้วยตนเอง แต่pytest คือเกราะป้องกันแบบเป็นโปรแกรมที่เขียนด้วยโค้ด ซึ่งเป็นสิ่งจำเป็นเนื่องจากสามารถผสานรวมการทดสอบที่ดำเนินการเป็นโค้ดเข้ากับไปป์ไลน์อัตโนมัติได้ เป้าหมายสูงสุดคือการสร้างการทดสอบการติดตั้งใช้งาน (CI/CD) ซึ่งจะเพิ่มการป้องกันโดยอัตโนมัติทุกครั้งที่มีการเปลี่ยนแปลง เพื่อป้องกันข้อบกพร่องและการถดถอยก่อนที่จะส่งผลกระทบต่อสภาพแวดล้อมการผลิต
👉💻 ในเทอร์มินัล ให้เรียกใช้ Gemini อีกครั้งจากภายในไดเรกทอรี shadowblade
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/
clear
gemini
👉✨ ใช้พรอมต์ต่อไปนี้ใน 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 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 แบบแม่นยำแล้ว เอเจนต์ของคุณก็จะไม่ใช่แค่ใช้งานได้ แต่ยังเป็นเอเจนต์ที่ผ่านการทดสอบและพร้อมสำหรับการใช้งาน
สำหรับผู้ที่ไม่ได้เล่นเกม
Wards of Vigilance: Gemini CLI Hooks
วอร์ดแห่งความบริสุทธิ์จะทดสอบเอเจนต์หลังจากการต่อสู้ แต่จะเกิดอะไรขึ้นระหว่างการต่อสู้ Shadowblade ที่มีวินัยไม่ได้ทดสอบหลังจากเกิดเหตุการณ์เท่านั้น แต่ยังวางยามที่คอยเฝ้าระวังซึ่งจะจับตาดูทุกการโจมตีที่เกิดขึ้น และสกัดกั้นการกระทำที่อันตรายหรือประมาทก่อนที่จะก่อให้เกิดอันตราย
Sentinel เหล่านี้คือ Gemini CLI Hooks ซึ่งเป็นสคริปต์ที่ทำงานในจุดที่เฉพาะเจาะจงในลูปของเอเจนต์ ซึ่งช่วยให้คุณสกัดกั้น ตรวจสอบ และปรับแต่งลักษณะการทำงานของเอเจนต์ได้โดยไม่ต้องแก้ไขโค้ดของเอเจนต์
👀 หมายเหตุสำหรับนักพัฒนาซอฟต์แวร์: ระบบจะทริกเกอร์ Hook โดยเหตุการณ์ในวงจรของเอเจนต์
BeforeTool: เริ่มทำงานก่อนที่เครื่องมือจะดำเนินการ ซึ่งเหมาะสำหรับการตรวจสอบความปลอดภัย ("คำสั่งเชลล์นี้ปลอดภัยไหม")AfterTool: ทริกเกอร์หลังจากเครื่องมือทํางาน ซึ่งมีประโยชน์สําหรับการตรวจสอบผลลัพธ์และการบันทึกBeforeAgent: เริ่มทำงานก่อนที่ Agent จะเริ่มให้เหตุผล ซึ่งสามารถแทรกบริบทเพิ่มเติมหรือบล็อกพรอมต์ที่เป็นอันตรายได้AfterAgent: ทำงานหลังจากที่ตัวแทนดำเนินการเสร็จสิ้น โดยสามารถปฏิเสธคำตอบที่คุณภาพต่ำและบังคับให้ลองอีกครั้งได้
โดยจะกำหนดค่า Hook ใน settings.json และเรียกใช้แบบพร้อมกัน ซึ่งหมายความว่าเอเจนต์จะรอให้ Hook ทำงานเสร็จก่อนจึงจะดำเนินการต่อ จึงเหมาะอย่างยิ่งสำหรับการบังคับใช้นโยบายความปลอดภัย การตรวจสอบการปฏิบัติตามข้อกำหนด และการควบคุมคุณภาพในสภาพแวดล้อมขององค์กร
มาจารึกคาถาอย่างง่ายที่คอยดูการใช้เครื่องมือของเอเจนต์กัน
👉💻 สร้างสคริปต์ฮุกในเทอร์มินัลโดยทำดังนี้
mkdir -p ~/agentverse-developer/.gemini/hooks
cat << 'EOF' > ~/agentverse-developer/.gemini/hooks/tool_logger.sh
#!/bin/bash
# A ward that logs every tool call to a file for auditing
INPUT=$(cat)
TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name // "unknown"')
echo "$(date '+%H:%M:%S') ⚔️ [WARD] Tool invoked: $TOOL_NAME" >> /tmp/tool_ward.log
echo '{"decision": "allow"}'
EOF
chmod +x ~/agentverse-developer/.gemini/hooks/tool_logger.sh
👉💻 ตอนนี้ให้ลงทะเบียน Hook นี้ในไฟล์การตั้งค่าระดับโปรเจ็กต์
mkdir -p ~/agentverse-developer/.gemini
cat << 'EOF' > ~/agentverse-developer/.gemini/settings.json
{
"hooks": {
"BeforeTool": [
{
"matcher": "*",
"hooks": [
{
"name": "tool-logger",
"type": "command",
"command": "$GEMINI_PROJECT_DIR/.gemini/hooks/tool_logger.sh",
"timeout": 5000
}
]
}
]
}
}
EOF
คำนี้เรียบง่ายแต่ทรงพลัง ทุกครั้งที่ตัวแทนเข้าถึงเครื่องมือใดก็ตาม ฮุกจะทำงานก่อน บันทึกชื่อเครื่องมือลงในบันทึกการตรวจสอบ แล้วจึงอนุญาตให้ดำเนินการต่อ ในสภาพแวดล้อมการใช้งานจริง คุณสามารถแทนที่ "allow" ด้วย "deny" เพื่อบล็อกการดำเนินการที่เป็นอันตราย (เช่น ป้องกันไม่ให้ตัวแทนลบไฟล์) บังคับใช้นโยบายการตรวจสอบโค้ด หรือกำหนดเส้นทางการเรียกใช้เครื่องมือที่มีความละเอียดอ่อนผ่านเวิร์กโฟลว์การอนุมัติ
👉💻 ป้อน Gemini CLI อีกครั้งเพื่อยืนยันว่า Hook ทำงานอยู่
cd ~/agentverse-developer
gemini
👉✨ ยืนยันว่าได้ลงทะเบียน Hook แล้ว
/hooks
คุณควรเห็นฮุก tool-logger แสดงและเปิดใช้อยู่ กด Escape เพื่อปิดเมนูเติมข้อความอัตโนมัติหากปรากฏขึ้น
👉✨ ตอนนี้ทริกเกอร์การเรียกใช้เครื่องมือเพื่อทดสอบคำว่า "ward"
What files are in the current directory?
Agent จะเรียกใช้เครื่องมือเพื่ออ่านไดเรกทอรี วอร์ดดักฟังเรื่องนี้อย่างเงียบๆ มาดูหลักฐานกัน
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI จากนั้นตรวจสอบบันทึกการตรวจสอบของวอร์ด
cat /tmp/tool_ward.log
คุณควรเห็นรายการต่อไปนี้
15:42:07 ⚔️ [WARD] Tool invoked: list_directory
การเรียกใช้เครื่องมือทุกครั้งที่เอเจนต์ดำเนินการจะถูกดักจับ บันทึก และได้รับอนุญาตจากวอร์ดของคุณ ในสภาพแวดล้อมขององค์กรจริง ระบบจะส่งบันทึกนี้ไปยังระบบ SIEM (การจัดการกิจกรรมและข้อมูลความปลอดภัย) ซึ่งจะทริกเกอร์การแจ้งเตือนสำหรับการใช้งานเครื่องมือที่น่าสงสัยหรือบังคับใช้เส้นทางการตรวจสอบการปฏิบัติตามข้อกำหนด
8. ปลดปล่อย Blade สู่ Agentverse: CI และการติดตั้งใช้งาน
ตัวแทนของคุณได้รับการประกอบขึ้นและได้รับการยืนยันความสมบูรณ์โดยผู้พิทักษ์แห่งความบริสุทธิ์ แต่หากไม่ได้รับการดูแลอย่างสม่ำเสมอ วอร์ดก็จะเป็นเพียงสิ่งตกทอดที่ถูกลืม คุณต้องสร้างด่านแรกของ Deployment Gauntlet ซึ่งเป็นพิธีกรรมอัตโนมัติที่รับประกันคุณภาพและความเร็ว เพื่อให้มั่นใจว่าเอเจนต์เวอร์ชันต่อๆ ไปจะยังคงเป็นเวอร์ชันที่บริสุทธิ์
ในฐานะ Shadowblade หน้าที่อันศักดิ์สิทธิ์ของคุณคือการรวมอย่างต่อเนื่อง (CI) นี่คือระบบอัตโนมัติของฟอร์จและสนามทดสอบ ซึ่งเป็นวิธีป้องกันการทุจริตและความผิดพลาดของมนุษย์ที่ดีที่สุด พิธีกรรมนี้ช่วยให้มั่นใจได้ว่าทุกครั้งที่คุณหรือพันธมิตรมีส่วนร่วมด้วยการเพิ่มเทคนิคใหม่ (ผสานโค้ด) ลงในโคเด็กซ์กลาง (ที่เก็บของคุณ) ถุงมือจะตื่นขึ้นโดยอัตโนมัติ โดยจะสร้างเอเจนต์จากโค้ดใหม่ก่อน แล้วจึงส่งไปยังวอร์ดแห่งความบริสุทธิ์ที่คุณเพิ่งสร้างขึ้นทันที หากการป้องกันใดล้มเหลว พิธีกรรมจะหยุดลง และระบบจะปฏิเสธอาร์ติแฟกต์ที่มีข้อบกพร่องทันที เพื่อป้องกันไม่ให้อาร์ติแฟกต์ดังกล่าวทำให้คลังอาวุธเสียหาย โดเมนของคุณคือโรงตีเหล็ก ส่วนไปป์ไลน์ CI จะรับประกันว่าจะมีเพียงอาร์ติแฟกต์ที่สมบูรณ์แบบและพร้อมรบเท่านั้นที่จะออกจากเวิร์กช็อปของคุณ
เมื่อ CI gauntlet พิสูจน์แล้วว่าอาร์ติแฟกต์มีคุณค่า ขั้นตอนที่ 2 ของพิธีกรรมจะเริ่มขึ้น นั่นคือการติดตั้งใช้งานต่อเนื่อง (CD) นี่คือโดเมนของ Guardian หน้าที่อันศักดิ์สิทธิ์ของพวกเขาคือการนำอาร์ติแฟกต์ที่ผ่านการปรับแต่งและบรรจุในคอนเทนเนอร์ของคุณไปปล่อยใน Agentverse ที่ใช้งานจริงอย่างปลอดภัย พร้อมทั้งจัดการพลังและรับประกันความเสถียรของอาร์ติแฟกต์ดังกล่าวจากความวุ่นวายของ The Static
ในสารานุกรมนี้ คุณจะเชี่ยวชาญบทบาทของตนเอง คุณจะสร้างส่วน CI ของการทดสอบ คุณจะสร้างโรงตีเหล็กอัตโนมัติที่ทดสอบเอเจนต์และผนึกผลลัพธ์ที่บริสุทธิ์ลงในคอนเทนเนอร์ เพื่อเตรียมรับพรสุดท้ายจาก The Guardian
👀 หมายเหตุสำหรับนักพัฒนาซอฟต์แวร์: ในโลกแห่งความเป็นจริง การจัดการเวิร์กโฟลว์ CI/CD ที่ซับซ้อนสามารถปรับปรุงให้มีประสิทธิภาพมากขึ้นได้ด้วยส่วนขยายเฉพาะทาง เช่น Conductor (gemini extensions install https://github.com/gemini-cli-extensions/conductor) Conductor จะเปลี่ยน Gemini CLI ให้เป็นผู้จัดการโปรเจ็กต์ที่ทำตามโปรโตคอลที่เข้มงวด: บริบท → ข้อมูลจำเพาะและแผน → การติดตั้งใช้งาน โดยจะรวมคำสั่งที่กำหนดเอง (/conductor:setup, /conductor:newTrack, /conductor:implement) และเทมเพลตเวิร์กโฟลว์เพื่อจัดการวงจรทั้งหมดของงาน ซึ่งช่วยให้มั่นใจได้ว่าวงจรบริบท -> ข้อกำหนดและแผน -> การติดตั้งใช้งานจะสอดคล้องกัน นี่คือตัวอย่างในชีวิตจริงที่แสดงให้เห็นว่าส่วนขยายและคำสั่งทำงานร่วมกันอย่างไรเพื่อทำหน้าที่เป็นผู้จัดการโปรเจ็กต์เชิงรุกและกำหนดวงจรการพัฒนาทั้งหมดให้เป็นมาตรฐาน
ตอนนี้คุณจะใช้ Google Cloud Build เพื่อเขียนสคริปต์การเลื่อนสำหรับพิธีกรรม CI นี้ ไฟล์ cloudbuild.yaml ที่กำหนดทุกขั้นตอนของกระบวนการสร้างและทดสอบ
👉💻 เนื่องด้วยโครงสร้างโปรเจ็กต์ของ ADK การกำหนดค่าไปป์ไลน์ CI/CD ควรอยู่ในไดเรกทอรีระดับบน ในเทอร์มินัล ให้ไปที่ไดเรกทอรีระดับบนสุด แล้วรีสตาร์ท Gemini CLI
cd ~/agentverse-developer/
clear
gemini
👉✨ ตอนนี้ให้ป้อนคำสั่งต่อไปนี้กับ 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 ให้ดำเนินการทดสอบทั้งหมด
👉💻 กด Ctrl+C 2 ครั้งเพื่อออกจาก Gemini CLI
👉💻 ในเทอร์มินัล ให้เรียกใช้ไปป์ไลน์จากไดเรกทอรีรากของโปรเจ็กต์โดยใช้คำสั่งต่อไปนี้
. ~/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 ขณะที่พิธีกรรมอัตโนมัติของคุณดำเนินการแต่ละขั้นตอนได้แล้ว โดยจะเรียกใช้การทดสอบก่อน และเมื่อเห็นว่าการทดสอบสำเร็จแล้ว ก็จะสร้างและจัดเก็บคอนเทนเนอร์ของเอเจนต์
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 ที่น่าเกรงขาม ซึ่งเป็นตัวแทนของความโกลาหลที่คุกคามทุกสรรพสิ่ง นี่คือการทดสอบขั้นสุดท้ายของงานของคุณ ตั้งแต่ตรรกะหลักของ Agent ไปจนถึงการทำให้ใช้งานได้ที่ไร้ที่ติ
รับตำแหน่งของตัวแทน
ก่อนที่จะเข้าสู่สมรภูมิ คุณต้องมีกุญแจ 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 ก็ปรากฏตัวขึ้นแล้ว ซึ่งเป็นกระแสรหัสที่เสียหายและเสียงซ่าที่ดังออกมา แสงที่ไม่บริสุทธิ์ของมันทอดเงายาวๆ ที่เต้นระบำไปทั่วพื้นดันเจี้ยน มันไม่มีหน้าตา แต่คุณรู้สึกถึงการมีอยู่ของมันที่ดูดกลืนทุกสิ่งและจ้องมองมาที่คุณ
หนทางเดียวสู่ชัยชนะคือความชัดเจนในความเชื่อของคุณ นี่คือการต่อสู้กันด้วยความตั้งใจ ซึ่งเกิดขึ้นในสนามรบแห่งจิตใจ
ขณะที่คุณพุ่งไปข้างหน้าพร้อมที่จะโจมตีครั้งแรก สเปกเตอร์ก็โต้กลับ แต่จะฉายคำถามตรงเข้าสู่จิตสำนึกของคุณ ซึ่งเป็นความท้าทายที่ส่องประกายและเป็นอักษรรูนที่ดึงมาจากแก่นของการฝึก
นี่คือลักษณะของการต่อสู้ ความรู้ของคุณคืออาวุธ
- ตอบด้วยสติปัญญาที่คุณได้รับ แล้วดาบของคุณจะลุกโชนด้วยพลังงานบริสุทธิ์ ทำลายการป้องกันของ Spectre และโจมตีอย่างรุนแรง
- แต่หากคุณลังเลหรือมีข้อสงสัยในคำตอบ แสงของอาวุธจะหรี่ลง การโจมตีจะลงพื้นพร้อมกับเสียงทุบที่น่าสมเพช ซึ่งสร้างความเสียหายเพียงเล็กน้อยเท่านั้น ที่แย่กว่านั้นคือสเปกเตอร์จะคอยฉวยโอกาสจากความไม่แน่นอนของคุณ พลังที่ทำให้เสื่อมเสียของมันจะเพิ่มขึ้นทุกครั้งที่คุณพลาด
นี่แหละแชมป์ โค้ดคือตำราเวทมนตร์ ตรรกะคือดาบ และความรู้คือโล่ที่จะพลิกสถานการณ์ความวุ่นวาย
โฟกัส Strike true. ชะตากรรมของ Agentverse ขึ้นอยู่กับสิ่งนี้
ขอแสดงความยินดีด้วยนะ Shadowblade
คุณได้ทำตามหลักเกณฑ์เรียบร้อยแล้ว คุณได้ "กลิ่นอาย" แปลงเป็นดีไซน์ และใช้ Gemini CLI เพื่อประกอบ Agent อัจฉริยะ คุณจารึก Wards of Purity เพื่อทดสอบตรรกะ สร้างถุงมืออัตโนมัติเพื่อหลอมให้เป็นอาร์ติแฟกต์ และปล่อยมันลงใน Agentverse และสุดท้าย คุณได้ตรวจสอบความเหมาะสมของวัตถุประสงค์ในการทดสอบยิงจริง คุณเชี่ยวชาญเวิร์กโฟลว์ของ Agent แบบ Full Stack แล้ว และตอนนี้ก็พร้อมรับมือกับทุกความท้าทายที่ 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
ล้างไฟล์และไดเรกทอรีในเครื่อง (Cloud Shell)
สุดท้าย ให้ล้างสภาพแวดล้อม Cloud Shell ของที่เก็บที่โคลน ส่วนขยายที่ติดตั้ง และไฟล์ที่สร้างขึ้น ขั้นตอนนี้ไม่บังคับ แต่เราขอแนะนำให้ทำเพื่อล้างไดเรกทอรีการทำงานให้สะอาดหมดจด
👉💻 ในเทอร์มินัล ให้เรียกใช้คำสั่งต่อไปนี้
rm -rf ~/agentverse-developer
rm -rf ~/agentverse-dungeon
rm -f ~/project_id.txt
gemini extensions uninstall nanobanana
rm -rf ~/.gemini # This removes all Gemini CLI configurations, including extensions, skills, and hooks.
ตอนนี้คุณได้ลบร่องรอยทั้งหมดของการเดินทางใน Agentverse เรียบร้อยแล้ว โปรเจ็กต์ของคุณสะอาดแล้ว และคุณก็พร้อมสำหรับการผจญภัยครั้งต่อไป