1 
2A **Model Context Protocol (MCP)** az Anthropic által létrehozott nyílt szabvány, amely meghatározza, hogyan kommunikálnak az AI modellek külső eszközökkel, adatforrásokkal és szolgáltatásokkal. Gondolj rá úgy, mint az "AI USB-C-je"  -  egy univerzális csatlakozó, amely lehetővé teszi bármely AI ügynök számára, hogy bármely eszközzel kommunikáljon egy szabványosított felületen keresztül.
3 
4A megjelenése óta az MCP átlépte a **havi 97 millió SDK letöltést** és minden nagy AI szolgáltató elfogadta: Anthropic, OpenAI, Google, Microsoft és Amazon. Ebben az útmutatóban mindent megvizsgálunk, amit tudnod kell az MCP-vel való fejlesztéshez.
5 
6## Miért Létezik az MCP
7 
8Az MCP előtt minden AI alkalmazásnak egyedi integrációkat kellett készítenie minden eszközhöz, amelyet használni akart. Szeretnéd, hogy az AI-d fájlokat olvasson? Írj egyedi kódot. Adatbázis lekérdezés? Több egyedi kód. Slack-re posztolás? Még egy integráció.
9 
10Ez egy **N×M problémát** hozott létre: N AI alkalmazás, amelyek mindegyike M egyedi integrációt igényelt, ami duplikált erőfeszítéshez és szétaprózott ökoszisztémákhoz vezetett.
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 
24Az MCP ezt **egyetlen protokollal** oldja meg, amelyet bármely AI kliens használhat bármely MCP szerverrel való kommunikációra:
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## Alapfogalmak
38 
39Az MCP három alapvető primitívvel rendelkezik:
40 
41### 1. Eszközök (Tools)
42Az eszközök olyan függvények, amelyeket az AI meghívhat. Olyan műveleteket képviselnek, mint "fájl létrehozása", "adatbázis lekérdezése" vagy "üzenet küldése". Minden eszköznek van neve, leírása és JSON Schema-ja a paramétereihez.
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. Erőforrások (Resources)
61Az erőforrások olyan adatok, amelyeket az AI olvashat. Fájlokat, adatbázis rekordokat, API válaszokat vagy bármely más adatforrást képviselnek. Az erőforrásokat URI-k azonosítják.
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. Promptok (Prompts)
72A promptok újrafelhasználható sablonok, amelyek segítenek az interakciók strukturálásában. Tartalmazhatnak dinamikus paramétereket és hasznosak a gyakori munkafolyamatok szabványosítására.
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## Architektúra
85 
86Az MCP kliens-szerver architektúrát követ:
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- **Gazdagép**: Az AI alkalmazás (Claude Desktop, Cursor, az egyedi alkalmazásod)
105- **Kliens**: 1:1 kapcsolatot tart fenn egy MCP szerverrel
106- **Szerver**: Eszközöket, erőforrásokat és promptokat tesz elérhetővé a kliens számára
107- **Szállítás**: A kommunikáció JSON-RPC 2.0-on keresztül történik stdio-n (helyi) vagy Server-Sent Events-en (távoli)
108 
109## MCP Szerver Építése
110 
111Építsünk egy gyakorlati MCP szervert, amely egy JSON fájlban tárolt feladatlistával kommunikál.
112 
113### Telepítés
114 
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120 
121### Szerver Implementáció
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### Konfiguráció
208 
209A szerver Claude Desktop-pal való használatához add hozzá a konfigurációdhoz:
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 Kliens Építése
223 
224Egyedi klienst is építhetsz, amely bármely MCP szerverhez csatlakozik:
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## Népszerű MCP Szerverek
251 
252Az MCP ökoszisztéma gyorsan nőtt. Íme néhány a legnépszerűbb szerverek közül:
253 
254| Szerver | Leírás | Felhasználási eset |
255|---------|--------|-------------------|
256| **GitHub** | Issue-k, PR-ek létrehozása, repók kezelése | Fejlesztési munkafolyamatok |
257| **Slack** | Üzenetek küldése, csatornák kezelése | Csapatkommunikáció |
258| **PostgreSQL** | Adatbázis lekérdezés és kezelés | Adathozzáférés |
259| **Filesystem** | Fájlok olvasása, írása és keresése | Helyi fejlesztés |
260| **Puppeteer** | Böngésző automatizálás és scraping | Webtesztelés |
261| **Sentry** | Hibamonitorozás és hibakeresés | Éles támogatás |
262| **Supabase** | Adatbázis, hitelesítés, tárolás | Backend műveletek |
263 
264## MCP vs A2A (Agent-to-Agent)
265 
266Míg az MCP az **ügynök-eszköz** kommunikációt kezeli, a Google **A2A (Agent-to-Agent)** protokollja az **ügynök-ügynök** kommunikációt kezeli. Kiegészítik egymást:
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**: Hogyan használ egy AI ügynök eszközöket (vertikális integráció)
276- **A2A**: Hogyan működnek együtt az AI ügynökök (horizontális integráció)
277 
278## Legjobb Gyakorlatok
279 
2801. **Tartsd a szervereket fókuszáltan**: Egy szerver doménenként (GitHub szerver, Slack szerver stb.). Ne építs monolitikus szervereket.
2812. **Validáld a bemeneteket Zod-dal**: Mindig validáld az eszköz bemeneteket megfelelő sémákkal.
2823. **Kezeld a hibákat elegánsan**: Értelmes hibaüzeneteket adj vissza, ne stack trace-eket.
2834. **Használj erőforrásokat csak olvasható adatokhoz**: Ha az AI-nak csak adatokat kell olvasnia, tedd elérhetővé erőforrásként eszköz helyett.
2845. **Adj hozzá megfelelő leírásokat**: A jó eszköz- és paraméterleírások segítenek az AI-nak megérteni, mikor és hogyan használja az egyes eszközöket.
2856. **Tesztelj az MCP Inspector-ral**: Használd az `npx @modelcontextprotocol/inspector`-t a szervered interaktív teszteléséhez.
286 
287## Kezdj Hozzá
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## Összegzés
298 
299Az MCP 2026-ban az AI eszközhasználat de facto szabványává vált. Akár egyedi AI ügynököket építesz, akár a Claude Code-ot bővíted, akár meglévő platformokhoz készítesz integrációkat, az MCP megértése elengedhetetlen. A protokoll elég egyszerű ahhoz, hogy egy délután alatt megtanuld, de elég erős ahhoz, hogy termelési szintű AI munkafolyamatokat építs.
300 
301**Következő lépések:**
302- Fedezd fel az [MCP Specifikációt](https://spec.modelcontextprotocol.io/)
303- Böngészd a [meglévő MCP szervereket](https://github.com/modelcontextprotocol/servers) inspirációért
304- Építsd meg az első szervered a TypeScript vagy Python SDK-val
305- Teszteld Claude Desktop-pal vagy az MCP Inspector-ral
306