כל שרת MCP שמחובר לסוכן AI גובה מס שקט. שמות הכלים, התיאורים וסכמות הפרמטרים שלהם מוזרקים להקשר של המודל בכל תור בשיחה, ולא פעם אחת בתחילת הסשן. בשרתי MCP עלות טוקנים נצברת אפוא בלי קשר לשימוש בפועל: שיחה של 50 הודעות משלמת את התקורה 50 פעמים, גם אם הסוכן לא הפעיל אף כלי.
המספרים כבר אינם תיאורטיים. issue במאגר של Claude Code תיעד 7 שרתי MCP פעילים שצרכו 67,300 טוקנים, כלומר 33.7% מחלון הקשר של 200 אלף טוקנים, עוד לפני שהשיחה התחילה. לפי Layered, הצעה שהוגשה במאגר של MCP מדדה שרת MySQL עם 106 כלים: 207KB של סכמה, כ-54,600 טוקנים בכל אתחול, גם כשהמודל צריך בסך הכול 2-3 כלים.
חלק מהבעיה נפתר כיום בצד ה-host, באמצעות טעינה עצלה וחיפוש כלים. אבל החלק שבשליטה המלאה של מי שכותב את השרת, ושעובד בכל לקוח MCP, הוא עיצוב הכלים עצמם: פחות כלים, בלי חפיפות, עם תיאורים קצרים ופלטים מצומצמים. המדריך עובר שלב אחר שלב על תהליך הביקורת והאיחוד, כולל קוד למדידה ודוגמה מעשית.
למה עלות הטוקנים של שרתי MCP גדלה בכל תור
Model Context Protocol מאפשר לסוכן לקרוא לכלים חיצוניים, אבל כדי שהמודל ידע שכלי קיים ואיך להפעיל אותו, הוא חייב לראות את השם, התיאור וסכמת ה-JSON של הפרמטרים. בלקוחות שעובדים בטעינה מוקדמת (eager loading), הקטלוג הזה נשלח מחדש עם כל בקשה למודל.
המשמעות: העלות גדלה עם מספר הכלים ועם אורך הסכמות, ולא עם השימוש בפועל. כלי שאף אחד לא הפעיל כבר חודש עדיין משלם את חלקו בכל הודעה.
כמה זה עולה בפועל
הנתונים מהשטח, ממקורות שונים ובתצורות שונות:
- הגדרה טיפוסית של ארבעה שרתים ב-Claude Code מוסיפה כ-7,000 טוקנים של הגדרות כלים לכל הודעה כשאין דחיית טעינה.
- הגדרות כבדות עוברות 50,000 טוקנים עוד לפני הפרומפט הראשון (נתון שהמקור מצטט ממקור משני).
- שרת ה-MCP של GitHub, עם 27 כלים, צרך כ-18 אלף טוקנים.
- הערכת מחבר ה-issue היא 550-850 טוקנים לכלי בודד.
אם מכפילים 7,000 טוקנים ב-50 הודעות, מקבלים 350,000 טוקני קלט בסשן אחד שהם תקורה טהורה. בצוות של כמה מפתחים שעובדים כך כל יום, זה מצטבר לשורה משמעותית בחשבונית ה-API, שבדרך כלל מחויבת בדולרים לפי שימוש.
הפלט נספר גם הוא
לא רק ההגדרות עולות כסף. Claude Code מזהיר כשתוצאה של כלי MCP בודד עוברת 10,000 טוקנים, ומגביל תוצאות ל-25,000 טוקנים כברירת מחדל באמצעות המשתנה MAX_MCP_OUTPUT_TOKENS. תוצאה מילולית אחת יכולה לעלות יותר מכל הגדרות הכלים יחד.
מי שכבר מכיר את העיקרון של ניהול חלון הקשר כמשאב מוגבל ימצא כאן יישום ישיר של מה שמתואר במדריך הנדסת קונטקסט לסוכני AI וצ'אטבוטים: כל טוקן שנכנס להקשר צריך להצדיק את מקומו.
ניפוח סכמות פוגע גם בדיוק: בעיית בחירת הכלי
קל לחשוב על כלים מיותרים כבעיה כספית בלבד, אבל יש לה מחיר נוסף. ככל שמספר הכלים המועמדים גדל והם דומים יותר זה לזה, מודלים בוחרים לעיתים קרובות יותר בכלי סביר אבל שגוי, למשל endpoint שהוצא משימוש, או חיפוש לקריאה בלבד במקום שליפה מהמקור המוסמך.
חפיפות שאיש לא בודק
הבעיה מחריפה כשמחברים כמה שרתים. לפי Decagon, כמה שרתים חושפים יכולות כמעט זהות, כמו שליפת לקוח או החזרים כספיים חופפים. משלמים עליהן פעמיים: פעם אחת בטוקנים כדי לתאר אותן, ופעם נוספת בהיגיון שהמודל מבזבז כדי להבחין ביניהן. ולרוב אף אחד לא עורך ביקורת על הסט המשולב.
מה אומרים המספרים על דיוק
מקור אחד טוען שחיפוש כלים העלה את דיוק בחירת הכלי מ-49% ל-74% בסביבות מורכבות. חשוב לציין שמדובר בבלוג משני שלא מציין את ה-benchmark שעליו הוא נשען, ולכן כדאי להתייחס לנתון כאינדיקציה ולא כעובדה מדודה. הכיוון, עם זאת, עקבי עם הטיעון האיכותני: פחות מועמדים דומים פירושו פחות טעויות.
שלב 1: מדידת נקודת הפתיחה של שרת MCP
אי אפשר לשפר את מה שלא נמדד. לפני כל שינוי צריך לדעת כמה כלים חושף השרת, וכמה טוקנים בערך עולה כל אחד מהם.
סקריפט מדידה פשוט
הסקריפט הבא משתמש ב-Python SDK הרשמי של MCP, מתחבר לשרת, שולף את רשימת הכלים ומעריך את גודל כל אחד. ההערכה מבוססת על כלל אצבע של כ-4 תווים לטוקן, שתואם את היחס שתועד ב-arxiv-mcp-server: כ-10,000 תווים, כ-2,500 טוקנים. זה קירוב בלבד, כי כל מודל משתמש ב-tokenizer משלו, והיחס עשוי להשתנות בטקסט שאינו באנגלית.
import asyncio
import json
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
params = StdioServerParameters(command="node", args=["dist/server.js"])
async def main():
async with stdio_client(params) as (read, write):
async with ClientSession(read, write) as session:
await session.initialize()
result = await session.list_tools()
rows = []
for tool in result.tools:
payload = json.dumps(
{
"name": tool.name,
"description": tool.description,
"inputSchema": tool.inputSchema,
},
ensure_ascii=False,
)
rows.append((tool.name, len(payload) // 4))
rows.sort(key=lambda r: r[1], reverse=True)
for name, est in rows:
print(f"{name:40} ~{est} tokens")
total = sum(est for _, est in rows)
print(f"\nTOTAL: {len(rows)} tools, ~{total} tokens per turn")
asyncio.run(main())מה לרשום בטבלת הבסיס
לכל שרת כדאי לתעד:
- מספר הכלים הכולל.
- סך הטוקנים המוערך של כל הסכמות.
- חמשת הכלים הכבדים ביותר, והאם התיאור או הסכמה הם שמנפחים אותם.
- גודל טיפוסי של תוצאה מכל כלי מרכזי, שהרי גם הפלט נכנס להקשר.
- תדירות שימוש בכל כלי, אם יש לוגים.
המספר הזה הוא קו הבסיס. בסוף התהליך מריצים את אותו סקריפט שוב ומשווים.
שלב 2: ביקורת חפיפות, כלים נדירים ותיאורים ארוכים
עם רשימת הכלים ממוינת לפי משקל, אפשר להתחיל בביקורת. המטרה היא לסווג כל כלי לאחת מארבע קטגוריות: להשאיר, לאחד, לקצר או למחוק.
דפוס 1: כלי לכל endpoint
הדפוס הנפוץ ביותר, והבזבזני ביותר, הוא עטיפה של כל endpoint ב-API ככלי נפרד. התוצאה היא התרבות של כלים ותגובות מילוליות שמחזירות יותר מדי מידע, למשל getUser שמחזיר את כל אובייקט המשתמש כשהסוכן צריך רק כתובת מייל.
שרת שנבנה כך משקף את מבנה ה-API, לא את המשימות שהסוכן באמת מבצע. סימן היכר מובהק: קבוצות של כלים עם אותו שם עצם ופעלים שונים, כמו get_order, list_orders, search_orders ו-get_order_status.
דפוס 2: כלים חופפים בין שרתים
כשמחוברים כמה שרתים, כדאי להניח את כל הכלים שלהם בטבלה אחת ולחפש יכולות דומות. שני כלים שמחפשים לקוח, אחד ב-CRM ואחד במערכת התמיכה, הם בדיוק המצב ש-Decagon מתאר ככפל עלות: טוקנים לתיאור וטוקנים להבחנה. לפעמים הפתרון הוא לנתק שרת שלם מסשן מסוים, ולא רק לקצץ כלים.
דפוס 3: תיאור שהפך למדריך
המקרה של arxiv-mcp-server הוא דוגמה מצוינת. הסכמות שלו עלו כ-2,500 טוקנים, והתיאור של search_papers לבדו הגיע לכ-1,086 טוקנים, כי הוטמעו בו קטלוגים של קטגוריות, מדריך לכתיבת שאילתות ודוגמאות. כמעט חצי מכל העלות של השרת ישבה בתיאור של כלי אחד.
שאלות מנחות לביקורת
- האם הכלי הופעל בחודש האחרון? אם לא, האם הוא חייב להיות זמין בכל סשן?
- האם יש כלי אחר שמבצע פעולה דומה על אותו משאב?
- האם התיאור ארוך מ-2-3 משפטים? מה בו קריטי להפעלה ומה הוא תיעוד?
- האם הסכמה מגדירה גבולות וערכים מותרים, או שהם מוסברים בטקסט חופשי בתיאור?
- האם התוצאה מחזירה שדות שהסוכן אף פעם לא משתמש בהם?
שלב 3: איחוד כלים בשרת MCP, דוגמה מעשית
השלב הזה הוא בדרך כלל זה שמביא את החיסכון הגדול ביותר. הדוגמה כאן היא שרת היפותטי של חנות אונליין, שנועד להמחיש את הטכניקה. המספרים שבה הם הערכות לצורך ההדגמה, לא מדידה של מערכת אמיתית.
לפני: 15 כלים שמשקפים את ה-API
נניח שרת שחושף את הכלים הבאים:
- הזמנות:
get_order,list_orders,search_orders,get_order_status,get_order_items - לקוחות:
get_customer,find_customer_by_email,find_customer_by_phone,list_customer_orders - מלאי:
get_product,search_products,get_stock_level - החזרים:
create_refund,get_refund,list_refunds
לפי הטווח של 550-850 טוקנים לכלי שהוערך ב-issue של Claude Code, 15 כלים כאלה עשויים לעלות כ-8,250-12,750 טוקנים בכל תור. וחשוב לא פחות: המודל צריך להבחין בין get_customer, find_customer_by_email ו-find_customer_by_phone, שלושה כלים שעושים בעצם אותו דבר.
אחרי: 4 כלים שמשקפים משימות
העיקרון הוא לקבץ לפי משאב וסוג פעולה, ולהשתמש בפרמטרים במקום בכלים נפרדים:
query_orders: שליפה וחיפוש של הזמנות, כולל סטטוס ופריטים.query_customers: איתור לקוח לפי מזהה, מייל או טלפון.query_products: מוצרים ומלאי.manage_refund: יצירה ושליפה של החזרים, הפעולה היחידה שכותבת נתונים.
כך נראית הסכמה של הכלי המאוחד להזמנות:
{
"name": "query_orders",
"description": "Find orders by ID, customer or filters. Returns only requested fields.",
"inputSchema": {
"type": "object",
"properties": {
"order_id": { "type": "string" },
"customer_id": { "type": "string" },
"status": {
"type": "string",
"enum": ["pending", "paid", "shipped", "delivered", "cancelled"]
},
"fields": {
"type": "array",
"items": {
"type": "string",
"enum": ["status", "total", "items", "shipping", "created_at"]
},
"default": ["status", "total"]
},
"limit": { "type": "integer", "minimum": 1, "maximum": 50, "default": 10 }
}
}
}כמה החלטות עיצוב ראויות לתשומת לב:
- הערכים המותרים נמצאים בסכמה, ב-
enumובגבולות מספריים, ולא בפסקה מסבירה בתיאור. - הפרמטר
fieldsמאפשר לסוכן לבקש רק את מה שהוא צריך, וכך פותר מראש את בעיית ה-over-fetching. - ברירות מחדל שמרניות (שני שדות, 10 תוצאות) מונעות פלטים ענקיים כשהסוכן לא מציין אחרת.
- הפרדה בין קריאה לכתיבה: פעולת ההחזר נשארת בכלי נפרד, כי זו פעולה עם השלכות כספיות שכדאי שתהיה מפורשת.
איפה עוצרים: הסכנה באיחוד יתר
איחוד אינו מטרה בפני עצמה. הניתוח של Layered מצביע על כך שאיחוד יתר עלול ליצור כלים עם פרמטרים מורכבים, ושנדרשים תיאורים מדויקים מספיק כדי שהשימוש יהיה נכון. כלי אחד בשם do_anything עם 40 פרמטרים אופציונליים פשוט מעביר את הבלבול מבחירת הכלי לבחירת הפרמטרים.
כמה כללי אצבע:
- לאחד כלים שפועלים על אותו משאב ומחזירים אותו סוג נתונים.
- לא לאחד פעולות קריאה עם פעולות כתיבה או מחיקה.
- אם פרמטר אחד משנה לחלוטין את משמעות הפרמטרים האחרים, כנראה שאלה שני כלים.
- לשמור על שמות תיאוריים. שמות כמו
search_customer_ordersעוזרים גם לגילוי מבוסס חיפוש.
שינויים שוברים
איחוד כלים הוא שינוי API לכל דבר. מי שכבר בנה פרומפטים או תהליכים סביב שמות הכלים הישנים יושפע, ו-Layered מציין במפורש שהגישה דורשת מאמץ עיצובי ועלולה לכלול שינויים שוברים למשתמשים קיימים. כדאי לפרסם גרסה חדשה עם הערת שינויים ברורה, ואם השרת ציבורי, לשקול תקופת מעבר שבה הכלים הישנים זמינים מאחורי דגל תצורה.
שלב 4: קיצור תיאורים והוצאת מדריכים מהסכמה
אחרי שמספר הכלים ירד, עוברים לתוכן של כל אחד. כאן החיסכון נראה קטן לכל כלי, אבל הוא מוכפל בכל תור ובכל סשן.
מה נכנס לתיאור ומה לא
הכלל שעלה מהדיון ב-arxiv-mcp-server ברור: התיאור צריך לכלול רק סמנטיקה קריטית להפעלה, אילוצים וברירות מחדל. מדריכים ארוכים, קטלוגים ודוגמאות עוברים ל-README, ל-resources או ל-prompts, וגבולות וערכים מותרים עוברים לסכמת הקלט.
הדוגמה ש-Layered מביאה ממחישה את הפער. במקום תיאור של כמה משפטים, מספיק: Search files by glob pattern. Returns matching paths. שני משפטים קצרים שאומרים מה הכלי מקבל ומה הוא מחזיר.
לפני ואחרי
תיאור מנופח טיפוסי:
This tool allows you to search for academic papers in the arXiv database.
You can use it whenever the user asks about research. Supported categories
include cs.AI (Artificial Intelligence), cs.CL (Computation and Language),
cs.LG (Machine Learning), ... [dozens more categories]
Query syntax tips: use AND/OR operators, quote exact phrases ...
Example 1: ... Example 2: ... Example 3: ...גרסה מקוצרת:
Search arXiv papers by query and optional category. Returns title, authors, ID, abstract.רשימת הקטגוריות עוברת ל-enum בסכמה, או ל-resource שהסוכן יכול לקרוא בעת הצורך. המדריך לתחביר שאילתות עובר לתיעוד. במקרה של arxiv-mcp-server, היעד שהוגדר היה הפחתה של לפחות 40% בגודל התיאור של search_papers. ה-issue לא מדווח את התוצאה המדויקת, אבל הכיוון ברור.
איך לכתוב תיאור טוב בשלושה רכיבים
- פועל ומשאב: מה הכלי עושה ועל מה (Search orders, Create refund).
- מתי לא להשתמש בו, אם יש כלי קרוב שעלול לבלבל. זה המשפט היחיד שמצדיק אורך נוסף.
- מה חוזר: שדות עיקריים, כדי שהמודל ידע אם התוצאה תספיק לו.
הערה על עברית בתיאורים
למפתחים בישראל יש שיקול נוסף, שכדאי להתייחס אליו כהנחה לבדיקה ולא כעובדה מבוססת. המקורות שעליהם נשען המאמר אינם עוסקים בעברית כלל, ואין בהם השוואת tokenizers בין עברית לאנגלית. ההנחה הרווחת היא שטקסט בעברית מתפרק ליותר טוקנים מטקסט מקביל באנגלית, אבל היחס משתנה בין מודלים ובין גרסאות tokenizer.
הדרך היחידה לדעת היא למדוד: לכתוב את אותו תיאור כלי בשתי השפות, להעביר את שתי הגרסאות דרך ספירת הטוקנים של המודל שבשימוש, ולהשוות. אותו דבר נכון לכלל האצבע של 4 תווים לטוקן שבסקריפט המדידה, שאין סיבה להניח שהוא תקף לטקסט עברי.
בלי קשר לתוצאה, ברירת מחדל סבירה היא לכתוב שמות כלים, תיאורים וסכמות באנגלית תמציתית, גם כשהממשק מול המשתמש כולו בעברית. המודל מסוגל לקבל הגדרת כלי באנגלית ולענות למשתמש בעברית, וסכמות JSON ממילא נשארות LTR גם בתוך ממשק RTL.
שלב 5: שליטה בפלט, דחיית טעינה ומדידה חוזרת
השלב האחרון משלים את התמונה: צמצום מה שהכלים מחזירים, ניצול היכולות של הלקוח עצמו, ומדידה חוזרת מול קו הבסיס.
צמצום פלטים בצד השרת
צמצום מספר הכלים אינו הפתרון היחיד. לפי MindStudio, סינון שדות וביצוע חישובים בצד השרת מקטינים את טוקני התוצאה, והמטרה היא להשתמש בכלים בצורה מדויקת יותר, לא רק בפחות כלים.
בפועל, זה אומר:
- להחזיר רק שדות מבוקשים, כמו פרמטר
fieldsשהודגם קודם. - לבצע אגרגציות בשרת: אם הסוכן צריך סכום הזמנות לחודש, השרת יחשב ויחזיר מספר, לא 300 שורות.
- לעמד (pagination) עם ברירת מחדל נמוכה ואפשרות לבקש עוד.
- לקצר שגיאות: הודעת שגיאה קצרה עם הוראה מה לתקן, בלי stack trace מלא.
כדאי לזכור את המגבלה של Claude Code: אזהרה מעל 10,000 טוקנים לתוצאה, ותקרה של 25,000 כברירת מחדל. כלי שמתקרב לגבולות האלה צריך עיצוב מחדש, לא העלאה של התקרה.
חיפוש כלים וטעינה עצלה
בצד ה-host, הפתרון המרכזי הוא לא לטעון את כל הכלים מראש. לפי Layered, כלי ה-MCP Tool Search של Claude Code, שהחל להתגלגל בגרסה 2.1.7, מופעל אוטומטית כשתיאורי הכלים היו עוברים 10% מחלון ההקשר, וטוען כלים לפי דרישה באמצעות חיפוש. עוד לפי Layered, Anthropic מדווחת על הפחתה של כ-85% בטוקנים עם ה-Tool Search Tool שלה, מ-10 אלף טוקנים ומעלה לכ-3,000 לבקשה.
יש מלכודת אחת שכדאי להכיר: Claude Code דוחה את טעינת הגדרות ה-MCP כברירת מחדל, אבל טוען אותן מראש כש-ANTHROPIC_BASE_URL מצביע על gateway או proxy, אלא אם מוגדר ENABLE_TOOL_SEARCH. צוותים שמנתבים את התעבורה דרך proxy פנימי לצורכי ניטור או בקרת עלויות עלולים לאבד את החיסכון בלי לשים לב.
# Claude Code behind a gateway: explicitly enable tool search
export ANTHROPIC_BASE_URL="https://llm-gateway.internal.example.com"
export ENABLE_TOOL_SEARCH=trueלמה זה לא מחליף עיצוב טוב
חיפוש כלים מצוין, אבל הוא לא פותר כלים חופפים או מבלבלים, והוא מוסיף שלב חיפוש. יתרה מזאת, כשהגילוי מבוסס חיפוש, המטא-דאטה התיאורית של הכלים נעשית חשובה עוד יותר. שם ותיאור קצר ומדויק הם בדיוק מה שמנוע החיפוש צריך כדי למצוא את הכלי הנכון.
ומעבר לכך, לא כל לקוח MCP תומך בחיפוש כלים. שרת שתוכנן היטב חוסך בכל לקוח, כולל לקוחות שעדיין טוענים הכול מראש.
לפי Agentic Patterns, טעינה עצלה מומלצת לשרתים עם 20 כלים ומעלה או כשהתיאורים עוברים 10% מההקשר, ומיותרת בכלי בודד, בסטים קטנים או בכלים שנדרשים בכל אינטראקציה. אחרי איחוד טוב, שרתים רבים פשוט יורדים מתחת לסף הזה.
השוואת שלוש הגישות
שלוש הגישות העיקריות להפחתת עלות הטוקנים של שרתי MCP אינן סותרות זו את זו. הן פועלות בשכבות שונות ומשלימות זו את זו.
גישה | איפה פועלת | יתרונות | חסרונות |
|---|---|---|---|
איחוד וקיצור בצד השרת | קוד השרת | עובדת בכל לקוח, מפחיתה טוקנים וגם בלבול, מסירה כפילויות במקור, בשליטה מלאה של המחבר | דורשת מאמץ עיצובי, שינויים שוברים אפשריים, סכנת פרמטרים מורכבים |
חיפוש כלים / טעינה עצלה | ה-host (למשל Claude Code) | כ-85% חיסכון מדווח בספריות גדולות, ברירת מחדל ב-Claude Code, בלי שינוי בשרת | שלב חיפוש נוסף, לא פעיל כברירת מחדל דרך proxy, לא פותר כלים חופפים |
Code Mode ב-gateway | שכבת gateway | חיסכון מדווח של 58%-93% בטוקני קלט ב-96 עד 508 כלים (נתוני ספק) | דורש אימוץ gateway של צד שלישי, benchmarks מהספק עצמו, משתלם רק בהיקפים גדולים |
מקורות לטבלה: Layered, Wati, Maxim.
השורה האחרונה בטבלה מתייחסת ל-Code Mode של Bifrost, מוצר מסחרי שמחליף את קטלוג הכלים המלא בארבעה מטא-כלים, כלומר גישת איחוד שמיושמת ברמת ה-gateway. המספרים מגיעים מהספק עצמו, והם גם לא עקביים לגמרי: בפרסום אחד מופיעה הפחתה של 58.2%, 84.5% ו-92.8% בטוקני קלט, ובפרסום אחר שינוי בעלות של 55.7%, 83.4% ו-92.2%. ההבדלים קטנים, אבל הם מזכירים שמדובר בנתונים שלא אומתו באופן עצמאי.
צ'קליסט לפני פרסום גרסה חדשה של השרת
- [ ] סקריפט המדידה הורץ וקו הבסיס תועד.
- [ ] אין שני כלים שמבצעים פעולה דומה על אותו משאב.
- [ ] כלים שלא נמצאים בשימוש הוסרו או הועברו מאחורי דגל תצורה.
- [ ] קריאה וכתיבה מופרדות לכלים שונים.
- [ ] כל תיאור הוא 1-3 משפטים: מה הכלי עושה, מתי לא להשתמש בו, מה חוזר.
- [ ] ערכים מותרים וגבולות מוגדרים ב-
enum,minimum,maximumולא בטקסט. - [ ] מדריכים, קטלוגים ודוגמאות הועברו ל-README או ל-resources.
- [ ] יש פרמטר לבחירת שדות וברירות מחדל שמרניות ל-limit.
- [ ] גודל פלט טיפוסי נבדק, והוא רחוק מ-10,000 טוקנים.
- [ ] סקריפט המדידה הורץ שוב והתוצאה הושוותה לקו הבסיס.
- [ ] כמה משימות אמיתיות נבדקו, והסוכן עדיין בוחר בכלי הנכון.
הבדיקה האחרונה חשובה במיוחד. אין בנתונים הזמינים כיום מדידה מסודרת של ההשפעה של איחוד כלים על דיוק הבחירה, וגם המחיר של סכמות פרמטרים גדולות יותר לא נבדק באופן שיטתי. לכן אין תחליף לסט קטן של משימות בדיקה, שרץ לפני ואחרי כל שינוי.
החשבון הכולל
חיסכון בטוקני קלט מצטרף לחיסכון במקומות אחרים. מי שמנתח את חשבונית ה-LLM שלו ימצא הקשר נוסף בניתוח על ירידת מחירי LLM ואיך לחתוך עלויות AI. גם כשהמחיר לטוקן יורד, תקורה של עשרות אלפי טוקנים בכל תור נשארת בזבוז שמצטבר.
שאלות נפוצות
האם הגדרות כלי MCP נטענות פעם אחת בסשן או בכל קריאה?
בלקוחות שעובדים בטעינה מוקדמת הן נכללות בכל תור, כך ששיחה של 50 הודעות משלמת את התקורה 50 פעמים. לקוחות עם חיפוש כלים דוחים את טעינת ההגדרות וטוענים רק את מה שנדרש.
האם Claude Code כבר פותר את הבעיה עם Tool Search?
בחלקה. הוא דוחה טעינת כלים כברירת מחדל, אבל לא כשמשתמשים בכתובת בסיס של gateway או proxy, אלא אם מוגדר ENABLE_TOOL_SEARCH. הוא גם לא פותר כלים חופפים, ולא עוזר ללקוחות MCP אחרים שמשתמשים באותו שרת.
האם יותר מדי כלים פוגעים גם בדיוק, ולא רק בעלות?
כן. לפי Decagon, כשיש הרבה כלים דומים, מודלים בוחרים יותר בכלי סביר אך שגוי. מקור משני מצטט עלייה בדיוק מ-49% ל-74% עם חיפוש כלים, אבל בלי ציון ה-benchmark, ולכן כדאי להתייחס לנתון בזהירות.
מה צריך להיכנס לתיאור של כלי?
רק סמנטיקה קריטית להפעלה, אילוצים וברירות מחדל. מדריכים, קטלוגים ודוגמאות עוברים ל-README, ל-resources או ל-prompts, וגבולות וערכים מותרים עוברים לסכמת הקלט.
האם צמצום מספר הכלים הוא הפתרון היחיד?
לא. גודל הפלט חשוב לא פחות, וסינון שדות וחישובים בצד השרת מקטינים את טוקני התוצאה. המטרה היא שימוש מדויק יותר בכלים, לא רק פחות כלים.
מתי טעינה עצלה מיותרת?
בכלי בודד, בסטים קטנים או בכלים שנדרשים בכל אינטראקציה. היא מומלצת לשרתים עם 20 כלים ומעלה או כשהתיאורים עוברים 10% מההקשר.
סיכום
עלות הטוקנים של שרתי MCP נובעת מעובדה פשוטה: בלקוחות שטוענים הכול מראש, כל כלי שחושף שרת נשלח למודל בכל תור, בין אם נעשה בו שימוש ובין אם לא. התוצאה היא עשרות אלפי טוקנים של תקורה, ולצידם סוכן שמתבלבל יותר בין כלים דומים.
לפתרון שתי שכבות. בצד ה-host, חיפוש כלים וטעינה עצלה מפחיתים את העלות באופן משמעותי, אבל דורשים תצורה נכונה ולא קיימים בכל לקוח. בצד השרת, ובשליטה המלאה של המחבר, נמצא התיקון שעובד בכל מקום: למדוד את קו הבסיס, לבקר חפיפות וכלים נדירים, לאחד כלים לפי משאב ומשימה, לקצר תיאורים ולהעביר מדריכים לתיעוד, ולצמצם פלטים.
הכלל המנחה פשוט: שרת MCP צריך לשקף את המשימות שהסוכן מבצע, לא את מבנה ה-API שמתחתיו. כלים מעטים וברורים, עם סכמות שמגדירות את הגבולות במקום להסביר אותם, הם הדרך לסוכן זול יותר ומדויק יותר.
מקורות
- How to Reduce MCP Token Costs for Claude Code at Scale (Maxim/Bifrost)
- Lazy-load MCP tool definitions · Issue #11364 · anthropics/claude-code
- Reduce MCP tool-schema token overhead · Issue #131 · arxiv-mcp-server
- MCP Tool Schema Bloat: The Hidden Token Tax (Layered System)
- What is MCP context bloat? (Decagon)
- Token Optimization for MCP Tool Calls: 5 Techniques (Maxim/Bifrost)
- Reducing MCP Token Usage by 100x (MCP Servers blog)
- How to Reduce Token Usage in AI Agents: 10 MCP Optimization Techniques (MindStudio)
- Tool Search Lazy Loading (Agentic Patterns)
- What Is Lazy Loading for MCP Tools? (Wati)
- Tool Search: Redefining Agent Tool Calling (Epsilla)






