דף זה תורגם על ידי Cloud Translation API.

איך בונים עוזר לתכנות באמצעות Gemini CLI, ‏ MCP ו-Go

1. מבוא

ב-codelab הזה תלמדו איך ליצור ולפרוס שרת Model Context Protocol ‏ (MCP) כדי להרחיב את היכולות של Gemini CLI. תבנו את godoctor, שרת מבוסס-Go שמספק כלים בהתאמה אישית לפיתוח ב-Go, והופך את Gemini CLI מעוזר תכנות למטרות כלליות למומחה לפיתוח ב-Go.

ב-codelab הזה נעשה שימוש בגישה מבוססת-הנחיות. אתה פועל כראש צוות טכני ומספק הנחיות לעוזר ה-AI שלך (Gemini CLI עצמו). המטרה שלכם היא ללמוד איך לתרגם דרישות של פרויקט להנחיות אפקטיביות, ולאפשר ל-AI לטפל בפרטי ההטמעה.

בבסיס הפרויקט הזה נמצא Model Context Protocol ‏ (MCP). פרוטוקול MCP הוא פרוטוקול קוד פתוח שמגדיר תקן לאופן שבו מודלים גדולים של שפה (LLM) כמו Gemini מתקשרים עם כלים ושירותים חיצוניים. היא משמשת כגשר ומאפשרת ל-AI לגשת למידע מהעולם האמיתי ולבצע פעולות מעבר לידע המובנה שלה. כשבונים שרת MCP, יוצרים תוסף בהתאמה אישית ש-Gemini CLI יכול לגלות ולהשתמש בו, וכך ללמד אותו מיומנויות חדשות.

מה תלמדו

איך מתקינים ומגדירים את Gemini CLI
איך לנסח הנחיות יעילות כדי להנחות עוזר AI בפיתוח תוכנה
איך מספקים הקשר והנחיות לעוזר מבוסס-AI
איך ליצור ולהגדיר שרת MCP כדי להרחיב את היכולות של Gemini CLI
איך ליצור קונטיינר לאפליקציית Go ולפרוס אותה ב-Google Cloud Run

מה נדרש

אפשר להשתתף בסדנה הזו באופן מלא ב-Google Cloud Shell, שבו מותקנים מראש כל יחסי התלות הנדרשים (gcloud CLI, ‏ Go, ‏ Docker, ‏ Gemini CLI).

לחלופין, אם אתם מעדיפים לעבוד במחשב שלכם, תצטרכו את הדברים הבאים:

‫Node.js 20 ואילך
פרויקט ב-Google Cloud שהחיוב בו מופעל
‫Google Cloud SDK‏ (gcloud CLI) מותקן ומופעל
‫Go בגרסה 1.24 ואילך מותקנת במערכת
‫Docker מותקן במערכת

טכנולוגיות מרכזיות

מידע נוסף על הטכנולוגיות שבהן נשתמש זמין כאן:

‫Gemini CLI: ממשק שורת הפקודה מבוסס-AI שאנחנו נרחיב
Model Context Protocol (MCP): פרוטוקול קוד פתוח שמאפשר ל-Gemini CLI לתקשר עם הכלי המותאם אישית שלנו
‫Go SDK for MCP: ספריית Go שבה נשתמש כדי להטמיע את שרת ה-MCP שלנו

טיפים לשימוש מוצלח ב-Codelab

עבודה עם עוזר מבוסס-AI היא דרך חדשה לפתח תוכנה. הנה כמה טיפים שיעזרו לכם ליהנות מחוויה חלקה ומוצלחת:

אל תחששו להקיש על ESC. לפעמים ה-AI יציע פעולות או קוד שלא תסכימו איתם. אפשר להשתמש במקש ESC כדי לבטל את הפעולה המוצעת ולספק הנחיה חדשה שתכוון אותו לכיוון הנכון. אתם משתתפים בתוכנית הפיילוט.
מעודדים את השימוש בכלים. אם נראה שה-AI לא מבין את ההקשר או שהוא ממציא מידע, כדאי לעודד אותו להשתמש בכלים הזמינים שלו. הנחיות כמו "תשתמש בחיפוש Google כדי לאמת את זה" או "תשתמש בכלי read_file כדי להבין את הקוד הנוכחי לפני שתבצע שינויים" יכולות להיות יעילות מאוד.
לא לבצע שינויים ידניים. כדאי לנסות שה-AI יבצע את כל העבודה. זו המיומנות העיקרית שאתם מתרגלים. עם זאת, אם אתם חייבים לבצע שינוי ידני, חשוב לספר על כך ל-AI אחר כך. הנחיה כמו "עדכנתי ידנית את הקובץ README.md. כדי לוודא שה-AI יישאר מסונכרן עם הפרויקט, אפשר להוסיף את ההנחיה הבאה: "עליך לקרוא את המסמך שוב כדי לרענן את הידע שלך".
ניסית לכבות את המחשב ולהדליק אותו מחדש? במקרים נדירים, יכול להיות שה-AI מנסה לכפות נתיב מסוים בניגוד לפקודה שלכם. זה יכול לקרות בגלל הידרדרות ההקשר (לפעמים נקראת גם "התיישנות ההקשר"). במקרה כזה, אפשר להשתמש בפקודה ‎/compress ב-Gemini CLI כדי לצמצם את הרעש בהקשר, או במקרים קיצוניים, אפשר להשתמש בפקודה ‎/clear כדי לנקות את כל היסטוריית השיחות.

2. הגדרת הסביבה

הגדרת סביבה בקצב אישי

נכנסים ל-Google Cloud Console ויוצרים פרויקט חדש או משתמשים בפרויקט קיים. אם עדיין אין לכם חשבון Gmail או חשבון Google Workspace, אתם צריכים ליצור חשבון.

שם הפרויקט הוא השם המוצג למשתתפים בפרויקט. זו מחרוזת תווים שלא נמצאת בשימוש ב-Google APIs. תמיד אפשר לעדכן את המיקום.
מזהה הפרויקט הוא ייחודי לכל הפרויקטים ב-Google Cloud, והוא קבוע (אי אפשר לשנות אותו אחרי שהוא מוגדר). מסוף Cloud יוצר באופן אוטומטי מחרוזת ייחודית. בדרך כלל לא צריך לדעת מה היא. ברוב המדריכים לתכנות תצטרכו להפנות למזהה הפרויקט (בדרך כלל מסומן כ-PROJECT_ID). אם לא אהבתם את המזהה שנוצר, תוכלו ליצור מזהה אקראי אחר. אפשר גם לנסות שם משתמש משלכם ולבדוק אם הוא זמין. אי אפשר לשנות את ההגדרה הזו אחרי השלב הזה, והיא נשארת לאורך הפרויקט.
לידיעתכם, יש ערך שלישי, מספר פרויקט, שחלק מממשקי ה-API משתמשים בו. במאמרי העזרה מפורט מידע נוסף על שלושת הערכים האלה.

בשלב הבא, תצטרכו להפעיל את החיוב במסוף Cloud כדי להשתמש במשאבי Cloud או בממשקי API של Cloud. השלמת ה-codelab הזה לא תעלה לכם הרבה, אם בכלל. כדי להשבית את המשאבים ולמנוע חיובים נוספים אחרי שתסיימו את המדריך הזה, תוכלו למחוק את המשאבים שיצרתם או למחוק את הפרויקט. משתמשים חדשים ב-Google Cloud זכאים לתוכנית תקופת ניסיון בחינם בשווי 300$.

הפעלת Cloud Shell

אפשר להפעיל את Google Cloud מרחוק מהמחשב הנייד, אבל ב-codelab הזה תשתמשו ב-Google Cloud Shell, סביבת שורת פקודה שפועלת בענן.

ב-Google Cloud Console, לוחצים על סמל Cloud Shell בסרגל הכלים שבפינה הימנית העליונה:

יחלפו כמה רגעים עד שההקצאה והחיבור לסביבת העבודה יושלמו. בסיום התהליך, אמור להופיע משהו כזה:

המכונה הווירטואלית הזו כוללת את כל הכלים הדרושים למפתחים. יש בה ספריית בית בנפח מתמיד של 5GB והיא פועלת ב-Google Cloud, מה שמשפר מאוד את הביצועים והאימות ברשת. אפשר לבצע את כל העבודה ב-codelab הזה בדפדפן. לא צריך להתקין שום דבר.

3. איך מתחילים להשתמש ב-Gemini CLI

בקטע הזה תלמדו על Gemini CLI, כולל איך להתקין אותו ולהגדיר אותו לסביבה שלכם.

מה זה Gemini CLI?

ממשק שורת הפקודה של Gemini הוא ממשק מבוסס-AI שיכול לעזור לכם במגוון רחב של משימות פיתוח. הוא יכול להבין את ההקשר של הפרויקט, לענות על שאלות, ליצור קוד ולהשתמש בכלים חיצוניים כדי להרחיב את היכולות שלו.

התקנה

מתקינים את Gemini CLI באופן גלובלי באמצעות npm.

npm install -g @google/gemini-cli

כדי לוודא שה-CLI מותקן, מריצים את הפקודה:

gemini --version

תצורה

ההתנהגות של Gemini CLI נשלטת על ידי קובצי הגדרה ומשתני סביבה. יש שני קובצי מפתח:

‫GEMINI.md: הקובץ הזה מספק לאינטליגנציה המלאכותית הנחיות והקשר בשפה טבעית. ממשק ה-CLI קורא את הקובץ הזה כדי להבין את הסטנדרטים והמוסכמות של הקידוד בפרויקט.
‫.gemini/settings.json: הקובץ הזה שולט בהגדרות של ה-CLI, כולל איך להתחבר לכלים חיצוניים. נשתמש בקובץ הזה כדי להגדיר את ה-CLI כך שישתמש בשרת ה-MCP שאנחנו בונים בשיעור ה-Lab הזה.

קודם נגדיר את הסביבה ואז ניצור את הקובץ GEMINI.md. הגדרת הקובץ settings.json תתבצע בשלב מאוחר יותר.

יוצרים ומפעילים ספריית פרויקט:

mkdir godoctor
cd godoctor
go mod init godoctor

אימות באמצעות Application Default Credentials של Google Cloud:

צריך להתחבר לחשבון שיש לו גישה לפרויקט Google Cloud Platform שבו תשתמשו בסדנת התכנות הזו:

מוודאים שהתקנתם ואתחלתם את Google Cloud SDK.
מריצים את הפקודה הבאה כדי להגדיר Application Default Credentials:

gcloud auth application-default login

4. הנחיות פיתוח

כדי לוודא שעוזר ה-AI יוצר קוד Go איכותי ואידיומטי, חשוב לספק לו הנחיות ברורות. הפעולה הזו מתבצעת בקובץ GEMINI.md.

המטרה: ליצור קובץ GEMINI.md שישמש כקבוצת הכללים של העוזר הדיגיטלי מבוסס-AI במהלך הפרויקט הזה.

משימה: יוצרים קובץ בשם GEMINI.md בתיקיית השורש של godoctor ומדביקים בו את התוכן הבא.

# Go Development Guidelines
All code contributed to this project must adhere to the following principles.

### 1. Formatting
All Go code **must** be formatted with `gofmt` before being submitted.

### 2. Naming Conventions
- **Packages:** Use short, concise, all-lowercase names.
- **Variables, Functions, and Methods:** Use `camelCase` for unexported identifiers and `PascalCase` for exported identifiers.
- **Interfaces:** Name interfaces for what they do (e.g., `io.Reader`), not with a prefix like `I`.

### 3. Error Handling
- Errors are values. Do not discard them.
- Handle errors explicitly using the `if err != nil` pattern.
- Provide context to errors using `fmt.Errorf("context: %w", err)`.

### 4. Simplicity and Clarity
- "Clear is better than clever." Write code that is easy to understand.
- Avoid unnecessary complexity and abstractions.
- Prefer returning concrete types, not interfaces.

### 5. Documentation
- All exported identifiers (`PascalCase`) **must** have a doc comment.
- Comments should explain the *why*, not the *what*.

# Agent Guidelines
- **Reading URLs:** ALWAYS read URLs provided by the user. They are not optional.

סביבת הפיתוח שלכם מוגדרת עכשיו באופן מלא.

5. הגרסה הראשונה: שרת godoc

היעד הראשון הוא ליצור את הגרסה הראשונית של שרת godoctor. הגרסה הזו צריכה להיות אפליקציה מינימלית שמוכנה לייצור, שמספקת כלי יחיד בשם godoc שמאפשר לחפש תיעוד של Go.

המטרה: ליצור שרת MCP מוכן לייצור שחושף את הפקודה go doc, כדי לאפשר למודל שפה גדול (LLM) לשלוח שאילתות לתיעוד של Go.

מריצים את הפקודה של Gemini CLI ב-Shell:

gemini

כשמריצים את ה-CLI בפעם הראשונה, תתבקשו לבחור מצב אימות ועיצוב. בקטע 'מצב אימות', בוחרים באפשרות 'כניסה באמצעות Google' כדי להיכנס באמצעות חשבון Google אישי וליהנות מהתוכנית הנדיבה ללא תשלום של Gemini CLI. אמורה להופיע אפשרות לבחור את מצב האימות, כמו בדוגמה הבאה:

אם אתם רוצים לשנות את הבחירה, אתם יכולים להקליד /auth ולהקיש על Enter כדי לפתוח שוב את התפריט הזה.

בשלב הבא תתבקשו לבחור עיצוב:

בדומה ל-/auth, אפשר גם לשנות את העיצוב מאוחר יותר באמצעות הפקודה /theme.

אחרי שבוחרים את שיטת האימות ואת העיצוב המועדף, מגיעים לשורת הפקודה. כאן אפשר להקליד את הפקודות, למשל:

Write a hello world application in Go.

ה-CLI משתמש בשילוב של יכולות ניתוח משלו (באמצעות מודל Gemini כמו Gemini Flash או Gemini Pro) וכלים כדי לבצע את המשימות. הוא משתמש בכלים כשהוא צריך ליצור אינטראקציה עם מערכת הקבצים או עם שירותים חיצוניים, כמו ממשקי API, מסדי נתונים וכו'. דוגמאות לכלים שזמינים מראש, או 'כלים פנימיים', הם read_file,‏ write_file,‏ web_fetch ו-google_search. שרת ה-MCP שאנחנו בונים יהפוך גם הוא לכלי שיהיה זמין ב-CLI.

בפעם הראשונה שבה הוא מפעיל כלי, הוא יבקש את ההרשאה שלכם. אתם יכולים לתת לה הרשאה חד-פעמית, אישור גורף לשאר השיחה או לדחות את הבקשה שלה. אם מדובר בפעולת עריכה של קובץ, תופיע גם האפשרות לערוך את הקובץ באמצעות עורך חיצוני, למקרה שתרצו לבצע שינויים. לדוגמה, זה הפלט של הפרומפט שלמעלה, ליצירת תוכנית Hello World:

בנוסף להנחיות, אפשר גם להשתמש בפקודות עם לוכסן. אם מקלידים '/', ה-CLI יציג אוטומטית את אפשרויות ההשלמה האוטומטית. אפשר להמשיך להקליד את הפקודה המלאה או לבחור אחת מהאפשרויות. הפקודות /auth ו-/theme שצוינו למעלה הן דוגמאות לפקודות כאלה.

אחרי שתכירו את הממשק, תוכלו להתחיל במשימה העיקרית של הקטע הזה, שהיא לבקש מ-CLI לכתוב את שרת ה-MCP בשבילכם.

יצירת שרת MCP של Hello World

אחת הדרכים הטובות ביותר לוודא שהמודל ייצור דברים באופן עקבי יותר היא לחלק משימות מורכבות לשלבים מצטברים. יכול להיות שהמודל יוכל להבין משימה מורכבת בעצמו, אבל בלי הגדרה נכונה ייקח לו הרבה זמן לגלות את ההטמעה הנכונה.

כדי להשיג גישה עקבית יותר, נורה לו קודם ליצור שרת MCP של Hello World לפני שנבקש ממנו ליישם את הפונקציונליות הרצויה (קריאת תיעוד של Go).

דוגמה להנחיה:

Your task is to create a Model Context Protocol (MCP) server to expose a "hello world" tool. For the MCP implementation, you should use the official Go SDK for MCP and use the stdio transport.

Read these references to gather information about the technology and project structure before writing any code:
- https://github.com/modelcontextprotocol/go-sdk/blob/main/README.md
- https://modelcontextprotocol.io/specification/2025-06-18/basic/lifecycle
- https://go.dev/doc/modules/layout

To test the server, use shell commands like these:
(
  echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-06-18"}}';
  echo '{"jsonrpc":"2.0","method":"notifications/initialized","params":{}}';
  echo '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}';
) | ./bin/godoctor

שימו לב שההנחיה שלמעלה מורכבת משלושה חלקים עיקריים:

פירוט הבעיה, כולל מה אנחנו רוצים לבנות והמגבלות (למשל, שימוש ב-SDK הרשמי במקום בכל SDK)
מסמכי עזר של המודל שיעזרו לו להבין את הבקשה
תהליך בדיקה שמשמש כקריטריון לקבלת המשימה

שלושת הרכיבים האלה עוזרים למודל להשיג את התוצאות הרצויות בצורה עקבית יותר.

הטמעה של כלי Go doc

אחרי שתהיה לכם הטמעה תקינה, נוכל להמשיך להטמעה של הכלי האמיתי 'go doc':

Add a new tool to our MCP server called "godoc" that invokes the "go doc" shell command. The tool will take a mandatory "package" argument and an optional "symbol" argument.

Read the reference for the go doc command to understand its API: https://pkg.go.dev/golang.org/x/tools/cmd/godoc

Test it by executing the call with:
  echo '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name": "godoc", "arguments": {"package": "fmt"} } }'
 | ./bin/godoctor

Test it using both a standard library package and an external package like "github.com/modelcontextprotocol/go-sdk/mcp", both with and without symbols.

אתם יכולים להתנסות בהנחיה הזו או לנסות ליצור הנחיה משלכם.

ממשק שורת פקודה שימושי

ברגע שתבחרו הטמעה טובה, תוכלו להנחות את המודל ליצור CLI של godoctor באמצעות לקוח MCP. השימוש ב-API הזה יאפשר לכם לייעל את הבדיקה של התכונות, כי לא תצטרכו ליצור את הקריאות ל-JSON-RPC באופן ידני כמו שעשיתם עד עכשיו.

הנחיה לדוגמה:

Now create a godoctor-cli component that will call the MCP server using command transport. This CLI will expose all tools using subcommands and allow us to test the MCP server implementation without needing to build the JSON-RPC calls manually.

Use the reference implementation at https://github.com/modelcontextprotocol/go-sdk/blob/main/README.md to build the client.

Test it by calling from the command line:
- the hello_world tool 
- the godoc tool with a local package
- the godoc tool with a local package and symbol
- the godoc tool with an external package
- the godoc tool with an external package and symbol

עכשיו, אחרי שיש לכם קבוצה פעילה של לקוח ושרת, בקטע הבא תגדירו את Gemini CLI עם שרת ה-MCP שיצרתם כדי להתחיל ליהנות מהיתרונות שלו במשימת התכנות הבאה.

מקורות מידע שימושיים

בהתחשב בכך ש-MCP הוא עדיין מושג חדש, ושה-SDK של Go ל-MCP הוא ספרייה חדשה, יכול להיות שיעבור זמן רב עד ש-Gemini יגלה בעצמו את ההטמעה הנכונה בשלב הזה. כדי לעזור למודל להגיע לפתרון הנכון, כדאי לספק לו את ההפניות הבאות:

כדי שהמודל יגלה את ה-SDK API באופן עקבי יותר, אפשר לתת לו את ההנחיה הבאה: "use the go doc shell command to discover the api for the go-sdk library" (תשתמש בפקודת המעטפת go doc כדי לגלות את ה-API של ספריית go-sdk).
אם המודל ינסה לבדוק את קוד המקור של ה-SDK באמצעות הכלי read_file, הפעולה תיכשל כי Gemini CLI לא יכול לקרוא קבצים מחוץ להיקף הנוכחי שלו. אפשר להנחות אותו להשתמש בפקודות cat ו-ls במקום זאת באמצעות הכלי run_shell_command.
אם למודל קשה לנפות באגים באפליקציה, אפשר להנחות אותו להוסיף רישום מפורט יותר ביומן ולשפר את המידע ההקשרי בהודעות השגיאה.
אם כל השאר לא עוזר, אפשר להשתמש בהטמעה לדוגמה: https://github.com/danicat/godoctor

6. הגדרת godoctor כשרת MCP ל-Gemini CLI

אחרי שעוזר ה-AI יצר את הקוד גם ללקוח וגם לשרת, אפשר להנחות אותו להריץ כמה בדיקות ידניות. לדוגמה:

retrieve the documentation for the package net/http

חשוב לבדוק את התלות גם עם תלות חיצונית (לא בספרייה הרגילה):

retrieve the documentation for the go-sdk package

אחרי שמרוצים מהתוצאות, מבקשים ממנו לכתוב קובץ README.md עם הוראות לשימוש בפרויקט הזה ולפיתוח שלו.

Now write a detailed README.md file explaining both from a user and a developer perspective how to use and to build this project.

עכשיו נגדיר את השרת כך ש-Gemini CLI יוכל להשתמש בו בשלב הבא של הפיתוח.

מבקשים מ-CLI לעדכן את GEMINI.md כדי להשתמש ב-godoc כשיטה המועדפת לקריאת תיעוד:

update the GEMINI.md file to use the godoc tool to retrieve documentation about Go packages or symbols. Always prefer to use godoc over WebFetch and GoogleSearch, and only use those when godoc doesn't give a clear answer.

עכשיו צריך להפעיל מחדש את Gemini CLI כדי להגדיר אותו. קודם כל, נשמור את סשן הצ'אט כדי שתוכלו להמשיך מהמקום שבו הפסקתם אחרי ההפעלה מחדש.

/chat save workshop001

יוצאים מ-CLI על ידי הקשה על Ctrl+D פעמיים.
קומפילציה של קובץ השרת הבינארי: יוצרים ספרייה בשם bin ומקמפלים לתוכה את שרת godoctor.

mkdir -p bin
go build -o ./bin/godoctor ./cmd/godoctor # adjust paths as needed

מגדירים את Gemini CLI לכלי המקומי: יוצרים קובץ .gemini/settings.json בתיקיית השורש של הפרויקט ומוסיפים קטע mcpServers כדי לציין ל-Gemini CLI איך להריץ את השרת המהודר.

mkdir -p .gemini
touch .gemini/settings.json

עכשיו מוסיפים את התוכן הבא לקובץ החדש באמצעות עורך שורת פקודה כמו vim או nano:

{
  "mcpServers": {
    "godoctor": {
      "command": "./bin/godoctor"
    }
  }
}

עכשיו מפעילים את Gemini CLI ומשחזרים את סשן הצ'אט:

/chat resume workshop001

אפשר לראות שהכלי נטען על ידי הקשה על Ctrl+T:

כדי לבדוק את השילוב, מבקשים מ-Gemini CLI להשתמש בכלי באמצעות הנחיה כמו 'קבלת התיעוד של net/http'

אתם אמורים לראות משהו כזה:

אם הכלי פועל בצורה תקינה, אמורה להופיע תיעוד שאוחזר באמצעות קריאה לכלי:

כל הכבוד, יצרת כלי MCP! אבל זה לא הסוף, עדיין אפשר לשפר את התוכן.

7. הוספת כלי מבוסס-AI לבדיקת קוד

בואו נוסיף תכונה מתוחכמת יותר שמבוססת על AI: בודק קוד שמשתמש ב-Gemini API.

יעד: הוספת כלי חדש בשם code_review לפרויקט הקיים. הכלי הזה ישתמש ב-Gemini API כדי לנתח קוד Go ולספק משוב.

הנחיה לדוגמה:

I want to add a new tool to my project called code_review. This tool should use the Gemini API to analyze Go code and provide a list of improvements in json format according to the best practices accepted by the Go community. The tool should take the Go code content and an optional hint as input. The hint will be used to provide additional guidance for the AI reviewer, like "focus on security" or "help me simplify this code". Please update the server to include this new tool and modify the CLI client to add a review command to use it.

Use this SDK to call Gemini: https://github.com/googleapis/go-genai

טיפים שימושיים

אחרי שהמודל יתחיל לעבוד על זה, יכול להיות שתראו באופן אוטומטי בקשה להפעיל את הכלי godoc כדי לעיין במסמכי התיעוד של חבילת genai. אם זה לא קורה, תמיד אפשר להפסיק את התהליך באמצעות מקש Escape ולהזכיר לו שעכשיו יש לו את הכלי godoc.

בדיקת כלי בודק הקוד

צריך להפעיל מחדש את Gemini CLI כדי ליצור ולטעון מחדש את שרת ה-MCP. שומרים את שיחת הצ'אט עם /chat save workshop002 ואז יוצאים מ-CLI על ידי הקשה על Ctrl+D פעמיים.
כדי להשתמש בכלי code_review, צריך מפתח API כי אנחנו קוראים למודל Gemini כדי שיכתוב את הביקורות בשבילנו. אפשר ליצור מפתח API באמצעות Google AI Studio.
מגדירים את משתנה הסביבה GEMINI_API_KEY עם מפתח ה-API שנוצר בשלב הקודם:

export GEMINI_API_KEY="YOUR_API_KEY"

קומפילציה מחדש של השרת: אחרי שמוסיפים את הכלי החדש, צריך לבצע קומפילציה מחדש של הקובץ הבינארי של השרת כדי לכלול את השינויים.

go build -o ./bin/godoctor ./cmd/godoctor

מפעילים שוב את Gemini CLI. שחזור שיחת הצ'אט עם /chat resume workshop002.
חשוב. חשוב לוודא שאתם מאומתים באמצעות חשבון Gmail האישי שלכם, כדי שממשק Gemini CLI לא ישתמש בחשבון לחיוב שלכם. כדי לעשות את זה, משתמשים בפקודה /auth:

כדי לוודא שהכלי מופעל, מקישים על Ctrl+T. אתם אמורים לראות משהו כזה:

עכשיו נבדוק את הכלי code-review על ידי בדיקת אחד מקובצי המקור של הכלי:

‫"Use the godoctor tool to review the cmd/godoctor/main.go file." ‏(שימוש בכלי godoctor כדי לבדוק את הקובץ cmd/godoctor/main.go).

    You should see something like this:

אחרי שהכלי לבדיקת קוד פועל, אפשר להציע למודל ליישם חלק מהשיפורים שהוא מצא, וכך ליצור תהליך עבודה מלא של "שיפור עצמי".

עכשיו אפשר לוודא שהכלי code-review פועל. בקטע הבא תלמדו איך לפרוס אותו בענן.

כדי למחוק את המשתנה GEMINI_API_KEY:

שמירת הסשן הנוכחי באמצעות /chat save workshop003 ויציאה מ-CLI
מגבים את מפתח ה-API במקום בטוח:

export | grep GEMINI_API_KEY > env.bkp

ביטול ההגדרה של GEMINI_API_KEY:

export GEMINI_API_KEY=

מפעילים מחדש את ה-CLI וטוענים את הסשן באמצעות /chat resume workshop003
מבקשים מהמודל ליישם את השיפורים של בדיקת הקוד.

8. הכנת השרת לענן

שרת ה-MCP שפיתחנו עד עכשיו פועל רק במכונה המקומית, וזה בסדר אם אתם מפתחים כלים לשימוש אישי. אבל לעיתים קרובות בסביבות ארגוניות אנחנו צריכים לפרוס כלים לשימוש נרחב של מאות או אפילו אלפי מפתחים.

כדי להרחיב את השרת של MCP, אנחנו צריכים להמיר אותו משרת שפועל רק עם קלט/פלט רגיל לשרת שיכול לתקשר באמצעות HTTP, ולפרוס אותו במקום שבו מפתחים שונים יוכלו לגשת אליו. כדי להשיג את המטרה הזו, נשתמש במצב העברה שמוגדר במפרט של MCP כ-HTTP שניתן להזרמה, ונשתמש ב-Cloud Run כיעד הפריסה שלנו.

המטרה: לבצע רפקטורינג בשרת godoctor כדי להשתמש ב-HTTP transport שניתן להזרמה.

הנחיה לדוגמה:

The godoctor server is currently using the stdio transport. I want to deploy it to Cloud Run, so I need to refactor it to use the streamable HTTP transport instead. Please modify the server to comply with the streamable HTTP specification.

מקורות מידע שימושיים

אם המודל מתקשה להטמיע את פרוטוקול ה-HTTP להעברת נתונים בסטרימינג, אפשר לתת לו את ההפניה הזו: https://github.com/modelcontextprotocol/go-sdk/blob/main/design/design.md
יכול להיות שהמודל ינסה להשתמש ב-HTTP+SSE במקום זאת, אבל הפרוטוקול הזה הוצא משימוש. אם אתם רואים שהבקשה עוברת בנתיב הזה, נסו להפנות אותה חזרה ל-HTTP שניתן להזרמה.

בדיקת השרת באמצעות HTTP

תבקש מהמודל לעדכן את לקוח godoctor כך שישתמש גם ב-HTTP שניתן להזרמה, כדי שתוכל לבדוק שהוא עדיין פועל.

Now update the client to use streamable HTTP and run a test by retrieving documentation from one package

אופציונלי: אם רוצים להגדיר את Gemini CLI כך שישתמש בשרת באמצעות HTTP:

שמירת הסשן ויציאה מה-CLI
עורכים את קובץ .gemini/settings.json ומשנים את ההגדרות כך שיצביעו על השרת המקומי הפעיל.

"mcpServers": {
  "godoctor": {
    "httpUrl": "http://localhost:8080"
  }
}

מריצים את השרת שעבר רפקטורינג באופן מקומי:

go run ./cmd/godoctor/main.go

בטרמינל חדש (כי הפעולה שלמעלה חוסמת), מפעילים את Gemini CLI ומזינים הנחיה כדי לבדוק את החיבור, למשל: ‫"Use the godoctor tool to get the documentation for fmt.Println."
כשמסיימים את הבדיקה, מקישים על Ctrl+C כדי לעצור את השרת.

9. יצירת קונטיינר לאפליקציה באמצעות Docker

עכשיו, כשהשרת שלנו משתמש בפרוטוקול התעבורה הנכון, אנחנו יכולים להכניס אותו למאגר לצורך פריסה.

המטרה: ליצור קובץ Dockerfile כדי לארוז את שרת godoctor בקובץ אימג' של קונטיינר נייד שמוכן לייצור.

הנחיה לדוגמה:

Please create a multi-stage Dockerfile that compiles the Go binary and copies it into a minimal golang image like golang:1.24-alpine.

בדיקת קובץ האימג' של Docker

אחרי שיוצרים את Dockerfile, בונים את התמונה ומריצים אותה כדי לוודא שהיא פועלת בצורה תקינה. אתם יכולים לתת ל-Gemini הוראות לעשות את זה בשבילכם:

build the image and test the connectivity to the server using the godoctor client

אופציונלי: אם רוצים לבצע את הבדיקה באופן ידני:

בונים את המאגר:

docker build -t godoctor:latest .

מריצים את הקונטיינר באופן מקומי:

docker run -p 8080:8080 -e PORT=8080 godoctor:latest

בודקים את הקונטיינר הפועל: במסוף אחר, מפעילים את Gemini CLI ומבקשים ממנו לאחזר תיעוד.
כשמסיימים את הבדיקה, מקישים על Ctrl+C כדי לעצור את השרת.

10. פריסה ב-Cloud Run

עכשיו הגיע הזמן לפרוס את הקונטיינר בענן.

המטרה: פריסת שרת godoctor בקונטיינר ב-Google Cloud Run.

הנחיות להנחיה: מבקשים מהעוזר הדיגיטלי מבוסס-AI לספק את פקודות gcloud לפריסת הקונטיינר.

הנחיה לדוגמה:

Now please deploy this image to Cloud Run and return me an URL I can use to call the MCP tool. Deploy it to us-central1 and use the project currently configured in the environment.

אחרי שהפריסה תסתיים, נגדיר את Gemini CLI כך שישתמש בכלי שפרסתם.

מבקשים מ-Gemini לעדכן את קובץ .gemini/settings.json כדי לשנות את ההגדרה של כלי ה-MCP כך שיצביע על השירות שנפרס.

now update the .gemini/settings.json file to use this URL for the godoctor server

הקטע הסופי mcpServers צריך להיראות כך (חשוב לזכור להחליף את ה-placeholder בכתובת ה-URL בפועל של אפליקציית Cloud Run):

"mcpServers": {
  "godoctor": {
    "httpUrl": "https://<your-cloud-run-id>.us-central1.run.app"
  }
}

בדיקת הפריסה של Cloud Run

עכשיו אפשר לבצע את הבדיקה הסופית מקצה לקצה.

מפעילים מחדש את Gemini CLI בפעם האחרונה (באמצעות /chat save ו-/chat resume כדי לשמור את ההקשר). עכשיו ה-CLI אמור להיות מסוגל להתקשר לשרת MCP המרוחק. אפשר לנסות לבקש תיעוד של חבילות.

חשוב לזכור שכדי להשתמש בכלי לבדיקת קוד, השירות צריך את GEMINI_API_KEY. אתם יכולים לבקש מ-Gemini CLI לפרוס אותו מחדש עם הסביבה הנכונה:

update the cloud run environment to add a GEMINI_API_KEY and use the value in @env.bkp. Then update the .gemini/settings.json file with the correct service URL

מפעילים מחדש את ה-CLI ובודקים אותו באמצעות הנחיה:

Use the godoctor tool to review the cmd/godoctor/main.go file

ה-CLI של Gemini יתחבר עכשיו לשירות Cloud Run שפרסתם ויבצע את בדיקת הקוד.

הנחיה לדוגמה:

I'm done with my tests on the CloudRun server, please delete this deployment for me and revert my .gemini/settings.json to use the local version.

11. מעולה!

הצלחתם להנחות עוזר דיגיטלי מבוסס-AI לבנות, להכניס לקונטיינר ולפרוס כלי מתוחכם שמבוסס על AI. חשוב מכך, תרגלתם את המיומנות החיונית של פיתוח תוכנה מודרני: תרגום דרישות להנחיות יעילות. הצלחתם להרחיב את Gemini CLI באמצעות כלי בהתאמה אישית, וכך הפכתם אותו לעוזר פיתוח Go יעיל וייעודי יותר.

איך בונים עוזר לתכנות באמצעות Gemini CLI, ‏ MCP ו-Go

1. מבוא

מה תלמדו

מה נדרש

טכנולוגיות מרכזיות

טיפים לשימוש מוצלח ב-Codelab

2. הגדרת הסביבה

הגדרת סביבה בקצב אישי

הפעלת Cloud Shell

3. איך מתחילים להשתמש ב-Gemini CLI

מה זה Gemini CLI?

התקנה

תצורה

4. הנחיות פיתוח

5. הגרסה הראשונה: שרת godoc

יצירת שרת MCP של Hello World

הטמעה של כלי Go doc

ממשק שורת פקודה שימושי

מקורות מידע שימושיים

6. הגדרת godoctor כשרת MCP ל-Gemini CLI

7. הוספת כלי מבוסס-AI לבדיקת קוד

טיפים שימושיים

בדיקת כלי בודק הקוד

8. הכנת השרת לענן

מקורות מידע שימושיים

בדיקת השרת באמצעות HTTP

9. יצירת קונטיינר לאפליקציה באמצעות Docker

בדיקת קובץ האימג' של Docker

10. פריסה ב-Cloud Run

בדיקת הפריסה של Cloud Run

11. מעולה!

Reference Docs