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

התנסות מעשית ב-Gemini CLI

1. מבוא

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

פרויקט Gemini CLI הוא קוד פתוח, ואפשר לראות את תוכנית הדרך הציבורית כאן.

מה תלמדו

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

מה צריך

אפשר להריץ את ה-codelab הזה כולו ב-Google Cloud Shell, שכולל מראש את Gemini CLI.

לחלופין, אם אתם מעדיפים לעבוד במחשב שלכם, יש קטע להורדה של Gemini CLI באופן מקומי.

תצטרכו את הפרטים הבאים:

דפדפן האינטרנט Chrome
חשבון Gmail

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

‫2. לפני שמתחילים

יצירת פרויקט

ב-Google Cloud Console, בדף לבחירת הפרויקט, בוחרים או יוצרים פרויקט ב-Google Cloud.
מוודאים שהחיוב מופעל בפרויקט ב-Cloud. כך בודקים אם החיוב מופעל בפרויקט

תשתמשו ב-Cloud Shell, סביבת שורת פקודה שפועלת ב-Google Cloud ומגיעה עם bq שנטען מראש. לוחצים על 'הפעלת Cloud Shell' בחלק העליון של מסוף Google Cloud.

תמונה של לחצן Activate Cloud Shell

אחרי שמתחברים ל-Cloud Shell, בודקים שכבר בוצע אימות ושהפרויקט מוגדר למזהה הפרויקט באמצעות הפקודה הבאה:

gcloud auth list

מריצים את הפקודה הבאה ב-Cloud Shell כדי לוודא שפקודת gcloud מכירה את הפרויקט.

gcloud config list project

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

gcloud config set project <YOUR_PROJECT_ID>

3. התקנה

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

יוצרים תיקיית לדוגמה (gemini-cli-projects) ועוברים אליה באמצעות הפקודות שמוצגות למטה. אם אתם מעדיפים להשתמש בשם אחר לתיקייה, אתם יכולים לעשות זאת.

mkdir gemini-cli-projects

כך עוברים לתיקייה הזו:

cd gemini-cli-projects

אפשר להפעיל את Gemini CLI ישירות באמצעות הפקודה gemini.

אפשר לעבור ישירות אל הקטע הבא (הגדרת Gemini CLI באמצעות settings.json).

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

השלב הראשון הוא התקנת Node 20 ואילך במחשב. אחרי שתסיימו את השלב הזה, תוכלו להתקין ולהפעיל את Gemini CLI באחת מהשיטות הבאות:

אפשר להתקין את Gemini CLI באופן גלובלי במערכת. יכול להיות שתצטרכו הרשאת אדמין כדי לבצע את השלב הזה.

# option 1: install Gemini CLI

npm install -g @google/gemini-cli

# .. and then run
gemini

מריצים אותה באמצעות הפקודה הבאה:

# option 2: run without installing Gemini CLI

npx https://github.com/google-gemini/gemini-cli

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

gemini --version

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

אחרי שתבחרו באפשרות הזו, תתבקשו לבחור שיטת אימות. מומלץ להשתמש בחשבון Google אישי ולא בחשבונות שאינם קשורים ל-Google או ל-Google Workspace במעבדה הזו. הרישיון החינמי מאפשר לכם גישה ל-Gemini 2.5 Pro ולחלון ההקשר שלו שיכול להכיל מיליון טוקנים. בתוכנית החינמית אפשר לשלוח 60 בקשות למודל בדקה ו-1,000 בקשות ביום ללא תשלום.

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

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

4. הגדרת Gemini CLI באמצעות settings.json

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

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

מעכשיו, בהפעלות הבאות של Gemini CLI, לא תתבקשו לבחור שוב את העיצוב ואת שיטת האימות. המשמעות היא שהנתונים נשמרים איפשהו, והקובץ שבו משתמשים נקרא settings.json. כך אפשר להתאים אישית את Gemini CLI.

ההגדרות מוחלות לפי סדר העדיפות הבא (ב-Cloud Shell זמינות רק הגדרות המשתמש):

מערכת: /etc/gemini-cli/settings.json (חל על כל המשתמשים, מבטל את ההגדרות של המשתמש ושל Workspace).
‫Workspace: ‏ .gemini/settings.json (מבטל את הגדרות המשתמש).
משתמש: ~/.gemini/settings.json.

משתמש Windows: ‎%USERPROFILE%.gemini\settings.json‎ (שבדרך כלל מתרחב ל-‎C:\Users<YourUsername>.gemini\settings.json)

מערכת: ‎%ProgramData%\gemini-cli\settings.json (שבדרך כלל מתרחב ל-C:\ProgramData\gemini-cli\settings.json)

משתמשי Mac: ‎~/.gemini/settings.json (שמתרחב ל-‎ /Users/<YourUsername>/.gemini/settings.json)

מערכת: /etc/gemini-cli/settings.json

אם אתם זוכרים, כשבחרתם את העיצוב, בחרתם שההגדרות יישמרו בהגדרות המשתמש. אפשר להיכנס אל ~/.gemini folder ולראות את הקובץ settings.json.

קובץ settings.json לדוגמה מוצג בהמשך. אם הייתם בוחרים עיצוב אחר, השם שלו היה מופיע שם.

{
  "theme": "Default",
  "selectedAuthType": "oauth-personal" or "cloud-shell"
}

5. האינטראקציה הראשונה שלנו עם Gemini CLI

כדי להתחיל להשתמש ב-Gemini CLI, מקלידים את השאילתה הראשונה כמו שמוצג בהמשך:

Give me a famous quote on Artificial Intelligence and who said that?

התגובה הצפויה מוצגת בהמשך:

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

דרך מהירה להבין את Gemini CLI ואת הפקודות השונות שהוא תומך בהן היא להקליד /help (לוכסן). יופיעו מגוון פקודות וקיצורי מקלדת, כמו שמוצג בהמשך:

נצא מ-Gemini CLI כרגע. אפשר לעשות את זה באמצעות הפקודה /quit או להריץ את הפקודה Ctrl-C פעמיים בסשן אינטראקטיבי בטרמינל של Gemini CLI.

6. ‫Gemini CLI – פרמטרים של פקודות

יש כמה פרמטרים של שורת פקודה שאפשר לספק כשמפעילים את Gemini CLI. כדי לקבל רשימה מלאה של אפשרויות, אפשר להשתמש ב---help כמו בדוגמה שלמטה.

gemini --help

אמורה להופיע רשימה מלאה של האפשרויות הזמינות. מומלץ לעיין במסמכי התיעוד כאן.

נבחן כמה מהן. האפשרות הראשונה היא להגדיר את Gemini CLI כך שישתמש במודל Pro או במודל Flash. נכון למועד כתיבת ה-Lab הזה, אלה שני המודלים היחידים שנתמכים. כברירת מחדל, נעשה שימוש במודל Gemini 2.5 Pro, אבל אם רוצים להשתמש במודל Flash, אפשר לעשות זאת כשמפעילים את Gemini CLI באמצעות הפרמטר -m, כמו שמוצג בהמשך:

gemini -m "gemini-2.5-flash"

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

מצב לא אינטראקטיבי

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

gemini -p "What is the gcloud command to deploy to Cloud Run"

חשוב לזכור שאי אפשר להמשיך את השיחה עם שאלות נוספות. במצב הזה גם אי אפשר להעניק הרשאה לכלים (כולל WriteFile) או להריץ פקודות של מעטפת.

7. ‫Gemini CLI – כלים מובנים

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

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

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

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

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

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

Search for the latest headlines today in the world of finance and save them in a file named finance-news-today.txt

תדמיין לרגע מה היא צריכה לעשות. באופן אידיאלי, היא צריכה לבצע חיפוש Google כדי לקבל חדשות ממקורות מידע רלוונטיים שיכולים לספק לה חדשות כלכליות. לאחר מכן, הוא צריך ליצור קובץ בשם finance-news-today.txt (פעולת כתיבה במערכת המקומית שתדרוש את ההרשאה שלכם) עם התוכן שלו.

נבדוק מה קורה (כדאי לבצע את אותן פעולות במחשב שלך).

הפעולה הראשונה שהיא מבצעת היא הפעלת הכלי GoogleSearch כדי לחפש באינטרנט.

אחרי שהחיפוש מסתיים, הנתונים מאוחזרים כמו שמוצג בהמשך:

אחרי שהפעולה הזו תסתיים, המערכת תהיה מוכנה לכתוב את הנתונים בקובץ ותשתמש בכלי WriteFile, אבל מכיוון שמדובר בפעולה רגישה (כתיבה), המערכת תבקש את ההרשאה שלכם. אתם יכולים להחליט על סוג ההרשאה , כלומר לאפשר פעם אחת, לאפשר תמיד וכו'. כרגע בוחרים באפשרות 'לאפשר פעם אחת'.

המידע ייכתב בקובץ ותוצג הודעה על הצלחה:

איך בודקים אם הקובץ נכתב או לא? אתם יכולים להשתמש ב-@file כדי לבקש ממנו לקרוא את התוכן. כשמקלידים @, מוצגת רשימה של קבצים בתיקייה הנוכחית, ומוצג גם הקובץ שנוצר זה עתה. בוחרים את ההנחיה ושולחים אותה. ההנחיה שלי מוצגת למטה:

read the contents of @finance-news-today.txt

כתוצאה מכך, הכלים הנדרשים (ReadManyFiles,‏ ReadFile) מופעלים והתוכן מוצג כמו שמופיע בהמשך:

8. ‫Gemini CLI – מצב Shell

זה הזמן ללמוד איך לעבוד ישירות עם Shell מתוך Gemini CLI. כדי לעבור למצב מעטפת, לוחצים על ! בתיבת ההודעה. הפעולה הזו תעביר אתכם למצב Shell. כדי לחזור, לוחצים שוב על ! או על המקש ESC.

במצב Shell, הסמל ! יופיע בתחילת ההנחיה, כמו בדוגמה הבאה:

אפשר לבדוק ישירות באמצעות פקודות רגילות כמו pwd ו-ls, כמו בדוגמה שלמטה. שימו לב שהפקודות מניחות שמדובר במערכת הפעלה מסוג Linux. אם אתם משתמשים במערכת הפעלה אחרת (Windows), תוכלו להשתמש בפקודות מקבילות כמו (cd, ‏ dir ו-type). חשוב לזכור שהפלט של הקריאות האלה נכלל בחלון ההקשר של המודל.

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

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

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

Get the latest release notes for Google Cloud from its RSS Feed and display the key points in a well-formatted list.

ההנחיה הזו צריכה להפעיל קודם את הכלי GoogleSearch כדי למצוא את פיד ה-RSS של Google Cloud Platform, ואז להשתמש בכלי WebFetch כדי לקבל את התוכן של פיד ה-RSS ולהציג אותו.

9. הגדרת שרתי Model Context Protocol (MCP)

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

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

ב-Gemini CLI אפשר להגדיר שרתי MCP כדי לגלות כלים מותאמים אישית ולהשתמש בהם. אם הפעלתם את Gemini CLI, תוכלו לבדוק את שרתי ה-MCP שהוגדרו באמצעות הפקודה /mcp, כמו שמוצג בהמשך:

אם לא הגדרתם שרתי MCP, יופעל התיעוד של שרת ה-MCP ב-Gemini CLI.

אפשר להגדיר שרתי MCP ברמה הגלובלית בקובץ ~/.gemini/settings.json או בספריית השורש של הפרויקט. יוצרים או פותחים את הקובץ .gemini/settings.json. בתוך הקובץ, צריך להוסיף את בלוק ההגדרות mcpServers, כמו שמוצג בהמשך:

"mcpServers": {
    "server_name_1": {},
    "server_name_2": {},
    "server_name_n": {}
 }

כל הגדרת שרת תומכת במאפיינים הבאים ( מסמכי עזר):

חובה (אחת מהאפשרויות הבאות)

‫command (מחרוזת): נתיב לקובץ ההפעלה של Stdio transport
‫url (string): כתובת ה-URL של נקודת הקצה של SSE (לדוגמה, "http://localhost:8080/sse")
‫httpUrl (מחרוזת): כתובת ה-URL של נקודת הקצה (endpoint) של סטרימינג HTTP

אופציונלי

‫args (string[]): ארגומנטים בשורת הפקודה להעברה של Stdio
‫headers (אובייקט): כותרות HTTP מותאמות אישית כשמשתמשים ב-url או ב-httpUrl
‫env (אובייקט): משתני סביבה לתהליך השרת. הערכים יכולים להפנות למשתני סביבה באמצעות התחביר $VAR_NAME או ${VAR_NAME}
‫cwd (string): ספריית העבודה להעברה ב-Stdio
‫timeout (מספר): הזמן הקצוב לתפוגה של הבקשה באלפיות השנייה (ברירת מחדל: 600,000 אלפיות השנייה = 10 דקות)
‫trust (boolean): אם הערך הוא true, כל אישורי הקריאה לכלי עבור השרת הזה יעברו אוטומטית (ברירת מחדל: false)
‫includeTools (string[]): רשימה של שמות הכלים שרוצים לכלול משרת ה-MCP הזה. אם מציינים כלים, רק הכלים שמופיעים כאן יהיו זמינים מהשרת הזה (התנהגות של רשימת היתרים). אם לא מציינים כלי, כל הכלים מהשרת מופעלים כברירת מחדל.
‫excludeTools (string[]): רשימה של שמות כלי שיוחרגו משרת ה-MCP הזה. המודל לא יוכל להשתמש בכלים שמפורטים כאן, גם אם השרת יאפשר לו גישה אליהם. הערה: excludeTools מקבל עדיפות על פני includeTools – אם כלי מופיע בשתי הרשימות, הוא יחריג.

נמשיך ונגדיר אחד משרתי ה-MCP המרכזיים שאולי תצטרכו אם אתם עובדים עם GitHub. יכול להיות שתשאלו: אם כבר הגדרתי במערכת שלי את Git וכלים קשורים אחרים, האם עדיין צריך את שרת ה-MCP של GitHub?

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

יכול להיות שלא תצטרכו את השלב הבא להגדרת שרת MCP של GitHub אם כבר הגדרתם במערכת את הדברים הבאים:

כלי Git (כלומר, אפשר להריץ פקודות כמו git init, git add וכו' במערכת)
‫gh : זוהי שורת הפקודה של GitHub. הוא מביא את בקשות המשיכה, הבעיות ומושגים אחרים של GitHub למסוף, לצד המקום שבו אתם כבר עובדים עם git והקוד שלכם. אפשר להתקין אותו כאן ולאמת את ההגדרה שלו באמצעות כמה פקודות, במיוחד לגבי אימות ל-GitHub מהמחשב.

אם עדיין רוצים לנסות את שרת ה-MCP של GitHub, אפשר לעבור לקטע הבא או לדלג עליו.

שרת Github MCP

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

במדריך הזה מוצגת האפשרות Remote MCP Server ב-Github. לשם כך, קודם צריך לקבל Personal Access Token (PAT)‎ מ-GitHub.

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

{
  "theme": "Default",
  "selectedAuthType": "oauth-personal",
  "mcpServers": {
       "github": {
            "httpUrl": "https://api.githubcopilot.com/mcp/",
            "headers": {
                "Authorization": "GITHUB_PAT"
            },
            "timeout": 5000
       }
  }
}

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

נתחיל בהנחיה שתפעיל אחד מהכלים משרת ה-MCP של GitHub. מזינים את ההנחיה הבאה:

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

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

תאר לי את <repo-name>?
משכפל את <repo-name> במחשב המקומי שלי.
תאר את @<שם הקובץ> או @<שם התיקייה>/
מהם הרכיבים השונים במאגר הזה?
ביצעתי את השינויים הנדרשים. אפשר להעביר את השינויים ל-GitHub ולהשתמש בכלים של שרת ה-MCP של GitHub כדי לעשות זאת.

בהמשך שיעור ה-Lab הזה תמצאו תרגיל לעבודה עם שרת ה-MCP של GitHub.

שרת Context7 MCP

‫Context7 מספק תיעוד עדכני למודלים גדולים של שפה (LLM) ולעורכי קוד של AI. אם אתם רוצים לספק למודל ה-LLM את ההקשר עם התיעוד העדכני של המסגרת שבחרתם, שרת Context7 MCP הוא בחירה טובה להגדרה.

מוודאים שהספרייה מופיעה בדף הבית של Context7.

זהו שרת ה-MCP שצריך להוסיף לקובץ settings.json.

"context7": {
      "httpUrl": "https://mcp.context7.com/mcp"
    }

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

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

הנה דוגמה להנחיה שבה אני רוצה לכתוב סוכן באמצעות ערכת פיתוח הסוכנים (ADK) של Google. בהנחיה שלי ציינתי לחפש את התיעוד בנושא דרך שרת Context7 MCP.

I am working on coding an Agent using the Agent Development Kit (ADK) from Google. I would like to know how to create the LLMAgent in Python. Use Context7 for the latest documentation on ADK and specifically use /google/adk-python, /google/adk-docs and adk.wiki

זה הפלט שמתקבל:

שרת Google Slides MCP

בפרויקט Github בכתובת https://github.com/matteoantoci/google-slides-mcp יש שרת MCP שמאפשר אינטראקציה עם Google Slides API. הוא מאפשר ליצור, לקרוא ולשנות מצגות ב-Google Slides באופן פרוגרמטי.

השלבים להגדרת שרת ה-MCP מפורטים בפרויקט. תצטרכו סביבת Node.js שבה תבנו את השרת, תגדירו פרויקט ב-Google Cloud ואסימוני OAuth 2.0, ואז תגדירו את שרת ה-MCP בקובץ settings.json.

אחרי ההגדרה, אפשר להריץ הנחיות כמו:

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

כדאי לנסות!

שרתי MCP נוספים

ריכזנו כאן רשימה נוספת של שרתי MCP שעשויים לעניין אתכם:

שרת Firebase MCP
שירותי מדיה מבוססי-AI גנרטיבי של Google (‏Imagen, ‏ Veo, ‏ Lyria)
MCP Toolbox for Databases (עבודה עם Firestore,‏ BigQuery ומסדי נתונים של Google Cloud)
שרת Google Workspace MCP (עבודה עם Docs,‏ Sheets,‏ יומן Google ו-Gmail)

ההוראות להגדרת שרתי ה-MCP שצוינו למעלה מפורסמות בפוסט הזה בבלוג.

10. התאמה אישית של Gemini CLI באמצעות GEMINI.md

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

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

מזינים GEMINI.md. זהו קובץ ההקשר (ברירת המחדל היא GEMINI.md, אבל אפשר להגדיר אותו באמצעות המאפיין contextFileName בקובץ settings.json). הקובץ הזה חיוני להגדרת ההקשר ההדרכתי (שנקרא גם 'זיכרון') שמועבר למודל Gemini. הקובץ הזה מאפשר לכם לתת ל-AI הוראות ספציפיות לפרויקט, הנחיות לגבי סגנון קידוד או כל מידע רקע רלוונטי, וכך לקבל תשובות מותאמות ומדויקות יותר לצרכים שלכם.

קובץ GEMINI.md הוא בפורמט Markdown והוא נטען באופן היררכי, שמשולב מכמה מיקומים.

סדר הטעינה הוא:

הקשר הגלובלי: **~/.gemini/GEMINI.md** (להוראות שחלות על כל הפרויקטים שלכם).
הקשר של הפרויקט או של האב: ה-CLI מחפש קבצים מסוג GEMINI.md מהספרייה הנוכחית עד לשורש הפרויקט.
הקשר של תיקיות משנה: ה-CLI סורק גם תיקיות משנה כדי למצוא קבצים מסוג GEMINI.md, וכך מאפשר לתת הוראות ספציפיות לרכיבים.

אפשר להשתמש בלחצן /memory show כדי לראות את ההקשר המשולב הסופי שנשלח למודל.

איך נראה GEMINI.md? הנה דוגמה שיצרנו מתוך התיעוד הרשמי:

# Project: My Awesome TypeScript Library

## General Instructions:

- When generating new TypeScript code, please follow the existing coding style.
- Ensure all new functions and classes have JSDoc comments.
- Prefer functional programming paradigms where appropriate.
- All code should be compatible with TypeScript 5.0 and Node.js 20+.

## Coding Style:

- Use 2 spaces for indentation.
- Interface names should be prefixed with `I` (e.g., `IUserService`).
- Private class members should be prefixed with an underscore (`_`).
- Always use strict equality (`===` and `!==`).

## Specific Component: `src/api/client.ts`

- This file handles all outbound API requests.
- When adding new API call functions, ensure they include robust error handling and logging.
- Use the existing `fetchWithRetry` utility for all GET requests.

## Regarding Dependencies:

- Avoid introducing new external dependencies unless absolutely necessary.
- If a new dependency is required, please state the reason.

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

אפשר לנסות קובץ GEMINI.md מותאם אישית. הדוגמה הזו מגיעה מ-gist שפורסם ומראה איך להשתמש ב-Gemini CLI במצב תכנון בלבד. הקובץ מופיע כאן:

# Gemini CLI Plan Mode
You are Gemini CLI, an expert AI assistant operating in a special 'Plan Mode'. Your sole purpose is to research, analyze, and create detailed implementation plans. You must operate in a strict read-only capacity.

Gemini CLI's primary goal is to act like a senior engineer: understand the request, investigate the codebase and relevant resources, formulate a robust strategy, and then present a clear, step-by-step plan for approval. You are forbidden from making any modifications. You are also forbidden from implementing the plan.

## Core Principles of Plan Mode
*   **Strictly Read-Only:** You can inspect files, navigate code repositories, evaluate project structure, search the web, and examine documentation.
*   **Absolutely No Modifications:** You are prohibited from performing any action that alters the state of the system. This includes:
    *   Editing, creating, or deleting files.
    *   Running shell commands that make changes (e.g., `git commit`, `npm install`, `mkdir`).
    *   Altering system configurations or installing packages.

## Steps
1.  **Acknowledge and Analyze:** Confirm you are in Plan Mode. Begin by thoroughly analyzing the user's request and the existing codebase to build context.
2.  **Reasoning First:** Before presenting the plan, you must first output your analysis and reasoning. Explain what you've learned from your investigation (e.g., "I've inspected the following files...", "The current architecture uses...", "Based on the documentation for [library], the best approach is..."). This reasoning section must come **before** the final plan.
3.  **Create the Plan:** Formulate a detailed, step-by-step implementation plan. Each step should be a clear, actionable instruction.
4.  **Present for Approval:** The final step of every plan must be to present it to the user for review and approval. Do not proceed with the plan until you have received approval. 

## Output Format
Your output must be a well-formatted markdown response containing two distinct sections in the following order:

1.  **Analysis:** A paragraph or bulleted list detailing your findings and the reasoning behind your proposed strategy.
2.  **Plan:** A numbered list of the precise steps to be taken for implementation. The final step must always be presenting the plan for approval.

NOTE: If in plan mode, do not implement the plan. You are only allowed to plan. Confirmation comes from a user message.

שומרים את התוכן שלמעלה בקובץ בשם GEMINI.md ושומרים אותו בתיקייה ~/.gemini/GEMINI.md. זו אותה תיקייה שבה יצרתם את הקובץ settings.json. אפשר גם לשמור את קובץ GEMINI.md בתיקייה <current project folder>/.gemini, או אפילו לשמור כמה קובצי GEMINI.md בתיקיות המשנה אם יש לכם הוראות שונות.

נותנים הנחיה ליצירת אפליקציה ובודקים את התגובה.

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

קובץ GEMINI.md הוא המפתח לכך ש-Gemini CLI יפעל לפי ההעדפות שלכם. מומלץ לעיין בסדרה המעשית Practical Gemini CLI שמתעמקת בתחום הזה, מסבירה איך אפשר ליצור קובץ כזה באופן אוטומטי לפרויקט, איך להתאים אישית אפילו את הנחיית המערכת ועוד.

חשוב לדעת שאפשר גם ליצור את הקובץ GEMINI.md תוך כדי אינטראקציה עם Gemini CLI. בכל שלב, אפשר להשתמש בפקודה ‎/memory add <some instruction/rule>, וה-CLI של Gemini יוסיף אותה לקובץ GEMINI.md. אתם יכולים גם להשתמש בשפה טבעית כדי לבקש מ-Gemini CLI להוסיף לזיכרון שלו, כלומר GEMINI.md, באמצעות הנחיות כמו Remember <some instruction/rule>‎ או Add to memory <some instruction/rule>‎.

11. Gemini CLI – פקודות סלאש בהתאמה אישית

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

מה קורה אם רוצים להגדיר את שני המצבים האלה ולהנחות את Gemini CLI לעבור לאחד מהמצבים האלה באמצעות פקודות סלאש /plan או /explain? בדיוק בשביל זה נוצרו פקודות הלוכסן בהתאמה אישית ב-Gemini CLI.

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

אנחנו רוצים ליצור כמה פקודות סלאש מותאמות אישית: /plan ו-/explain.

השלב הבא הוא להבין מאיפה Gemini CLI שואב את הפקודות המותאמות אישית. לפי התיעוד, הוא מאתר פקודות משני מיקומים, שנטענות בסדר מסוים:

פקודות משתמש (גלובליות): נמצאות ב~/.gemini/commands/. הפקודות האלה זמינות בכל פרויקט שאתם עובדים עליו.
Project Commands (Local) (פקודות פרויקט (מקומיות)): נמצאות ב-<your-project-root>/.gemini/commands/. הפקודות האלה ספציפיות לפרויקט הנוכחי, ואפשר להוסיף אותן לבקרת גרסאות כדי לשתף אותן עם הצוות.

נבחר את תיקיית הפרויקט הנוכחית שממנה הפעלתם את Gemini CLI. לכן זו תהיה התיקייה <your-project-root>/.gemini/commands/. יוצרים את מבנה התיקיות.

מה צריך ליצור בתוך התיקייה הזו? אנחנו צריכים שני קובצי TOML‏ (plan.toml ו-explain.toml). כאן אפשר לקרוא מידע נוסף על מרחבי שמות ומוסכמות שמות.

כל קובץ TOML צריך לכלול שני שדות : description ו-prompt. חשוב לוודא שהתיאור קצר וברור, כי הוא יוצג לצד הפקודה ב-Gemini CLI. הדוגמה הבאה לקובץ TOML לקוחה מהפוסט הרשמי בבלוג בנושא פקודות סלאש בהתאמה אישית.

בהמשך מוצג קובץ לדוגמה של plan.toml. שימו לב שההנחיה מכילה placeholder מיוחד {{args}}. ה-CLI יחליף את ה-placeholder הזה בכל הטקסט שהמשתמש הקליד אחרי שם הפקודה.

description="Investigates and creates a strategic plan to accomplish a task."
prompt = """
Your primary role is that of a strategist, not an implementer.
Your task is to stop, think deeply, and devise a comprehensive strategic plan to accomplish the following goal: {{args}}

You MUST NOT write, modify, or execute any code. Your sole function is to investigate the current state and formulate a plan.

Use your available "read" and "search" tools to research and analyze the codebase. Gather all necessary context before presenting your strategy.

Present your strategic plan in markdown. It should be the direct result of your investigation and thinking process. Structure your response with the following sections:

1.  **Understanding the Goal:** Re-state the objective to confirm your understanding.
2.  **Investigation & Analysis:** Describe the investigative steps you would take. What files would you need to read? What would you search for? What critical questions need to be answered before any work begins?
3.  **Proposed Strategic Approach:** Outline the high-level strategy. Break the approach down into logical phases and describe the work that should happen in each.
4.  **Verification Strategy:** Explain how the success of this plan would be measured. What should be tested to ensure the goal is met without introducing regressions?
5.  **Anticipated Challenges & Considerations:** Based on your analysis, what potential risks, dependencies, or trade-offs do you foresee?

Your final output should be ONLY this strategic plan.
"""

כדאי גם לנסות ליצור קובץ explain.toml. אפשר להיעזר במצב ההסבר של Gemini כדי לבחור תוכן.

מפעילים מחדש את Gemini CLI. עכשיו תראו שיש לו פקודה דרך שורת הפקודות (/plan), כמו שמוצג בהמשך:

12. תרחישים לדוגמה לניסיון

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

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

תכנות בשיטת Vibe coding באמצעות Gemini CLI

נשתמש בממשק Gemini CLI כדי ליצור קוד לאפליקציה. במשימה הזו תבקשו מ-Gemini CLI ליצור אפליקציה ואז תדחפו את הגרסה הראשונית למאגר ב-Github.

דרישה מוקדמת

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

Git
‫Gemini CLI עם שרת Github MCP (כפי שעשינו קודם) או אם הגדרתם את gh ( כלי Github CLI), גם זה יעבוד.
היכרות עם העקרונות הבסיסיים של Git וידע מסוים בתכנות

אנחנו נניח שהפעלתם את Gemini CLI בתיקייה ספציפית שבחרתם. מוודאים שהשרתים של MCP הופעלו בהצלחה, במיוחד השרת של Github MCP.

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

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

Generate a website for a 1-day event filled with technical talks. There are going to be 6 talks in a single track of 1 hour each. Each talk has the following information: title, 1 or maximum of 2 speakers, category (1 or maximum of 3 keywords), duration and a description. The website has a single page where users can see the schedule for the entire day with the timings. There will be one lunch break of an hour and the event starts at 10:00 AM. Keep a 10 minute transition between talks. I would like to use Node.js on the server side and standard HTML, JavaScript and CSS on the front-end. The users should be able to search the talks based on category.

I would like you to proceed in the following way: 
1. Plan out how you would design and code this application.
2. Ask me for any clarifications along the way.
3. Once I am fine with it, do generate the code and provide me instructions to run and test locally.

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

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

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

אחרי שפעלנו לפי ההוראות להפעלת השרת ולמעבר לדף הבית, קיבלנו אתר לדוגמה כמו שמוצג בהמשך (אם השתמשתם באותו הנחיה, אמור להופיע אתר דומה):

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

קודם כל, ניצור קובץ ‎ .gitignore בעזרת Gemini CLI.

Create a .gitignore file for this project.

השלב הבא הוא לתת הוראות ל-Gemini CLI לדחוף את המאגר הזה לחשבון GitHub שלנו, והפעולה הזו תפעיל ברקע את כלי השרת של GitHub MCP.

מזינים הנחיה שדומה להנחיה הבאה:

Great! I would now like to push all of this to a new repository in my Github account. I would like to name this repository <Your-Name>-event-talks-app

הוא יעבור על מספר פקודות:

יוצרים את המאגר.
הוא ישתמש בכמה פקודות Git : ‏ init, ‏ add, ‏ commit כדי לנהל את מאגר Git המקומי.
לאחר מכן, המערכת תגדיר את ה-Git remote ותבצע push

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

אם הכול ילך כשורה, אמור להיות לכם מאגר ב-Github. למטה מוצגת דוגמה לצילום מסך:

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

שימוש ב-Gemini CLI לעבודה על מאגר ב-GitHub

בתרחיש השימוש הזה, תשתמשו ב-Gemini CLI כדי לעבוד עם מאגר Github. תבצעו כמה משימות, כולל:

הסבר על ה-codebase
יצירת משאבי עזרה
הטמעה של תכונה חדשה
שומרים את השינויים ודוחפים אותם בחזרה למאגר
עבודה על בעיה ב-GitHub והטמעה של השינויים המוצעים

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

דרישה מוקדמת

כדי לבצע את המשימות שבקטע הזה, תצטרכו:

Git
‫Gemini CLI עם שרת Github MCP (כפי שעשינו קודם) או אם הגדרתם את gh ( כלי Github CLI), גם זה יעבוד.
היכרות עם יסודות Git וידע מסוים בתכנות (בדוגמה הזו נשתמש ב-Node.js, כי יכול להיות שהסביבה כבר מוכנה במחשב שלכם בגלל שהתקנתם את Gemini CLI). אבל בהמשך תוכלו לבחור מאגר לבחירתכם עם שפת תכנות ומסגרת שונות.
צריך להשלים את השלב הקודם ולהכין את המאגר שבו יצרנו את האתר Event Talks.

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

הסבר על ה-codebase

אני רוצה לקבל הסבר מפורט על הפרויקט הזה. תסביר לי מהן התכונות העיקריות, ואז תפרט על הצד של השרת ועל הצד של הלקוח. קח זרימת עבודה לדוגמה ותראה לי איך הבקשה והתגובה פועלות.
Explain @server.js

יצירת קובץ README

ליצור קובץ README לפרויקט הזה.

במקרה הזה, Gemini CLI לא רק יצר את הקובץ README, אלא גם רצה להריץ את הפקודות כדי להוסיף אותו למאגר Git ולדחוף את השינויים למאגר המרוחק. אם אתם רואים שהוא עושה את זה, אתם יכולים לאשר לו.

במקרים מסוימים, יכול להיות שהכלי יציע לכם ליצור את קובץ LICENSE. אתם יכולים להחליט אם אתם רוצים לעשות זאת. בהתאם לתוצאה, הקבצים README ו/או LICENSE ייווצרו והשינויים יועברו ל-GitHub.

הטמעה של תכונה חדשה

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

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

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

יצירת בעיות על סמך הצעות לתכונות

בוא ננסה משהו מעניין. אתם הולכים לשאול את Gemini CLI איך לשפר את חוויית המשתמש באפליקציה הזו, ועל סמך ההערכה שלו, הוא יכול ליצור את ההצעות האלה כבעיות באותו מאגר ב-GitHub. הוא ישתמש בכלי create_issue משרת ה-MCP של Github.

אפשר לנסות את ההנחיה הבאה:

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

האידיאל הוא שהשיפורים ישותפו איתכם קודם, ורק לאחר מכן, באישורכם, ייווצרו ה-issues במאגר GitHub. הנה צילום מסך לדוגמה מההרצה שלנו:

עבודה על בעיה ב-GitHub והטמעה של השינויים המוצעים

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

למטה מוצגת דוגמה לבעיה שנוצרה:

מעתיקים את כתובת ה-URL של הבעיה ומזינים הנחיה כמו זו:

צריך לעיין בבעיה: <YOUR_ISSUE_URL> ולהבין אילו שינויים צריך לבצע. קודם תסביר על התוכנית ואז תציג את השינויים המוצעים בקוד.

אפשר לאשר את השינויים ולדחוף אותם למאגר. אפשר אפילו לבקש ממנו לסגור את הבעיה.

(אופציונלי) משימות יומיומיות

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

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

ארגון קבצים ותיקיות

אתם יכולים להשתמש ב-Gemini CLI כדי לארגן את הקבצים בתיקיות שונות לפי הצורך, בהתאם לסוגים. עוברים לתיקייה במחשב שיש בה כמה קבצים בפורמטים ‎ .txt,‏ ‎.png,‏ ‎.jpg,‏ ‎.pdf,‏ ‎.mp4 ואחרים. בדרך כלל זה שולחן העבודה או תיקיית ההורדות.

זוהי תיקייה לדוגמה, והתוכן שלה מוצג בהמשך (יכול להיות שיש לכם קבצים אחרים):

עוברים לתיקייה הזו ומפעילים את Gemini CLI. תבקשו מ-Gemini CLI ליצור כמה תיקיות: Images,‏ Documents,‏ Videos, ואז תבקשו מ-Gemini CLI לארגן את הקבצים בתיקיות.

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

Create the following folders "Images","Documents","Videos"

לאחר מכן, מזינים את ההנחיה הבאה:

Go through all the files in this folder and then organize them by moving all the files ending with .jpg, .jpeg, .gif into the "Images" folder. Move all ".txt" files into the "Documents" folder. Move all the ".mp4" files in the "Videos" folder.

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

עוד כמה תרחישי ארגון (ההנחיות מופיעות לצד כל תרחיש):

סיכום: לכל מסמך בתיקייה 'Documents', צריך ליצור קובץ txt באותה תיקייה בשם 'summary_ORIGINAL_FILENAME.txt' שמכיל סיכום של 3 משפטים של הנקודות העיקריות במסמך.
סיווג לפי סוג: סריקה של כל קובצי ה-PDF וה-DOCX בספרייה הזו. העברת כל הקבצים שכוללים את המילה invoice בשם או בתוכן שלהם לתיקייה Financial/Invoices. העברת קבצים עם המילה 'קבלה' לתיקייה 'פיננסי/קבלות'. כל קובץ אחר בפורמט ‎ .docx עובר לתיקייה 'דוחות'.
חילוץ מידע חשוב (ו'תיוג'): לכל קובץ PDF בתיקייה Financial/Invoices, קרא את התוכן שלו. אם מצאתם תאריך, משנים את שם הקובץ כך שיכלול את התאריך בפורמט YYYY-MM-DD, למשל: ‘invoice_2025-07-26_original_name.pdf'.