USB-C ל- AI (plus SDK).

ב-2025, כל אינטגרציה של LLM לשירות חיצוני הייתה דורשת adapter ייעודי. כל מי שרצה לחבר ChatGPT ל-Asana כתב פלאגין של ChatGPT. כל מי שרצה לחבר את אותו Asana ל-Claude כתב את הקוד שוב. כל מי שרצה ל-Cursor — שוב. הכאוס הזה נגמר ב-2026 כשהתקן MCP הפך לסטנדרט תעשייתי.

MCP — Model Context Protocol — הוא תקן פתוח של Anthropic לחיבור LLMs לשירותים חיצוניים. במקום שכל ספק AI יבנה את ה-adapters שלו, השירות עצמו (Asana, Vercel, GitHub, או הכלי הפנימי שלך) חושף MCP server אחד, וכל LLM שמדבר MCP יודע להשתמש בו. USB-C ל-AI — מטבע לשון של Anthropic שתפס.

למה זה קריטי

ב-2026, MCP נתמך כבר ע"י Claude (Code ו-Desktop), ChatGPT, Cursor, Cline, Continue, ו-Zed. כשמ-developer בונה MCP server אחד — הוא מקבל אינטגרציה ל-חמישה LLMs בו-זמנית. זה הפך את MCP מ-"עוד פרוטוקול" ל-standard אמיתי.

ה-spec מנוהל ע"י קונסורציום פתוח ב-modelcontextprotocol.io. הוא לא Anthropic-only — חברות אחרות תורמות ומציעות שיפורים. זו הנקודה המרכזית: MCP מנצח דווקא בגלל שהוא לא בבעלות מישהו אחד.

שלוש קונספטים מרכזיים

Tools — פונקציות ש-Claude יכול להפעיל. לדוגמה: asana.create_task או vercel.deploy. הן בעלות side effects. Resources — נתונים ש-Claude יכול לקרוא. לדוגמה: docs://api/v2 מחזיר מסמכי API. הן read-only. Prompts — תבניות פרומפט פרמטריות שהמשתמש יכול להפעיל. לדוגמה: prompt בשם summarize-pr שמקבל PR number ומייצר prompt מתאים.

לבנות MCP server משלך זה הצעד שמפריד בין משתמש ל-MCP-developer. זה פחות מורכב ממה שחושבים — 30 דקות לקבל משהו פועל. הנה ה-recipe המלא ב-Python.

שלב 1 — התקנה

pip install mcp fastapi uvicorn

שלב 2 — הקובץ הראשי

ה-package הרשמי mcp נותן לך את כל ה-boilerplate. אתה כותב decorators על functions Python, וזה מתבצע התרגום ל-protocol אוטומטית.

# my_mcp_server.py
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
import asyncio
import os

server = Server("my-tools")

@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="search_files",
            description="Search files in a directory by name pattern",
            inputSchema={
                "type": "object",
                "properties": {
                    "pattern": {"type": "string", "description": "Glob pattern"},
                    "path": {"type": "string", "description": "Root path"}
                },
                "required": ["pattern"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "search_files":
        from glob import glob
        path = arguments.get("path", os.getcwd())
        pattern = arguments["pattern"]
        results = glob(f"{path}/**/{pattern}", recursive=True)
        return [TextContent(type="text", text="\n".join(results) or "No files found")]

async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write, server.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

שלב 3 — להוסיף ל-Claude

# Recommended: claude mcp add my-tools "python /path/to/my_mcp_server.py"
# Manual alternative — edit ~/.claude.json (under "mcpServers" key):
{
  "mcpServers": {
    "my-tools": {
      "command": "python",
      "args": ["/path/to/my_mcp_server.py"]
    }
  }
}

פתח סשן חדש של Claude Code. תראה את mcp__my-tools__search_files זמין כ-tool. זהו. אתה כעת developer של MCP.

Claude Code הוא נהדר — אבל הוא רץ ב-CLI, מצריך אדם שלוחץ Enter, ולא מתאים לכל סצנה. ל-3 הסצנות האלה אתה צריך משהו אחר: cron jobs, Lambda functions, ואפליקציות שמטמיעות Claude כעוזר פנימי. זה התפקיד של Agent SDK.

Agent SDK הוא ספריה רשמית של Anthropic, זמינה ב-Python וב-TypeScript. היא חושפת את כל היכולות של Claude Code (tool use, prompt caching, sub-agents, MCP) כ-API שאפשר לקרוא מקוד. אין CLI. אין UI. רק import + run.

מה ה-SDK מטפל בו אוטומטית

Tool use loop — אתה נותן רשימת tools, ה-SDK רץ את לולאת call→response עד שיש תשובה סופית. Streaming — תשובות מגיעות chunk-by-chunk, נוח ל-UI realtime. Prompt caching — אוטומטי לקבצים גדולים שאתה מעביר שוב ושוב (כמו קובץ הקוד שלך). חוסך 90% מהעלות. Error handling — retries עם backoff, timeout management.

סצנת שימוש קלאסית

# agent.py — Claude that searches the web and writes a summary
from claude_agent_sdk import Agent
from claude_agent_sdk.tools import web_search, write_file

agent = Agent(
    model="claude-opus-4-7",
    system="You are a research assistant. Search the web, summarize findings.",
    tools=[web_search, write_file]
)

result = agent.run(
    "Find the top 3 papers from 2025 on agentic memory architectures, "
    "summarize each in 100 words, save to research-notes.md"
)
print(result.summary)
print(f"Cost: ${result.usage.total_cost:.4f}")

תריץ עם python agent.py. האדם שלוחץ Enter? לא צריך. ה-SDK מטפל בכל לולאת ה-tool calls אוטומטית.

רוב המפתחים שבונים MCP servers מתעלמים מ-2 מתוך 3 הקונספטים של MCP. הם בונים רק Tools. הם פועלים בלי Resources. הם לא מנצלים Prompts. וזה חבל — כי שם מסתתרת חוויית משתמש שלמה שלא קיימת בלעדיהם.

Resources — נתונים read-only ש-Claude יכול לקרוא

Tool הוא פעולה. Resource הוא נתון. ההבדל קריטי: Claude יכול להציג Resource למשתמש, להעביר את ה-URL שלו לכלים אחרים, או לטעון אותו ל-context. דוגמה: MCP server שחושף docs://api/v2 — Claude קורא את התיעוד ומשיב על שאלות API מבלי שאתה צריך לפרסם תיעוד נפרד.

@server.list_resources()
async def list_resources():
    return [{
        "uri": "docs://api/v2",
        "name": "API v2 Documentation",
        "mimeType": "text/markdown"
    }]

@server.read_resource()
async def read_resource(uri: str):
    if uri == "docs://api/v2":
        return [{"type": "text", "text": open("/docs/api-v2.md").read()}]

Prompts — תבניות פרומפט שהמשתמש יכול להפעיל

Prompts הם shortcuts ל-prompt engineering. במקום שהמשתמש יכתוב prompt מורכב כל פעם, ה-MCP server מספק תבנית פרמטרית. ב-Claude Code, התבניות נחשפות כ-slash commands כמו /summarize-pr 123.

@server.list_prompts()
async def list_prompts():
    return [{
        "name": "summarize-pr",
        "description": "Summarize a GitHub PR with risks and review checklist",
        "arguments": [{"name": "pr_number", "required": True}]
    }]

@server.get_prompt()
async def get_prompt(name, arguments):
    if name == "summarize-pr":
        pr = arguments["pr_number"]
        return {
            "messages": [{
                "role": "user",
                "content": f"Fetch PR #{pr} from github, summarize: "
                           f"(1) intent, (2) risks, (3) review checklist."
            }]
        }

מתי להשתמש במה

Tool — פעולה עם side effect (יצירת קובץ, שליחת מייל, חיוב). Resource — נתון שאתה רוצה ש-Claude יקרא או שיופיע אצל המשתמש (תיעוד, סטטוס, נתוני config). Prompt — workflow מוכן שאתה רוצה שמשתמש יוכל להפעיל בקלות (slash command, sidebar).