מהו MCP, ולמה כל כלי בינה מלאכותית מדבר אותו פתאום?
במשך רוב העשור האחרון, חיבור מודל בינה מלאכותית לכלי החברה דרש אינטגרציה מותאמת לכל זוג. Model Context Protocol, התקן הפתוח ש-Anthropic הציגה בנובמבר 2024, החליף את זה בתקע אחד שמתאים בכל מקום — ומאז אימצו אותו גם OpenAI, Google ו-Microsoft. כך זה עובד בפועל, ורשימת בדיקה אמיתית לפני שמחברים אחד לנתוני הצוות.
פותחים את אפליקציית שולחן העבודה של Claude ומבקשים ממנה לבדוק את בקשות המשיכה הפתוחות של הצוות, והיא פשוט יכולה לעשות את זה. לא מפני ש-Anthropic בנתה אינטגרציית GitHub לתוך Claude. מפני שבמקום כלשהו — צוות ה-IT שלכם, ספק, מפתח ב-GitHub — מישהו כתב תוכנית קטנה שמדברת פרוטוקול בשם MCP, ו-Claude כבר יודעת לדבר עם כל דבר שמדבר אותו. אותו דבר נכון עכשיו גם ל-ChatGPT, ל-Gemini של Google ול-Microsoft Copilot. ההתכנסות הזו, יותר מכל השקה של יכולת בודדת, היא הסיבה ש-MCP הפך לדבר שכמעט כל ספק בינה מלאכותית בילה את השנה האחרונה בבניית תמיכה עבורו.
מה MCP באמת
MCP הם ראשי התיבות של Model Context Protocol. Anthropic תכננה אותו, ופתחה את המפרט יחד עם ערכות ה-SDK הראשונות ב-25 בנובמבר 2024. חומרי ההשקה שלה תיארו את הרעיון באנלוגיה שנשארה: חשבו על MCP כיציאת USB-C ליישומי בינה מלאכותית — תקן מחבר פיזי אחד במקום כבל אחר לכל אביזר. בהשקה, Anthropic נקבה בשמות מאמצים מוקדמים שכבר בנו תמיכת MCP לתוך המוצרים שלהם, ובהם חברות התוכנה הארגוניות Block ו-Apollo, וגם יצרניות כלי המפתחים Zed, Replit, Codeium ו-Sourcegraph. אפליקציית שולחן העבודה של Claude יצאה, באותו יום, עם היכולת להריץ שרתי MCP באופן מקומי על המחשב של אדם.
הבעיה שהוא פותר: N כלים כפול M מקורות נתונים
לבעיה ש-MCP פותר יש שם שמהנדסים משתמשים בו בטבעיות: בעיית האינטגרציה N-על-M. נניח שחברה משתמשת בחמישה כלי בינה מלאכותית שצריכים לפעול על נתוני החברה — Claude, ChatGPT, GitHub Copilot, Cursor ובוט תמיכה פנימי — והנתונים האלה חיים בשמונה מקומות: Slack, GitHub, מסד Postgres, Salesforce, Notion, Google Drive, Jira ו-API פנימי. בלי פרוטוקול משותף, חיבור כל כלי לכל מקור בצורה שימושית דורש עד ארבעים אינטגרציות נפרדות — חמש כפול שמונה — לכל אחת סכמת אימות משלה, טיפול בשגיאות משלה, ומס תחזוקה משלה בכל פעם שאחד מאותם API משנה צורה. מוסיפים כלי בינה מלאכותית שישי והמספר קופץ לארבעים ושמונה. בפועל, אף אחד לא בנה את כל הארבעים. כל ספק בנה את קומץ הכלים ששפט ששווים את זמן ההנדסה, וכל השאר נשאר ידני: להעתיק, להדביק, להסביר מחדש, לחזור.
MCP הופך כפל לחיבור. חברה שרוצה ש-Claude יקרא ממסד Postgres שלה לא בונה מחבר Postgres ייעודי ל-Claude. היא בונה — או עושה שימוש חוזר באחד שמישהו אחר כבר פרסם — שרת MCP אחד שחושף את Postgres, והשרת הזה עובד עם Claude, ChatGPT, Gemini או כל סוכן אחר תואם MCP בלי קוד נוסף. הרשימה של Anthropic עצמה, בהשקה, נקבה בשרתים מוכנים ל-Google Drive, Slack, GitHub, Git, Postgres ולכלי אוטומציה לדפדפן בשם Puppeteer. הנקודה מעולם לא הייתה ש-Anthropic תבנה את כולם. הנקודה הייתה שכל אחד יכול, וקטלוג השרתים הזמינים גדל הרבה מעבר למה שחברה אחת יכולה לאייש.
איך הפרוטוקול באמת עובד
אם מסירים את המסגרת, MCP הוא פרוטוקול לקוח-שרת די פשוט, לא זוהר בכוונה. הוא מגדיר שלושה תפקידים. Host הוא היישום שאדם באמת פותח — Claude Desktop, סביבת פיתוח כמו Cursor, אפליקציית ChatGPT. ה-Host מטמיע MCP Client, שפותח חיבור ישיר ובעל מצב אל MCP Server — תוכנית קטנה שחושפת מערכת מסוימת אחת: מסד נתונים, כלי כרטיסים, מערכת קבצים, API פנימי. הלקוח והשרת מחליפים הודעות בפורמט JSON-RPC 2.0, פורמט קל לקריאה לפרוצדורה מרחוק שכבר נפוץ בתשתית קיימת, על אחד משני אמצעי העברה: stdio, כשהשרת הוא תוכנית שרצה באופן מקומי על אותה מכונה, או Streamable HTTP, כשזה שירות מתארח שרץ במקום אחר.
מה ששרת יכול לחשוף מסתכם בשלושה פרימיטיבים. Tools הן פונקציות שהמודל יכול לקרוא להן כדי לבצע פעולה — create_task, run_query, send_message — והמודל מחליט מתי לקרוא לאחת לפי השיחה. Resources הם הקשר לקריאה בלבד שה-Host יכול למשוך ולהעביר למודל בלי שהמודל יצטרך לבקש — תוכן של קובץ, סכמת מסד נתונים, כרטיס תמיכה. Prompts הן תבניות לשימוש חוזר שהמשתמש מפעיל — «סכם את השרשור הזה» או «נסח עדכון סטטוס» מוכן שאדם מפעיל במפורש, ולא משהו שהמודל מחליט לעשות בעצמו. שרת שנבנה היטב מפורש לגבי איזה משלושתם הוא מציע ליכולת נתונה, כי ההבחנה הזו היא בדיוק מה שקובע אם כלי בינה מלאכותית מחובר יכול להסתכל על משהו או לשנות אותו.
מי עוד אימץ, ומתי
החודשים הראשונים של MCP היו פרויקט של Anthropic בלבד. זה השתנה מהר, ובאופן באמת חריג בבינה מלאכותית: מתחרים ישירים התכנסו לפרוטוקול של חברה אחת במקום לשחרר פרוטוקול משלהם. OpenAI הוסיפה תמיכת MCP ל-Agents SDK שלה במרץ 2025, ואפשרה למפתחים לחבר זרימות עבודה של סוכנים לכל שרת MCP במקום לבנות אינטגרציות כלים מותאמות וספציפיות ל-OpenAI. בחודש שאחר כך, Google DeepMind אישרה ש-Gemini וערכת פיתוח הסוכנים שלה יתמכו גם הם ב-MCP — מהלך ש-Google צירפה לפרוטוקול המשלים שלה, Agent2Agent, שנועד לאפשר לסוכנים עצמאיים לתאם זה עם זה ולא עם כלים. עד מאי 2025, Microsoft הביאה תמיכת MCP מובנית ל-Windows 11 דרך מה שהיא קוראת לו Windows AI Foundry, ותמיכה נחתה גם בתוך GitHub Copilot ו-Copilot Studio.
אף אחת מארבע החברות האלה לא מסכימה על הרבה כשמדובר בארכיטקטורת מודלים, בתמחור או באסטרטגיית פלטפורמה. כולן מוציאות עכשיו מוצרים שמדברים את אותו פרוטוקול לחיבור סוכן לכלי. זה נדיר מספיק בתעשייה הזו כדי להיות הסיפור האמיתי — יותר מכל יכולת בודדת ש-MCP מאפשר.
למה זו שאלת אמון, לא רק צנרת
ההתכנסות הזו מועילה באמת, והיא גם בדיוק הסיבה ש-MCP ראוי לבדיקה ולא לאמון עיוור. פרוטוקול שהופך לטריוויאלי את החיבור של סוכן למערכות החברה הוא פרוטוקול שהופך לטריוויאלי גם את ההגעה של חיבור שנבנה רע או הוגדר רע לאותן מערכות. MCP עצמו לא מונע את זה. המפרט מגדיר איך לקוח ושרת מדברים זה עם זה — הוא לא אומר דבר על מי רשאי להעניק חיבור, למה החיבור רשאי לגעת, או אם מישהו ישים לב אם משהו משתבש. הבחירות האלה יושבות לגמרי אצל מי שבנה או הגדיר את השרת או הלקוח הספציפי שמולכם. חלק מהספקים בונים את כל זה בזהירות. חלק לא בונים את זה בכלל, והפרוטוקול לא יעצור אותם.
MCP הוא פרוטוקול חוט, לא מערכת בקרת גישה. הוא מתקנן איך סוכן מבקש מכלי לעשות משהו. אם הבקשה הזו מתוחמת, מתועדת וניתנת לביטול זו החלטה שמישהו קיבל — או לא קיבל — מעליו.
רשימת בדיקה לפני שמחברים אחד
לפני שהצוות מחבר שרת MCP — בין שזה מוצר של ספק, כלי קוד פתוח שמישהו מצא ב-GitHub, או משהו שנבנה בבית — שש שאלות מפרידות חיבור מנוהל מדלת פתוחה. אף אחת לא דורשת לקרוא את המפרט. הן רק דורשות שמישהו ישאל לפני שלוחצים על אישור, ויקרא בפועל את התשובה שמסך החיבור מחזיר.
| שאלו את זה | איך נראה טוב | שימו לב |
|---|---|---|
| אילו היקפים או Tools הוא מבקש? | מפורט רשימה נקובה וספציפית שאפשר לקרוא לפני האישור — «ליצור משימות, לקרוא הודעות בערוץ הזה». | גורף «גישה מלאה לחשבון» בלי רשימה מפורטת של מה שהוא באמת יכול לעשות. |
| האם הוא לקריאה בלבד, או יכול לכתוב ולפעול? | מופרד גישת קריאה כברירת מחדל; כל פעולה שמשנה נתונים צריכה הענקה נראית משלה. | ארוז יחד גישת כתיבה כלולה אוטומטית, בלי דרך לדעת איזו יכולת עושה מה. |
| לפי אדם, או משותף לכל הצוות? | לפי אדם כל אדם נכנס עם ההתחברות שלו; הסוכן רואה רק מה שהאדם הזה יכול לראות. | משותף מפתח API אחד או חשבון שירות שכל הצוות משתמש בו, ועוקף הרשאות אישיות. |
| יש יומן ביקורת של מה שהוא עשה? | מתועד כל קריאה ל-Tool נרשמת — מי חיבר אותה, למה היא נגעה, ומתי. | בלי תיעוד אין תיעוד מעבר למה שכלי הבינה המלאכותית עצמו בוחר לספר לכם שקרה. |
| אפשר לבטל אותו מיד? | מיידי מתג אחד, בתוקף מיד, מעמוד הגדרות שבשליטתכם. | מעוכב הביטול דורש כרטיס תמיכה, שיחה לספק, או אינו אפשרי כלל. |
| האם ביטול שלו שובר משהו אחר? | מבודד מתוחם לחיבור האחד הזה; כיבוי משפיע רק עליו. | סבוך חולק אישור עם כלים אחרים, כך שביטול אחד שובר בשקט שלושה אחרים. |
איך נראה בפועל חיבור שנבנה היטב
ההגדרה של FabricLoop עצמה ל-MCP היא תשובה קונקרטית לרשימה הזו — לא מפני שהיא חריגה, אלא מפני שכל חלק ממפה ישירות לאחת משש השאלות למעלה, וכדאי לנקוב במכניקה האמיתית ולא בגרסת השיווק. FabricLoop רצה בשני התפקידים בבת אחת: הוא שרת MCP שכלים חיצוניים מתחברים אליו, כך ש-Cursor, Claude או ChatGPT יכולים ליצור משימה, להוסיף תגובה או לקרוא פתק בהרשאות FabricLoop של אדם מסוים — והוא לקוח MCP שמתחבר החוצה, כך שערוץ יכול למשוך אפליקציית MCP של ספק, כמו GitHub או Linear, ולעשות לה @mention כמו לחבר צוות.
כל חיבור, בכל כיוון, מתחיל באדם, לא בסביבת עבודה. חיבור לקוח חיצוני כמו Cursor פותח מסך הסכמת OAuth ב-app.fabricloop.com/oauth/consent, שבו האדם בוחר סביבת עבודה ומאשר את ה-Tools הספציפיים שהלקוח מבקש — אחר כך הלקוח יכול לפעול רק בהיקפים שהוענקו במסך הזה, תחת ההרשאות של אותו אדם אחד, אף פעם לא דרך חשבון שירות משותף. הכיוון ההפוך רץ באותו אופן: מנהל יכול להפעיל אפליקציית MCP של ספק לכל הצוות, אבל כל אדם עדיין משלים התחברות משלו לפני שזה עובד עבורו, ומנהל יכול להגדיר את האפליקציה למצב קריאה בלבד או להגביל אותה לרשימת היתר של Tools מסוימים במקום לכל מה שהספק חושף.
כל לקוח מחובר מופיע במסך הגדרות ליד בקרת ביטול שמנתקת אותו מיד — העמוד של האדם עצמו, לא כרטיס תמיכה. בתוכניות Enterprise, הפעילות הזו — כולל הענקות MCP ומה שסוכן מחובר באמת עשה — נכנסת ליומן ביקורת שצוות אבטחה יכול לעיין בו לפי דרישה, ולא לצילומי מסך שנשלפים משרשור צ'אט אחרי מעשה.
שום דבר מזה אינו הנדסה אקזוטית. זו קבוצה קטנה של החלטות, לא זוהרות בכוונה, שחוזרות בעקביות: לתחם, לקשור לאדם, לתעד, לאפשר ביטול בלי נזק נלווה. זו אותה טענה שהאתר הזה מעלה לגבי Legibility במובן רחב יותר — גישה שאפשר לנקוב בשמה, לתעד ולבטל עדיפה על גישה שאף אחד לא צריך לחשוב עליה — ו-MCP מספק את זה רק כשמישהו בונה אותו כך. הפרוטוקול הופך את הצנרת לתקנית. הוא לא הופך את הממשל לאוטומטי.
ההחלטה שבאמת חשובה
MCP לא הולך לשום מקום, והתנגדות לו בשלב הזה דומה קצת להתנגדות ל-USB. כל ספק מודלים גדול מוציא אותו עכשיו, רשימת השרתים הזמינים ממשיכה לגדול, וסוכן שלא יכול להגיע לכלים שלכם הוא, לרוב העבודה האמיתית, סוכן שלא יכול לעשות הרבה. ההחלטה המעניינת אינה אם לאפשר לכלי בינה מלאכותית להתחבר למערכות שלכם — יותר ויותר, גרסה כלשהי של ההחלטה הזו כבר מתקבלת עבורכם, אינטגרציה אחרי אינטגרציה, כשכלים שהצוות כבר משתמש בהם מוסיפים בשקט תמיכת MCP מתחת ליכולת שלחצתם עליה בלי לקרוא את האותיות הקטנות. ההחלטה שעדיין באמת שלכם היא מה אתם בודקים לפני שלוחצים על אישור.
MCP תיקנן איך סוכן בינה מלאכותית מבקש מכלי לעשות משהו. הוא לא עשה דבר כדי לתקנן אם הבקשה הזו בטוחה להענקה — החלק הזה עדיין, ויישאר, החלטה של האדם שלוחץ «אישור».