Tools ו-MCP

Tool כיחידת היסוד — תזכורת קצרה

tool, כפי שנלמד בפרק ה-Tool Use בנושא ה-LLM, הוא פעולה בודדת עם schema של פרמטרים, והמודל מחליט אם ומתי להפעיל אותה. הפרק הזה עוסק בשאלה אחרת: איך כלים מתחברים בפועל לסוכן, ומה הבעיה ש-MCP בא לפתור. איך מתכננים כלי טוב — בפרק הבא.

הבעיה: אינטגרציה נפרדת לכל כלי

לפני שהיה סטנדרט, כל אפליקציה שרצתה לחבר ל-LLM כלי או מקור מידע (מסד נתונים, מערכת קבצים, API חיצוני) כתבה קוד אינטגרציה ייעודי, בפורמט משלה. אפליקציה אחרת שרצתה את אותו כלי — כתבה אותו שוב.

התוצאה היא בעיית N×M: N כלים כפול M אפליקציות, וכל צירוף דורש קוד גישור משלו. ככל שנוספים כלים ואפליקציות, העבודה גדלה במכפלה ולא בסכום.

תרשים המציג ארבע נקודות כחולות בטור משמאל (כלים) ושלוש נקודות כתומות בטור מימין (אפליקציות), עם רשת צפופה של קווים אפורים המחברים כל כלי לכל אפליקציה בנפרד — שנים-עשר חיבורים נפרדים, ממחיש את בעיית ה-N×M.
בעיית N×M: כל כלי דורש קוד אינטגרציה נפרד לכל אפליקציה שרוצה להשתמש בו

מה MCP בעצם מתקנן

MCP‏ (Model Context Protocol) הוא פרוטוקול פתוח לחשיפת יכולות ל-LLM בפורמט אחיד: כלים (tools) שאפשר להפעיל, משאבי מידע (resources) שאפשר לקרוא, ותבניות פרומפט (prompts) מוכנות.

מי שבונה חיבור, למשל למסד נתונים, כותב אותו פעם אחת כשרת MCP, וכל אפליקציה שתומכת בפרוטוקול יכולה להשתמש בו מיד. כך N×M הופך ל-N+M: כל כלי נכתב פעם אחת, וכל אפליקציה מממשת את הפרוטוקול פעם אחת.

תרשים המציג את אותם ארבעה כלים כחולים ושלוש אפליקציות כתומות כמו בתרשים הקודם, אך הפעם כולם מחוברים דרך צומת מרכזי אחד (סמל פרוטוקול) במקום זה לזה ישירות — רק שבעה חיבורים בסך הכל במקום שנים-עשר, ממחיש איך MCP הופך את N×M ל-N+M.
MCP הופך את בעיית ה-N×M ל-N+M: כל כלי ואפליקציה מתחברים פעם אחת לפרוטוקול משותף

Client, Server ודרכי חיבור

MCP server הוא התוכנה שחושפת יכולות — חיבור ל-GitHub, למסד נתונים, למערכת קבצים. MCP client הוא הצד שצורך אותן, בדרך כלל בתוך ה-harness שמריץ את הסוכן.

בזמן ריצה ה-client שואל את השרת אילו כלים יש לו, ומקבל רשימת תיאורים כמו בדוגמה למטה. ה-harness מעביר את התיאורים למודל כמו כל כלי אחר — מבחינת המודל אין הבדל בין כלי מקומי לכלי שמגיע משרת MCP. ב-MCP שדה הסכמה נקרא inputSchema; ב-API של ספקי המודלים השם משתנה (למשל input_schema), וה-harness מתרגם ביניהם.

שרת MCP יכול לרוץ בשתי דרכים עיקריות: כתהליך מקומי שה-harness מפעיל ומדבר איתו דרך stdin/stdout (נקרא stdio) — מתאים לכלים שעובדים על המחשב שלכם, כמו גישה לקבצים; או כשירות מרוחק שמדברים איתו ב-HTTP — מתאים לשירותי ענן, ובדרך כלל כולל הזדהות (למשל OAuth).

JSON
{
  "name": "query_database",
  "description": "מריץ שאילתת SQL לקריאה בלבד על מסד הנתונים של ההזמנות",
  "inputSchema": {
    "type": "object",
    "properties": {
      "sql": { "type": "string", "description": "שאילתת SELECT אחת" }
    },
    "required": ["sql"]
  }
}

למה זה חשוב בפרקטיקה

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

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

אמון: שרת MCP הוא קוד של מישהו אחר

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

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

שאלות נפוצות

האם כדאי לבנות שרת MCP לכלי שרק סוכן אחד משתמש בו?

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

כמה שרתי MCP אפשר לחבר לסוכן אחד?

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

האם MCP עובד רק עם ספק מודלים מסוים?

לא. MCP הוא פרוטוקול פתוח, והוא נתמך כיום על ידי ספקי מודלים, עורכי קוד ו-frameworks רבים. שרת שכתבתם פעם אחת יעבוד עם כל client שמממש את הפרוטוקול — וזה בדיוק המעבר מ-N×M ל-N+M.