📘 תיעוד 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"           # Server executable
args = ["--flag", "value"]            # Command arguments
env = { API_KEY = "sk-..." }          # Environment variables
enabled = true                        # Enable or disable the server (default: true)
startup_timeout_sec = 30              # Server startup timeout, seconds (default: 30)
tool_timeout_sec = 6000               # Per-tool-call timeout fallback, seconds (default: 6000)
tool_timeouts = { slow_op = 120 }     # Per-tool timeout overrides, seconds

עקיפת זמן ההמתנה הגלובלי להפעלה: במקום להגדיר 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 > env > .grok/config.toml של המאגר > הגדרת משתמש או הגדרה מנוהלת > ברירת מחדל. עריכות במאגר חלות על סשנים שרצים בתיקייה הזו דרך טעינה מחדש חמה של ההגדרות.

#תעבורת 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 משורת הפקודה בלי לערוך קבצי הגדרות:

# List configured MCP servers
grok mcp list
grok mcp list --json          # Machine-readable output

# Add a stdio server. Everything after -- is the server command, so flags
# like -y reach the server instead of being parsed by grok.
grok mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /path/to/dir

# Add a stdio server with environment variables (-e is repeatable)
grok mcp add postgres -e DATABASE_URL=postgres://localhost/mydb -- npx -y @modelcontextprotocol/server-postgres

# Add a remote HTTP server
grok mcp add --transport http sentry https://mcp.sentry.dev/mcp

# Add a remote server with an authentication header (--header is repeatable)
grok mcp add --transport http api https://mcp.example.com/mcp --header "Authorization: Bearer YOUR_TOKEN"

# Add a remote SSE server
grok mcp add --transport sse linear https://mcp.linear.app/sse

# Remove a server
grok mcp remove github

# Enable or disable a local/TOML (or compat-sourced) server
grok mcp enable github
grok mcp disable github

# Diagnose a server's configuration and connectivity
grok mcp doctor               # Check every configured server
grok mcp doctor github        # Check one server
grok mcp doctor --json        # Machine-readable output

ברירת המחדל של התעבורה היא 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/config.toml של פרויקט גובר על קובץ המשתמש: מדיניות הארגון בוחנת הוספה בהיקף משתמש של שם שהיא מגדירה כהיקף פרויקט, והסירוב מציין את הקובץ הזה.

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 דביק, המפתח הבודד הזה מנוקה (הערות נשמרות). disable לעולם לא כותב מחדש הגדרות פרויקט.
• אין שוויון מלא מול /mcps: מחברי שער (managed_gateway:…, שמורים תחת disabled_mcp_tools.__managed_gateway_connectors) נשארים רק עם Space ב-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 בכל רמה:

אם פרויקט מגדיר שרת עם אותו שם כמו שרת גלובלי, גרסת הפרויקט מחליפה אותו לגמרי (השדות אינם ממוזגים). requirements.toml ו-MDM הם החריג: כשהם מגדירים command או url של שרת, הגדרת הארגון גוברת על כל קובץ פרויקט, וכשהם מגדירים enabled = false, שרת הפרויקט נשאר כבוי. בין ~/.grok/config.toml, הגדרה מנוהלת וקבצי requirements, קובץ בעדיפות גבוהה יותר שמגדיר command, url או urlTemplate לשרת מחליף את כל התעבורה של הקובץ הנמוך יותר, כולל args, env, cwd, type, headers, אסימונים, oauth ו-setup. רק enabled, expose_image_base64 והגדרות הזמן המוקצב עוברים מהקובץ הנמוך יותר. אותו דבר חל על טלאי קמפיין ועל [[version_overrides]] ו-[[experiments]] של הקובץ עצמו, ולכן עקיפה שמכוונת מחדש את url גם משמיטה את הכותרות והאסימונים של הקובץ הזה.

קבצים בהיקף פרויקט תורמים רשומות [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):

כלי שנדחה מדולג. שורת הלוג היא 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 כפקודת לוכסן
• או הריצו את /plugins ופתחו את הלשונית MCP Servers

מהחלון אפשר:

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

#גילוי כלים

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

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

#ארגומנטים של MCP שמגובים בקובץ

במערכת הקבצים המקומית של מעטפת Rust (Linux, macOS ו-Windows), use_tool מקבל בדיוק צורה אחת:

השתמשו בסריאלייזר למסמכים גדולים או לשרתים שדורשים JSON בתוך מחרוזת:

import json
from pathlib import Path

body = Path("/tmp/page.html").read_text(encoding="utf-8")
arguments = {"input": json.dumps({"page_id": "123", "body": body})}
Path("/tmp/mcp-arguments.json").write_text(json.dumps(arguments), encoding="utf-8")
Path("/tmp/mcp-call.json").write_text(
    json.dumps({"tool_name": "example__update_page", "tool_input": arguments}),
    encoding="utf-8",
)

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

כל מודל ב-Anthropic Messages API רואה רק את הצורה שבתוך השורה, וכך גם מודלי Claude דרך ממסר chat-completions: הספק הזה דוחה את סכמת צורות הקובץ (oneOf ברמת השורש) עם HTTP 400, וזה היה מכשיל כל תור. חלק מהספקים התואמים ל-OpenAI, כגון Azure OpenAI, דוחים גם הם oneOf ברמת השורש, ולכן ב-chat completions וב-Responses API מודל רואה את צורות הקובץ רק כאשר כתובת הבסיס שלו היא כתובת https על x.ai או על מארח *.x.ai, פרוקסי הצ'אט של Grok ([endpoints] cli_chat_proxy_base_url או GROK_CLI_CHAT_PROXY_BASE_URL), או [endpoints] xai_api_base_url (GROK_XAI_API_BASE_URL). פרוקסי צ'אט מוגדר או כתובת API של xAI חייבים להתאים לכתובת הבסיס בדיוק. / בסוף לא תואם. models_base_url לא מוסיף אמון משלו: מודלים שמוגשים ממנו שומרים את צורות הקובץ רק כאשר הכתובת הזו היא גם אחת מהכתובות שלמעלה.

המקורות חייבים להיות אובייקטי JSON רגילים, מלאים, בקידוד UTF-8, לכל היותר 8 MiB. JSON פגום או עם תוכן עודף אחריו, מפתחות מעטפה כפולים, שדות חסרים, נתיבי null וארגומנטי הפעלה שאינם אובייקט נדחים. כל אצווה מוכנה מתירה 16 MiB של קלט מקור ו-32 MiB של הפעלות אפקטיביות אחרי סריאליזציה, כולל שכתובים של hooks. לפעולות קובץ יש דדליין של 10 שניות, בלי זמני המתנה להרשאה. המגבלות האלה לא משנות חלונות קריאה רגילים, לא מבטיחות קבלה מרוחקת, ולא קוטעות קלט/פלט של הליבה.

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

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

#תאימות

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

כל המקורות ממוזגים לפי סדר עדיפות: 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]).

#OAuth של MCP

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

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

השתמש בטופס url לשרתי MCP מתארחים ובטופס command / args לכלי stdio מקומיים.

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

עליך לאמת שרתי MCP מבוססי OAuth לפני שאפשר להשתמש בהם. גרוק שומר את האסימונים שמתקבלים תחת ~/.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

לשרתים פנימיים או באירוח עצמי שמאמתים עם אסימון bearer סטטי ולא עם 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}). גרוק מרחיב בזמן הטעינה שדות מחרוזת ב-[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}" }

כשתהליך אחר שומר אסימון קצר מועד בקובץ (עוזר אישורים, sidecar, או משימת cron), כוון את bearer_token_file אליו. גרוק קורא את הקובץ בכל בקשה לשרת ושולח Authorization: Bearer <contents>, כשהרווח הלבן מסביב נחתך, כך שאסימון שהוחלף נכנס לתוקף בבקשה הבאה בלי להפעיל מחדש את גרוק ובלי לחבר מחדש את השרת:

[mcp_servers.internal-tools]
url = "https://mcp.internal.example.com/mcp"
bearer_token_file = "~/.config/internal-tools/token"

הנתיב חייב להיות מוחלט או להתחיל ב-~/, והוא יכול להפנות ל-${VAR}. כל נתיב אחר מפיל את השרת עם שגיאה. bearer_token_file עובד לשרתי HTTP ו-SSE ומחליף כותרת Authorization או bearer_token_env_var. שרתים עם קובץ אסימון מדלגים על גילוי OAuth. בקשה נכשלת עם שגיאה שמציינת את הנתיב כשהקובץ חסר, ריק, גדול מ-16 KiB, אינו UTF-8, או מכיל תווים שאינם מותרים בכותרת HTTP.

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

#stdio מקומי

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

# Filesystem access scoped to a directory
[mcp_servers.filesystem]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/directory"]

# Local Postgres
[mcp_servers.postgres]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:pass@localhost/db"]

# Custom server with a longer startup timeout and tuned per-tool timeouts
[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 כמעטפות אצווה .cmd (אין npx.exe). גרוק פותר command חשוף כמו npx לנתיב המשגר האמיתי שלו ב-PATH (תוך כיבוד PATHEXT) לפני יצירת התהליך, כך שהם עובדים בלי לעטוף אותם ידנית ב-cmd /c. command שניתן כנתיב מוחלט או שמכיל מפריד נתיב משמש כפי שהוא.

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

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

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

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

כשאותו שם שרת מופיע גם ב-config.toml / .mcp.json וגם ב-frontmatter של mcpServers של הסוכן הפעיל, agent.md מנצח (כולל כותרות HTTP). השכבה מוחלת מחדש בטעינה חמה של ההגדרות, בטעינה מחדש של תוסף ובהחלפת סוכן, כך שמימוש מחדש מהדיסק לא יכול להחזיר את כותרות ה-toml. החלפת סוכן מחליפה את השכבה במושב החדש בלבד: שרתים שהסוכן החדש משמיט מוסרים, וסוכן בלי mcpServers מנקה את השכבה הקודמת.

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

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

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

#MCP בתאי Execute

במסלול ה-daemon, תאי Execute של המודל יכולים לקרוא לכלי MCP דרך host.mcp, לפי אותם כללים, hooks וכרטיסי אישור כמו CallMcpTool. תהליכי עבודה במסלול ה-daemon מפרט את ה-API ואת החריגים.

#פתרון בעיות

#השרת לא עולה

# Test the server command manually
npx -y @modelcontextprotocol/server-filesystem /path

# Increase startup timeout
# In config.toml:
[mcp_servers.filesystem]
startup_timeout_sec = 30

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

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

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

אם מדיניות TOML מקורית או managed-settings.json של Claude מגדירים deniedMcpServers, allowedMcpServers לא ריק, או allowManagedMcpServersOnly, גרוק משמיט שרתים שלא תואמים בזמן המיזוג ורושם ביומן 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 כשמות פונקציה. ראה שמות כלים.

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

#צפייה בסטטוס השרת

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

grok inspect          # Human-readable
grok inspect --json   # Machine-readable

#רישום יומן לניפוי

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

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