דלגו לתוכן
גיליון 001·חי·20:20 IL
→ יומן/2026-06-10·10 דק׳

מה זה MCP? פרוטוקול הקונטקסט למודלים, מוסבר על ידי מישהו ששולח שרתים

MCP הוא ה-USB-C של כלי LLM: פרוטוקול אחד שנותן לכל מודל לדבר עם כל כלי או מקור נתונים. הנה מה זה, למה זה קיים, ואיך אני חושב על בניית שרת.

מאת Harel Asaf·בונה בינה מלאכותית·תל אביב

לפני MCP, כל פעם שרציתם ש-LLM ייגע במערכת אמיתית - מסד הנתונים שלכם, מערכת הקבצים, GitHub, API של SaaS - כתבתם אינטגרציה בהתאמה אישית. המודל היה צריך כלי, הכלי היה צריך קוד דבק, קוד הדבק היה ספציפי לפורמט קריאת-הכלים של אותו מודל אחד ולרנטיים של אותה אפליקציה אחת. רוצים את אותה יכולת באפליקציה אחרת? כתבו מחדש. רוצים מודל אחר? כתבו מחדש שוב. כולם בנו את אותן N-כפול-M אינטגרציות שוב ושוב.

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

אני בונה כאלה. אז תנו לי לתת לכם את הגרסה שבאמת שימושית, לא סיור המפרט.

צורת הפרוטוקול

יש שלושה תפקידים, ולשמור אותם ישר מבהיר את רוב הבלבול.

המארח (host) הוא אפליקציית ה-LLM שהמשתמש מתקשר איתה - סוכן קידוד, עוזר דסקטופ, סוכן שכתבתם. זה הדבר עם המודל בתוכו.

הלקוח (client) חי בתוך המארח ומדבר MCP. יש לקוח אחד לכל חיבור שרת; הוא המתאם ברמת הפרוטוקול.

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

שרת יכול לחשוף שלושה סוגי דברים:

  • כלים (tools) - פעולות שהמודל יכול להפעיל. "הרץ את השאילתה הזו," "צור את ה-issue הזה," "פרוס את הסקריפט הזה." זה מה שאנשים מושיטים יד אליו ראשון, וזה איפה שרוב הערך נמצא.
  • משאבים (resources) - נתונים שהמארח יכול לקרוא לתוך קונטקסט. קבצים, רשומות, מסמכים. מכוון-קריאה ולא מכוון-פעולה.
  • פרומפטים (prompts) - תבניות פרומפט לשימוש חוזר שהשרת מציע למארח, לעיתים קרובות מוצגות כפקודות מופעלות-משתמש.

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

למה פרוטוקול מנצח פלאגין

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

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

קונקרטית, הניידות ההיא קונה לכם שלושה דברים:

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

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

3. אקוסיסטם אמיתי. כי שרתים מנותקים, אנשים מפרסמים אותם. אתם יכולים למשוך שרת לשירות שאתם לא רוצים לשלב בעצמכם, והמארח שלכם פשוט משתמש בו.

זה ההבדל בין פיצ'ר לממשק. קריאת פונקציות היא פיצ'ר. MCP הוא ממשק, וממשקים הם מה שנותן לאקוסיסטמים להיווצר.

איך חיבור באמת רץ

מתחת למכסה זה חילופי הודעות מובנים (JSON-RPC) בין לקוח לשרת, ויש שני תעבורות עיקריות תלוי איפה השרת חי.

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

שרתים מרוחקים רצים במקום אחר ומדברים על פני HTTP (תעבורת Streamable HTTP). ככה שרתים מאוחסנים, מרובי-דיירים עובדים - שירות מפרסם נקודת קצה MCP בכתובת URL, וכל מארח מכוון אליה.

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

החלק שכולם ממעיטים בו: אימות ואמון

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

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

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

איך אני חושב על בניית אחד

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

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

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

גרסת המשפט האחד

MCP הוא פרוטוקול פתוח שהופך "שלב את הכלי הזה עם המודל הזה באפליקציה הזו" מכתיבה-מחדש של N-כפול-M לשרת כתוב-פעם שכל מארח יכול להשתמש בו - פורט ה-USB-C לכלי LLM.

מקורות

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

שאלות נפוצות

מהו פרוטוקול הקונטקסט למודלים (MCP)?

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

איזו בעיה MCP פותר?

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

מה הם כלי MCP, משאבים ופרומפטים?

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

איך MCP שונה מקריאת פונקציות?

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

אילו תעבורות MCP משתמש?

שתיים עיקריות. שרתים מקומיים רצים כתת-תהליך ומתקשרים על פני קלט ופלט סטנדרטיים, טוב לכלים שנוגעים במכונה שלכם. שרתים מרוחקים רצים במקום אחר ומתקשרים על פני HTTP (תעבורת Streamable HTTP), טוב לשירותים מאוחסנים, מרובי-דיירים שמפורסמים בכתובת URL.

איך לטפל באימות בשרת MCP?

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

איך בונים שרת MCP טוב?

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

קריאה נוספת

יומן הבנייה

לעקוב אחרי העבודה.

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

עקבו ב-RSS