MCP (Model Context Protocol): Teljes Útmutató Fejlesztőknek

A 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.

A 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.

Miért Létezik az MCP

Az 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ó.

Ez 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.

Az MCP ezt egyetlen protokollal oldja meg, amelyet bármely AI kliens használhat bármely MCP szerverrel való kommunikációra:

Alapfogalmak

Az MCP három alapvető primitívvel rendelkezik:

1. Eszközök (Tools)

Az 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.

{
  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. Erőforrások (Resources)

Az 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.

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

3. Promptok (Prompts)

A 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.

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

Architektúra

Az MCP kliens-szerver architektúrát követ:

• Gazdagép: Az AI alkalmazás (Claude Desktop, Cursor, az egyedi alkalmazásod)
• Kliens: 1:1 kapcsolatot tart fenn egy MCP szerverrel
• Szerver: Eszközöket, erőforrásokat és promptokat tesz elérhetővé a kliens számára
• 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)

MCP Szerver Építése

Építsünk egy gyakorlati MCP szervert, amely egy JSON fájlban tárolt feladatlistával kommunikál.

Telepítés

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

Szerver Implementáció

// 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);

Konfiguráció

A szerver Claude Desktop-pal való használatához add hozzá a konfigurációdhoz:

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

MCP Kliens Építése

Egyedi klienst is építhetsz, amely bármely MCP szerverhez csatlakozik:

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);

Népszerű MCP Szerverek

Az MCP ökoszisztéma gyorsan nőtt. Íme néhány a legnépszerűbb szerverek közül:

MCP vs A2A (Agent-to-Agent)

Mí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:

• MCP: Hogyan használ egy AI ügynök eszközöket (vertikális integráció)
• A2A: Hogyan működnek együtt az AI ügynökök (horizontális integráció)

Legjobb Gyakorlatok

1. Tartsd a szervereket fókuszáltan: Egy szerver doménenként (GitHub szerver, Slack szerver stb.). Ne építs monolitikus szervereket.
2. Validáld a bemeneteket Zod-dal: Mindig validáld az eszköz bemeneteket megfelelő sémákkal.
3. Kezeld a hibákat elegánsan: Értelmes hibaüzeneteket adj vissza, ne stack trace-eket.
4. 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.
5. 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.
6. Tesztelj az MCP Inspector-ral: Használd az npx @modelcontextprotocol/inspector-t a szervered interaktív teszteléséhez.

Kezdj Hozzá

# 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

Összegzés

Az 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.

Következő lépések:

• Fedezd fel az MCP Specifikációt
• Böngészd a meglévő MCP szervereket inspirációért
• Építsd meg az első szervered a TypeScript vagy Python SDK-val
• Teszteld Claude Desktop-pal vagy az MCP Inspector-ral