מדריך גרוק CLI בעברית
לאתר הראשי כל המדריכים קלוד קוד קלאודפלייר קלוד דסקטופ גרוק בוט MCP קרסור וואטסאפ OpenClaw n8n בענן n8n בהתקנה עצמית

תיעוד 31

שרתי MCP

שרתי MCP (Model Context Protocol) מרחיבים את Grok עם שילובי כלים חיצוניים. הם מאפשרים ל-Grok לקיים אינטראקציה עם כל שירות שמיישם את תקן MCP.

#מה הם שרתי MCP?

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

לדוגמה, שרת MCP של GitHub עשוי לחשוף כלים כמו create_issue, list_pull_requests ו-search_code. שרת מסד נתונים עשוי לחשוף את query, list_tables ו-describe_schema.

ראה את מפרט MCP לפרטי הפרוטוקול.

#הגדרה

שרתי MCP מוגדרים ב-~/.grok/config.toml תחת מקטעי [mcp_servers.<name>].

כדי להפיץ שרתי MCP לצוות, או כדי להגביל אילו שרתים משתמשים רשאים להריץ (allowedMcpServers / deniedMcpServers ב-requirements.toml / managed_config.toml, עם הנחיית Claude managed-settings.json עבור שרתים שהוגדרו חיצונית), ראה הפצה ברחבי ארגון במדריך התוספים.

#תעבורת stdio (תהליך מקומי)

Grok מפעיל תהליך מקומי ומתקשר דרך stdin/stdout:

[mcp_servers.my-server]
command = "/path/to/server"           
# קובץ ההפעלה של השרת
args = ["--flag", "value"]            
# ארגומנטים של הפקודה
env = { API_KEY = "sk-..." }          
# משתני סביבה
enabled = true                        
# הפעלה או השבתה של השרת (ברירת מחדל: true)
startup_timeout_sec = 30              
# פסק זמן להפעלת השרת, שניות (ברירת מחדל: 30)
tool_timeout_sec = 6000               
# ברירת מחדל לפסק זמן לקריאת כלי, שניות (ברירת מחדל: 6000)
tool_timeouts = { slow_op = 120 }     
# דריסות פסק זמן לפי כלי, שניות

דריסה גלובלית של פסק זמן להפעלה: במקום להגדיר את startup_timeout_sec לכל שרת בנפרד, תוכל לשנות את ברירת המחדל לכל השרתים דרך משתנה הסביבה MCP_TIMEOUT (מילישניות, תואם ל-Claude Code) או GROK_MCP_STARTUP_TIMEOUT_SECS (שניות). ערך startup_timeout_sec ברמת השרת עדיין קודם לשניהם. שרתי npx/uvx בהפעלה קרה שמורידים חבילות בהרצה הראשונה זקוקים לכך לעיתים קרובות, ברירת המחדל היא 30 שניות.

מגבלת גודל של תוצאת כלי MCP: תוצאות גדולות של MCP / use_tool נחתכות בגוף הפלט (כל המטען נשפך תחת תיקיית mcp/ של ההפעלה). ברירת המחדל היא 20_000 בתים. ניתן לדרוס באמצעות:

  • משתנה סביבה GROK_MAX_MCP_OUTPUT_BYTES או MAX_MCP_OUTPUT_BYTES (בתים, הערך המקורי של Grok מנצח אם שניהם מוגדרים, שם בסגנון Claude, אך אנו מגבילים לפי בתים ולא אסימונים).
  • config.toml: ברמת המשתמש (~/.grok/config.toml) או ברמת המאגר (.grok/config.toml בכל מקום בשרשרת שבין cwd לשורש ה-git, הקובץ העמוק ביותר מנצח, וערך המאגר חל רק לאחר שהתיקייה מהימנה):
[mcp]
max_output_bytes = 40000

סדר קדימויות: requirements.toml > משתני סביבה > .grok/config.toml של המאגר > הגדרות משתמש/מנוהלות > ברירת מחדל. עריכות במאגר חלות על הפעלות פעילות באותה תיקייה באמצעות טעינה חמה של ההגדרות (config hot-reload).

#תעבורת HTTP/SSE (שרת מרוחק)

עבור שרתי MCP מרוחקים הנגישים דרך HTTP:

[mcp_servers.remote-api]
url = "https://mcp.example.com/api"
headers = { "Authorization" = "Bearer token" }

בקשות במישור הנתונים של MCP (כלומר JSON-RPC ו-SSE) ובדיקת הגישה האנונימית נושאות כותרת ברירת מחדל של User-Agent: grok-cli/<version>, כאשר <version> הוא גרסת הקובץ הבינארי של Grok. גילוי OAuth, רישום לקוח ובקשות אסימון מונפקים על ידי לקוח ה-OAuth של rmcp ושומרים על ההתנהגות שלו (ללא User-Agent ברירת מחדל). ערך User-Agent תקין ב-headers של השרת דורס את ברירת המחדל, ערך User-Agent מוגדר שאינו תקין מושמט במהלך פענוח הכותרות (עם אזהרה), ולכן שרת כזה עדיין מקבל את ברירת המחדל. חריג: שרתי MCP של Figma (שם שרת figma, שם מנוהל מדור קודם grok_com_figma, או מארח figma.com, כולם ללא תלות באותיות רישיות או קטנות) שולחים את האסימון הפשוט grok-cli ללא גרסה, אלא אם ההגדרה מספקת User-Agent משלה.

#HTTP בהזרמה עם מזהה הפעלה

[mcp_servers.my-streamable-server]
url = "https://mcp.example.com/api/mcp"
headers = { "x-mcp-session-id" = "{{session_id}}" }

#ניהול דרך ה-CLI

נהל שרתי MCP משורת הפקודה בלי לערוך קובצי הגדרות:

# הצגת שרתי MCP מוגדרים
grok mcp list
grok mcp list --json          
# פלט קריא למכונה

# הוספת שרת stdio. כל מה שאחרי -- הוא פקודת השרת, כך שדגלים
# כמו y- מגיעים לשרת במקום שיפוענחו על ידי grok.
grok mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/dir

# הוספת שרת stdio עם משתני סביבה (ניתן לחזור על e- מספר פעמים)
grok mcp add postgres -e DATABASE_URL=postgres://localhost/mydb -- npx -y @modelcontextprotocol/server-postgres

# הוספת שרת HTTP מרוחק
grok mcp add --transport http sentry https://mcp.sentry.dev/mcp

# הוספת שרת מרוחק עם כותרת אימות (ניתן לחזור על header-- מספר פעמים)
grok mcp add --transport http api https://mcp.example.com/mcp --header "Authorization: Bearer YOUR_TOKEN"

# הוספת שרת SSE מרוחק
grok mcp add --transport sse linear https://mcp.linear.app/sse

# הסרת שרת
grok mcp remove github

# הפעלה או השבתה של שרת מקומי/TOML (או ממקור תאימות)
grok mcp enable github
grok mcp disable github

# אבחון הגדרות וקישוריות של שרת
grok mcp doctor               
# בדיקת כל שרת מוגדר
grok mcp doctor github        
# בדיקת שרת יחיד
grok mcp doctor --json        
# פלט קריא למכונה

ברירת המחדל של התעבורה היא stdio. העבר את --transport http או את --transport sse עבור שרתים מרוחקים.

כברירת מחדל grok mcp add כותב אל ~/.grok/config.toml (--scope user). השתמש ב---scope project כדי לכתוב במקום זאת אל .grok/config.toml בתיקייה הנוכחית, שאותו ניתן לשמור ב-commit ולשתף עם הצוות שלך (ראה שרתי MCP ברמת הפרויקט). ערכי כותרות ומשתני סביבה נשמרים כלשונם, לכן הפנה לסודות בתור ${VAR} במקום להדביק אותם לקובץ הגדרות פרויקט שנשמר ב-commit (ראה דוגמאות הגדרה). הפקודה grok mcp list מציגה שרתים משני הטווחים, ומסמנת שרתים ברמת הפרויקט באמצעות (project) ושרתים מושבתים באמצעות (disabled).

הפקודה grok mcp remove מחפשת בשני הטווחים ומסתיימת בקוד 0 לאחר הסרת השרת. היא מסתיימת בקוד 1 כאשר השם אינו נמצא, או כאשר השם מוגדר גם בטווח המשתמש וגם בטווח הפרויקט: העבר את --scope כדי לציין איזה מהם להסיר.

הפקודות grok mcp enable ו-disable שומרות את מצב ההפעלה או הכיבוי האישי ב-~/.grok/config.toml של המשתמש (disabled_mcp_servers, ו-[mcp_servers.<name>].enabled כאשר רשומה זו קיימת). טווח:

  • שמות מוכרים: TOML של Grok למשתמש או לפרויקט, שמות שכבר נמצאים ברשימת המושבתים, מקורות תאימות (.mcp.json, Claude, Cursor), ושרתי MCP של תוספים (אותו גילוי כמו ב-doctor//mcps).
  • הפעלה בלבד: אם להגדרת הפרויקט הקרובה ביותר ל-cwd יש enabled = false קבוע, המפתח הבודד הזה נמחק (הערות נשמרות). פעולת השבתה לעולם אינה כותבת מחדש הגדרות פרויקט.
  • אין תאימות מלאה ל-/mcps: מחברי שער (gateway connectors, כגון ...:managed_gateway, המאוחסנים תחת disabled_mcp_tools.__managed_gateway_connectors) נשארים להפעלה באמצעות מקש הרווח ב-TUI בלבד. הפעולה אידמפוטנטית, שמות לא מוכרים מסתיימים בקוד 1.

שינויים שוברים מגרסאות קודמות: הדגל --env מקבל כעת KEY=value יחיד לכל דגל (השתמש ב--e A=1 -e B=2, ולא ב---env A=1 B=2), ושמות שרתים רשאים להכיל רק אותיות, מספרים, מקפים וקווים תחתונים.

#שרתי MCP ברמת הפרויקט

ניתן להגדיר שרתי MCP לכל פרויקט על ידי הצבת .grok/config.toml במאגר שלך:

my-project/
  .grok/
    config.toml
  src/
  ...
# .grok/config.toml
[mcp_servers.linear]
url = "https://mcp.linear.app/mcp"
enabled = true

כאשר שרת חושף נקודת קצה מקורית של HTTP/SSE, העדף את תצורת ה-url על פני עטיפתו בפרוקסי של stdio כגון npx mcp-remote <url>. Grok מטפל ב-HTTP/SSE וב-OAuth ישירות, ולכן התצורה המקורית מונעת תהליך משנה נוסף לכל הפעלה. היא גם רושמת את לקוח ה-OAuth של Grok עצמו מול הספק.

Grok עובר מהתיקייה הנוכחית ומעלה עד לשורש מאגר ה-git, וטוען את .grok/config.toml בכל רמה:

מיקוםטווחעדיפות
~/.grok/config.tomlכל הפרויקטיםהנמוכה ביותר
<repo-root>/.grok/config.tomlמאגר זהבינונית
<cwd>/.grok/config.tomlתיקייה נוכחיתהגבוהה ביותר

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

קובצי הגדרות ברמת הפרויקט תורמים רשומות [mcp_servers], [plugins] ו-[permission]. Grok קורא את רוב מקטעי ההגדרות האחרים רק מ-~/.grok/config.toml.

#מתן שמות לכלים

כלי MCP מקבלים מרחב שמות עם שם השרת כדי למנוע התנגשויות. מפתח הקטלוג הוא server__tool (שני קווים תחתונים):

  • שרת filesystem עם כלי read_file הופך ל-filesystem__read_file
  • שרת github עם כלי create_issue הופך ל-github__create_issue
  • מקטע כלי יכול להתחיל בספרה: שרת auth עם כלי 2fa_enable הופך ל-auth__2fa_enable

#מה ש-Grok מקבל

Grok מקבל כלי שנרשם לקטלוג ההפעלה כאשר כל התנאים הבאים מתקיימים (xai-grok-mcp qualify_mcp_tool_name):

חלקכלל
שם השרתמתחיל באות או בקו תחתון. לאחר מכן אותיות ASCII, ספרות, קווים תחתונים ומקפים בלבד.
שם הכליאינו ריק. אותיות ASCII, ספרות, קווים תחתונים ומקפים בלבד. יכול להתחיל בספרה.
מפרידבדיוק __ אחד. שמות עם __ שני, או עם ___, מושמטים.
מפתח קטלוגserver + __ + tool הוא לכל היותר 256 תווים.

כלי שנדחה מושמט. שורת היומן היא Skipping MCP tool בצירוף הסיבה. שאר הכלים של אותו שרת עדיין נטענים.

המגבלה של 64 תווים היא תקציב שם פונקציה של הספק. היא חלה על מטא-הכלים search_tool ו-use_tool עצמם. היא אינה חלה על מפתחות קטלוג. שם server__tool שארוך מ-64 תווים נשאר בקטלוג. המודל עדיין קורא לו דרך use_tool באמצעות השם המלא הזה. בעבר Grok השמיט כלים אלה ב-64 תווים. הוא כבר אינו עושה זאת.

שם השרת ב-[mcp_servers.<name>] או ב-grok mcp add הוא קידומת הקטלוג. שם שמתחיל בספרה הוא מפתח TOML תקין. עם זאת, הקבלה לקטלוג דוחה אותו (InvalidServerName). שנה את שם השרת כך שיתחיל באות או בקו תחתון.

שם שרת שמסתיים ב-_ גורם לכך ש-server__tool יכיל ___. הקבלה מדלגת על מפתח זה (InvalidOrAmbiguousQualifiedName).

הכלים search_tool ו-use_tool מקבלים את מפתח הקטלוג המלא, ולא את שם כלי ה-MCP הגולמי. לדוגמה: github__create_issue, ולא create_issue.

#החלפת מצב שרתים בזמן ריצה

תוכל להפעיל או להשבית שרתי MCP מבלי להפעיל מחדש את Grok (ב-TUI באמצעות /mcps או ב-CLI, ראה ניהול דרך ה-CLI).

#חלונית /mcps

פתח את חלונית שרתי ה-MCP ב-TUI:

  • הרץ את /mcps כפקודת לוכסן (slash command)
  • או לחץ על Ctrl+L (בסביבות שאינן ממשפחת VS Code) ונווט ללשונית MCP Servers. במשפחת VS Code השתמש ב-/plugins או ב-/mcp ופתח את לשונית MCP Servers

מהחלונית תוכל:

  • לראות את המקור, מצב ההפעלה ומספר הכלים של כל שרת
  • להפעיל או להשבית שרת באמצעות Space
  • להרחיב שרת כדי לצפות בכלים שהוא מספק
  • לרענן את הרשימה באמצעות r לאחר עריכת config.toml
  • לאמת שרת OAuth באמצעות i
  • להוסיף שרת באמצעות a, או להסיר שרת מקומי באמצעות x (החלונית מבקשת אישור, לחץ על y קטנה להסרה, או על כל מקש אחר לביטול)

#גילוי כלים

למודל יש גישה לשני כלים מובנים לעבודה עם שרתי MCP:

  • search_tool: גילוי כלי אינטגרציה זמינים בכל שרתי ה-MCP המופעלים. השתמש בו כדי למצוא כלים לפי שם או תיאור.
  • use_tool: קריאה לכלי אינטגרציה שהתגלה דרך search_tool. ציין את שם הכלי המלא (לדוגמה, github__create_issue).

#תאימות

Grok טוען הגדרות של שרתי MCP ממספר מקורות לצורך תאימות:

מקורפורמטמיקוםניתן להגדרה
config.tomlהגדרת Grok מקורית~/.grok/config.toml, .grok/config.tomlפועל תמיד
.claude.jsonפורמט Claude Code~/.claude.json[compat.claude] mcps
.cursor/mcp.jsonפורמט Cursor~/.cursor/mcp.json, <project>/.cursor/mcp.json[compat.cursor] mcps
.mcp.jsonפורמט תקן MCPשורש הפרויקט (מ-cwd ועד שורש git)נטען אלא אם ייבאת או דחית את בקשת הייבוא של Claude (סמן הייבוא הוגדר)

כל המקורות ממוזגים לפי סדר עדיפות: config.toml > Claude > Cursor > .mcp.json. שרתים ממקורות בעלי עדיפות גבוהה יותר מקבלים קדימות במקרה של התנגשות שמות.

מקורות ה-MCP של Claude ושל Cursor נסרקים כברירת מחדל. כדי להשבית סריקה עבור ספק מסוים, הגדר [compat.<vendor>] mcps = false ב-~/.grok/config.toml או את משתנה הסביבה התואם (GROK_CURSOR_MCPS_ENABLED, GROK_CLAUDE_MCPS_ENABLED). ראה הגדרה לפרטים. השתמש ב-grok inspect כדי לראות אילו שרתי MCP נטענו ואת מקור הספק שלהם ([cursor], [claude]).

#אימות MCP OAuth

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

#דוגמאות הגדרה

השתמש בתצורת url עבור שרתי MCP מתארחים (hosted) ובתצורת command / args עבור כלי stdio מקומיים.

#HTTP מקורי (שירותים מתארחים)

עליך לאמת שרתי MCP מבוססי OAuth לפני שתוכל להשתמש בהם. Grok שומר את האסימונים שמתקבלים תחת ~/.grok/mcp_credentials.json כטקסט פשוט מקומי עם הרשאות קובץ לבעלים בלבד (0600 ב-Unix). מומלץ להשתמש בהצפנת דיסק מלאה במחשב המארח. לאחר עריכת config.toml, לחץ על r בחלונית /mcps כדי לרענן את רשימת השרתים.

[mcp_servers.linear]
url = "https://mcp.linear.app/mcp"
enabled = true

[mcp_servers.sentry]
url = "https://mcp.sentry.dev/mcp"
enabled = true

[mcp_servers.mixpanel]
url = "https://mcp.mixpanel.com/mcp"
enabled = true

עבור שרתים פנימיים או באירוח עצמי (self-hosted) המאמתים באמצעות bearer token סטטי ולא דרך OAuth, הגדר את כותרת Authorization במפורש:

[mcp_servers.internal-tools]
url = "https://mcp.internal.example.com/mcp"
enabled = true

[mcp_servers.internal-tools.headers]
Authorization = "Bearer <token>"

כדי להימנע מהצבת סודות בקובץ ההגדרות, הפנה למשתנה סביבה באמצעות ${VAR} (או ${VAR:-default}). בזמן הטעינה, Grok מרחיב שדות מחרוזת ב-[mcp_servers.*], כולל url, command, args, והערכים ב-env וב-headers:

[mcp_servers.internal-tools]
url = "https://mcp.internal.example.com/mcp"
enabled = true
headers = { "Authorization" = "Bearer ${INTERNAL_MCP_TOKEN}" }

#stdio מקומי

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

# גישה למערכת הקבצים מוגבלת לתיקייה
[mcp_servers.filesystem]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/directory"]

# מסד נתונים מקומי מסוג Postgres
[mcp_servers.postgres]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/db"]

# שרת מותאם אישית עם פסק זמן הפעלה ארוך יותר ופסקי זמן מכווננים לכל כלי
[mcp_servers.my-tools]
command = "/usr/local/bin/my-mcp-server"
args = ["--config", "/etc/my-mcp.json"]
startup_timeout_sec = 30
tool_timeout_sec = 120
tool_timeouts = { slow_analysis = 300, quick_lookup = 10 }

ב-Windows, כלי npm מתקין מפעילים כמו npx, npm, pnpm ו-yarn בתור קובצי מעטפת batch מסוג .cmd (אין npx.exe). Grok מפענח command חשוף כגון npx לנתיב המפעיל האמיתי שלו ב-PATH (תוך התחשבות ב-PATHEXT) לפני ההפעלה, כך שהם פועלים מבלי לעטוף אותם ידנית ב-cmd /c. ערך command שניתן כנתיב מוחלט או כזה המכיל מפריד נתיבים משמש כפי שהוא.

#שרתי MCP זמינים

רשימה חלקית של שרתי MCP שתוכל להגדיר באמצעות תצורות url או command שהוצגו לעיל. ודא את נקודת הקצה או שם החבילה הנוכחיים מול כל ספק לפני השימוש:

שרתתעבורהנקודת קצה / חבילה
LinearHTTP (OAuth)https://mcp.linear.app/mcp
SentryHTTP (OAuth)https://mcp.sentry.dev/mcp
MixpanelHTTP (OAuth)https://mcp.mixpanel.com/mcp
Filesystemstdio@modelcontextprotocol/server-filesystem
Gitstdio@modelcontextprotocol/server-git
GitHubstdio@modelcontextprotocol/server-github
GitLabstdio@modelcontextprotocol/server-gitlab
PostgreSQLstdio@modelcontextprotocol/server-postgres
SQLitestdio@modelcontextprotocol/server-sqlite
Puppeteerstdio@modelcontextprotocol/server-puppeteer

ראה את רישום שרתי MCP לרשימה המלאה של שרתי הקהילה, ואת מפרט MCP לפרטי הפרוטוקול.

#סוכני משנה ו-MCP

סוכני משנה יורשים כברירת מחדל את שרתי ה-MCP המחוברים של הפעלת ההורה, כולל סוכנים שמקורם בתוספים. השתמש ב-mcpInheritance ב-frontmatter של הסוכן כדי להגביל קבוצה זו (all, none, named או except). פרטים נוספים נמצאים במדריך סוכני משנה: הורשת MCP.

אם סוכן צאצא מציג את search_tool / use_tool אך מחזיר קטלוג ריק, בדוק כי:

  1. הפעלת ההורה אכן חיברה את השרת (ראה Extensions / grok inspect).
  2. ה-mcpInheritance של הסוכן אינו none או מסנן שמחריג את השרת.
  3. סוכני תוספים אינם יכולים להצהיר על mcpServers משלהם ב-frontmatter, הם רואים רק שרתים שמחוברים להורה.

#פתרון בעיות

#השרת אינו מופעל

# בדיקת פקודת השרת ידנית
npx -y @modelcontextprotocol/server-filesystem /path

# הגדלת פסק הזמן להפעלה
# בתוך config.toml:
[mcp_servers.filesystem]
startup_timeout_sec = 30

עבור שרתי stdio,‏ Grok לוכד את הפלט של שגיאת התהליך הסטנדרטית (stderr) אל ~/.grok/logs/mcp/<server>.stderr.log, אשר נחתך בכל הפעלה. בדוק קובץ זה כאשר שרת מופעל אך נכשל בלחיצת היד (handshake):

tail -f ~/.grok/logs/mcp/filesystem.stderr.log

#חסום על ידי מדיניות הארגון

אם מדיניות TOML מקורית או קובץ managed-settings.json של Claude מגדירים את deniedMcpServers, ערך לא ריק של allowedMcpServers, או allowManagedMcpServersOnly,‏ Grok משמיט שרתים שאינם תואמים בזמן המיזוג וכותב ביומן MCP server blocked by managed settings policy. שכבות Grok המקוריות מחייבות כל שרת, בעוד קובץ Claude מחייב רק שרתים שהוגדרו חיצונית. הפקודה grok inspect מציגה את הרשימות, את היקף הנעילה ואת כל השרתים שנותרו. פרטים ודוגמאות: הגבלת שרתי ה-MCP המורשים לריצה.

#כלי שמופיע ברשימה אינו מופיע לעולם

השרת מופעל והקריאה tools/list מחזירה את הכלי, אך /mcps ו-search_tool משמיטים אותו.

  1. בדוק את ההודעה Skipping MCP tool ב-GROK_LOG_FILE / --debug. הסיבה מציינת את הכלל שנכשל (שם שרת לא תקין, שם כלי לא תקין, __ דו-משמעי, או מפתח קטלוג שאורכו עולה על 256 תווים).
  2. ודא שמפתח הגדרת השרת מתחיל באות או בקו תחתון. מפתח שמתחיל בספרה לעולם אינו נכנס לקטלוג. מפתח שמסתיים ב-_ מושמט כשם ___ דו-משמעי.
  3. ודא ששם הכלי משתמש רק ב-[A-Za-z0-9_-]. נקודות ונקודתיים בשם ה-MCP הגולמי מושמטים.
  4. אל תקצר מפתח server__tool ל-64 תווים. מפתחות קטלוג יכולים להגיע עד 256 תווים. מגבלת 64 התווים מיועדת רק ל-search_tool / use_tool כשמות פונקציות. ראה מתן שמות לכלים.

זה שונה ממצב שבו כלי חסר בהנחיה הראשונה מכיוון שלחיצת היד עדיין רצה. שלח הנחיה שנייה לאחר שהשרת הופעל, או הרץ את grok mcp doctor.

#הצגת מצב השרת

השתמש ב-grok inspect כדי לראות את כל שרתי ה-MCP שנטענו ואת המקורות שלהם:

grok inspect          
# פלט קריא לבני אדם
grok inspect --json   
# פלט קריא למכונה

#יומני ניפוי שגיאות

RUST_LOG=debug GROK_LOG_FILE=/tmp/grok.log grok
tail -f /tmp/grok.log

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