MCP — התחבר לכל דבר

1. מה זה MCP ולמה זה משנה הכל

MCP זה ראשי תיבות של Model Context Protocol — פרוטוקול הקשר למודל. זה תקן פתוח שנוצר על ידי Anthropic בנובמבר 2024 ומגדיר איך סוכני AI מתחברים לכלים חיצוניים, מקורות מידע, ושירותים. חשוב על זה ככה: בלי MCP, ל-Claude Code יש רק את הכלים המובנים — Read, Edit, Write, Bash, Grep, Glob, WebSearch, WebFetch. זה שמונה כלים חזקים, אבל הם מוגבלים לקבצים ולטרמינל שלך. אין שם גישה לדפדפן, ל-API של GitHub, למסד נתונים, או לשום שירות חיצוני.

עם MCP, Claude מקבל גישה לכל דבר: מסדי נתונים, דפדפנים, APIs של GitHub, Google Sheets, Slack, Notion, ועוד מאות שירותים. נכון למרץ 2026, האקוסיסטם של MCP כולל מאות שרתים — מהרשמיים של Anthropic ועד שרתים קהילתיים שנכתבו על ידי מפתחים ברחבי העולם. כל שירות שיש לו שרת MCP — Claude יכול לעבוד איתו.

נקודה חשובה: MCP הוא לא ספציפי ל-Claude. זה תקן פתוח שעובד עם כל סוכן AI שמיישם את הפרוטוקול. אבל ל-Claude Code יש את האינטגרציה העמוקה ביותר עם MCP מכל כלי בשוק — וזה יתרון משמעותי.

לפני MCP מול אחרי MCP

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

זה ההבדל המהותי. MCP לא מוסיף יכולת חדשה שלא הייתה אפשרית קודם — הוא הופך פעולות שדרשו עבודה ידנית לאוטומטיות לחלוטין, ונותן ל-Claude כלים ייעודיים במקום עבודה "דרך הדלת האחורית" של Bash.

מה משתנה עם MCP?

בלי MCP, אם רצית ש-Claude יבדוק משהו ב-GitHub, היית צריך להריץ פקודת gh דרך Bash. זה עובד, אבל זה מוגבל — Claude צריך לנחש את התחביר, לפרסר את הפלט הטקסטואלי, ולטפל בשגיאות ידנית. עם MCP, Claude מקבל כלי GitHub ייעודי שמבין את כל ה-API: יצירת Issues, קריאת Pull Requests, בדיקת CI/CD, ניהול Releases. הכלי חכם יותר, מהיר יותר, ובטוח יותר מהרצת פקודות Bash — כי הפרמטרים מוגדרים בסכמה ברורה, והתשובה מגיעה כ-JSON מובנה.

כל שרת MCP מספק כלי אחד או יותר (tools). הכלים האלה מופיעים לצד הכלים המובנים של Claude, והוא משתמש בהם באותו אופן — Claude לא מבדיל בין כלי מובנה לכלי MCP. הוא פשוט בוחר את הכלי המתאים ביותר למשימה.

הקידומת של כלי MCP היא תמיד mcp__ ואחריה שם השרת והפעולה. ככה Claude (ואתה) יכולים לזהות מאיפה הכלי בא:

• mcp__playwright__browser_navigate — נווט לכתובת בדפדפן
• mcp__github__create_issue — צור Issue חדש ב-GitHub
• mcp__postgres__query — הרץ שאילתה על מסד נתונים

ציר הזמן של MCP

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

2. איך שרתי MCP עובדים — ארכיטקטורה

שרת MCP הוא תהליך מקומי (local process) שרץ על המחשב שלך ומדבר JSON-RPC דרך stdio (Standard Input/Output). במילים פשוטות: Claude Code מפעיל את השרת, שולח לו בקשות בפורמט JSON, ומקבל תשובות בפורמט JSON. זה כל הסיפור.

הזרימה צעד אחר צעד

1. הפעלה: כשאתה פותח session חדש ב-Claude Code, הוא קורא את settings.json, מוצא שרתי MCP מוגדרים, ומפעיל כל אחד כתהליך נפרד
2. הכרזת יכולות: כל שרת מצהיר מה הוא יכול — אילו כלים הוא מציע, מה הפרמטרים של כל כלי, ומה הוא מחזיר
3. שימוש: כש-Claude מחליט שהוא צריך כלי MCP, Claude Code מעביר את הבקשה לשרת המתאים, מחכה לתשובה, ומזין אותה חזרה ל-Claude
4. סיום: כשאתה סוגר את ה-session, כל תהליכי השרתים נסגרים

למה stdio ולא HTTP?

שאלה שעולה הרבה: למה MCP משתמש ב-stdio (כמו pipe בין תהליכים) ולא ב-HTTP רגיל? התשובה: אבטחה ופשטות. כש-Claude Code מפעיל שרת MCP, הוא יוצר תהליך-בן (child process) ומתקשר איתו דרך stdin/stdout. אין פורט פתוח, אין שרת רשת, אין אפשרות שמישהו מבחוץ יתחבר לשרת. זה הרבה יותר בטוח מ-HTTP endpoint שצריך אימות, הצפנה, ו-CORS.

בנוסף, stdio פשוט להפליא. לא צריך להגדיר פורט, לא צריך TLS, לא צריך DNS. הפקודה npx @package מפעילה את השרת, Claude Code מתחבר, וזהו. זו אחת הסיבות ש-MCP הצליח כל כך מהר — הסף להתקנת שרת הוא אפסי.

שרתי MCP יכולים להיכתב בכל שפת תכנות — Python, TypeScript, Go, Rust — כל עוד הם מיישמים את פרוטוקול MCP. רוב השרתים מופצים בשלוש דרכים:

שרתי MCP רצים כל עוד ה-session של Claude Code פעיל. כשאתה סוגר את ה-session, התהליכים נעצרים. כשאתה פותח session חדש, הם מופעלים מחדש. אין צורך לנהל אותם ידנית.

מה קורה "מתחת למכסה" — הזרימה הטכנית

בואו ניכנס לרגע לפרטים הטכניים. כשClaude מחליט שהוא צריך כלי MCP (נגיד browser_navigate), הנה מה שקורה ברגע אחד:

1. Claude Code שולח JSON-RPC request ל-stdin של תהליך השרת: {"method": "tools/call", "params": {"name": "browser_navigate", "arguments": {"url": "https://example.com"}}}
2. השרת מעבד את הבקשה — במקרה של Playwright, הוא פותח דפדפן Chromium ומנווט לכתובת
3. השרת מחזיר תשובה ב-stdout כ-JSON: {"content": [{"type": "text", "text": "Navigated to https://example.com. Page title: Example Domain"}]}
4. Claude Code מזין את התשובה חזרה ל-Claude, שממשיך מהנקודה שבה עצר

כל התהליך הזה שקוף לך. אתה רואה רק ש-Claude "השתמש" בכלי וקיבל תוצאה. אבל חשוב להבין את המנגנון — הוא עוזר לאבחן בעיות כש-MCP לא עובד כמו שצריך.

ומה ש-MCP באמת מיוחד? שרתים מרובים יכולים לרוץ במקביל. Claude יכול להשתמש ב-Playwright כדי לבדוק אתר, ב-GitHub כדי ליצור Issue על הבעיה שמצא, וב-PostgreSQL כדי לוודא שהנתונים נכונים — הכל באותו session, בלי שתצטרך לעשות שום דבר.

מה Claude "רואה" כשיש שרתי MCP

כשאתה פותח session עם שרתי MCP מותקנים, Claude מקבל רשימה של כלים זמינים. הכלים המובנים (Read, Edit, Bash) תמיד שם. כלי MCP נוספים להם. Claude לא מבדיל ביניהם — הוא פשוט בוחר את הכלי המתאים ביותר למשימה. אם ביקשת ממנו לנווט לאתר, הוא ישתמש ב-mcp__playwright__browser_navigate. אם ביקשת ממנו לקרוא קובץ, הוא ישתמש ב-Read המובנה. הבחירה אוטומטית ואינטליגנטית.

דוגמה למה Claude רואה בתחילת session עם Playwright ו-Context7 מותקנים:

Built-in tools:
  Read, Edit, Write, Bash, Grep, Glob, WebSearch, WebFetch

MCP tools (playwright):
  mcp__playwright__browser_navigate
  mcp__playwright__browser_click
  mcp__playwright__browser_fill_form
  mcp__playwright__browser_take_screenshot
  mcp__playwright__browser_snapshot
  ... (20+ tools)

MCP tools (context7):
  mcp__context7__resolve-library-id
  mcp__context7__query-docs

שים לב: Playwright מביא יותר מ-20 כלים! זה מדגיש למה Tool Search (סעיף 6) כל כך חשוב — כל הכלים האלה צורכים tokens מחלון ההקשר שלך.

3. איתור והתקנת שרתי MCP

אחרי שהבנת מה MCP עושה ואיך הוא עובד, הגיע הזמן להתקין שרת. אבל קודם — איפה מוצאים שרתים?

היכן למצוא שרתי MCP

איך מתקינים שרת MCP

ההתקנה מתבצעת ב-settings.json. יש שתי אפשרויות:

• ברמת פרויקט: .claude/settings.json — השרת זמין רק כשאתה עובד בפרויקט הזה
• גלובלי: ~/.claude/settings.json — השרת זמין בכל session

ההגדרה נעשית תחת המפתח mcpServers. הנה הדוגמה הבסיסית ביותר — התקנת שרת Playwright (אוטומציית דפדפן):

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-playwright"]
    }
  }
}

אחרי הוספת שרת, חובה להפעיל מחדש את ה-session של Claude Code. השרת יופעל, וכל הכלים שלו יופיעו ב-/help או /tools. Claude ישתמש בהם אוטומטית כשהם רלוונטיים.

מה אם זה לא עובד?

אם הכלים לא מופיעים אחרי ההפעלה מחדש, בדוק:

1. תחביר JSON תקין? — טעות בפסיק או סוגריים גורמת לכשל שקט. בדוק עם cat .claude/settings.json | python3 -m json.tool
2. npx מותקן? — הרץ npx --version. אם לא מותקן, התקן Node.js
3. החבילה קיימת? — הרץ את פקודת ה-npx ידנית בטרמינל. אם יש שגיאה — תראה אותה
4. הפעלת מחדש? — שרתי MCP נטענים רק בהתחלת session. חייב לסגור ולפתוח מחדש

אפשר להפעיל שרתים מרובים בו-זמנית. פשוט הוסף עוד שרתים תחת mcpServers:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-playwright"]
    },
    "context7": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-context7"]
    },
    "github": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

4. שרתי MCP חיוניים — The Power Stack

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

Playwright — אוטומציית דפדפן

Playwright הוא שרת ה-MCP הפופולרי ביותר, ומסיבה טובה. הוא מאפשר ל-Claude לשלוט בדפדפן אמיתי: לנווט לעמודים, ללחוץ על כפתורים, למלא טפסים, לצלם Screenshots, ולהריץ בדיקות Frontend. זה כמו לתת ל-Claude ידיים שיכולות ללחוץ על מסך.

שימושים נפוצים:

• בדיקת אתרים ואפליקציות Web — האם הכפתור עובד? האם הטופס נשלח?
• Scraping של נתונים מאתרים — מחירי מתחרים, תוכן, מידע עסקי
• אוטומציה של Workflows בדפדפן — מילוי טפסים, התחברות, ניווט
• צילום מסך לתיעוד, אישור, או הוכחת עבודה
• בדיקות E2E (End-to-End) — Claude כותב ומריץ בדיקות על אתר חי

כשאתה מתקין את Playwright, Claude מקבל גישה ליותר מ-20 כלים: browser_navigate, browser_click, browser_fill_form, browser_take_screenshot, browser_snapshot, browser_evaluate (הרצת JavaScript), browser_console_messages (קריאת Console), browser_network_requests (מעקב אחרי בקשות רשת), ועוד. זה דפדפן מלא בשליטה מרחוק.

Context7 — דוקומנטציה עדכנית

Context7 פותר בעיה קריטית: הידע של Claude מוגבל לתאריך הלמידה שלו. כש-Library חדשה יוצאת, API משתנה, או framework מעדכן syntax — Claude לא בהכרח יודע. Context7 שולף את הדוקומנטציה הכי עדכנית של כל ספרייה ומזין אותה ל-Claude בזמן אמת.

למה זה קריטי? כי כשאתה אומר ל-Claude "צור קומפוננטה ב-React 19 עם Server Components", Claude אולי ישתמש ב-syntax של React 18 כי זה מה שהוא למד. עם Context7, Claude שולף את הדוקומנטציה העדכנית של React 19 ומשתמש ב-syntax הנכון.

שימושים נפוצים:

• עבודה עם Frameworks חדשים שהשתנו אחרי תאריך הלמידה של Claude
• בדיקת שינויי API ו-deprecated patterns
• וידוא שהקוד משתמש בגרסה הנוכחית של ספרייה
• לימוד ספריות חדשות — Claude קורא את הדוקומנטציה ומסביר לך

GitHub — כל ה-API של GitHub

שרת ה-GitHub מאפשר ל-Claude לעבוד ישירות עם GitHub API: ליצור ולקרוא Issues, לנהל Pull Requests, לבדוק סטטוס של CI/CD Workflows, לנהל Releases, ולעקוב אחרי שינויים. זה הרבה יותר עוצמתי משימוש ב-gh CLI דרך Bash, כי הכלים מובנים עם סכמה ברורה ו-Claude מבין בדיוק מה כל פרמטר עושה.

תרחיש יומיומי: אתה אומר "Review the open PRs and check if any of them have failing CI checks." Claude שולף את כל ה-PRs הפתוחים, בודק את סטטוס ה-checks של כל אחד, ומחזיר דוח מסודר — הכל בפעולה אחת.

PostgreSQL / SQLite — גישה למסדי נתונים

שרתי Database מאפשרים ל-Claude לשלוח שאילתות ישירות למסד נתונים, לבדוק סכמות (schema), להריץ Migrations, ולייצר דוחות מנתונים חיים. קריטי למפתחים ולאנשי Data.

דוגמה מעשית: "Show me all customers who signed up this week but haven't made a purchase yet, grouped by acquisition channel." Claude כותב את ה-SQL, מריץ אותו על המסד שלך, ומציג טבלת תוצאות — בלי שתכתוב שורת SQL אחת.

Brave Search — חיפוש Web מתקדם

Brave Search מספק חיפוש Web דרך API של Brave. שימושי כשיש לך מפתח API של Brave ואתה רוצה שליטה מלאה על תוצאות החיפוש — סינון תוצאות, חיפוש חדשות, תמונות, או local results. זה חלופה חזקה ל-WebSearch המובנה, עם יותר שליטה על הפרמטרים.

מתי להשתמש ב-Brave Search MCP במקום WebSearch המובנה? כשאתה צריך שליטה על סוג החיפוש (news/images/videos), כשאתה רוצה תוצאות ממדינה ספציפית, או כשאתה צריך JSON מובנה של התוצאות לעיבוד נוסף. ל-WebSearch המובנה אין את כל האפשרויות האלה.

Filesystem — פעולות קבצים מתקדמות

שרת Filesystem מרחיב את יכולות הקבצים של Claude מעבר ל-Read/Write המובנים — קבצים בינאריים (תמונות, PDFs), ניטור שינויים (file watching), וטיפול בקבצים גדולים שהכלים המובנים מתקשים איתם.

סיכום: טבלת שרתי MCP חיוניים

5. הגדרות מתקדמות — Environment, Disabled, Multiple Instances

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

משתני סביבה (Environment Variables)

שרתים רבים צריכים מפתחות API או הגדרות נוספות. העברת ערכים דרך env:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    }
  }
}

השבתה זמנית של שרת

לפעמים אתה רוצה להשבית שרת בלי למחוק את ההגדרות שלו. פשוט הוסף "disabled": true:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-playwright"],
      "disabled": true
    }
  }
}

השרת לא יופעל, אבל ההגדרות נשמרות. שנה ל-false (או מחק את השדה) כדי להפעיל מחדש.

מופעים מרובים (Multiple Instances)

אפשר להריץ כמה מופעים של אותו סוג שרת עם הגדרות שונות. לדוגמה, שני שרתי PostgreSQL לשני מסדי נתונים שונים:

{
  "mcpServers": {
    "postgres-production": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${PROD_DATABASE_URL}"
      }
    },
    "postgres-staging": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${STAGING_DATABASE_URL}"
      }
    }
  }
}

נעילת גרסאות (Version Pinning)

כשאתה כותב "args": ["@anthropic-ai/mcp-playwright"], npx תמיד מוריד את הגרסה האחרונה. זה נשמע טוב, אבל זה מסוכן: גרסה חדשה יכולה לשבור דברים. נעל את הגרסה להגנה:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-playwright@1.3.2"]
    }
  }
}

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

Timeout Settings

חלק מהשרתים תומכים בהגדרות Timeout לפעולות ארוכות. לדוגמה, שרת Playwright שמנווט לדף כבד עם הרבה JavaScript יכול לקחת 30 שניות. אם יש לך פעולות ארוכות — בדוק בדוקומנטציה של השרת אם יש הגדרת timeout שאפשר להרחיב.

גלובלי מול ברמת פרויקט

איפה לשים כל הגדרה?

MCP ו-Permissions — שליטה על מה Claude יכול לעשות

מערכת ההרשאות של Claude Code (שלמדת עליה בקורס הבסיסי) עובדת גם עם כלי MCP. אפשר לאשר או לחסום כלי MCP ספציפיים ב-permissions.allow ו-permissions.deny:

{
  "permissions": {
    "allow": [
      "mcp__playwright__*",
      "mcp__context7__*",
      "mcp__github__create_issue",
      "mcp__github__list_pull_requests"
    ],
    "deny": [
      "mcp__github__delete_repository",
      "mcp__postgres__*"
    ]
  }
}

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

6. Tool Search — טעינה חכמה של כלים

כאן מגיע אחד הנושאים הכי חשובים בעבודה עם MCP, ואחד שהרבה אנשים מפספסים: Tool Search (חיפוש כלים), או בשם הטכני — Deferred Loading (טעינה עצלה).

הבעיה

כל שרת MCP מצהיר על הכלים שלו: שם, תיאור, פרמטרים, סוגי החזרה. המידע הזה נטען ב-תחילת ה-session ותופס מקום בחלון ההקשר (Context Window). חלון ההקשר הוא 200K tokens בברירת מחדל, ועד 1M tokens עם Opus 4.6 למנויי Max, Team, ו-Enterprise (ממרץ 2026). אם יש לך 5 שרתים עם 50 כלים סך הכל, הגדרות הכלים לבדן יכולות לצרוך 77,000 tokens — זה אחוז משמעותי מהחלון שלך, בטח אם אתה על חלון 200K רגיל.

הפתרון: Tool Search

במקום לטעון את כל הגדרות הכלים מראש, Claude רואה רק את ToolSearch meta-tool ורשימה של שמות כלים (בלי הסכמה המלאה). כשהוא צריך כלי ספציפי, הוא קורא ל-ToolSearch, מקבל את הסכמה המלאה, ואז משתמש בכלי.

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

מתי Tool Search מופעל

• אוטומטית: כשהגדרות הכלים היו תופסות יותר מ-10% מחלון ההקשר. עם Context Window של 200K tokens, זה אומר שאם כלי ה-MCP שלך צורכים יותר מ-~20,000 tokens — Tool Search מופעל אוטומטית. זה קורה ברוב המקרים כשיש לך 5+ שרתי MCP
• ידנית: הוסף "defer_loading": true בהגדרות שרת MCP ב-settings.json כדי לכפות טעינה עצלה גם כשלא נחצה הסף

הגדרת deferred loading ידנית נעשית ברמת השרת:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-playwright"],
      "defer_loading": true
    }
  }
}

מתי כדאי לכפות ידנית? כשאתה יודע שהשרת מביא הרבה כלים (Playwright = 20+ כלים) אבל אתה לא משתמש בהם בכל session. במקום שהכלים יצרכו tokens "סתם", הם ייטענו רק כש-Claude באמת צריך אותם.

איך Claude מחפש כלים

כש-Tool Search מופעל, Claude משתמש ב-meta-tool בשם ToolSearch כדי למצוא ולטעון כלים ספציפיים. הוא עושה את זה אוטומטית כשהוא צריך כלי — אתה לא צריך לעשות שום דבר. אבל כדאי להבין את המנגנון כי לפעמים תרצה לכוון את Claude לכלי ספציפי.

Claude יכול לחפש כלים בשלוש דרכים:

7. MCP Elicitation — דיאלוגים אינטראקטיביים

תכונה חדשה שנוספה ב-14 במרץ 2026 (גרסה 2.1.76): Elicitation — יכולת של שרת MCP לבקש ממך קלט מובנה באמצע Workflow.

מה זה Elicitation?

עד עכשיו, כשClaude היה צריך אישור או קלט ממך, הוא פשוט שאל בצ'אט: "Do you want to proceed?" ואתה ענית "yes" או "no" כטקסט חופשי. הבעיה: טקסט חופשי לא מובנה. אתה יכול לכתוב "yep", "sure", "כן", "OK" — והשרת צריך לפרסר את כל הווריאציות. עם Elicitation, שרת MCP יכול לפתוח דיאלוג מובנה — טופס עם שדות מוגדרים, Dropdown עם אפשרויות קבועות, כפתורי אישור/ביטול, ואימות קלט. זה הרבה יותר מדויק, בטוח, ומקצועי.

דוגמאות שימוש

• שרת Deploy: "לאיזה סביבה? [staging/production]" — עם Dropdown, לא טקסט חופשי שיכול להיות שגוי
• שרת אבטחה: "סריקת האבטחה מצאה 3 בעיות. להמשיך עם הפריסה? [כן/לא]" — אישור מפורש
• אשף הגדרות: "הגדרת חיבור למסד נתונים: host, port, database, username" — טופס מלא עם אימות
• Workflow מרובה שלבים: טפסים שמוצגים אחד אחרי השני לפי הלוגיקה של השרת

Hook Events של Elicitation

אם למדת על Hooks בפרק 1, הנה איך הם מתחברים ל-Elicitation. שני אירועי Hook חדשים נוספו ב-v2.1.76:

• Elicitation — מופעל כששרת MCP מבקש קלט מהמשתמש. אפשר להשתמש ב-Hook הזה כדי לתעד את הבקשה, לשלוח התראה, או לבדוק שהבקשה תקינה
• ElicitationResult — מופעל כשהמשתמש מספק את הקלט. אפשר להשתמש ב-Hook הזה כדי לתעד את ההחלטה, לשלוח עדכון לצוות, או להפעיל פעולה נוספת

דוגמה מעשית: Hook שמתעד כל Elicitation ל-log file:

// hooks בתוך settings.json
"hooks": {
  "ElicitationResult": [{
    "command": "echo \"$(date) | $TOOL_NAME | $RESULT\" >> /var/log/claude-approvals.log"
  }]
}

ככה יש לך רישום של כל אישור שניתן — מי אישר מה, מתי, ולאיזה סביבה. קריטי לתאימות רגולטורית (Compliance) ולביקורות אבטחה (Auditing).

8. OAuth לשרתי MCP צד-שלישי

חלק משרתי MCP מתחברים לשירותי צד-שלישי שדורשים אימות OAuth — Google, Slack, GitHub, Notion, Jira. במקום לנהל tokens ידנית, Claude Code תומך בזרימת OAuth מובנית.

איך זה עובד

1. בפעם הראשונה שאתה משתמש בכלי שדורש אימות — חלון דפדפן נפתח עם מסך ההסכמה של השירות (OAuth Consent Screen)
2. אתה מאשר גישה
3. ה-Token נשמר מקומית ב-Keychain/Credential Manager של המערכת
4. מפה ולהבא — האימות אוטומטי. לא צריך לאשר שוב (עד שה-Token פג)

שרתים נפוצים עם OAuth

ההבדל בין OAuth לבין API Key

חלק מהשרתים עובדים עם API Key (כמו GitHub Token), וחלק עם OAuth. מה ההבדל?

אבטחה בסביבת צוות

בסביבה צוותית, כל חבר צוות מאמת עם הפרטים שלו. ה-Token של חבר צוות אחד לא עובר לאחר. זה אומר שבקרת גישה (Access Control) היא לפי אדם — כל אחד רואה רק מה שהוא מורשה לראות. OAuth tokens נשמרים ב-Keychain/Credential Manager של המערכת — לא ב-settings.json. זה שכבת אבטחה נוספת: גם אם מישהו מקבל גישה לקובץ ההגדרות, ה-tokens לא חשופים.

9. בניית שרת MCP משלך

לא צריך לחכות שמישהו יבנה שרת MCP עבור השירות שאתה צריך. אפשר לבנות בעצמך. ה-SDK של Anthropic זמין ב-Python (mcp package) וב-TypeScript (@modelcontextprotocol/sdk), ושרת בסיסי לוקח 30-50 שורות קוד.

המבנה הבסיסי של שרת MCP (Python)

1. ייבוא ספריית ה-MCP
2. הגדרת כלים — שם, תיאור, סכמת קלט (JSON Schema)
3. כתיבת Handler — הפונקציה שמבצעת את העבודה בפועל
4. הפעלת השרת על stdio

# weather_server.py
from mcp import Server, Tool
import json

server = Server("weather")

@server.tool(
    name="get_weather",
    description="Get current weather for a city",
    input_schema={
        "type": "object",
        "properties": {
            "city": {
                "type": "string",
                "description": "City name"
            }
        },
        "required": ["city"]
    }
)
async def get_weather(city: str) -> str:
    # Mock data - replace with real API call
    weather_data = {
        "Tel Aviv": {"temp": 28, "condition": "Sunny"},
        "Jerusalem": {"temp": 22, "condition": "Partly Cloudy"},
        "Haifa": {"temp": 25, "condition": "Humid"},
    }
    data = weather_data.get(city, {"temp": 20, "condition": "Unknown"})
    return json.dumps({
        "city": city,
        "temperature": data["temp"],
        "condition": data["condition"]
    })

if __name__ == "__main__":
    server.run()

הוספת השרת ל-settings.json

{
  "mcpServers": {
    "weather": {
      "command": "python3",
      "args": ["/path/to/weather_server.py"]
    }
  }
}

אחרי שמירה והפעלה מחדש של Claude Code, תוכל לשאול: "What's the weather in Tel Aviv?" ו-Claude ישתמש בכלי mcp__weather__get_weather כדי לקבל תשובה.

בדיקה מקומית לפני חיבור ל-Claude

לפני שאתה מוסיף שרת ל-settings.json, בדוק שהוא רץ. פתח טרמינל והרץ:

python3 weather_server.py

השרת צריך להתחיל ולחכות לקלט ב-stdin. אם אתה מקבל שגיאה — תקן אותה לפני שמחברים ל-Claude. בעיות נפוצות: ספרייה חסרה (pip install mcp), שגיאת תחביר, או חוסר הרשאות.

שרת MCP ב-TypeScript — חלופה

אם אתה מעדיף TypeScript, הנה אותו שרת:

// weather-server.ts
import { Server } from "@modelcontextprotocol/sdk/server";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio";

const server = new Server({
  name: "weather",
  version: "1.0.0"
});

server.setRequestHandler("tools/list", async () => ({
  tools: [{
    name: "get_weather",
    description: "Get current weather for a city",
    inputSchema: {
      type: "object",
      properties: {
        city: { type: "string", description: "City name" }
      },
      required: ["city"]
    }
  }]
}));

server.setRequestHandler("tools/call", async (request) => {
  if (request.params.name === "get_weather") {
    const city = request.params.arguments.city;
    // Mock data - replace with real API
    return {
      content: [{
        type: "text",
        text: JSON.stringify({
          city, temperature: 28, condition: "Sunny"
        })
      }]
    };
  }
});

const transport = new StdioServerTransport();
await server.connect(transport);

התקנת ה-SDK: npm install @modelcontextprotocol/sdk. ההגדרה ב-settings.json: "command": "npx", "args": ["ts-node", "weather-server.ts"].

שרת MCP מעשי: חיבור ל-API פנימי

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

• get_customer_info — שלוף פרטי לקוח מה-CRM
• update_ticket_status — עדכן סטטוס של Ticket במערכת ה-Support
• check_inventory — בדוק מלאי במחסן
• send_notification — שלח התראה לצוות

פתאום, Claude הופך מ"כלי תכנות" לשותף עסקי שיכול לגשת לכל מערכת בחברה. וזכור: בפרק הקודם למדנו על Custom Agents. דמיין Agent מותאם שמשתמש בשרת MCP מותאם — לדוגמה, סוכן "Customer Support" שקורא Tickets מ-MCP, בודק נתוני לקוח ב-MCP, ומעדכן סטטוס ב-MCP. הכל אוטומטי, הכל בשליטה מלאה.

מה שרת MCP מותאם אישית יכול לעשות בשבילך?

בואו נחשוב על תרחישים מעשיים לפי תפקיד:

המפתח לשרת MCP מוצלח: כלים ממוקדים עם שמות ברורים. במקום כלי אחד גנרי do_everything, צור 3-5 כלים ספציפיים שכל אחד עושה דבר אחד טוב. Claude יודע לבחור את הכלי הנכון למשימה הנכונה — תן לו אפשרויות ברורות.

טיפים לכתיבת שרת MCP טוב

1. שמות כלים מתארים: get_customer_by_email עדיף על get_data. Claude בוחר כלי לפי השם והתיאור — ככל שהם ברורים יותר, הבחירה מדויקת יותר
2. תיאורים מפורטים: כתוב description ברור עם דוגמאות. "Get customer info by email address. Returns name, plan, signup date, and last activity." זה הרבה יותר טוב מ-"Get customer"
3. סכמת קלט מדויקת: הגדר את כל הפרמטרים עם סוג (string, number, boolean), תיאור, וערכי ברירת מחדל. ככל שהסכמה מדויקת יותר, Claude שולח פרמטרים נכונים יותר
4. טיפול בשגיאות: אם הכלי נכשל (API לא זמין, פרמטר שגוי), החזר הודעת שגיאה ברורה ב-JSON. לא stack trace — הודעה שClaude יכול להבין ולתקן
5. ביצועים: שרת MCP צריך להיות מהיר. אם כלי לוקח 30 שניות, שקול להוסיף caching או timeout. Claude לא יחכה לנצח

10. Best Practices ופתרון בעיות

אחרי שהתקנת שרתים, הגדרת אותם, ואולי גם בנית אחד משלך — הגיע הזמן לדבר על מה שרוב האנשים מגלים אחרי שבוע-שבועיים של עבודה עם MCP: הכללים שמבדילים בין setup שעובד חלק לבין setup שגורם לכאבי ראש.

כללי זהב ל-MCP

1. אל תתקין יותר מדי שרתים. כל שרת צורך משאבים (זיכרון, זמן הפעלה). 3-5 שרתים פעילים הוא איזון טוב. יותר מזה — השתמש ב-deferred loading
2. הפעל deferred loading. אם יש לך יותר מ-5 שרתים או 20+ כלים סך הכל, הפעל Tool Search כדי לחסוך מקום ב-context
3. נעל גרסאות (Version Pinning). במקום npx @package, השתמש ב-npx @package@1.2.3. זה מונע שבירות כשיוצאת גרסה חדשה
4. בדוק בריאות שרת. אם כלי לא עובד — בדוק: האם השרת רץ? האם משתנה סביבה חסר? האם API key פג?
5. סקירת אבטחה. שרת MCP יכול להריץ קוד על המחשב שלך. התקן רק שרתים ממקורות מהימנים. בדוק את הקוד אם הוא לא מ-maintainer מוכר
6. ביצועים. קריאה לכלי MCP כוללת Overhead (תקשורת בין תהליכים, לפעמים latency של רשת). לפעולות בתדירות גבוהה, שקול אם פקודת Bash ישירה תהיה מהירה יותר
7. תיעוד. תעד את ה-MCP Stack שלך: אילו שרתים מותקנים, למה, ומה ה-env vars שנדרשים. כשצוות חדש מצטרף, הוא צריך לדעת מה להגדיר
8. גיבוי settings.json. שמור את קובץ ההגדרות ב-Git (בלי secrets!). ככה כל הצוות משתמש באותו Stack, ושינויים עוברים Code Review

מתי MCP ומתי Bash?

שאלה חשובה שצריך לענות עליה: אם Claude יכול להריץ כל פקודה דרך Bash, למה בכלל צריך MCP? התשובה היא נוחות, בטיחות, ואמינות.

כלל אצבע: אם יש כלי MCP שעושה את מה שאתה צריך — השתמש בו. אם אין — Bash זה הפתרון. שניהם לגיטימיים, אבל MCP עדיף כשהוא זמין.

פתרון בעיות נפוצות

תרחישים מהעולם האמיתי: MCP בפעולה

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

{
  "permissions": {
    "allow": [
      "mcp__playwright__*",
      "mcp__context7__*"
    ]
  },
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-playwright"],
      "defer_loading": true
    },
    "context7": {
      "command": "npx",
      "args": ["@anthropic-ai/mcp-context7"]
    },
    "github": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      },
      "defer_loading": true
    }
  }
}

שגרת תחזוקת MCP — Daily, Weekly, Monthly

אבטחת MCP — מה שכל Power User צריך לדעת

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

עלויות MCP — כמה זה עולה?

MCP עצמו הוא חינמי — הפרוטוקול הוא Open Source, ורוב השרתים הם קוד פתוח בלי עלות. אבל יש עלויות עקיפות שכדאי להכיר:

סיכום: הוספת MCP מוסיפה בערך $2-4 ל-session ממוצע (תלוי כמה שרתים ואיך משתמשים). בהשוואה לזמן שאתה חוסך (עשרות דקות של עבודה ידנית), ההשקעה מחזירה את עצמה בקלות.

"mcpServers": {
  "playwright": {
    "command": "npx",
    "args": ["@anthropic-ai/mcp-playwright"]
  }
}

MCP בתמונה הגדולה — הקשר לפרקים אחרים

MCP הוא לא פיצ'ר בודד — הוא חלק ממערכת שלמה. הנה איך הוא מתחבר לכל מה שלמדת ומה שתלמד:

הנוסחה המלאה: Skill מפעיל Agent שמשתמש ב-MCP tools, עם Hooks שמוודאים אבטחה. זה הכוח האמיתי של Claude Code כפלטפורמה — והפרקים הבאים יחברו את כל החלקים.

צ'קליסט — סיום פרק 3

• ☐ מבין/ה מה MCP עושה — פרוטוקול פתוח שמחבר Claude לכלים חיצוניים
• ☐ מכיר/ה את הארכיטקטורה: שרת מקומי, JSON-RPC, stdio
• ☐ יודע/ת איפה למצוא שרתי MCP — Registry רשמי, mcp.run, Glama
• ☐ מותקן לפחות שרת MCP אחד ומאומת (Playwright, Context7, או אחר)
• ☐ מוגדר settings.json עם שרתי MCP, כולל Environment Variables
• ☐ מבין/ה את Tool Search ו-Deferred Loading — חיסכון של ~85% tokens
• ☐ מכיר/ה את MCP Elicitation — דיאלוגים אינטראקטיביים (מרץ 2026)
• ☐ מבין/ה OAuth לשרתי MCP צד-שלישי
• ☐ בנית שרת MCP בסיסי (לפחות "Hello World") ב-Python או TypeScript
• ☐ מכיר/ה Best Practices: version pinning, deferred loading, 3-5 שרתים
• ☐ יודע/ת לאבחן בעיות MCP — /doctor, בדיקת env vars, הפעלה מחדש
• ☐ בחרת MCP Stack מותאם לתפקיד שלך (Developer/Marketer/Analyst)
• ☐ השלמת לפחות תרגיל אחד מהתרגילים המעשיים