1. של גורל
העידן של פיתוח מבודד מסתיים. הגל הבא של ההתפתחות הטכנולוגית לא מתבסס על גאונות בודדת, אלא על שיתוף פעולה. יצירת סוכן חכם יחיד היא ניסוי מרתק. האתגר הגדול של ארגונים מודרניים הוא בניית סביבה עסקית חזקה, מאובטחת וחכמה של סוכנים – Agentverse אמיתי.
כדי להצליח בעידן החדש הזה, צריך לשלב בין ארבעה תפקידים חשובים, שהם אבני היסוד של כל מערכת אוטונומית משגשגת. ליקוי באחד מהתחומים יוצר חולשה שעלולה לפגוע במבנה כולו.
הסדנה הזו היא מדריך מקיף לארגונים שרוצים להתכונן לעתיד של סוכנים ב-Google Cloud. אנחנו מספקים מפת דרכים מקיפה שתעזור לכם להפוך רעיון ראשוני למציאות מבצעית בקנה מידה מלא. בארבעת שיעורי ה-Lab האלה, שקשורים זה לזה, תלמדו איך הכישורים המיוחדים של מפתח, ארכיטקט, מהנדס נתונים ומומחה SRE צריכים להתחבר כדי ליצור, לנהל ולהתאים לעומס Agentverse עוצמתי.
אי אפשר להסתמך רק על אחד מהעקרונות האלה כדי להשתמש ב-Agentverse. התוכנית הגדולה של הארכיטקט לא שווה בלי הביצוע המדויק של המפתח. הסוכן של המפתח לא יכול לפעול בלי הידע של מהנדס הנתונים, והמערכת כולה פגיעה בלי ההגנה של מהנדס ה-SRE. רק באמצעות סינרגיה והבנה משותפת של התפקידים של כל אחד, הצוות שלכם יכול להפוך רעיון חדשני למציאות תפעולית קריטית. המסע שלכם מתחיל כאן. הכנה לשליטה בתפקיד ולמידה על מקומכם בתמונה הגדולה.
ברוכים הבאים ל-Agentverse: קריאה לאלופים
בעידן הדיגיטלי הרחב של הארגון, נפתח עידן חדש. אנחנו נמצאים בעידן של סוכנים דיגיטליים, תקופה עם פוטנציאל עצום, שבה סוכנים חכמים ואוטונומיים פועלים בהרמוניה מושלמת כדי להאיץ את החדשנות ולבטל את השגרה.
המערכת האקולוגית המחוברת הזו של כוח ופוטנציאל נקראת Agentverse.
אבל אנטרופיה זוחלת, שחיתות שקטה שנקראת 'הסטטיק', מתחילה לשחוק את הקצוות של העולם החדש הזה. הסטטיק הוא לא וירוס או באג, אלא גילום של כאוס שטורף את עצם פעולת היצירה.
התסכולים הישנים מתעצמים ומתפתחים לצורות מפלצתיות, ויוצרים את שבעת רוחות הרפאים של הפיתוח. אם לא תסמנו את התיבה, הסטטי והספקטרים שלו יגרמו לעצירה מוחלטת של ההתקדמות, וההבטחה של Agentverse תהפוך לשממה של חוב טכני ופרויקטים נטושים.
היום אנחנו קוראים לאנשים שמוכנים להוביל שינוי כדי לעצור את גל הכאוס. אנחנו צריכים גיבורים שמוכנים לשפר את הכישורים שלהם ולעבוד יחד כדי להגן על Agentverse. הגיע הזמן לבחור את המסלול.
בחירת כיתה
לפניכם ארבעה נתיבים שונים, שכל אחד מהם הוא נדבך חשוב במאבק נגד הסטטיק. האימון שלכם יהיה משימה סולו, אבל ההצלחה הסופית שלכם תלויה בהבנה של האופן שבו הכישורים שלכם משתלבים עם הכישורים של אחרים.
- Shadowblade (מפתח): אומן הנפחות והחזית. אתם האומנים שמייצרים את הלהבים, בונים את הכלים ומתמודדים עם האויב בפרטים המורכבים של הקוד. המסלול שלך הוא מסלול של דיוק, מיומנות ויצירה מעשית.
- האסטרטג (אדריכל): אסטרטג ומנהל פרויקטים. אתם לא רואים סוכן יחיד, אלא את כל שדה הקרב. אתם מעצבים את תוכניות האב שמאפשרות למערכות שלמות של סוכנים לתקשר, לשתף פעולה ולהשיג מטרה גדולה בהרבה מכל רכיב בודד.
- המלומד (מהנדס נתונים): מחפש את האמת הנסתרת ושומר על החוכמה. אתם יוצאים למסע אל מרחבי הנתונים העצומים והפראיים כדי לחשוף את התובנות שיעזרו לסוכנים שלכם להבין את המטרה ולראות את התמונה המלאה. הידע שלכם יכול לחשוף חולשה של אויב או להעצים את היכולות של בעל ברית.
- השומר (DevOps / SRE): המגן הנאמן של הממלכה. אתם בונים את המבצרים, מנהלים את קווי האספקה של החשמל ומוודאים שהמערכת כולה יכולה לעמוד בפני המתקפות הבלתי נמנעות של הסטטיק. החוזק שלכם הוא הבסיס שעליו נבנה הניצחון של הקבוצה.
המשימה שלך
האימון יתחיל כתרגיל עצמאי. תלכו בנתיב שבחרתם ותלמדו את הכישורים הייחודיים שנדרשים כדי לשלוט בתפקיד. בסוף תקופת הניסיון, תתמודדו עם רוח רפאים שנולדה מתוך הסטטיות – מיני-בוס שטורף את האתגרים הספציפיים של המלאכה שלכם.
רק אם תהיו מומחים בתפקיד שלכם, תוכלו להתכונן למבחן הסופי. לאחר מכן, תצטרכו להקים קבוצה עם אלופים מהכיתות האחרות. יחד, תצאו למסע אל לב השחיתות כדי להתמודד עם הבוס האחרון.
אתגר אחרון ושיתופי שיבחן את הכוח המשולב שלכם ויקבע את גורל ה-Agentverse.
הגיבורים של Agentverse מחכים לכם. תענו לשיחה?
2. The Shadowblade's Codex
הקודקס של Shadowblade פתוח לפניך. עונים לשיחה. הכאוס המתפשט של הסטטיק מאיים על Agentverse, ורק מי שישלוט בטכניקות שמופיעות בקודקס הזה יוכל להילחם בו. זו דרך שדורשת דיוק ומשמעת. היום מתחיל האימון שלך. תלמדו להשתמש ב-AI לא ככלי פשוט, אלא כלהב בעל תבונה שצריך לאלף ולשלוט בו. אם תפעלו לפי ההנחיות במאמר הזה, תוכלו ליצור כלי נשק של לוגיקה טהורה – סוכן חכם, מוכן ומזומן לקרב.
מה תלמדו
- הנשק העיקרי שלכם: Gemini CLI.
- אפשר לשלב כלי MCP עם Gemini CLI כדי לנתח בסיסי קוד לא מוכרים.
- אתם יכולים להשתמש במסמכי עיצוב כדי להעביר את הכוונה שלכם ל-AI Partner וליצור 'אווירה'.
- אתם יכולים ליצור פתרון נקי ומודולרי על ידי בניית סוכן אוטונומי ראשון באמצעות ערכת פיתוח הסוכנים (ADK).
- בניית חבילות של בדיקות אוטומטיות כדי לבדוק ולאמת את הסוכן.
- יצירת צינור CI מלא לבדיקה אוטומטית, להעברה לקונטיינר ולארכיון של הסוכן.
3. הכנת אזור האימונים
👈 לוחצים על 'הפעלת Cloud Shell' בחלק העליון של מסוף Google Cloud (זהו סמל הטרמינל בחלק העליון של חלונית Cloud Shell), 
👈 לוחצים על הלחצן 'פתיחת הכלי לעריכה' (הוא נראה כמו תיקייה פתוחה עם עיפרון). חלון Cloud Shell Code Editor ייפתח. בצד ימין יופיע סייר הקבצים. 
👈פותחים את הטרמינל בסביבת הפיתוח המשולבת (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
👈💻 מריצים את סקריפט ההגדרה מהספרייה של הפרויקט.
⚠️ הערה לגבי מזהה הפרויקט: הסקריפט יציע מזהה פרויקט שנוצר באופן אקראי כברירת מחדל. אפשר להקיש על Enter כדי לאשר את ברירת המחדל.
עם זאת, אם אתם מעדיפים ליצור פרויקט חדש ספציפי, אתם יכולים להקליד את מזהה הפרויקט הרצוי כשתתבקשו לעשות זאת על ידי הסקריפט.
cd ~/agentverse-developer
./init.sh
הסקריפט יטפל בשאר תהליך ההגדרה באופן אוטומטי.
👉 שלב חשוב אחרי השלמת התהליך: אחרי שהסקריפט מסיים לפעול, צריך לוודא שבמסוף Google Cloud מוצג הפרויקט הנכון:
- נכנסים לכתובת console.cloud.google.com.
- לוחצים על התפריט הנפתח לבחירת פרויקט בחלק העליון של הדף.
- לוחצים על הכרטיסייה All (הכל) (כי יכול להיות שהפרויקט החדש עדיין לא יופיע ב-Recent (אחרונים)).
- בוחרים את מזהה הפרויקט שהגדרתם בשלב
init.sh.
👈💻 חוזרים לטרמינל. מגדירים את מזהה הפרויקט הנדרש:
gcloud config set project $(cat ~/project_id.txt) --quiet
👈💻 מריצים את הפקודה הבאה כדי להפעיל את ממשקי ה-API הנדרשים של Google Cloud:
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
אם מוצגת בקשה לעשות זאת, בוחרים באפשרות לא.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 כדי לצאת מ-Gemini CLI
5. ניתוח שדה הקרב: אינטראקציה מעשית של תכנות בשיטת Vibe coding
תרגילי האימון הושלמו. למדתם את העמדות והמכות הבסיסיות של הנשק העיקרי שלכם, Gemini CLI. אבל אי אפשר לשלוט בלהב באמת עד שהוא נבדק בכור ההיתוך של היצירה והותאם לארסנל של המלחמה. לפני שמתמודדים עם האויב האמיתי, צריך קודם לסקור את הסביבה הקרובה ולעצב אותה – שדה הקרב הדיגיטלי.
בפרק הזה נסביר איך עוברים מתיאוריה למעשים. קודם כול, תצטרכו לבסס את הנוכחות שלכם ב-Agentverse על ידי מתן פקודה ל-Gemini blade ליצור את חותם היוצר שלכם – חתימה דיגיטלית בצורה של אתר אישי, שנבנה מאפס על סמך הכוונה שלכם. לאחר מכן, תוכלו להרחיב את היכולות שלכם על ידי הפעלת ארסנל מקומי של כלים מתקדמים – שרת MCP – ולהתאים את הלהב לתדר שלו, וכך תוכלו לבצע תמרונים מורכבים כמו ניהול מאגרי קוד באמצעות פקודות פשוטות וחד-משמעיות.
יצירת חותם ייחודי
לוחם אמיתי מסוג 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 place holder spot for profile picture. Do not attempt to start the server.
Gemini חישב את רצף הפעולות הנדרש.
👈💻 מקישים על Ctrl+C פעמיים כדי לצאת מ-Gemini CLI ומריצים את הפקודה הבאה בטרמינל.*
python -m http.server
👀 כדי לראות את העבודה שלכם, לוחצים על הסמל Web preview (תצוגה מקדימה באינטרנט) בסרגל הכלים של Cloud Shell. בוחרים באפשרות שינוי היציאה, מגדירים אותה ל-8000 ולוחצים על שינוי ותצוגה מקדימה. תופיע תצוגה מקדימה של האתר. 
יכול להיות שהאתר שלכם ייראה שונה משלי. זה הסימן הייחודי שלכם. 
הטכניקה שלך לביצוע החתימה השתפרה, ולא צריך יותר את הסימולציה בזמן אמת. תנו ל-Blade פקודה להפסיק את הפעולה.
👈💻 מקישים על Ctrl+C כדי לצאת משרת ה-HTTP.
הזהות הדיגיטלית שלכם נוצרה, וחשוב מכך, למדתם את החוכמה הקריטית של שימוש בכוח רב בזהירות רבה עוד יותר.
הפעלת הארסנל המקומי: Gitea Armory
הפוטנציאל האמיתי של Shadowblade מתגלה לא רק בזכות הכישורים האישיים שלו, אלא גם בזכות איכות כלי הנשק שלו. עכשיו תפעילו את מתקן הנשק המקומי – שרת Gitea – ותתאימו את הלהב שלכם לכוח שלו. הארסנל הזה מחובר ל-Gemini CLI דרך שרת Model Context Protocol (פרוטוקול הקשר של מודל, MCP), פורטל ייעודי שמאפשר לכלי ה-AI שלכם ליצור אינטראקציה עם כלים ושירותים חיצוניים, וכך הופך את הטרמינל לסביבת עבודה חכמה וממוקדת פעולה.
הערה למפתחים: אפשר לחשוב על שרת MCP כצינור להעברת כוח, פורטל ייעודי שמחבר בין התודעה של ה-AI לבין הגוף של כלי חיצוני. היכולת הזו היא מה שהופכת את Gemini CLI לא רק לממשק שיחה, אלא לסוכן אמיתי שמכוון לפעולה. התאמת הלהב לפורטלים האלה של MCP מעניקה לו את היכולת לבצע פעולות מוחשיות: לנהל קבצים, לשלוח שאילתות למסדי נתונים, ליצור אינטראקציה עם ממשקי API ועוד. קיים אקוסיסטם שלם של פורטלים כאלה, שנוצרו על ידי מפתחים כדי לקשר בין סוכני AI לפלטפורמות חזקות. יש שרתי MCP לאינטראקציה עם מסדי נתונים, לאבטחת קוד ואפילו לתמיכה בתכנות בזוגות. האפשרויות הן רבות, ומאפשרות למפתחים להתאים אישית את סביבת העבודה שלהם לכל פרויקט.
היום נתמקד בשני כוחות בסיסיים שחיוניים לכל 'יוצר אווירה': הכוח לשלוט בנפחייה והכוח ליצור מתוך הדמיון. קודם כל, תתאימו את הלהב לשרת Git, וכך תקבלו שליטה במאגר קוד המקור. לאחר מכן תתחברו לשרת MCP שני כדי ליצור תמונות, ותוכלו ליצור נכסים חזותיים באמצעות פקודה בלבד.
נתחיל בזימון הפריט הראשון והבסיסי ביותר באוסף החדש שלך: הנשקייה עצמה.
👈💻 בטרמינל, מריצים את סקריפט ההפעלה כדי להפעיל את ארגז הכלים:
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, את המראה שלו, וחשוב מכול, את היכולות החיצוניות שהוא יכול להפעיל. הקובץ הזה נמצא בדרך כלל בספריית הבית בכתובת ~/.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 
כדי ליצור את הסמל החסר, צריך להפעיל כוח מסוג אחר – רוח יצירה מ-Vertex AI שיכולה ליצור תמונות ממחשבה טהורה. לשם כך נדרש פורטל MCP נוסף.
👈💻 מקישים פעמיים על Ctrl+C כדי לצאת מ-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 לשמירת התמונות, ומזהה הפרויקט והמיקום לשימוש בממשקי ה-API בענן". הגדרת שרת MCP הזה מאפשרת למעשה ל-Gemini CLI לגשת ליכולות יצירת התמונות של Imagen."
👈💻 נכנסים ל-Gemini ומזינים את פקודת העידון. בטרמינל, מריצים את הפקודה:
clear
cd ~/agentverse-developer/tabletop/
gemini
👈✨ בעזרת פקודה אחת עוצמתית, אתם יכולים להנחות את 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 כבר עשה את זה בשבילכם! כדאי לבדוק את התשובה הקודמת, יכול להיות שהיא מספיק חכמה כדי לעשות את זה לפני שתבקשו ממנה!!!! )
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
👀 כדי לראות את העבודה שלכם, לוחצים על הסמל Web preview (תצוגה מקדימה באינטרנט) בסרגל הכלים של Cloud Shell. בוחרים באפשרות שינוי היציאה, מגדירים אותה ל-8000 ולוחצים על שינוי ותצוגה מקדימה. תופיע תצוגה מקדימה של האתר. 
👉✨ בחזרה במסוף שבו פועל Gemini CLI, מבצעים קומיט לתיקון, מציינים שהמשימה הושלמה וסוגרים את הבעיה שפתחתם ברשומות של מאגר הנשקים.
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 פעמיים כדי לצאת מ-Gemini CLI.
👀 כדי לראות את העבודה שלכם, לוחצים על הסמל Web preview (תצוגה מקדימה באינטרנט) בסרגל הכלים של Cloud Shell. בוחרים באפשרות שינוי יציאה, מגדירים אותה לערך 3005 ולוחצים על שינוי ותצוגה מקדימה. תופיע תצוגה מקדימה של האתר. 
👈💻 במסוף שבו פועל שרת ה-HTTP,מקישים על Ctrl+C כדי לצאת משרת ה-HTTP.
למי שלא משחק
6. הרכבת סוכן Shadowblade: קוד Vibe עם הגבלות
הגיע הזמן לתרגל. ההד של הפלדה על האבן דועך. השתלטתם על הנשק הראשי והכנתם את הארסנל למלחמה. עכשיו, תעברו את המבחן האמיתי של Shadowblade: הרכבת הלוחם עצמו. זוהי אומנות של הוספת חיים ללוגיקה, באמצעות תוכנית קדושה מתוך הקודקס כדי לבנות את ליבת האינטליגנציה של סוכן – יצירת משתמש בעל תבונה בלהבים בארסנל שלכם שיכול לחשוב, להסיק מסקנות ולפעול באופן עצמאי.
המשימה הראשונה היא להיכנס לסדנה קיימת – בסיס קוד מוכן מראש – וליצור ממנה את האלוף שלכם.
The Assembly Ritual
לפני הניצוץ הראשון בכבשן, טכנאי מומחה בודק את בית המלאכה שלו, ומבין כל כלי וכל תרשים. כשנכנסים לשדה קרב לא מוכר כמו בסיס קוד גדול וקיים, העדיפות הראשונה היא לבצע סיור מקדים. חשוב להבין את המצב הקיים – הארכיטקטורה הקיימת, המטרות הסופיות והפרוטוקולים של ההתקשרות. רק אם תכירו את התוכניות של המבצר ואת הסטנדרטים שלו, תוכלו לתרום את הכישורים שלכם בצורה יעילה.
Gemini CLI, הסייר שתמיד זמין, יכול לעזור לכם בסיור הזה:
- לספק סיכומים ברמה גבוהה: הוא יכול לקרוא את כל הקודקס (או בסיס הקוד) ולתת לכם במהירות הבנה של המטרה והרכיבים העיקריים שלו.
- עזרה בהגדרת הסביבה: הוא יכול להדריך אתכם בתהליכי ההתקנה של כלים ובהגדרת המחשב.
- ניווט בבסיסי קוד: הוא יכול לשמש כמדריך שיעזור לכם לחקור לוגיקה מורכבת ולמצוא קטעים נסתרים בקוד.
- יצירת מסמכי הדרכה: הוא יכול ליצור מסמכים מותאמים אישית שמסבירים את המטרות, התפקידים והמשאבים של בעלי ברית חדשים שמצטרפים למטרה שלכם.
- אוטומציה של למידה ושאלות ותשובות: הוא הופך להיות חוקר אישי, עונה על שאלות לגבי תכונות או התנהגות של קוד, ומאפשר לכם להילחם באופן עצמאי יותר.
👈💻 במסוף הראשון, עוברים לספרייה shadowblade ומזמנים את שותף ה-AI:
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/shadowblade
clear
gemini
👈✨ עכשיו, תן פקודה לסייר לסרוק את שדה הקרב ולדווח על הממצאים.
Analyze the entire project and provide a high-level summary.
אחרי שמיפיתם את השטח הקיים, אתם צריכים לעיין בתוכנית הבנייה כדי להבין מה אתם עומדים לבנות. הפעולות הכי יעילות לא מאולתרות, אלא מבוססות על תכנון מדויק.
הערה למפתחים: מסמך התכנון הזה משמש כתוכנית הראשית של הפרויקט. המטרה היא להבהיר את היעדים וההטמעה הטכנית לפני שמשקיעים מאמץ פיתוח משמעותי. תכנית מוגדרת היטב מבטיחה שכל המפתחים יפעלו בהתאם, מצמצמת את הסיכון לעבודה חוזרת ועוזרת למנוע חוב טכני והתרחבות של היקף הפרויקט. זהו הכלי העיקרי לשמירה על מהירות הפרויקט ואיכות הקוד, במיוחד כשהצוות גדל או כשמצטרפים אליו חברים חדשים.
מטרה חשובה של המסמך הזה היא להגדיר לא רק את התרחיש הרגיל, אלא גם את המקרים הקיצוניים ואת מצבי הכשל, במיוחד כשמשתמשים במודלים גדולים של שפה. הניסיון שלי עם מודלים מסוג LLM הוא מצוין בכל הנוגע ליצירת קוד אופטימי שבו כל נתוני הקלט תקינים וכל הקריאות החיצוניות מצליחות. כדי ליצור תוכנה חזקה ומוכנה לייצור, אנחנו צריכים להנחות את ה-AI באופן מפורש על ידי הגדרת תוכניות מגירה לתרחישים כמו:
- ארגומנטים לא חוקיים או שגויים הועברו לפונקציה.
- קריאות ל-API נכשלות, פסק זמן ברשת או קודי שגיאה לא צפויים משירותים חיצוניים.
- טיפול במבני נתונים ריקים או עם ערך null במקומות שבהם צפויים נתונים.
- מרוץ תהליכים או בעיות של פעולות מקבילות.
על ידי ציון ההתנהגות הצפויה למקרים האלה בתכנון, אנחנו מנחים את מודל ה-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.
עכשיו יש לכם את התוכנית. אבל לפני שיוצרים שורת קוד אחת, אומן מומחה קובע את חוקי הנפחייה. הכול עניין של משמעת ויכולת התאמה לעומס. הנחיות התכנות הן לא סתם הצעות, אלא רונות של כוח שמבטיחות שכל רכיב ייבנה באותה רמת דיוק ועוצמה. הן מונעות את הכאוס של סגנון אישי שעלול לפגום ביצירה הסופית, ומבטיחות שהסוכן יהיה גמיש, ניתן לתחזוקה וטהור, כך שאומנים חדשים יוכלו להצטרף לפרויקט בלי לשבש את ההרמוניה של השלם.
כדי להטמיע את החוקים האלה ישירות בתודעה של שותף ה-AI שלנו, אנחנו משתמשים בארטיפקט מיוחד: קובץ GEMINI.md. כשמפעילים את Gemini CLI, הוא מחפש את הקובץ הזה באופן אוטומטי וטוען את התוכן שלו לזיכרון העבודה של ה-AI. היא הופכת להוראה קבועה ברמת הפרויקט. קמע שלוחש כל הזמן ל-AI את הכללים של הנפחייה.
בואו נחרט את הרונות האלה עכשיו.
👉💻 כדי לצאת מ-Gemini לרגע, לוחצים פעמיים על Ctrl+C.
👈💻 בטרמינל, מריצים את הפקודה הבאה כדי לכתוב את קובץ ההנחיות.
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
זה הרגע המכריע. תספק את הסכימה (agent_design.md) ואת חוקי הנפחייה (GEMINI.md), ותטיל את לחש היצירה הגדול.
👈✨ זוהי הפקודה היחידה והעוצמתית שתבנה את הסוכן. אני רוצה להנפיק אותו עכשיו:
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 ליצור שבעה כלי נשק חדשים לארסנל. מזינים את ההנחיה הבאה ב-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() נוספו בהצלחה. בודקים את הפונקציה hone_refactoring_sickle. האם יש לו את מחרוזת התיעוד הנכונה ואת נתוני הנשק הנכונים? אימות העבודה של ה-AI הוא הרגל חיוני של ה-Shadowblade המומחה.
אחרי שהסוכן נוצר ועבר שיפורים, הגיע הזמן להפעיל אותו.
👈💻 מקישים פעמיים על Ctrl+C כדי לצאת מ-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. ההרכבה הושלמה.
למי שלא משחק
7. Wards of Purity: Evaluating the agents
נציג שהורכב הוא לא נציג מוכח. להב לא בדוק הוא נטל, אבל סוכן AI לא בדוק הוא סכנה גדולה בהרבה – גורם בלתי צפוי שעלול לשבש את המשימה שלכם מבפנים. זו לא ספקולציה בלבד, אלא עיקרון בסיסי שכל Shadowblade חייב להבין.
הערכת סוכני AI היא חשובה מאוד ומאתגרת במיוחד. בניגוד לתסריט פשוט, סוכן הוא שילוב דינמי של הקוד שלכם והיכולת של מודל LLM לבצע משימות מורכבות שכוללות כמה שלבים. ההתנהגות שלהם היא אקראית. המשמעות היא שצריך להעריך לא רק את איכות הפלט הסופי, אלא גם את היעילות והדיוק של המסלול הפנימי שלו. הנתיב שבו עבר כדי להגיע לשם. האם הוא השתמש בכלים הנכונים? האם נוצרו יותר מדי טוקנים? האם שינוי בגרסת המודל גרם לרגרסיה קלה של זמן האחזור? חשוב מאוד לזהות את השיבוש הזה – רגרסיות בחביון, בעלות או באיכות הפלט – כשמבצעים כל שינוי, החל משינוי פשוט בהנחיה ועד לשיפוץ ארכיטקטוני משמעותי, לפני שהשינוי עלול לפגוע בסביבת הייצור.
הגישה הכללית להערכה הזו כוללת טקס קדוש:
- קודם כל, מגדירים "מערך נתונים מושלם". קבוצה של גלילות שמכילות דוגמאות לקלט ולפלט או להתנהגויות הצפויות שלהן. התשובות יכולות לכלול תשובות סופיות, שימוש נכון בכלי או אפילו מסלולים שלמים של שלבים.
- בשלב הבא מגדירים את הלוגיקה של האפליקציה של הסוכן, שהיא הליבה של הישות שלו.
- לבסוף, מגדירים בודקים, שהם כמו רונות של שיפוט. הם יכולים להיות מודלים גדולים של שפה אחרים שפועלים כשופטים של איכות, קוד היוריסטי מדויק שמאמת שלב אחד או פונקציות מותאמות אישית שמנתחות את כל תהליך החשיבה של הסוכן.
ערכת פיתוח הסוכנים (ADK) של Google היא ערכת הכלים של הנשקייה שמוענקת למובילים בדיוק למטרה הזו. היא מאפשרת את ההערכה המורכבת הזו בכמה שיטות:
- מאגר לחיזוי עתידות מבוסס-אינטרנט (
adk web) להערכה אינטראקטיבית - הרצה משורת הפקודה (
adk eval) להרצת סוכן באמצעות רשימת בדיקות מוגדרת מראש. - שילוב פרוגרמטי דרך
pytestלהוספת מילות קסם קבועות
ה-ADK תומך בשתי גישות עיקריות: 'קובצי בדיקה' פשוטים לאינטראקציות נפרדות בין סוכן למודל (דו-קרב יחיד), ו'ערכות הערכה' מקיפות למספר סשנים ארוכים פוטנציאלית עם כמה תורות (קרב המוני). הם יכולים למדוד מדדים מורכבים כמו tool_trajectory_avg_score, שמשווה בין השימוש בפועל בכלי של סוכן לבין הנתיב האידיאלי, כדי לוודא שהוא פועל בטכניקה מושלמת.
עכשיו, אחרי שהבנתם את התיאוריה, הגיע הזמן ליישם אותה בפועל. בתור Shadowblade, תכתבו Wards of Purity. אלה לא רק בדיקות, אלא טקסים שמבוססים על ADK ונועדו לוודא שהלוגיקה של הנציג מושלמת וההתנהגות שלו אמיתית.
בשלב הזה, מומלץ מאוד להשתמש ב-2 טרמינלים – אחד ל-Gemini CLI ואחד להרצת הבדיקה, כי יכול להיות שתצטרכו לצאת מספריית העבודה הנוכחית (ADK)
האתגר של שיטת הבידינג (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, כאשר כל מקרה הוא ניסיון ייחודי של הסוכן. בכל ניסיון, מערך השיחות מתעד אינטראקציה אחת מלאה. למטרה שלנו, יש חשיבות קריטית לשלושה רונות:
- user_content: זהו האתגר. זו ההנחיה שאתם נותנים לסוכן, המפלצת שהוא צריך להתמודד איתה.
- final_response: התוצאה הצפויה. זוהי מחרוזת הטקסט המדויקת שאתם מצפים שהנציג יגיד בסיום המשימה. ה-ADK משווה את המילים הסופיות בפועל של הסוכן לרונה הזו כדי להעריך את רמת הרהיטות שלו.
- intermediate_data.tool_uses: זוהי טכניקת ה-Arcane. עבור סוכן אמיתי, זוהי הרונה החשובה ביותר מכולן. ההגדרה הזו לא קובעת מה הסוכן אומר, אלא מה הוא עושה. הוא מתעד את שם הכלי (enchant_soulshard_dagger) שאתם מצפים שהסוכן ישתמש בו. כך אפשר לוודא שהסוכן הוא לא רק מנהל שיחה חכם, אלא גם גורם מכריע שמבצע את הפעולה הנכונה.
אחרי שהבנתם את התוכנית, תתנו ל-Gemini פקודה לכתוב גרסה חדשה ומורכבת יותר של המגילה הזו.
👈💻 בטרמינל, מזינים את ספריית shadowblade ומפעילים את Gemini CLI:
clear
cd ~/agentverse-developer/shadowblade/
gemini
👈✨ מריצים פקודה ב-Gemini CLI כדי להגדיר אותו ככותב של בדיקות בקרת איכות, וליצור סדרה של תרחישי בדיקה שמגדירים את ההתנהגות הצפויה של הסוכן.
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.
👉💻 כדי לצאת מ-Gemini CLI, לוחצים פעמיים על Ctrl+C.
הכללים של שיקול הדעת
אין משמעות לקרב ללא כללים לניצחון. לפני שמריצים את תקופת הניסיון, צריך לבדוק את מגילת המשפט – הקובץ test_config.json. הגלילה הזו מציינת ל-ADK איך לשפוט את הביצועים של הסוכן.
👀 בסייר הקבצים, פותחים את ~/agentverse-developer/shadowblade/test_config.json. יוצגו לכם הרונות הבאים:
{
"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)
במסגרת Gauntlet נבדקה אסטרטגיה רחבה. הלחש השני, Shield of Clarity (מגן הבהירות), בודק את המשמעת וההתנהגויות הספציפיות. הכול קשור לאוטומציה. adk eval הוא כלי מצוין לבדיקות ידניות, אבל המגן pytest הוא אמצעי הגנה שכתוב בקוד. זה חשוב במיוחד כי אפשר לשלב צינור אוטומטי לעיבוד נתונים עם בדיקה שאפשר להריץ כקוד. המטרה הסופית היא ליצור מערכת לבדיקת פריסה (CI/CD) שבה אמצעי ההגנה שלנו מופעלים באופן אוטומטי בכל פעם שמבוצע שינוי, כדי למנוע באגים ונסיגות לפני שהם עלולים לפגוע בסביבת הייצור.
👈💻 במסוף,מזמנים שוב את Gemini מתוך ספריית shadowblade:
. ~/agentverse-developer/set_env.sh
cd ~/agentverse-developer/
clear
gemini
👉✨ כדי להטביע את הלוגיקה של Shield בקובץ pytest, משתמשים בהנחיה הבאה ב-Gemini CLI:
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.
אחרי שכותבים את הרונות של המגן השני, יוצאים מ-Gemini CLI.
👉💻 לוחצים על Ctrl+C פעמיים.
👀 בסייר הקבצים, פותחים את המגילה שביקשתם מ-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 הזה הוא אתם, הקוסמים, שמטילים את הלחש הבסיסי בעצמכם. כלי שורת הפקודה הוא פשוט עטיפה נוחה סביב אותה ספריית ליבה 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 בפלט של היומן. אם השגיאה הזו מופיעה, פשוט מחכים דקה או שתיים עד שהמכסה מתאפס, ואז מריצים שוב את הפקודה pytest.
אחרי שגם ה-Gauntlet הרחב וגם ה-Shield המדויק נכתבו ואומתו, הנציג שלכם לא רק מתפקד – הוא טהור, נבדק ומוכן לפריסה.
למי שלא משחק
8. הפעלת Blade ב-Agentverse: CI ופריסה.
הנציג שלך הורכב והיושרה שלו אומתה על ידי שומרי הטוהר. אבל אם לא מקפידים על תחזוקה שוטפת של השמירה, היא הופכת לשריד נשכח. כדי לוודא שכל גרסה עתידית של הסוכן תישאר טהורה, צריך לבנות את השלב הראשון של תהליך ההפצה – טקס אוטומטי שמבטיח איכות ומהירות.
התפקיד הקדוש שלכם כ-Shadowblade הוא אינטגרציה רציפה (CI). זוהי המערכת האוטומטית של הנפחייה ושל שדה הניסויים. היא ההגנה האולטימטיבית שלכם מפני שחיתות וטעויות אנוש. הטקס הזה מבטיח שבכל פעם שאתם או בעל ברית תורמים טכניקה חדשה (מיזוג קוד) לקודקס המרכזי (המאגר שלכם), הכפפה מתעוררת באופן אוטומטי. הוא קודם יוצר את הסוכן מהקוד החדש ואז מעביר אותו מיד את תהליך הניקוי שיצרתם. אם אחת מההגנות נכשלת, הטקס נעצר והחפץ הפגום נדחה באופן מיידי, וכך נמנעת האפשרות שהוא יגרום נזק לארסנל. הדומיין הוא הנפחייה, וצינור ה-CI מבטיח שרק ארטיפקטים מושלמים ומוכנים לקרב יוצאים מהסדנה.
אחרי שמוכיחים שארטיפקט ראוי באמצעות בדיקות CI, מתחיל השלב השני של התהליך: פריסה רציפה (CD). זהו הדומיין של The Guardian. התפקיד שלהם הוא לקחת את הארטיפקט המושלם שלכם, שנמצא בתוך קונטיינר, ולשחרר אותו בבטחה אל Agentverse הפעיל, תוך ניהול הכוח שלו והבטחת היציבות שלו מול הכאוס של The Static.
במדריך הזה תלמדו איך לשלוט בתפקיד שלכם. תבנו את החלק של ה-CI ב-gauntlet. תבנו את הנפחייה האוטומטית שתבדוק את הנציג ותארוז את התוצאה הטהורה במאגר, כדי להכין אותה לאישור הסופי של The Guardian.
עכשיו נשתמש ב-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.
לצאת מ-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 Cloud, בדף Google Build, בזמן שהטקס האוטומטי מבצע כל שלב. קודם יופעלו הבדיקות, ואם הן יצליחו, ייווצר מאגר התגים של הנציג והוא יישמר.
הסוכן עבר את המבחן. פריט מאומת וטהור נמצא עכשיו באוסף שלכם. הפעולה הסופית היא בהוראתך. בעזרת קסם אחד, תוכלו לזמן את הארטיפקט הזה מהמאגר ולהפיח בו חיים כשירות ציבורי ב-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. הטקסים של הקודקס הושלמו. הגיע הזמן להוכיח את יכולותיה. ממתין לכם אתגר בדמות רוח רפאים, שנולדה מהכאוס שאתם למדתם לביית. מתכוננים למשפט האחרון.
למי שלא משחק
9. הקרב נגד הבוס
הקריאה במגילות הסתיימה, הטקסים בוצעו והמשימה הושלמה. הסוכן שלכם הוא לא רק פריט שמאוחסן; הוא סוכן מוביל שנוצר באמצעות קוד, שומר פעיל ב-Agentverse שמחכה לפקודה הראשונה שלו. הגיע הזמן להוכיח את יכולותיו בכור ההיתוך של הקרב.
תעברו עכשיו לסימולציה של ירי חי כדי להפגיש את Shadowblade החדש שלכם עם Spectre אימתני – גילום של הכאוס שפוגע בכל היצירה. זו הבדיקה הסופית של העבודה שלכם, החל מהלוגיקה הבסיסית של הנציג ועד לפריסה ללא רבב שלו.
איך מקבלים את המיקום של הנציג
כדי להיכנס לזירת הקרב, צריך להחזיק בשני מפתחות: החתימה הייחודית של הדמות (Agent Locus) והנתיב הנסתר למאורה של Spectre (כתובת ה-URL של הצינוק).
👉💻 קודם צריך לקבל את הכתובת הייחודית של הנציג ב-Agentverse – המיקום שלו. זוהי נקודת הקצה הפעילה שמחברת את הדמות שלכם לזירת הקרב.
. ~/agentverse-developer/set_env.sh
echo https://shadowblade-agent-${PROJECT_NUMBER}.${REGION}.run.app
👈💻 לאחר מכן, מציינים את היעד. הפקודה הזו חושפת את המיקום של מעגל ההעתקה, הפורטל אל הדומיין של ספקטר.
. ~/agentverse-developer/set_env.sh
echo https://agentverse-dungeon-${PROJECT_NUMBER}.${REGION}.run.app
חשוב: צריך להכין את שתי כתובות ה-URL האלה. תצטרכו אותם בשלב האחרון.
התמודדות עם פרצת Spectre
אחרי שרושמים את הקואורדינטות, מנווטים אל Translocation Circle ומטילים את הכישוף כדי לצאת לקרב.
👈 פותחים את כתובת ה-URL של מעגל ההעברה בדפדפן כדי לעמוד מול הפורטל הנוצץ אל The Crimson Keep.
כדי לפרוץ את המבצר, צריך להתאים את מהות ה-Shadowblade לפורטל.
- בדף, מחפשים את שדה הקלט של הכתובת ברונות עם התווית A2A Endpoint URL (כתובת נקודת הקצה של A2A).
- כדי להוסיף את הסמל של הדמות האהובה, מדביקים את כתובת ה-URL של מיקום הסוכן (כתובת ה-URL הראשונה שהעתקתם) בשדה הזה.
- לוחצים על 'חיבור' כדי להפעיל את הקסם של הטלפורטציה.
האור המסנוור של הטלפורטציה דועך. אתם כבר לא במקדש. האוויר רוטט מאנרגיה, קרה וחדה. לפניכם, רוח הרפאים מתממשת – מערבולת של רעשי רקע וקוד פגום, והאור הטמא שלה מטיל צללים ארוכים ורוקדים על רצפת הצינוק. אין לו פנים, אבל אתם מרגישים את הנוכחות העצומה והמתישה שלו, שמתמקדת רק בכם.
הדרך היחידה שלכם לניצחון היא הבהירות של האמונה שלכם. זהו דו-קרב של רצונות, שנערך בשדה הקרב של המוח.
כשאתם מסתערים קדימה, מוכנים לשחרר את המתקפה הראשונה, ה-Spectre מגיב. היא לא מרימה מגן, אלא מקרינה שאלה ישירות לתודעה שלכם – אתגר מנצנץ עם כתב רוני, שנלקח מליבת האימונים שלכם.
זה אופי המאבק. הידע שלך הוא הנשק שלך.
- ענה על השאלה מתוך הידע שצברת, והלהב שלך יתלקח באנרגיה טהורה, ינפץ את ההגנה של הרוח וינחית מכה קריטית.
- אבל אם תהססו, אם ספק יעיב על התשובה שלכם, האור של הנשק ידעך. המכה תנחת עם חבטה עלובה, ותגרום רק לשבריר מהנזק שלה. יותר גרוע מכך, הספקטר יתחזק מהספקות שלכם, והכוח המשחית שלו יגדל עם כל טעות שתעשו.
זהו, אלופה. הקוד הוא ספר הלחשים, הלוגיקה היא החרב והידע הוא המגן שיעצור את גל הכאוס.
מיקוד. פוגעים במטרה. הגורל של Agentverse תלוי בזה.
מזל טוב, Shadowblade.
סיימת בהצלחה את הקודקס. יצרתם 'אווירה', תרגמתם אותה לעיצוב והשתמשתם ב-Gemini CLI כדי להרכיב סוכן חכם. הטמעתם את הכישוף Wards of Purity כדי לבדוק את הלוגיקה שלו, בנייתם כפפה אוטומטית כדי לזייף אותו לחפץ, ושיחררתם אותו ל-Agentverse. לבסוף, אימתתם את המטרה שלו בניסוי חי. השתלטתם על תהליך העבודה המלא של סוכנים ואתם מוכנים לכל אתגר שיוצג לכם ב-Agentverse.
10. ניקוי: השבתת Agentverse
כל הכבוד על השלמת המדריך Shadowblade's Codex! כדי לוודא ש-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. הפרויקט שלכם נקי, ואתם מוכנים להרפתקה הבאה.