MCP Servers — הרחבת היכולות

מה זה MCP — ה-USB-C של עולם ה-AI

דמיינו עולם שבו לכל מכשיר יש כבל שונה. הטלפון צריך כבל אחד, הטאבלט כבל שני, המסך כבל שלישי. ואז הגיע USB-C — כבל אחד שמחבר הכל. MCP (Model Context Protocol) הוא ה-USB-C של עולם ה-AI.

MCP הוא תקן פתוח (Open Standard) שמגדיר איך יישומי AI — כמו GitHub Copilot, Claude Code, Cursor, ועוד — מתחברים לכלים ושירותים חיצוניים. במקום שכל כלי AI יבנה אינטגרציה ייחודית עם כל שירות, MCP מגדיר שפה משותפת: אתה בונה שרת MCP פעם אחת, והוא עובד עם כל client שתומך בפרוטוקול.

מה שרת MCP חושף? שלושה דברים:

• Tools (כלים) — פעולות שה-AI יכול להפעיל. למשל: "חפש issues פתוחים", "צלם מסך של דף", "הרץ שאילתת SQL"
• Resources (משאבים) — מידע שה-AI יכול לקרוא. למשל: תוכן קובץ, טבלה ממסד נתונים, תגובות מ-API
• Prompts (תבניות) — פרומפטים מוגדרים מראש שניתן להפעיל. למשל: "סקור PR" עם פורמט מובנה

הרעיון המרכזי: Copilot הוא ה-client, שרת MCP הוא הגשר לשירות חיצוני. ה-client שולח בקשה דרך פרוטוקול MCP, השרת מבצע את הפעולה, ומחזיר תוצאה. Copilot לא צריך לדעת איך GitHub API עובד — הוא רק צריך לדעת לדבר MCP.

למה MCP חשוב לכם — תרחיש מעשי

נניח שאתם עובדים על פרויקט ורוצים שCopilot יוכל:

• לחפש issues פתוחים ב-GitHub שלכם
• לבדוק סטטוס CI/CD של PR
• לשלוף מידע ממסד נתונים מקומי
• לגלוש לאתר ולצלם מסך

בלי MCP, הייתם צריכים לעשות כל דבר ידנית — לפתוח דפדפן, לגלוש ל-GitHub, לחפש issues, לחזור ל-VS Code, להעתיק את המידע. עם MCP, Copilot עושה את כל זה בעצמו. אתם כותבים בצ'אט: "מצא issues פתוחים עם תגית bug ושנפתחו השבוע" — ו-Copilot מפעיל את כלי GitHub MCP Server, מביא את התוצאות, ומציג לכם סיכום.

איך MCP עובד — שלב אחרי שלב

נעקוב אחרי מה שקורה כשאתם כותבים בCopilot Chat: "מצא issues פתוחים עם תגית bug":

1. Copilot מקבל את הפרומפט ומנתח אותו — הוא מזהה שצריך גישה ל-GitHub
2. Copilot בודק את רשימת הכלים הזמינים (כולל כלי MCP). הוא מוצא את search_issues מ-GitHub MCP Server
3. Copilot שולח בקשה לשרת MCP: {"method": "tools/call", "params": {"name": "search_issues", "arguments": {"query": "is:issue is:open label:bug"}}}
4. שרת MCP מקבל את הבקשה, מתרגם אותה לקריאת GitHub API, ושולח בקשה ל-api.github.com
5. GitHub API מחזיר תוצאות — רשימת issues עם כותרות, מספרים, תיאורים
6. שרת MCP מעצב את התוצאה ומחזיר אותה ל-Copilot בפורמט שהמודל מבין
7. Copilot מציג לכם סיכום של ה-issues הפתוחים בצ'אט

כל התהליך הזה לוקח 2-5 שניות. בלי MCP, הייתם צריכים לפתוח דפדפן, לגלוש ל-GitHub, לסנן issues ידנית, ולחזור ל-VS Code — דקות של עבודה חוזרת, שוב ושוב, כל יום.

שימו לב שהתהליך הזה זהה ללולאה האגנטית שלמדתם עליה בפרק 1 — קלט, תכנון, בחירת כלי, הפעלה, בדיקת תוצאה. ההבדל היחיד הוא שהכלי מגיע משרת MCP חיצוני ולא ממנוע מובנה של VS Code. וזה בדיוק הכוח של MCP: מבחינת Copilot, כלי MCP וכלי מובנה נראים זהים. הוא לא "מרגיש" שהוא פונה לשרת חיצוני — הוא פשוט מפעיל כלי ומקבל תוצאה.

MCP Apps — ממשקי משתמש אינטראקטיביים (תכונה חדשה)

מעבר ל-Tools, Resources, ו-Prompts, שרתי MCP יכולים גם לספק MCP Apps — ממשקי משתמש אינטראקטיביים שמוצגים ישירות בתוך Copilot Chat. זו תכונה חדשה יחסית (הושקה בינואר 2026) שמאפשרת לשרת MCP להחזיר לא רק טקסט, אלא ממשק עשיר עם כפתורים, טפסים, וויזואליזציות.

לדוגמה: שרת MCP של מסד נתונים יכול להחזיר טבלה אינטראקטיבית שמאפשרת מיון וסינון, במקום רק טקסט גולמי. זה עדיין בשלבים מוקדמים, אבל כדאי להכיר את הכיוון — ניתן להפעיל את התכונה ב-Settings עם chat.mcp.apps.enabled.

MCP הפך ל-GA — מה זה אומר

MCP ב-VS Code יצא מ-Preview ועבר ל-General Availability בגרסה 1.102 (יולי 2025). זה אומר שזה לא עוד ניסוי — זה פיצ'ר יציב, מתוחזק, ומומלץ לשימוש יומיומי. כל מי שמשתמש ב-VS Code בגרסה עדכנית יכול להתחיל להשתמש ב-MCP עכשיו.

Extensions מתים, MCP מחליף — מה השתנה

עד נובמבר 2025, Copilot תמך ב-Copilot Extensions — תוספים שנבנו כ-GitHub Apps. הם עבדו רק עם Copilot, דרשו רישום מורכב, ולא היה להם תקן אחיד. ב-24 בספטמבר 2025, GitHub הודיע: Copilot Extensions יורדים. ב-10 בנובמבר 2025 הם הפסיקו לעבוד.

מה שעלה במקומם? MCP. וההבדל הוא דרמטי:

השורה התחתונה: בנו MCP server פעם אחת — והוא עובד בכל מקום. זה היתרון המרכזי של תקן פתוח מול API ייחודי.

חשוב להבין: זה לא "עוד migration". ההחלפה מ-Extensions ל-MCP היא שינוי אסטרטגי. GitHub למעשה אומר: "אנחנו לא רוצים שכלים יעבדו רק עם Copilot. אנחנו רוצים תקן שכולם משתמשים בו." זה פותח דלת: כל שרת MCP שתבנו היום יעבוד גם עם Claude Code, גם עם Cursor, גם עם כל IDE שיתמוך ב-MCP בעתיד.

ההשלכה המעשית: אם אתם מפתחים כלים פנימיים בארגון שלכם, MCP הוא הפורמט הנכון. אם הספק שלכם (Sentry, Datadog, Stripe) עדיין לא הוציא שרת MCP — זה עניין של זמן. הרכבת כבר יצאה.

ומה לגבי Extensions שכבר היו מותקנים? Extensions של VS Code (כמו Python, Docker, Live Preview) ממשיכים לעבוד — רק Copilot Extensions (שנבנו כ-GitHub Apps ספציפית בשביל Copilot Chat) הם אלה שנסגרו. אם יש לכם VS Code Extension רגיל שמוסיף כלים ל-Copilot — הוא ממשיך לעבוד כרגיל. הבלבול בין סוגי ה-Extensions הוא נפוץ, אז חשוב להבחין. בקיצור: VS Code Extensions = ממשיכים. Copilot Extensions (GitHub Apps) = מתים, עוברים ל-MCP.

שני סוגי שרתים — מקומי ומרוחק

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

שרת מקומי (Local — stdio)

• איך רץ: VS Code מפעיל תהליך על המחשב שלכם (npx, python, docker run)
• תקשורת: Standard Input/Output — VS Code כותב ל-stdin, קורא מ-stdout
• יתרונות: גישה למשאבים מקומיים (קבצים, מסדי נתונים, Docker), ללא תלות ברשת
• חסרונות: דורש התקנה, תפוסת משאבים על המחשב, קשה לשתף בצוות
• הגדרה: type: "stdio" + command + args

שרת מרוחק (Remote — HTTP/SSE)

• איך רץ: מתארח בענן, VS Code מתחבר אליו דרך URL
• תקשורת: HTTP או Server-Sent Events (SSE) — בקשות ותגובות דרך הרשת
• יתרונות: אין צורך בהתקנה, אימות OAuth בלחיצה אחת, קל לשתף
• חסרונות: תלות ברשת, אין גישה למשאבים מקומיים, אפשרויות התאמה מוגבלות
• הגדרה: type: "http" + url

דוגמה מעשית — אותה משימה, שני סוגי שרתים

נניח שאתם רוצים ש-Copilot יוכל לחפש ב-GitHub API. יש שתי דרכים:

דרך 1: Remote (מומלץ לרוב המשתמשים)

// .vscode/mcp.json — 3 שורות, בלי התקנות
{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    }
  }
}

זהו. בפעם הראשונה שתבקשו מ-Copilot לחפש issue — ייפתח חלון OAuth, תאשרו, וזה עובד. אין Docker, אין PAT, אין התקנות.

דרך 2: Local (לשליטה מלאה או Enterprise)

// .vscode/mcp.json — דרך Docker
{
  "servers": {
    "github-local": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github-pat}"
      }
    }
  }
}

פה צריך Docker מותקן, PAT מוכן, ויותר הגדרות. בתמורה — שליטה מלאה: אתם בוחרים אילו toolsets מופעלים, איזה PAT scopes לתת, ואתם לא תלויים בשרת חיצוני.

הכלל הפשוט: התחילו עם remote. עברו ל-local רק אם יש לכם סיבה ספציפית (Enterprise requirements, offline, גישה מקומית, sandbox).

נקודה חשובה נוספת: שרת אחד יכול לתמוך בשני הסוגים. GitHub MCP Server, למשל, זמין גם כ-remote (OAuth, ברירת מחדל מומלצת) וגם כ-local (Docker + PAT). הבחירה היא שלכם ותלויה בנסיבות. רוב השרתים ב-Registry הם מקומיים (stdio) כי זה פשוט יותר לפתח, אבל המגמה ברורה: יותר ויותר שרתים מציעים גם אפשרות remote.

גלריית MCP — @mcp בתוך VS Code

הדרך הכי קלה להתקין שרת MCP היא דרך הגלריה המובנית של VS Code. בדיוק כמו שמתקינים Extensions — אבל עם @mcp.

איך לפתוח את הגלריה

1. פתחו את תצוגת Extensions: Ctrl+Shift+X (Windows/Linux) או Cmd+Shift+X (Mac)
2. בשדה החיפוש הקלידו: @mcp
3. תופיע רשימה של שרתי MCP זמינים — עם תיאור, מפרסם, וכפתור Install

התקנה — User Profile vs Workspace

כשמתקינים שרת MCP, יש שתי אפשרויות:

• Install (User Profile): השרת זמין בכל פרויקט שתפתחו. ההגדרה נשמרת בפרופיל האישי
• Install in Workspace (קליק ימני → Install in Workspace): השרת מתווסף ל-.vscode/mcp.json של הפרויקט. אידיאלי לשיתוף בצוות — הקובץ נכנס ל-Git

אישור Trust: בפעם הראשונה שמפעילים שרת MCP חדש, VS Code ישאל אם אתם סומכים עליו. זה חשוב — שרת מקומי יכול להריץ קוד על המחשב שלכם. בדקו מי המפרסם לפני שמאשרים. אם בטעות אישרתם שרת שאתם לא בטוחים לגביו, השתמשו בפקודה MCP: Reset Trust כדי לאפס את כל אישורי ה-Trust ולהתחיל מחדש.

מעבר לגלריה, אפשר גם להתקין ישירות מ-GitHub MCP Registry. כשלוחצים "Install in VS Code" באתר ה-Registry, VS Code נפתח ומוסיף את השרת אוטומטית. זו הדרך הנוחה ביותר אם אתם כבר מדפדפים ב-Registry באתר.

שרתי MCP פופולריים שכדאי להכיר

GitHub MCP Registry — גלריה מרוכזת של שרתים מאושרים

מעבר לגלריה הפנימית של VS Code, GitHub הקים GitHub MCP Registry — מעין "App Store" לשרתי MCP. הכתובת: registry.modelcontextprotocol.io.

מה הוא מציע:

• 44+ שרתים מאושרים מספקים מובילים: Playwright (Microsoft), Context7, MarkItDown, Terraform (HashiCorp), Notion, Unity, Stripe, Firecrawl
• התקנה בלחיצה אחת — כפתור "Install in VS Code" שפותח את VS Code ומוסיף את השרת
• מטריקות קהילה — כוכבי GitHub, פעילות קהילה, מידע על המפרסם
• README מובנה — תיעוד מלא של כל שרת ישירות בדף

ההבדל מהגלריה הפנימית

הגלריה הפנימית (@mcp ב-Extensions) היא חלק מ-VS Code ומכילה את אותם שרתים. ה-Registry הוא אתר אינטרנט חיצוני שמאפשר גלישה, חיפוש, וסינון נוח יותר. למעשה, הם משלימים — חפשו ב-Registry, התקינו ב-VS Code.

למה ה-Registry חשוב לארגונים

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

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

איך לבחור שרת MCP מה-Registry

כשאתם מדפדפים ב-Registry, שימו לב ל-4 דברים:

1. מפרסם: שרת מ-GitHub, Microsoft, או Stripe אמין יותר משרת ממפתח אנונימי
2. כוכבים ופעילות: 500+ כוכבים ועדכון אחרון בחודש האחרון = סימן טוב. 10 כוכבים ועדכון אחרון לפני שנה = סימן אזהרה
3. סוג שרת: Remote = פשוט יותר להתקנה. Local = יותר שליטה אבל דורש התקנות
4. תיעוד: README מפורט עם דוגמאות שימוש = שרת שהמפתחים שלו אכפתיים. README ריק = אזהרה

הגדרה ב-.vscode/mcp.json — הפורמט המלא

כשמתקינים שרת MCP מהגלריה, הוא מתווסף אוטומטית. אבל הכוח האמיתי הוא בהגדרה ידנית — קובץ .vscode/mcp.json שאתם שולטים בו.

מבנה הקובץ

הקובץ מכיל שני חלקים:

• "servers" — אובייקט שממפה שם שרת להגדרה שלו
• "inputs" — מערך אופציונלי של משתני קלט (למפתחות API ומידע רגיש)

דוגמה מלאה — קובץ mcp.json עם 3 שרתים

{
  "inputs": [
    {
      "type": "promptString",
      "id": "github-pat",
      "description": "GitHub Personal Access Token",
      "password": true
    }
  ],
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp-server"]
    },
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    }
  }
}

Transport Types — סוגי תחבורה

Input Variables — משתנים רגישים

לעולם אל תכתבו מפתחות API ישירות בקובץ. השתמשו ב-Input Variables:

"inputs": [
  {
    "type": "promptString",
    "id": "my-api-key",
    "description": "API Key for My Service",
    "password": true
  }
]

ואז הפנו אליהם בהגדרת השרת:

"my-server": {
  "command": "node",
  "args": ["server.js"],
  "env": {
    "API_KEY": "${input:my-api-key}"
  }
}

VS Code ישאל אתכם את הערך בפעם הראשונה שהשרת מופעל, ויזכור אותו אחר כך.

Environment Variables ו-envFile

בנוסף ל-Input Variables, אפשר להעביר משתני סביבה ישירות או מקובץ .env:

"my-server": {
  "command": "node",
  "args": ["server.js"],
  "env": {
    "NODE_ENV": "development",
    "LOG_LEVEL": "debug"
  },
  "envFile": "${workspaceFolder}/.env"
}

הערך ${workspaceFolder} מתרגם אוטומטית לנתיב הפרויקט הנוכחי. משתנים נוספים שניתן להשתמש בהם: ${userHome} (תיקיית הבית), ${env:VARIABLE} (משתנה סביבה של המערכת).

VS Code Settings — אלטרנטיבה ל-mcp.json

אם אתם מעדיפים לא ליצור קובץ נפרד, אפשר להגדיר שרתי MCP גם ב-VS Code Settings:

1. פתחו Settings (Ctrl+,)
2. חפשו mcp
3. הגדירו שרתים ב-chat.mcp.servers

אבל — מומלץ להשתמש ב-.vscode/mcp.json בפרויקט. הסיבה: קובץ mcp.json נכנס ל-Git ומשותף עם הצוות. Settings הם אישיים למחשב שלכם. היתרון הנוסף של mcp.json: אפשר להגדיר שרתים שונים לפרויקטים שונים. פרויקט frontend עם Playwright, פרויקט backend עם Postgres — כל פרויקט מקבל בדיוק את השרתים שהוא צריך.

Dev Containers: אם אתם עובדים עם Dev Containers, אפשר להגדיר שרתי MCP ישירות ב-devcontainer.json תחת customizations.vscode.mcp.servers. כשמישהו פותח את הפרויקט ב-Dev Container, השרתים מוגדרים אוטומטית — אפילו בלי .vscode/mcp.json.

Sandbox — הגבלת גישה

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

"my-server": {
  "command": "node",
  "args": ["server.js"],
  "sandboxEnabled": true,
  "sandbox": {
    "filesystem": {
      "allowWrite": ["${workspaceFolder}"],
      "denyRead": ["${userHome}/.ssh"]
    },
    "network": {
      "allowedDomains": ["api.example.com"]
    }
  }
}

חשוב: Sandbox זמין כרגע ב-macOS ו-Linux בלבד. ב-Windows, שרתים מקומיים רצים ללא sandbox — מה שהופך את בדיקת האמינות של השרת לחשובה אפילו יותר.

אבטחת MCP — כללי אצבע

{
  "servers": {
    "fetch": {
      "command": "uvx",
      "args": ["mcp-server-fetch"]
    }
  }
}

GitHub MCP Server — גישה מלאה ל-GitHub מתוך Copilot

GitHub MCP Server הוא השרת הרשמי שמתוחזק על ידי GitHub. הוא מחבר את Copilot ישירות ל-API של GitHub — issues, pull requests, code search, repos, actions, ועוד. זה אחד השרתים החשובים ביותר שתגדירו.

הגדרה מהירה — Remote (מומלץ)

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

// .vscode/mcp.json
{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    }
  }
}

בפעם הראשונה ש-Copilot מנסה להשתמש בכלי GitHub, ייפתח חלון OAuth ותתבקשו לאשר גישה. אין צורך ליצור PAT, אין צורך בהתקנות. לחיצה אחת וזה עובד.

הגדרה מקומית — PAT + Docker

אם אתם מעדיפים שליטה מלאה, או עובדים עם GitHub Enterprise:

{
  "servers": {
    "github-local": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
        "-e", "GITHUB_TOOLSETS=repos,issues,pull_requests,code_search",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${input:github-pat}"
      }
    }
  }
}

Toolsets — קבוצות כלים

GitHub MCP Server מחולק ל-toolsets — קבוצות כלים לפי תחום. אתם יכולים להפעיל רק את מה שצריכים:

טיפ: הפעלה של רק ה-toolsets שאתם צריכים מקטינה את מספר הכלים שה-LLM צריך לבחור מהם — מה שמשפר את הדיוק ומזרז תגובות.

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

הנה כמה פרומפטים שעובדים יפה עם GitHub MCP Server ב-Agent Mode:

שימו לב שאתם לא צריכים לציין "use GitHub MCP" — Copilot בוחר את הכלי הנכון אוטומטית על סמך הבקשה. אם יש לכם GitHub MCP Server מוגדר ואתם שואלים על issues — הוא ישתמש בכלי search_issues. אם אתם שואלים על PR — הוא ישתמש ב-get_pull_request. זו הלולאה האגנטית שלמדתם עליה בפרק 1 — Copilot מזהה את המשימה, בוחר כלי, מפעיל, ובודק תוצאה.

GitHub MCP Server — Remote vs Local, מה לבחור

ל-GitHub MCP Server יש שתי גרסאות. הנה המלצה ברורה:

• Remote (OAuth): מומלץ ב-99% מהמקרים. אין התקנות, אין Docker, אין PAT. עובד בלחיצה אחת. GitHub מתחזק את השרת ומעדכן אותו אוטומטית. זה הפתרון הנכון למפתחים בודדים ולצוותים קטנים-בינוניים
• Local (PAT + Docker): רק אם אתם עובדים עם GitHub Enterprise Server (לא Cloud), צריכים offline access, רוצים לשלוט בדיוק אילו toolsets מופעלים, או שמדיניות הארגון דורשת שרת מקומי

אם אתם לא בטוחים — התחילו עם Remote. תמיד אפשר לעבור ל-Local אחר כך.

תרגיל מעשי — פרויקט עם 3 שרתי MCP

בניית שרת MCP מותאם — מאפס לכלי עובד

זה החלק המרגש — אתם הולכים לבנות שרת MCP משלכם שמוסיף כלי חדש ל-Copilot. לא צריך להיות מומחי backend — שרת בסיסי לוקח פחות מ-50 שורות קוד.

אפשרות א: Node.js (TypeScript)

שלב 1: אתחול פרויקט

mkdir my-mcp-server && cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk

שלב 2: כתיבת השרת

צרו קובץ server.js:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new McpServer({
  name: "my-tools",
  version: "1.0.0"
});

// Tool 1: Get current date/time in different formats
server.tool(
  "get-datetime",
  "Returns current date and time in various formats",
  {
    format: {
      type: "string",
      description: "Output format: 'iso', 'hebrew', 'unix'",
      enum: ["iso", "hebrew", "unix"]
    }
  },
  async ({ format }) => {
    const now = new Date();
    let result;

    switch (format) {
      case "iso":
        result = now.toISOString();
        break;
      case "hebrew":
        result = now.toLocaleDateString("he-IL", {
          year: "numeric", month: "long", day: "numeric",
          hour: "2-digit", minute: "2-digit"
        });
        break;
      case "unix":
        result = Math.floor(now.getTime() / 1000).toString();
        break;
      default:
        result = now.toISOString();
    }

    return {
      content: [{ type: "text", text: result }]
    };
  }
);

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

שלב 3: הוספת "type": "module" ל-package.json

// package.json — הוסיפו את השורה הזו
{
  "type": "module",
  ...
}

שלב 4: חיבור ל-VS Code

הוסיפו ל-.vscode/mcp.json:

{
  "servers": {
    "my-tools": {
      "command": "node",
      "args": ["path/to/my-mcp-server/server.js"]
    }
  }
}

אפשרות ב: Python

שלב 1: התקנת SDK

pip install mcp

שלב 2: כתיבת השרת

צרו קובץ server.py:

from datetime import datetime
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-tools")

@mcp.tool()
def get_datetime(format: str = "iso") -> str:
    """Returns current date and time.

    Args:
        format: Output format - 'iso', 'hebrew', or 'unix'
    """
    now = datetime.now()

    if format == "iso":
        return now.isoformat()
    elif format == "hebrew":
        months = ["ינואר","פברואר","מרץ","אפריל","מאי","יוני",
                  "יולי","אוגוסט","ספטמבר","אוקטובר","נובמבר","דצמבר"]
        return f"{now.day} ב{months[now.month-1]} {now.year}, {now.hour:02d}:{now.minute:02d}"
    elif format == "unix":
        return str(int(now.timestamp()))
    return now.isoformat()

if __name__ == "__main__":
    mcp.run(transport="stdio")

שלב 3: חיבור ל-VS Code

{
  "servers": {
    "my-tools": {
      "command": "python",
      "args": ["path/to/server.py"]
    }
  }
}

מה קורה מאחורי הקלעים

כשאתם מפעילים את השרת ומחברים אותו ל-VS Code, הנה מה שקורה:

1. VS Code מריץ את הפקודה (node server.js או python server.py) כתהליך ברקע
2. VS Code שולח בקשת initialize דרך stdin — "מי אתה ומה אתה יודע לעשות?"
3. השרת מחזיר דרך stdout רשימה של כלים — שם, תיאור, פרמטרים
4. Copilot מוסיף את הכלים לתפריט Configure Tools
5. כשמשתמש שואל שאלה שדורשת את הכלי — Copilot שולח בקשת tools/call
6. השרת מפעיל את הפונקציה ומחזיר תוצאה

כל התקשורת היא דרך JSON-RPC על stdin/stdout. אתם לא צריכים לממש את הפרוטוקול — ה-SDK עושה את זה בשבילכם. אתם רק כותבים את ה-function ומגדירים את הפרמטרים שלה.

רעיונות לשרתי MCP שימושיים

מעבר ל-datetime, הנה רעיונות לשרתי MCP שיכולים לחסוך לכם זמן ביומיום:

• Project Health: שרת שסופר TODO/FIXME/HACK בקוד ומחזיר דוח בריאות
• Package Checker: שרת שבודק אם יש עדכוני אבטחה ל-dependencies
• Deployment Status: שרת שמתחבר ל-Vercel/Netlify ובודק סטטוס deploy
• Database Schema: שרת שמחזיר סכמה של מסד נתונים מקומי
• Team Conventions: שרת שמחזיר את ה-coding standards של הצוות
• Hebrew Dates: שרת שמחזיר תאריך עברי, חגים, ושעות שבת

איך Copilot רואה את הכלי החדש

ברגע שהשרת מחובר ורץ:

1. פתחו Copilot Chat → Configure Tools
2. תראו כלי חדש בשם get-datetime תחת שרת my-tools
3. נסו: "What's the current time in hebrew format?"
4. Copilot יפעיל את הכלי שלכם ויציג את התוצאה

טיפים לבניית שרת MCP מוצלח

• שמות ברורים: תנו לכלי שם שמתאר מה הוא עושה. get-datetime טוב. tool1 רע. Copilot משתמש בשם ובתיאור כדי לבחור את הכלי הנכון
• תיאורים מפורטים: התיאור של הכלי הוא מה ש-Copilot קורא כדי להחליט אם להשתמש בו. כתבו מה הכלי עושה, מתי להשתמש בו, ומה הוא מחזיר
• פרמטרים עם ברירות מחדל: אם יש פרמטר אופציונלי — תנו לו ברירת מחדל. זה מקטין חיכוך — Copilot לא צריך לנחש מה להעביר
• טיפול בשגיאות: כשמשהו נכשל — החזירו הודעת שגיאה ברורה, לא stack trace. Copilot ינסה להבין מההודעה מה השתבש
• לוגים ל-stderr בלבד: כל console.log ל-stdout שובר את פרוטוקול MCP. השתמשו ב-console.error ב-Node.js או print(..., file=sys.stderr) ב-Python

אימות — OAuth, PAT, ובלי אימות

שרתי MCP שונים דורשים שיטות אימות שונות. בואו נבין מתי להשתמש בכל אחת:

1. OAuth — אימות בלחיצה אחת

• איך עובד: VS Code פותח חלון דפדפן, מתחברים לחשבון, מאשרים הרשאות
• יתרונות: Scoped access (רק ההרשאות שאישרתם), תמיכה ב-SAML, אין צורך ליצור טוקן ידנית
• שימוש: GitHub MCP Server (remote), שרתים של ספקים גדולים
• דוגמה: פשוט מגדירים "type": "http" עם "url" — ה-OAuth מטופל אוטומטית

2. PAT — Personal Access Token

• איך עובד: יוצרים טוקן ידנית ב-GitHub Settings, מעבירים אותו לשרת
• יתרונות: שליטה מלאה בהרשאות, עובד ב-CI/CD, תואם GitHub Enterprise
• חסרון: צריך לנהל ולחדש ידנית, סיכון אם הטוקן דולף
• חשוב: ב-PAT ל-GitHub MCP Server, חייבים להפעיל הרשאת "Copilot Requests"

3. ללא אימות

• איך עובד: השרת זמין לכל מי שמתחבר — אין שלב אימות
• שימוש: שרתים מקומיים שאתם בנוי בעצמכם, שרתים ציבוריים (fetch, time, datetime)
• אזהרה: לעולם אל תשתמשו בזה לשרתים שחושפים מידע רגיש

בקצרה — זרימת אימות לכל סוג

OAuth (remote): מגדירים URL → Copilot מבקש גישה → חלון דפדפן → מאשרים → עובד. הטוקן מתחדש אוטומטית.

PAT (local): יוצרים PAT ב-GitHub Settings → מגדירים ב-mcp.json עם input variable → VS Code שואל בפעם הראשונה → עובד. אתם אחראים לחדש את הטוקן כשפג תוקף.

ללא אימות: מגדירים command → עובד. אין שלב ביניים.

ניהול MCP בארגון — מדיניות Admin (Business/Enterprise)

אם אתם עובדים בארגון עם Copilot Business או Copilot Enterprise, יש שכבה נוספת: מדיניות MCP. ה-Admin של הארגון שולט אם בכלל אפשר להשתמש בשרתי MCP, ובאילו.

הנקודות הקריטיות

• ברירת מחדל: מדיניות MCP כבויה. מפתחים לא יוכלו להשתמש בשרתי MCP עד שה-Admin מפעיל אותה
• איפה מפעילים: Settings → Copilot → Policies → "MCP servers in Copilot" → Enable
• שתי רמות בקרה:
  • Allow all — כל שרת MCP מותר. מתאים לצוותים קטנים עם אמון גבוה
  • Registry only — רק שרתים מה-Registry המאושר. מתאים לארגונים גדולים שצריכים בקרה
• היררכיה: הגדרות Enterprise דורסות הגדרות Organization. אם ה-Enterprise חסם — ה-Org לא יכול לפתוח
• Allow list: ניתן ליצור רשימת שרתים מותרים ברמת הארגון — רק שרתים ברשימה יעבדו

תרחיש אמיתי

יוסי מנסה להגדיר GitHub MCP Server בפרויקט בעבודה. הכל מוגדר נכון — אבל Copilot לא רואה את הכלים. הוא שולח הודעה לאדמין ומגלה שמדיניות MCP כבויה. האדמין מפעיל אותה ב-"Registry only" — ויוסי חייב להשתמש רק בשרתים מה-Registry הרשמי. השרת המותאם שבנה בבית לא יעבוד בעבודה עד שהאדמין יוסיף אותו ל-allow list.

המלצות לאדמינים

• צוות קטן (5-15 מפתחים): התחילו עם "Allow all" ואספו משוב. אחרי חודש — צמצמו ל-Registry only אם צריך
• ארגון בינוני (15-100): התחילו עם "Registry only" + allow list מותאמת לשרתים ספציפיים
• Enterprise (100+): הגדירו ברמת Enterprise, לא Organization. יצרו allow list שמאושרת על ידי צוות Security

אל תשכחו: מדיניות MCP חלה על VS Code ועל Copilot CLI. אם חסמתם ב-VS Code — גם ב-CLI לא יעבוד.

סיכום מדיניות MCP בטבלה

ניפוי באגים — כשה-MCP Server לא מתחבר

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

שלב 1: בדקו סטטוס שרתים

Command Palette (Ctrl+Shift+P) → MCP: List Servers. כל שרת צריך להיות Running. אם הוא Stopped או Error — יש בעיה.

שלב 2: בדקו לוגים

1. Command Palette → Developer: Set Log Level → בחרו Trace
2. Command Palette → Output: Show Output Channels → בחרו GitHub Copilot Chat
3. חפשו שגיאות שקשורות ל-MCP

שלב 3: בעיות נפוצות

שלב 4: Debug Configuration

VS Code תומך ב-debugging ישיר של שרתי MCP ב-Node.js ו-Python. הוסיפו ל-mcp.json:

"my-server": {
  "command": "node",
  "args": ["server.js"],
  "dev": {
    "debug": {
      "type": "node"
    },
    "watch": "**/*.js"
  }
}

זה יפעיל debugger כש-VS Code מריץ את השרת, ויפעיל restart אוטומטי כשקבצי JS משתנים.

תרחיש ניפוי באגים מעשי

נניח שבניתם שרת MCP מותאם ב-Node.js, אבל Copilot לא רואה את הכלים. הנה התהליך:

1. בדקו שהשרת עולה: הריצו node server.js בטרמינל. אם יש שגיאות — תראו אותן מיד
2. בדקו MCP: List Servers: אם השרת לא מופיע — בדקו שה-path ב-mcp.json נכון
3. בדקו לוגים: פתחו Output → GitHub Copilot Chat. חפשו הודעות MCP
4. בדקו stdout: הפעילו את השרת ידנית וכתבו הודעת JSON-RPC. אם הוא מחזיר תשובה — הבעיה בהגדרה. אם לא — הבעיה בקוד
5. בדקו stderr: אם יש console.log בקוד — העבירו ל-console.error. כל הודעה ל-stdout שאינה JSON-RPC שוברת את הפרוטוקול

טיפ מקצועי: הפעילו MCP: Reset Trust אחרי שמשנים הגדרות שרת. לפעמים VS Code שומר cache של ההגדרה הישנה ולא מזהה שינויים. אם שום דבר לא עוזר — מחקו את השרת מ-mcp.json, שמרו, ואז הוסיפו אותו מחדש. זה "איפוס מלא" שפותר את רוב הבעיות.

עוד טיפ שחוסך זמן: אם אתם עובדים עם שרת מותאם בשלבי פיתוח, הפעילו את אופציית dev.watch ב-mcp.json. היא תפעיל restart אוטומטי כל פעם שתשמרו שינויים בקבצי השרת — בלי צורך לעצור ולהפעיל ידנית כל פעם. לשרת Node.js זה עובד עם "watch": "**/*.js" ולשרת Python עם "watch": "**/*.py".

הקשר בין MCP ל-Configure Tools

זוכרים את Configure Tools מפרק 2? עכשיו אתם מבינים את התמונה המלאה. כשאתם פותחים את Configure Tools ב-Copilot Chat, אתם רואים שלוש קבוצות של כלים:

• כלים מובנים: editFiles, runInTerminal, readFile — כלים שמגיעים עם VS Code
• כלי MCP: כלים שמגיעים משרתי MCP שהגדרתם. כל כלי מסומן עם שם השרת שלו (למשל "github: search_issues")
• כלי Extensions: כלים שמגיעים מ-Extensions של VS Code (כמו Python, Docker)

בפרק 2 למדתם לכבות כלים מיותרים כדי לשפר ביצועים. אותו עיקרון חל על כלי MCP: אם הגדרתם 5 שרתי MCP אבל רק 2 רלוונטיים למשימה הנוכחית — כבו את השאר. ככל שיש פחות כלים זמינים, Copilot בוחר טוב יותר.

שגרת עבודה — תחזוקת MCP

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

אם אתם עושים רק דבר אחד

{
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    }
  }
}

בדקו את עצמכם

סיכום הפרק

מה הלאה — קריאה מומלצת

אם אתם רוצים להעמיק, הנה המשאבים הרשמיים:

• VS Code MCP Documentation — התיעוד הרשמי המלא של MCP ב-VS Code
• GitHub Copilot MCP Concepts — הבנה עמוקה של MCP בהקשר של Copilot
• GitHub MCP Server Repository — הקוד, התיעוד, וה-Issues של GitHub MCP Server
• GitHub MCP Registry — גלריית שרתי MCP מאושרים
• MCP Specification — המפרט המלא של הפרוטוקול (למתקדמים)

עולם ה-MCP מתפתח מהר. שרתים חדשים מתווספים ל-Registry כל שבוע, היכולות גדלות (MCP Apps, Sandbox, Dev Mode), ויותר ויותר כלי AI מאמצים את הפרוטוקול. המיומנות שרכשתם בפרק הזה — הגדרה, שימוש, ובנייה של שרתי MCP — היא מיומנות שתשרת אתכם בכל כלי AI שתעבדו איתו בעתיד, לא רק ב-Copilot. ההשקעה של 3-4 שעות בפרק הזה פותחת בפניכם עולם שלם של אינטגרציות שלא היו זמינות קודם — מגישה ל-GitHub API ישירות מהצ'אט, דרך אוטומציית דפדפן, ועד בניית כלים מותאמים שפותרים בדיוק את הבעיות של הצוות שלכם.

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