MCP (Model Context Protocol): המדריך המלא למפתחים

Model Context Protocol (MCP) הוא תקן פתוח שנוצר על ידי Anthropic המגדיר כיצד מודלי AI מתקשרים עם כלים חיצוניים, מקורות נתונים ושירותים. חשבו עליו כ-"USB-C של AI" - מחבר אוניברסלי שמאפשר לכל סוכן AI לדבר עם כל כלי דרך ממשק מתוקנן.

מאז ההשקה, MCP חצה 97 מיליון הורדות SDK חודשיות ואומץ על ידי כל ספקי ה-AI המרכזיים: Anthropic, OpenAI, Google, Microsoft ו-Amazon. במדריך זה, נחקור את כל מה שאתם צריכים לדעת כדי לבנות עם MCP.

למה MCP קיים

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

זה יצר בעיית N×M: N אפליקציות AI שכל אחת מהן צריכה M אינטגרציות מותאמות, מה שהוביל למאמץ כפול ואקוסיסטמים מפוצלים.

MCP פותר את זה עם פרוטוקול יחיד שכל לקוח AI יכול להשתמש בו כדי לתקשר עם כל שרת MCP:

מושגי ליבה

ל-MCP שלושה פרימיטיבים בסיסיים:

1. כלים (Tools)

כלים הם פונקציות שה-AI יכול לקרוא להן. הם מייצגים פעולות כמו "צור קובץ", "תשאל מסד נתונים" או "שלח הודעה". לכל כלי יש שם, תיאור ו-JSON Schema עבור הפרמטרים שלו.

{
  name: "create_issue",
  description: "Create a new GitHub issue",
  inputSchema: {
    type: "object",
    properties: {
      title: { type: "string", description: "Issue title" },
      body: { type: "string", description: "Issue body" },
      repo: { type: "string", description: "Repository name" }
    },
    required: ["title", "repo"]
  }
}

2. משאבים (Resources)

משאבים הם נתונים שה-AI יכול לקרוא. הם מייצגים קבצים, רשומות מסד נתונים, תגובות API או כל מקור נתונים אחר. משאבים מזוהים באמצעות URIs.

{
  uri: "file:///Users/dev/project/README.md",
  name: "Project README",
  mimeType: "text/markdown"
}

3. פרומפטים (Prompts)

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

{
  name: "code_review",
  description: "Review code changes for quality and security",
  arguments: [
    { name: "diff", description: "The code diff to review", required: true }
  ]
}

ארכיטקטורה

MCP עוקב אחר ארכיטקטורת לקוח-שרת:

• מארח: אפליקציית ה-AI (Claude Desktop, Cursor, האפליקציה המותאמת שלכם)
• לקוח: שומר על חיבור 1:1 עם שרת MCP
• שרת: חושף כלים, משאבים ופרומפטים ללקוח
• תעבורה: התקשורת מתבצעת דרך JSON-RPC 2.0 על stdio (מקומי) או Server-Sent Events (מרוחק)

בניית שרת MCP

בואו נבנה שרת MCP מעשי שמתקשר עם רשימת משימות השמורה בקובץ JSON.

הגדרה

mkdir mcp-todo-server && cd mcp-todo-server
npm init -y
npm install @modelcontextprotocol/sdk zod

מימוש השרת

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs";

const TODO_FILE = "./todos.json";

function readTodos(): { id: number; text: string; done: boolean }[] {
  if (!fs.existsSync(TODO_FILE)) return [];
  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
}

function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
}

const server = new McpServer({
  name: "todo-server",
  version: "1.0.0",
});

// Tool: Add a todo
server.tool(
  "add_todo",
  "Add a new todo item",
  { text: z.string().describe("The todo text") },
  async ({ text }) => {
    const todos = readTodos();
    const newTodo = { id: Date.now(), text, done: false };
    todos.push(newTodo);
    writeTodos(todos);
    return { content: [{ type: "text", text: `Added: "${text}"` }] };
  }
);

// Tool: List todos
server.tool(
  "list_todos",
  "List all todo items",
  {},
  async () => {
    const todos = readTodos();
    const list = todos
      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
      .join("\n");
    return { content: [{ type: "text", text: list || "No todos yet." }] };
  }
);

// Tool: Complete a todo
server.tool(
  "complete_todo",
  "Mark a todo as completed",
  { id: z.number().describe("The todo ID to complete") },
  async ({ id }) => {
    const todos = readTodos();
    const todo = todos.find((t) => t.id === id);
    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
    todo.done = true;
    writeTodos(todos);
    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
  }
);

// Resource: Current todos as a readable resource
server.resource(
  "todos://list",
  "Current todo list",
  async () => ({
    contents: [{
      uri: "todos://list",
      mimeType: "application/json",
      text: JSON.stringify(readTodos(), null, 2),
    }],
  })
);

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);

תצורה

כדי להשתמש בשרת זה עם Claude Desktop, הוסיפו אותו לתצורה שלכם:

{
  "mcpServers": {
    "todo": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
    }
  }
}

בניית לקוח MCP

אתם יכולים גם לבנות לקוח מותאם שמתחבר לכל שרת MCP:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["tsx", "./src/index.ts"],
});

const client = new Client({ name: "my-client", version: "1.0.0" });
await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log("Available tools:", tools.map((t) => t.name));

// Call a tool
const result = await client.callTool({
  name: "add_todo",
  arguments: { text: "Write MCP blog post" },
});
console.log(result);

שרתי MCP פופולריים

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

MCP מול A2A (Agent-to-Agent)

בעוד MCP מטפל בתקשורת סוכן-כלי, פרוטוקול A2A (Agent-to-Agent) של Google מטפל בתקשורת סוכן-סוכן. הם משלימים זה את זה:

• MCP: כיצד סוכן AI משתמש בכלים (אינטגרציה אנכית)
• A2A: כיצד סוכני AI משתפים פעולה זה עם זה (אינטגרציה אופקית)

שיטות עבודה מומלצות

1. שמרו על שרתים ממוקדים: שרת אחד לכל תחום (שרת GitHub, שרת Slack וכו'). אל תבנו שרתים מונוליטיים.
2. אמתו קלטים עם Zod: תמיד אמתו קלטי כלים עם סכמות מתאימות.
3. טפלו בשגיאות בחן: החזירו הודעות שגיאה משמעותיות, לא stack traces.
4. השתמשו במשאבים לנתונים לקריאה בלבד: אם ה-AI צריך רק לקרוא נתונים, חשפו אותם כמשאב ולא ככלי.
5. הוסיפו תיאורים מתאימים: תיאורים טובים של כלים ופרמטרים עוזרים ל-AI להבין מתי ואיך להשתמש בכל כלי.
6. בדקו עם MCP Inspector: השתמשו ב-npx @modelcontextprotocol/inspector כדי לבדוק את השרת שלכם באופן אינטראקטיבי.

התחלת עבודה

# Create a new MCP server from template
npx @modelcontextprotocol/create-server my-server

# Test with the MCP Inspector
npx @modelcontextprotocol/inspector npx tsx ./src/index.ts

סיכום

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

צעדים הבאים:

• חקרו את מפרט MCP
• עיינו בשרתי MCP קיימים להשראה
• בנו את השרת הראשון שלכם עם TypeScript או Python SDK
• בדקו אותו עם Claude Desktop או MCP Inspector