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

איך בונים שרת MCP באמצעות Gemini CLI ו-Go

1. מבוא

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

בשיעור הזה נשתמש בגישה מבוססת-הנחיות. אתה תפעל כראש צוות טכני ותספק הנחיות לעוזר ה-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) מותקן ומופעל
גרסה 1.24 ואילך של Go מותקנת במערכת
‫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 יוצר באופן אוטומטי מחרוזת ייחודית, ובדרך כלל לא צריך לדעת מה היא. ברוב ה-Codelabs, תצטרכו להפנות למזהה הפרויקט (בדרך כלל מסומן כ-PROJECT_ID). אם אתם לא אוהבים את המזהה שנוצר, אתם יכולים ליצור מזהה אקראי אחר. אפשר גם לנסות שם משתמש משלכם ולבדוק אם הוא זמין. אי אפשר לשנות את ההגדרה הזו אחרי השלב הזה, והיא תישאר לאורך הפרויקט.
לידיעתכם, יש ערך שלישי, מספר פרויקט, שחלק מממשקי ה-API משתמשים בו. במאמרי העזרה מפורט מידע נוסף על שלושת הערכים האלה.

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

הפעלת Cloud Shell

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

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

הפעלת Cloud Shell

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

צילום מסך של טרמינל Google Cloud Shell שבו מוצג שהסביבה מחוברת

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

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

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

מה זה Gemini CLI?

‫Gemini CLI הוא ממשק שורת פקודה מבוסס-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. כך תוכלו לייעל את הבדיקה של התכונות בלי שתצטרכו ליצור קריאות 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 shell כדי לגלות את ה-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 github.com/modelcontextprotocol/go-sdk/mcp 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 פעמיים או הקלדת הפקודה /quit.
קומפילציה של קובץ השרת הבינארי: יוצרים ספרייה בשם 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

כדי לראות שהכלי נטען, מקלידים את הפקודה /mcp. אפשר גם להציג את התיאור המלא של הכלים באמצעות /mcp desc:

כדי לבדוק את השילוב, אפשר לבקש מ-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 on Vertex AI (with gemini-2.5-flash) 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.

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

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

gcloud services enable aiplatform.googleapis.com

יוצרים קובץ .env עם התוכן שבהמשך. אל תשכחו להחליף את המשתנה GOOGLE_CLOUD_PROJECT במזהה הפרויקט בפועל של הפרויקט שיצרתם בתחילת שיעור ה-Lab הזה, ואת המשתנה GOOGLE_CLOUD_LOCATION במיקום המועדף עליכם (למשל, us-central1).

export GOOGLE_GENAI_USE_VERTEXAI=true
export GOOGLE_CLOUD_PROJECT='your-project-id'
export GOOGLE_CLOUD_LOCATION='your-location'

טוענים את קובץ ‎ .env באמצעות פקודת המקור:

source .env

קומפילציה מחדש של השרת עם הגדרת הכלי החדשה:.

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

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

עכשיו נבדוק את הכלי 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 פועל. בקטע הבא תעבדו על פריסת האפליקציה בענן. שמירת הסשן הנוכחי באמצעות /chat save workshop003 ויציאה מ-CLI.

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

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

כדי להרחיב את השרת של MCP, אנחנו צריכים להמיר אותו משרת שמדבר רק I/O רגיל לשרת שיכול לדבר 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. Configure Cloud Run to use the environment variables in the .env file.

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

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

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 המרוחק. אפשר לנסות לבקש תיעוד של חבילות.

אפשר גם לבדוק את כלי בקרת הקוד:

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

ניקוי

אחרי שמסיימים את הבדיקה, חשוב לנקות את הסביבה. אתם יכולים להנחות את Gemini למחוק את הפרויקט או רק להסיר את הפריסה של CloudRun. הנחיה לדוגמה:

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 באמצעות כלי MCP בהתאמה אישית, והפכתם אותו לעוזר פיתוח Go יעיל וייעודי יותר.

איך בונים שרת MCP באמצעות Gemini CLI ו-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. מעולה!

מסמכי עזר