תיעוד 61

שליטה בגישה לשרתי MCP עבור הארגון שלך

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

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

הגבלות אלו מכסות את השרתים ש-Claude Code טוען בעצמו, כולל המחברים שהוא מושך מ-claude.ai. מחברים שיישום שולחן העבודה מעביר להפעלות מקומיות ולהפעלות SSH שלו מגיעים בתוך התהליך (in-process) ונשלטים במקום זאת מהגדרות הארגון שלך ב-claude.ai. המדריך כיצד מחברים מגיעים אל Claude Code מציג אילו בקרות חלות על מחברים בכל סוג הפעלה, כולל הפעלות ענן.

דף זה מכסה כיצד:

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

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

#בחירת תבנית

Claude Code תומך במגוון רמות הגבלה. כל תבנית משתמשת באחד או בשני המנגנונים המפורטים להלן: managed-mcp.json לפריסת ערכה קבועה, ו-allowedMcpServers/deniedMcpServers לסינון מה שמשתמשים מגדירים.

תבנית	מה היא עושה	מה להגדיר
השבתת MCP	שום שרת לא נטען, למעט שרתים בתוך התהליך שהיישום שהפעיל את ההפעלה רושם	`managed-mcp.json` עם מיפוי שרתים ריק
פריסה קבועה	כל משתמש מקבל את אותם השרתים ואינו יכול להוסיף אחרים	`managed-mcp.json` עם השרתים הרצויים לך
קטלוג מאושר	פרסום רשימה של שרתים מאושרים. משתמשים מוסיפים את אלה שהם רוצים, כל השאר נחסמים	`allowedMcpServers` בתוספת `allowManagedMcpServersOnly: true`
שרתי תוספים בלבד	משתמשים אינם יכולים להוסיף שרתים דרך `~/.claude.json` או `.mcp.json`. שרתי תוספים עדיין נטענים	`strictPluginOnlyCustomization` עם `mcp` ברשימה
רשימת היתר גמישה	אכיפת רשימת היתר שמשתמשים יכולים להרחיב בהגדרות שלהם	`allowedMcpServers` ללא `allowManagedMcpServersOnly`
רשימת חסימה בלבד	חסימת שרתים הידועים כמזיקים, והתרת כל השאר	`deniedMcpServers`
ללא הגבלות	משתמשים יכולים להוסיף כל דבר	אין לפרוס תצורת MCP מנוהלת כלשהי

הערה: ל-Claude Code אין מאגר שרתי MCP מובנה שמשתמשים יכולים לעיין בו ולהתקין ממנו. עבור תבנית הקטלוג המאושר, שתף את הרשימה המאושרת ואת פקודות ה-claude mcp add שלה במקום שהמשתמשים שלך ימצאו, כגון ויקי פנימי, או הפץ את השרתים כתוספים דרך מרקטפלייס תוספים מנוהל כדי שמשתמשים יוכלו לעיין בהם ולהתקין אותם מתוך /plugin.

#שליטה בלעדית באמצעות managed-mcp.json

אם פורסים קובץ managed-mcp.json, Claude Code טוען רק את השרתים שקובץ זה מגדיר, בנוסף לשרתים כלשהם בתוך התהליך (in-process) שהיישום שהפעיל את ההפעלה רושם, כגון השרת של תוסף VS Code עצמו או המחברים שיישום שולחן העבודה מעביר. משתמשים אינם יכולים להוסיף, לשנות או להשתמש באף שרתי MCP אחרים, כולל שרתים המסופקים על ידי תוספים ושרתים המועברים באמצעות דגל ה-CLI בשם --mcp-config. הקובץ גם מנטרל את מחברי claude.ai ש-Claude Code מושך בעצמו, אלא אם מתירים אותם לצד הערכה המנוהלת.

מה שמשתמש רואה כאשר הפעלה אכן מקבלת שרתי --mcp-config תלוי במקום שבו ההפעלה רצה:

בתחנת עבודה, Claude Code יוצא בעת ההפעלה עם השגיאה You cannot dynamically configure MCP servers when an enterprise MCP config is present.
בהפעלות ענן במארח שבו הקובץ פרוס, כגון מריץ באירוח עצמי (self-hosted runner), Claude Code מופעל עם השרתים המנוהלים בלבד ומדלג על מחברי claude.ai ושרתים אחרים שמארח הענן מעביר דרך --mcp-config. שום דבר בתוך ההפעלה אינו מדווח למשתמש אילו שרתים הושמטו. Claude Code מציין את שמותיהם באזהרה בפלט השגיאות הסטנדרטי (stderr), שמריץ באירוח עצמי מתעד ברמת יומן debug. לפני גרסה v2.1.229, הפעלות אלו יצאו עם אותה שגיאה שמוצגת בתחנת עבודה.

אם משתמש מעביר את הדגל --strict-mcp-config, Claude Code יוצא בעת ההפעלה הן בתחנת עבודה והן בהפעלת ענן כאחד, מכיוון שדגל זה מבקש להחליף את הערכה המנוהלת.

שתי הגדרות נוספות יכולות לסנן עוד יותר את הערכה המנוהלת:

allowedMcpServers ו-deniedMcpServers חלות גם על שרתים מנוהלים, כך ששרת מנוהל שאינו עובר אותן לא ייטען.
ה-deniedMcpServers של המשתמש עצמו מתמזג מתוך ההגדרות שלו, כך שמשתמשים יכולים לחסום שרת מנוהל עבור עצמם.

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

managed-mcp.json הוא קובץ עצמאי, ולכן לא ניתן להעביר אותו דרך הגדרות מנוהלות שרת. כל תהליך שיכול לכתוב לנתיב מערכת עם הרשאות מנהל יכול לפרוס אותו. בכלל מכשירי הארגון, הדבר נעשה בדרך כלל באמצעות כלי ניהול מכשירים, כגון Jamf או פרופיל תצורה ב-macOS, פוליסות Group Policy או Intune ב-Windows, או כלי ניהול המכשירים המועדף עליך ב-Linux. Claude Code מחפש את הקובץ באחד הנתיבים הבאים:

פלטפורמה	נתיב
macOS	`/Library/Application Support/ClaudeCode/managed-mcp.json`
Linux ו-WSL	`/etc/claude-code/managed-mcp.json`
Windows	`C:\Program Files\ClaudeCode\managed-mcp.json`

הקובץ משתמש באותו פורמט כמו קובץ .mcp.json ברמת הפרויקט:

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "sentry": {
      "type": "http",
      "url": "https://mcp.sentry.dev/mcp"
    },
    "company-internal": {
      "type": "stdio",
      "command": "/usr/local/bin/company-mcp-server",
      "args": ["--config", "/etc/company/mcp-config.json"],
      "env": {
        "COMPANY_API_URL": "https://internal.example.com"
      }
    }
  }
}

#אימות באמצעות פרטי זיהוי פר-משתמש

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

הרחבת ${VAR} כדי לקרוא סודות מסביבת המשתמש של כל אחד.
OAuth או כותרות פר-משתמש כדי שכל משתמש יזדהה בעצמו.
headersHelper ליצירת פרטי זיהוי בעת החיבור.

#אימות התצורה

כדי לוודא שהקובץ פעיל, בצע שתי בדיקות במכונה מנוהלת:

הפקודה claude mcp list מציגה רק את השרתים שב-managed-mcp.json. אם שרתים של המשתמש עצמו עדיין מופיעים, הקובץ אינו נקרא. יש לבדוק את הנתיב ואת ההרשאות.
הפקודה claude mcp add --transport http test https://example.com/mcp נכשלת עם הודעת השגיאה Cannot add MCP server: enterprise MCP configuration is active and has exclusive control over MCP servers. כתובת ה-URL אינה חייבת להיות שרת אמיתי, מכיוון שבדיקת המדיניות דוחה את הפקודה לפני שמתבצעת פנייה כלשהי.

#השבתת MCP לחלוטין

פרוס קובץ managed-mcp.json המכיל מיפוי שרתים ריק כדי לחסום כל שרת MCP, למעט שרתים בתוך התהליך שהיישום שהפעיל את ההפעלה רושם:

{
  "mcpServers": {}
}

הפקודה claude mcp add נכשלת עם שגיאת מדיניות הארגון המוזכרת לעיל. שרתים שמשתמשים הגדירו בעבר מפסיקים להיטען בפעם הבאה שהם מפעילים הפעלה, ללא אזהרה שמדיניות היא הסיבה לכך.

#התרת מחברי claude.ai לצד הערכה המנוהלת

כברירת מחדל, פריסת managed-mcp.json מנטרלת את מחברי claude.ai ש-Claude Code מושך בעצמו, כולל מחברים שמנהל מערכת הגדיר עבור הארגון בלוח הניהול של claude.ai. כדי לטעון מחברים אלה לצד השרתים שב-managed-mcp.json, הגדר "allowAllClaudeAiMcps": true בתוך מקור הגדרות מנוהל.

כאשר הגדרה זו מופעלת, Claude Code טוען את אותם מחברי claude.ai שהיה טוען אלמלא managed-mcp.json היה פרוס. רשימות היתר ורשימות חסימה עדיין חלות על מחברים אלה, כך שבאפשרותך לחסום מחברים ספציפיים באמצעות deniedMcpServers. ההגדרה משפיעה רק על מחברי claude.ai ש-Claude Code מושך בעצמו. שרתים המסופקים על ידי תוספים נשארים מנוטרלים.

הפעלות ענן, וכן הפעלות מקומיות והפעלות SSH של יישום שולחן העבודה, מקבלות מחברים בדרך אחרת, המתוארת בסעיף כיצד מחברים מגיעים אל Claude Code. קובץ managed-mcp.json במארח שמריץ הפעלת ענן, כגון מארח של מריץ באירוח עצמי, מנטרל את המחברים של אותה הפעלה בין אם הגדרת את allowAllClaudeAiMcps ובין אם לא. שום managed-mcp.json אינו משפיע על המחברים שיישום שולחן העבודה מעביר להפעלות המקומיות ולהפעלות ה-SSH שלו.

Claude Code קורא את allowAllClaudeAiMcps רק מרמות מדיניות הנשלטות על ידי מנהל מערכת: הגדרות מנוהלות שרת, פרופיל plist שנפרס על ידי MDM או מפתח רישום HKLM, או קובץ מערכת מסוג managed-settings.json. הצבתו בהגדרות משתמש או בהגדרות פרויקט אינה משפיעה, ולכן משתמשים אינם יכולים להפעיל מחדש מחברים שנוטרלו בעקבות שליטה בלעדית.

#שליטה מבוססת מדיניות באמצעות רשימות היתר ורשימות חסימה

רשימות היתר ורשימות חסימה מסננות אילו שרתים מוגדרים מורשים להיטען. הן אינן מאגר רישום: על השרת עדיין להתווסף על ידי משתמש, תוסף או managed-mcp.json לפני שרשימת ההיתר או רשימת החסימה חלה עליו. כדי לפרוס שרתים למשתמשים, השתמש ב-managed-mcp.json. שתי הרשימות מסננות גם שרתים המועברים באמצעות דגל ה-CLI בשם --mcp-config, למעט רשומות בתוך התהליך מסוג type: "sdk". הדגל --strict-mcp-config מגביל אילו קובצי תצורה נטענים ואינו עוקף אף אחת מהרשימות.

כדי להפוך את רשימת ההיתר למחייבת, הגדר את allowedMcpServers יחד עם allowManagedMcpServersOnly: true בתוך מקור הגדרות מנוהל, כגון הגדרות מנוהלות שרת או קובץ managed-settings.json פרוס. הסעיף הגבלת רשימת ההיתר להגדרות מנוהלות בלבד מציג את התצורה. ללא allowManagedMcpServersOnly, רשימות היתר מכל מרחב הגדרות מתמזגות, כולל קובץ ~/.claude/settings.json האישי של המשתמש, כך שמשתמש יכול להרחיב את מה שרשימת ההיתר שלך מתירה. רשימות חסימה מתמזגות מכל מרחב בכל מקרה.

הערה: ההגדרה allowManagedMcpServersOnly נפרדת מ-allowManagedPermissionRulesOnly, אשר נועלת כללי הרשאות בלבד. הגדרת דגל זה אינה אוכפת את רשימת ההיתר של MCP.

#התאמת שרתים לפי URL, פקודה או שם

allowedMcpServers ו-deniedMcpServers הן רשימות של רשומות. כל רשומה היא אובייקט עם מפתח יחיד שמזהה שרתים לפי ה-URL שלהם, הפקודה שלהם או השם שלהם:

מפתח	מה הוא מתאים	שימוש עבור
`serverUrl`	כתובת URL של שרת מרוחק, מדויקת או עם תווי כוכבית `*` כלליים	שרתי HTTP ו-SSE
`serverCommand`	הפקודה והארגומנטים המדויקים שמפעילים שרת stdio	שרתי Stdio
`serverName`	התווית שהוקצתה על ידי המשתמש. התאמה מדויקת בלבד. תווים כלליים אינם מורחבים	כל אחד מהסוגים, אך ראו את האזהרה להלן

השארת allowedMcpServers ללא הגדרה שונה מהגדרתו כמערך ריק:

הגדרה	לא מוגדר (ברירת מחדל)	מערך ריק `[]`	מאוכלס
`allowedMcpServers`	כל השרתים מותרים	שום שרת אינו מותר	רק שרתים תואמים מותרים
`deniedMcpServers`	שום שרת אינו חסום	שום שרת אינו חסום	שרתים תואמים נחסמים

ראו רשומות לא תקינות בהגדרות מנוהלות לגבי מה שקורה כאשר רשומה נכשלת באימות סכמה.

אזהרה: רשומת serverName, בכל אחת מהרשימות, אינה בקרת אבטחה. השם הוא התווית שמשתמש מקצה בעת הרצת claude mcp add או בעת עריכת קובץ תצורה, ולא השרת שמתחתיו, כך שמשתמש יכול לקרוא לכל שרת בשם github. עבור מחברי claude.ai השם הוא שם התצוגה המוחזר על ידי claude.ai, אשר עשוי להשתנות. כדי לאכוף אילו שרתים רצים בפועל, הוסף רשומות serverCommand או serverUrl.

אימות serverName שונה בין שתי הרשימות:

ב-deniedMcpServers, הערך serverName מקבל כל מחרוזת שאינה ריקה, כך שניתן לחסום מחברי claude.ai לפי שם התצוגה שלהם. לדוגמה, { "serverName": "claude.ai Slack" } חוסם את מחבר Slack. העדף רשומת serverUrl כאשר נדרש שהחסימה תהיה עמידה בפני שינויי שמות, או כאשר שם מחבר מתנגש ומקבל סיומת (N).
ב-allowedMcpServers, הערך serverName מוגבל לאותיות, מספרים, מקפים וקווים תחתונים. השתמש ב-serverUrl כדי להוסיף לרשימת ההיתר מחבר claude.ai ש-Claude Code מושך בעצמו. עבור מחברים שמארח ענן מעביר להפעלות באירוח עצמי, השתמש במקום זאת ברשומות המפורטות תחת תעבורת מחברים יוצאת מהרשת שלך.

כדי לכבות את כל מחברי claude.ai ש-Claude Code מושך בעצמו, ראו disableClaudeAiConnectors.

#כיצד שרת מוערך

לפני טעינת שרת, כולל שרת מתוך managed-mcp.json, Claude Code מריץ את שלוש הבדיקות שלהלן לפי הסדר. הוא מריץ אותן שוב כאשר משתמש מחבר מחדש שרת או מפעיל מחדש שרת שהושבת בתוך /mcp. שרתי type: "sdk" בתוך התהליך, אשר היישום שהפעיל את ההפעלה רושם, מדלגים על כל שלוש הבדיקות.

מיזוג הרשימות. רשומות רשימת ההיתר ורשימת החסימה מכל מרחב הגדרות משתלבות לרשימת היתר אחת ולרשימת חסימה אחת, כאשר רשימות המרחב המנוהל מגיעות מתוך המקור או המקורות המנוהלים ש-Claude Code מחיל. כאשר allowManagedMcpServersOnly מוגדר כ-true, רק רשימת ההיתר המנוהלת נשמרת. רשימת החסימה מתמזגת תמיד מכל המרחבים.
בדיקת רשימת החסימה. שרת שתואם לרשומת רשימת חסימה כלשהי, לפי URL, פקודה או שם, נחסם. שום דבר אינו גובר על התאמה ברשימת חסימה.
בדיקת רשימת ההיתר. אם allowedMcpServers אינו מוגדר באף מקום, כל שרת שעבר את רשימת החסימה נטען. אם הוא מוגדר, מה שהשרת חייב להתאים לו תלוי בסוג שלו, כפי שמוצג בטבלה להלן. שרתים מובנים כגון Claude in Chrome, שרת ה-ide ש-Claude Code מתחבר אליו בסביבת עבודה פועלת של VS Code או JetBrains, ושרתים שה-CLI עצמו מגדיר, מדלגים על בדיקה זו.

סוג שרת	מותר כאשר הוא תואם ל-
מרוחק (HTTP או SSE)	רשומת `serverUrl`. התאמת `serverName` נחשבת רק כאשר רשימת ההיתר אינה מכילה רשומות `serverUrl`
Stdio	רשומת `serverCommand`. התאמת `serverName` נחשבת רק כאשר רשימת ההיתר אינה מכילה רשומות `serverCommand`

שלושה כללי התאמה חלים בתוך בדיקות אלו:

פקודות מתאימות במדויק. כל ארגומנט, לפי הסדר. ["npx", "-y", "server"] אינו תואם ל-["npx", "server"] או ל-["npx", "-y", "server", "--flag"].
ערכי serverCommand ו-serverUrl מורחבים לפני ההתאמה. גם רשומת המדיניות וגם הערך המוגדר של השרת עוברים הרחבת ${VAR} ו-${VAR:-default}, כך שרשומה שנכתבה בתור ["${HOME}/bin/server"] תואמת לתצורת שרת שמשתמשת באותה הפניה או בנתיב המורחב. ב-Windows, יש להפנות למשתנה סביבה שמוגדר שם, כגון ${USERPROFILE} במקום ${HOME}. ערכי serverName מתאימים באופן מילולי ולעולם אינם מורחבים. שני הצדדים קוראים סביבות שונות. הסעיף כיצד רשומות מדיניות מורחבות מכסה אילו סביבות, וכיצד רשומות רשימת היתר ורשימת חסימה נבדלות.
כתובות URL תומכות בתווי כוכבית * כלליים בכל מקום בתבנית, כולל בפרוטוקול. התאמת שמות מארח אינה תלויה באותיות גדולות או קטנות ומתעלמת מנקודת FQDN בסוף, כך ש-https://Mcp.Example.com/* תואם ל-https://mcp.example.com/api. נתיבים נשארים תלויי אותיות גדולות או קטנות.

תבנית	מתירה
`https://mcp.example.com/*`	כל הנתיבים בדומיין ספציפי
`https://mcp.example.com`	גם כן כל הנתיבים באותו דומיין. תבנית ללא נתיב תואמת לכל נתיב
`https://.example.com/`	כל תת-דומיין של `example.com`
`http://localhost:/`	כל יציאה (port) ב-localhost
`://mcp.example.com/`	כל פרוטוקול לדומיין ספציפי

#כיצד רשומות מדיניות מורחבות

הערך המוגדר של השרת מתרחב מסביבת התהליך החיה, כמו שאר .mcp.json. לעומת זאת, רשומת מדיניות מתרחבת מסביבה מקובעת (pinned environment), כך שמשתנה שנקבע על ידי קובץ הגדרות פרויקט או משתמש אינו יכול לשנות את המשמעות של רשומת רשימת היתר. מכיוון שרשומת מדיניות עדיין תלויה בערך של המעטפת (shell) המפעילה עבור כל משתנה שהיא מפנה אליו, השתמש בכתובות URL ובפקודות מילוליות עבור רשומות שאתה מסתמך עליהן לצורך אכיפה.

רשימת רשומות	מתרחבת מתוך	הרחבה שהייתה משנה פרוטוקול, מארח או היקף נתיב של רשומת URL
`allowedMcpServers`	הסביבה ש-Claude Code הופעל איתה, בתוספת ערכי `env` מהגדרות מנוהלות	Claude Code מתעלם מהרשומה
`deniedMcpServers`	אותו הדבר, ומשתנה ללא ערך הפעלה וללא `:-default` מתמלא מקובצי הגדרות שמחוץ למאגר, כגון הגדרות משתמש או הגדרות מנוהלות, מה שרק מרחיב את מה שהרשומה מתאימה לו	הרשומה עדיין מתאימה

דורש את Claude Code בגרסה v2.1.219 ומעלה.

#דוגמת תצורה

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

{
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://mcp.sentry.dev/*" },
    { "serverCommand": ["npx", "-y", "@modelcontextprotocol/server-filesystem", "."] },
    { "serverCommand": ["python", "/usr/local/bin/approved-server.py"] },
    { "serverUrl": "https://mcp.example.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ],
  "deniedMcpServers": [
    { "serverName": "dangerous-server" },
    { "serverCommand": ["npx", "-y", "unapproved-package"] },
    { "serverUrl": "https://*.untrusted.example.com/*" }
  ]
}

שורה 3: רשומת ה-serverUrl הראשונה. מרגע שקיימת רשומה כזו, כל שרת מרוחק חייב להתאים לתבנית URL, כך שמשתמש אינו יכול להעביר שרת מרוחק שאינו ברשימה על ידי מתן שם מורשה.
שורה 5: רשומת ה-serverCommand הראשונה. אותה השפעה עבור שרתי stdio, כך שכל שרת מקומי חייב להתאים במדויק לפקודה רשומה.
שורה 11: רשומת serverName ברשימת החסימה. רשומות רשימת חסימה חלות תמיד, כך שכל שרת בשם dangerous-server נחסם ללא תלות ב-URL או בפקודה שלו.

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

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

#רשימת היתר מבוססת URL בלבד

{
  "allowedMcpServers": [
    { "serverUrl": "https://mcp.example.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ]
}

שרת	תוצאה
שרת HTTP בכתובת `https://mcp.example.com/api`	מותר: תואם לתבנית URL
שרת HTTP בכתובת `https://api.internal.example.com/mcp`	מותר: תואם לתת-דומיין עם תו כוכבית כללי
שרת HTTP בכתובת `https://external.example.com/mcp`	חסום: אינו תואם לאף תבנית URL
שרת Stdio עם פקודה כלשהי	חסום: אין רשומות שם או פקודה להתאמה

#רשימת היתר מבוססת פקודות בלבד

{
  "allowedMcpServers": [
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}

שרת	תוצאה
שרת Stdio עם `["npx", "-y", "approved-package"]`	מותר: תואם לפקודה
שרת Stdio עם `["node", "server.js"]`	חסום: אינו תואם לפקודה
שרת HTTP בשם `my-api`	חסום: אין רשומות שם להתאמה

#רשימת היתר מעורבת של שם ופקודה

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverCommand": ["npx", "-y", "approved-package"] }
  ]
}

שרת	תוצאה
שרת Stdio בשם `local-tool` עם `["npx", "-y", "approved-package"]`	מותר: תואם לפקודה
שרת Stdio בשם `local-tool` עם `["node", "server.js"]`	חסום: קיימות רשומות פקודה אך אינו תואם
שרת Stdio בשם `github` עם `["node", "server.js"]`	חסום: שרתי stdio חייבים להתאים לפקודות כאשר קיימות רשומות פקודה
שרת HTTP בשם `github`	מותר: תואם לשם
שרת HTTP בשם `other-api`	חסום: השם אינו תואם

#רשימת היתר מבוססת שם בלבד

{
  "allowedMcpServers": [
    { "serverName": "github" },
    { "serverName": "internal-tool" }
  ]
}

שרת	תוצאה
שרת Stdio בשם `github` עם פקודה כלשהי	מותר: אין הגבלות פקודה
שרת Stdio בשם `internal-tool` עם פקודה כלשהי	מותר: אין הגבלות פקודה
שרת HTTP בשם `github`	מותר: תואם לשם
כל שרת בשם `other`	חסום: השם אינו תואם

#רשימת היתר עם עקיפת רשימת חסימה

{
  "allowedMcpServers": [
    { "serverUrl": "https://*.example.com/*" }
  ],
  "deniedMcpServers": [
    { "serverUrl": "https://staging.example.com/*" }
  ]
}

שרת	תוצאה
שרת HTTP בכתובת `https://mcp.example.com/api`	מותר: תואם לתבנית URL ברשימת ההיתר, אין התאמה ברשימת החסימה
שרת HTTP בכתובת `https://staging.example.com/api`	חסום: תואם לשתיהן, אך רשימת החסימה מקבלת קדימות
שרת HTTP בכתובת `https://other.com/mcp`	חסום: אינו תואם לרשימת ההיתר

#הגבלת רשימת ההיתר להגדרות מנוהלות בלבד

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

{
  "allowManagedMcpServersOnly": true,
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://*.internal.example.com/*" }
  ]
}

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

#כיצד הגבלות נראות למשתמשים

לגבי מה שמשתמשים רואים בעת ההפעלה כאשר managed-mcp.json פרוס ולהפעלה יש גם שרתי --mcp-config, ראו שליטה בלעדית באמצעות managed-mcp.json. השתמש בטבלה זו כדי לזהות את הדיווחים האחרים וכדי ליידע משתמשים למה לצפות לפני החלת שינוי:

הגבלה	מה המשתמש רואה
`managed-mcp.json` קיים והמשתמש מריץ `claude mcp add`	`Cannot add MCP server: enterprise MCP configuration is active and has exclusive control over MCP servers`
השרת נמצא ברשימת חסימה והמשתמש מריץ `claude mcp add`	`Cannot add MCP server "<name>": server is explicitly blocked by enterprise policy`
השרת אינו ברשימת ההיתר והמשתמש מריץ `claude mcp add`	`Cannot add MCP server "<name>": not allowed by enterprise policy`
שרת שהוגדר בעבר נחסם כעת על ידי מדיניות	השרת נעלם בשקט מתוך `/mcp` ומתוך `claude mcp list` ללא אזהרה
שרת נחסם בזמן שהפעלה רצה, והמשתמש בוחר ב-Reconnect או מפעיל אותו מחדש בתוך `/mcp`	`MCP server <name> is blocked by enterprise managed policy`

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

#ניטור השימוש ב-MCP

כאשר ייצוא OpenTelemetry מוגדר, Claude Code יכול לתעד אילו שרתי MCP וכלים המשתמשים מפעילים. הגדר את OTEL_LOG_TOOL_DETAILS=1 כדי לכלול שמות שרתי MCP וכלים באירועי כלים, ולאחר מכן רכז אותם ב-collector שלך כדי לראות לאילו שרתים המשתמשים שלך מתחברים בפועל. ראו ניטור להגדרת המייצא ולסכמת האירועים המלאה.

#סיכום תצורה

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

רכיב	על מה הוא שולט	היכן הוא נמצא	כיצד להעביר
`managed-mcp.json`	ערכת שרתים קבועה, שליטה בלעדית	נתיב מערכת: `/Library/Application Support/ClaudeCode/`, `/etc/claude-code/`, או `C:\Program Files\ClaudeCode\`	MDM, פוליסות GPO, כלי ניהול מכשירים, או כל תהליך עם הרשאות מנהל מערכת. לא ניתן להגדרה דרך הגדרות מנוהלות שרת
`allowedMcpServers`	רשימת היתר של שרתים מורשים	כל מרחב הגדרות. Claude Code ממזג את הרשימות מכל מרחב אלא אם כן `allowManagedMcpServersOnly` מוגדר, ולוקח את רשימת המרחב המנוהל מתוך המקור המנוהל היחיד שהוא בוחר או מרכיב	לצורך אכיפה, מקור הגדרות מנוהל: הגדרות מנוהלות שרת, `managed-settings.json`, פרופיל MDM, או רישום (registry)
`deniedMcpServers`	רשימת חסימה של שרתים חסומים	כל מרחב הגדרות. Claude Code ממזג את הרשימות מכל מרחב, ומבין מקורות מנוהלים כפי שמתואר בסעיף כיצד Claude Code משלב מקורות מנוהלים	זהה ל-`allowedMcpServers`
`allowManagedMcpServersOnly`	נועל את רשימת ההיתר למקורות מנוהלים בלבד	מקורות הגדרות מנוהלים בלבד. אין להגדרה שום השפעה במקום אחר	זהה ל-`allowedMcpServers`
`allowAllClaudeAiMcps`	טוען את מחברי `claude.ai` ש-Claude Code מושך בעצמו לצד `managed-mcp.json`. קובץ `managed-mcp.json` במארח שמריץ הפעלת ענן עדיין מנטרל את המחברים של אותה הפעלה	מקורות הגדרות מנוהלים בלבד. אין להגדרה שום השפעה במקום אחר	זהה ל-`allowedMcpServers`

#משאבים קשורים

החלטה מה לאכוף: הגבלות MCP לצד כללי הרשאות, ארגז חול (sandboxing) ובקרות ניהוליות נוספות
חיבור Claude Code לכלים באמצעות MCP: מדריך ה-MCP המלא, כולל סוגי תעבורה, מרחבים ואימות
הגדרות: היררכיית ההגדרות וכיצד הגדרות מנוהלות מקבלות עדיפות
הגדרות מנוהלות שרת: העברת allowedMcpServers ו-deniedMcpServers מלוח הניהול של Claude.ai
אבטחה: מודל האיומים שבקרות אלו מגנות מפניו
מדריך מנהל מערכת של Claude Enterprise: SSO, SCIM, ניהול מושבים ותוכנית פריסה