1~
2**Model Context Protocol (MCP)** הוא תקן פתוח שנוצר על ידי Anthropic המגדיר כיצד מודלי AI מתקשרים עם כלים חיצוניים, מקורות נתונים ושירותים. חשבו עליו כ-"USB-C של AI"  -  מחבר אוניברסלי שמאפשר לכל סוכן AI לדבר עם כל כלי דרך ממשק מתוקנן.
3~
4מאז ההשקה, MCP חצה **97 מיליון הורדות SDK חודשיות** ואומץ על ידי כל ספקי ה-AI המרכזיים: Anthropic, OpenAI, Google, Microsoft ו-Amazon. במדריך זה, נחקור את כל מה שאתם צריכים לדעת כדי לבנות עם MCP.
5~
6## למה MCP קיים
7~
8לפני MCP, כל אפליקציית AI הייתה צריכה לבנות אינטגרציות מותאמות אישית עבור כל כלי שרצתה להשתמש בו. רוצים שה-AI שלכם יקרא קבצים? כתבו קוד מותאם. לתשאל מסד נתונים? עוד קוד מותאם. לפרסם ב-Slack? עוד אינטגרציה.
9~
10זה יצר **בעיית N×M**: N אפליקציות AI שכל אחת מהן צריכה M אינטגרציות מותאמות, מה שהוביל למאמץ כפול ואקוסיסטמים מפוצלים.
11~
12```mermaid
13graph TD
14    subgraph "Before MCP (N×M)"
15        A1[AI App 1] --> T1[GitHub Integration]
16        A1 --> T2[Slack Integration]
17        A1 --> T3[DB Integration]
18        A2[AI App 2] --> T4[GitHub Integration]
19        A2 --> T5[Slack Integration]
20        A2 --> T6[DB Integration]
21    end
22```
23~
24MCP פותר את זה עם **פרוטוקול יחיד** שכל לקוח AI יכול להשתמש בו כדי לתקשר עם כל שרת MCP:
25~
26```mermaid
27graph TD
28    subgraph "With MCP (N+M)"
29        A1[AI App 1] --> MCP[MCP Protocol]
30        A2[AI App 2] --> MCP
31        MCP --> S1[GitHub Server]
32        MCP --> S2[Slack Server]
33        MCP --> S3[DB Server]
34    end
35```
36~
37## מושגי ליבה
38~
39ל-MCP שלושה פרימיטיבים בסיסיים:
40~
41### 1. כלים (Tools)
42כלים הם פונקציות שה-AI יכול לקרוא להן. הם מייצגים פעולות כמו "צור קובץ", "תשאל מסד נתונים" או "שלח הודעה". לכל כלי יש שם, תיאור ו-JSON Schema עבור הפרמטרים שלו.
43~
44```typescript
45{
46  name: "create_issue",
47  description: "Create a new GitHub issue",
48  inputSchema: {
49    type: "object",
50    properties: {
51      title: { type: "string", description: "Issue title" },
52      body: { type: "string", description: "Issue body" },
53      repo: { type: "string", description: "Repository name" }
54    },
55    required: ["title", "repo"]
56  }
57}
58```
59~
60### 2. משאבים (Resources)
61משאבים הם נתונים שה-AI יכול לקרוא. הם מייצגים קבצים, רשומות מסד נתונים, תגובות API או כל מקור נתונים אחר. משאבים מזוהים באמצעות URIs.
62~
63```typescript
64{
65  uri: "file:///Users/dev/project/README.md",
66  name: "Project README",
67  mimeType: "text/markdown"
68}
69```
70~
71### 3. פרומפטים (Prompts)
72פרומפטים הם תבניות לשימוש חוזר שעוזרות למבנה אינטראקציות. הם יכולים לכלול פרמטרים דינמיים ושימושיים לתקנון תהליכי עבודה נפוצים.
73~
74```typescript
75{
76  name: "code_review",
77  description: "Review code changes for quality and security",
78  arguments: [
79    { name: "diff", description: "The code diff to review", required: true }
80  ]
81}
82```
83~
84## ארכיטקטורה
85~
86MCP עוקב אחר ארכיטקטורת לקוח-שרת:
87~
88```mermaid
89graph LR
90    subgraph "Host Application"
91        Client[MCP Client]
92    end
93~
94    subgraph "MCP Server"
95        Server[Server Process]
96        Server --> Tools[Tools]
97        Server --> Resources[Resources]
98        Server --> Prompts[Prompts]
99    end
100~
101    Client -- "JSON-RPC 2.0\n(stdio or SSE)" --> Server
102```
103~
104- **מארח**: אפליקציית ה-AI (Claude Desktop, Cursor, האפליקציה המותאמת שלכם)
105- **לקוח**: שומר על חיבור 1:1 עם שרת MCP
106- **שרת**: חושף כלים, משאבים ופרומפטים ללקוח
107- **תעבורה**: התקשורת מתבצעת דרך JSON-RPC 2.0 על stdio (מקומי) או Server-Sent Events (מרוחק)
108~
109## בניית שרת MCP
110~
111בואו נבנה שרת MCP מעשי שמתקשר עם רשימת משימות השמורה בקובץ JSON.
112~
113### הגדרה
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### מימוש השרת
122~
123```typescript
124// src/index.ts
125import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
126import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
127import { z } from "zod";
128import fs from "fs";
129~
130const TODO_FILE = "./todos.json";
131~
132function readTodos(): { id: number; text: string; done: boolean }[] {
133  if (!fs.existsSync(TODO_FILE)) return [];
134  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
135}
136~
137function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
138  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
139}
140~
141const server = new McpServer({
142  name: "todo-server",
143  version: "1.0.0",
144});
145~
146// Tool: Add a todo
147server.tool(
148  "add_todo",
149  "Add a new todo item",
150  { text: z.string().describe("The todo text") },
151  async ({ text }) => {
152    const todos = readTodos();
153    const newTodo = { id: Date.now(), text, done: false };
154    todos.push(newTodo);
155    writeTodos(todos);
156    return { content: [{ type: "text", text: `Added: "${text}"` }] };
157  }
158);
159~
160// Tool: List todos
161server.tool(
162  "list_todos",
163  "List all todo items",
164  {},
165  async () => {
166    const todos = readTodos();
167    const list = todos
168      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
169      .join("\n");
170    return { content: [{ type: "text", text: list || "No todos yet." }] };
171  }
172);
173~
174// Tool: Complete a todo
175server.tool(
176  "complete_todo",
177  "Mark a todo as completed",
178  { id: z.number().describe("The todo ID to complete") },
179  async ({ id }) => {
180    const todos = readTodos();
181    const todo = todos.find((t) => t.id === id);
182    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
183    todo.done = true;
184    writeTodos(todos);
185    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
186  }
187);
188~
189// Resource: Current todos as a readable resource
190server.resource(
191  "todos://list",
192  "Current todo list",
193  async () => ({
194    contents: [{
195      uri: "todos://list",
196      mimeType: "application/json",
197      text: JSON.stringify(readTodos(), null, 2),
198    }],
199  })
200);
201~
202// Start the server
203const transport = new StdioServerTransport();
204await server.connect(transport);
205```
206~
207### תצורה
208~
209כדי להשתמש בשרת זה עם Claude Desktop, הוסיפו אותו לתצורה שלכם:
210~
211```json
212{
213  "mcpServers": {
214    "todo": {
215      "command": "npx",
216      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
217    }
218  }
219}
220```
221~
222## בניית לקוח MCP
223~
224אתם יכולים גם לבנות לקוח מותאם שמתחבר לכל שרת MCP:
225~
226```typescript
227import { Client } from "@modelcontextprotocol/sdk/client/index.js";
228import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
229~
230const transport = new StdioClientTransport({
231  command: "npx",
232  args: ["tsx", "./src/index.ts"],
233});
234~
235const client = new Client({ name: "my-client", version: "1.0.0" });
236await client.connect(transport);
237~
238// List available tools
239const { tools } = await client.listTools();
240console.log("Available tools:", tools.map((t) => t.name));
241~
242// Call a tool
243const result = await client.callTool({
244  name: "add_todo",
245  arguments: { text: "Write MCP blog post" },
246});
247console.log(result);
248```
249~
250## שרתי MCP פופולריים
251~
252האקוסיסטם של MCP צמח במהירות. הנה כמה מהשרתים הפופולריים ביותר:
253~
254| שרת | תיאור | מקרה שימוש |
255|-----|-------|-----------|
256| **GitHub** | יצירת issues, PRs, ניהול repos | תהליכי פיתוח |
257| **Slack** | שליחת הודעות, ניהול ערוצים | תקשורת צוות |
258| **PostgreSQL** | שאילתות וניהול מסדי נתונים | גישה לנתונים |
259| **Filesystem** | קריאה, כתיבה וחיפוש קבצים | פיתוח מקומי |
260| **Puppeteer** | אוטומציית דפדפן וסריקה | בדיקות ווב |
261| **Sentry** | ניטור שגיאות ודיבאג | תמיכת ייצור |
262| **Supabase** | מסד נתונים, אימות, אחסון | פעולות backend |
263~
264## MCP מול A2A (Agent-to-Agent)
265~
266בעוד MCP מטפל בתקשורת **סוכן-כלי**, פרוטוקול **A2A (Agent-to-Agent)** של Google מטפל בתקשורת **סוכן-סוכן**. הם משלימים זה את זה:
267~
268```mermaid
269graph TD
270    Agent1[Agent 1] -- "A2A Protocol" --> Agent2[Agent 2]
271    Agent1 -- "MCP Protocol" --> Tool1[GitHub MCP Server]
272    Agent2 -- "MCP Protocol" --> Tool2[Database MCP Server]
273```
274~
275- **MCP**: כיצד סוכן AI משתמש בכלים (אינטגרציה אנכית)
276- **A2A**: כיצד סוכני AI משתפים פעולה זה עם זה (אינטגרציה אופקית)
277~
278## שיטות עבודה מומלצות
279~
2801. **שמרו על שרתים ממוקדים**: שרת אחד לכל תחום (שרת GitHub, שרת Slack וכו'). אל תבנו שרתים מונוליטיים.
2812. **אמתו קלטים עם Zod**: תמיד אמתו קלטי כלים עם סכמות מתאימות.
2823. **טפלו בשגיאות בחן**: החזירו הודעות שגיאה משמעותיות, לא stack traces.
2834. **השתמשו במשאבים לנתונים לקריאה בלבד**: אם ה-AI צריך רק לקרוא נתונים, חשפו אותם כמשאב ולא ככלי.
2845. **הוסיפו תיאורים מתאימים**: תיאורים טובים של כלים ופרמטרים עוזרים ל-AI להבין מתי ואיך להשתמש בכל כלי.
2856. **בדקו עם MCP Inspector**: השתמשו ב-`npx @modelcontextprotocol/inspector` כדי לבדוק את השרת שלכם באופן אינטראקטיבי.
286~
287## התחלת עבודה
288~
289```bash
290# Create a new MCP server from template
291npx @modelcontextprotocol/create-server my-server
292~
293# Test with the MCP Inspector
294npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
295```
296~
297## סיכום
298~
299MCP הפך לסטנדרט דה-פקטו לשימוש בכלי AI ב-2026. בין אם אתם בונים סוכני AI מותאמים, מרחיבים את Claude Code או יוצרים אינטגרציות לפלטפורמות קיימות, הבנת MCP היא חיונית. הפרוטוקול פשוט מספיק ללמוד בחצי יום אבל חזק מספיק לבניית תהליכי עבודה AI ברמת ייצור.
300~
301**צעדים הבאים:**
302- חקרו את [מפרט MCP](https://spec.modelcontextprotocol.io/)
303- עיינו ב[שרתי MCP קיימים](https://github.com/modelcontextprotocol/servers) להשראה
304- בנו את השרת הראשון שלכם עם TypeScript או Python SDK
305- בדקו אותו עם Claude Desktop או MCP Inspector
306~