MCP — הפרוטוקול שמחבר
AI לכל כלי בעולם

מה זה MCP ולמה זה חשוב?

לפני MCP, כל מי שרצה לחבר AI לכלי חיצוני — Slack, GitHub, מסד נתונים, קבצים — היה צריך לכתוב integration מאפס, מותאם אישית לכל מודל ולכל שירות. כפולת עבודה אינסופית, תחזוקה קשה, וחוסר תאימות.

MCP פותר את זה בצורה אלגנטית: פרוטוקול תקשורת אחיד (JSON-RPC מעל stdio או SSE) שמגדיר כיצד AI Clients (כמו Claude Desktop, Cursor, Windsurf) מדברים עם MCP Servers שחושפים tools, resources ו-prompts.

MCP לעומת Function Calling

Function Calling (שיש ב-OpenAI ו-Anthropic) מאפשר ל-AI להפעיל פונקציות — אבל הפונקציות האלה מוגדרות ב-prompt ורצות בצד ה-client. MCP הוא שכבה מעל זה: הכלים חיים בשרת נפרד, מנוהלים בנפרד, וניתן לחבר אותם לכל AI client שתומך בפרוטוקול.

איך MCP עובד — מתחת למכסה

שלושת הפרימיטיבים של MCP

Transport Layers — איך Client ו-Server מתקשרים

• stdio — הנפוץ ביותר. השרת רץ כ-subprocess, תקשורת דרך stdin/stdout. מהיר ופשוט, מתאים לשרתים מקומיים.
• SSE (Server-Sent Events) — לשרתים מרוחקים שרצים ב-HTTP. מאפשר חיבור מרחוק ומשיתוף שרת בין מספר לקוחות.
• Streamable HTTP — הדור הבא של SSE. תומך בסיגנלים דו-כיוונים ומשופר לביצועים.

המפרט של 2026-07-28 — מה השתנה ולמה זה שובר קוד

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

מה הוסר

• לחיצת היד. initialize ו-notifications/initialized נמחקו. גרסת הפרוטוקול ויכולות הלקוח עוברות עכשיו ב-_meta של כל בקשה, תחת מפתחות כמו io.modelcontextprotocol/protocolVersion.
• הסשן. הכותרת Mcp-Session-Id הוסרה מתעבורת Streamable HTTP. שרת שצריך מצב בין קריאות מקבל אותו כארגומנט רגיל של כלי — מזהה שהשרת עצמו הנפיק.
• ping, logging/setLevel ו-notifications/roots/list_changed נמחקו. רמת הלוג נקבעת לכל בקשה בנפרד דרך _meta.
• המשכיות זרם. Last-Event-ID ומזהי אירועי SSE הוסרו. זרם שנקטע מאבד את הבקשה שהייתה באוויר — הלקוח חייב לשלוח אותה מחדש כבקשה חדשה.

מה נוסף

• server/discover — שרת חייב לממש את ה-RPC הזה. הוא מכריז אילו גרסאות פרוטוקול הוא תומך בהן ומה היכולות שלו, ומחליף את מה שלחיצת היד עשתה קודם.
• subscriptions/listen — זרם אחד ארוך-חיים במקום נקודת ה-GET ו-resources/subscribe. הלקוח נרשם במפורש לסוגי שינויים שמעניינים אותו.
• resultType — שדה חובה בכל תוצאה. הערך complete לתוצאה רגילה, או input_required כשהשרת צריך מידע נוסף. תוצאה משרת ישן שאין בה את השדה נחשבת complete.
• MRTR — הדפוס שמחליף בקשות שהשרת יוזם. במקום שהשרת יבקש מהלקוח משהו באמצע, הוא מחזיר תוצאה מסוג input_required עם רשימת מה שחסר לו, והלקוח שולח את הבקשה המקורית שוב עם התשובות.

מה זה אומר בפועל

אם אתה משתמש ב-MCP דרך Claude Desktop, Cursor או כלי אחר — כמעט כלום. הכלי מתעדכן, ואתה ממשיך. מה שכן שווה לבדוק הוא שהשרתים שהתקנת עודכנו גם הם; שרת ישן מול לקוח חדש לא בהכרח יעבוד.

אם אתה כותב שרת MCP, שלושה דברים דורשים עבודה. הראשון — מימוש server/discover, שהוא חובה. השני — הוצאת המצב מהחיבור: כל מקום שבו שמרת נתונים "לאורך הסשן" צריך לעבור למזהה מפורש שעובר בארגומנטים. השלישי — עדכון ספריית הפיתוח: הגרסאות הרשמיות שמיישמות את המפרט הזה הן שינוי גרסה ראשי, כמו python-sdk שעבר לגרסה 2.

שני שינויים קטנים ששווה להכיר

• סדר דטרמיניסטי ל-tools/list. המפרט ממליץ שהשרת יחזיר כלים באותו סדר בכל פעם. הסיבה מעשית: רשימת כלים שמשנה סדר שוברת את מטמון הפרומפט של המודל, וזה עולה כסף אמיתי בכל קריאה.
• ttlMs ו-cacheScope נדרשים עכשיו בתוצאות של רשימות וקריאת משאבים. הראשון רמז לכמה זמן התוצאה טרייה, השני קובע אם מתווך משותף רשאי לשמור אותה במטמון. יחד הם מפחיתים תשאול מיותר.

המקור: מסמך השינויים הרשמי של המפרט, גרסה 2026-07-28. אומת מול המפרט עצמו, לא מול סיכום.

הגירה מעשית — שרת ישן לשרת חדש

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

1. מצב שהיה בסשן — עובר לארגומנט

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

# לפני — מצב תלוי-חיבור
sessions = {}

@server.tool()
def open_cart(session_id: str):        # הגיע מ-Mcp-Session-Id
    sessions[session_id] = {"items": []}

@server.tool()
def add_item(session_id: str, sku: str):
    sessions[session_id]["items"].append(sku)   # נשבר מול מופע אחר


# אחרי — מזהה מפורש שהשרת מנפיק, ומצב שנשמר בחוץ
@server.tool()
def open_cart() -> dict:
    cart_id = uuid4().hex
    store.put(cart_id, {"items": []}, ttl=3600)   # Redis / DB
    return {"cart_id": cart_id}                    # הלקוח שומר ומחזיר

@server.tool()
def add_item(cart_id: str, sku: str) -> dict:
    cart = store.get(cart_id)
    if cart is None:
        raise ValueError("cart_id לא קיים או פג תוקף")
    cart["items"].append(sku)
    store.put(cart_id, cart, ttl=3600)
    return {"items": len(cart["items"])}

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

2. server/discover — חובה

@server.discover()
def discover() -> dict:
    return {
        "protocolVersions": ["2026-07-28"],
        "serverInfo": {"name": "inventory-mcp", "version": "2.0.0"},
        "capabilities": {"tools": {}, "resources": {}},
    }

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

3. בקשות שהשרת יזם — לדפוס MRTR

שרת שהיה עוצר באמצע כדי לבקש מהלקוח משהו — אישור, בחירה, הרשאה — לא יכול לעשות את זה יותר. במקום זה הוא מחזיר תוצאה שאומרת "חסר לי", והלקוח שולח את הבקשה שוב עם המידע.

@server.tool()
def delete_records(query: str, confirmed: bool = False) -> dict:
    n = count_matching(query)
    if n > 10 and not confirmed:
        return {
            "resultType": "input_required",
            "inputRequests": [{
                "type": "confirmation",
                "message": f"הפעולה תמחק {n} רשומות. להמשיך?",
            }],
        }
    return {"resultType": "complete", "deleted": run_delete(query)}

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

סדר העבודה שאני ממליץ עליו

• עדכן קודם את הספרייה והרץ את חבילת מבחני התאימות הרשמית. היא תגיד לך מה שבור לפני שתגלה את זה מלקוח.
• אל תתמוך בשתי הגרסאות באותו קוד אם אפשר להימנע. הפרש התפיסה בין תלוי-מצב לחסר-מצב מייצר קוד שקשה לתחזק. עדיף שתי נקודות קצה לתקופת מעבר.
• בדוק מול לקוח אמיתי ולא רק מול מבחנים. חלק מהשינויים — במיוחד MRTR — נראים תקינים בבדיקה ומתנהגים אחרת מול לקוח שמנהל שיחה.

חיבור MCP ל-Claude Desktop

Claude Desktop הוא ה-MCP client הרשמי של Anthropic. הגדרת שרתי MCP נעשית דרך קובץ JSON אחד.

מיקום קובץ ההגדרה

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

מבנה הקובץ

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/Documents"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA..."
      }
    }
  }
}

5 שרתים שכדאי להוסיף מיד

MCP עם Cursor ו-Windsurf

גם Cursor וגם Windsurf תומכים ב-MCP ומאפשרים לעורכי הקוד לגשת לכלים חיצוניים ישירות מ-Agent Mode. זה עוצמתי במיוחד כשמפתחים — Claude ב-Cursor יכול לשלוח metrics ל-Datadog, לפתוח tickets ב-Jira, ולבדוק Supabase — הכל בלי לצאת מה-IDE.

הגדרה ב-Cursor

ב-Cursor, עוברים ל-Settings → Features → MCP ולוחצים על "Add new MCP server". ניתן גם לערוך ישירות את ~/.cursor/mcp.json:

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server-supabase@latest",
               "--supabase-url", "https://xxx.supabase.co",
               "--supabase-service-role-key", "eyJ..."]
    }
  }
}

אבטחה — מה שמשתנה כששרת נגיש לרשת

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

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

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

שרתי MCP שכדאי להכיר

פיתוח ו-DevTools

ניהול ותפעול

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

בניית שרת MCP היא מפתיעה בפשטותה. Anthropic מספקת SDK ל-Python ול-TypeScript. תוך 30 שורות קוד אפשר ליצור שרת שחושף כלים ל-Claude.

שרת בסיסי ב-Python (FastMCP)

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool()
def get_weather(city: str) -> str:
    """קבל תחזית מזג אוויר לעיר"""
    # בפועל — קריאה ל-API
    return f"מזג האוויר ב-{city}: 25°C, מעונן חלקית"

@mcp.tool()
def calculate(expression: str) -> float:
    """חשב ביטוי מתמטי"""
    return eval(expression)  # רק לדוגמה!

@mcp.resource("docs://readme")
def get_readme() -> str:
    """קרא את ה-README של הפרויקט"""
    with open("README.md") as f:
        return f.read()

if __name__ == "__main__":
    mcp.run()  # stdio transport כברירת מחדל

שרת ב-TypeScript

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

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

server.tool(
  "search_database",
  { query: z.string(), limit: z.number().optional() },
  async ({ query, limit = 10 }) => {
    // קריאה ל-DB בפועל
    const results = await db.search(query, limit);
    return {
      content: [{ type: "text", text: JSON.stringify(results) }]
    };
  }
);

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

חיבור השרת שבנית ל-Claude Desktop

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

דוגמאות מהשדה — מה אנשים בונים עם MCP

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