MCP (Model Context Protocol): Kompletní průvodce pro vývojáře

Model Context Protocol (MCP) je otevřený standard vytvořený společností Anthropic, který definuje, jak AI modely komunikují s externími nástroji, datovými zdroji a službami. Představte si ho jako "USB-C pro AI" - univerzální konektor, který umožňuje jakémukoli AI agentovi komunikovat s jakýmkoli nástrojem prostřednictvím standardizovaného rozhraní.

Od svého spuštění MCP překonal 97 milionů měsíčních stažení SDK a byl přijat všemi hlavními poskytovateli AI: Anthropic, OpenAI, Google, Microsoft a Amazon. V tomto průvodci prozkoumáme vše, co potřebujete vědět pro vývoj s MCP.

Proč MCP existuje

Před MCP musel každá AI aplikace vytvářet vlastní integrace pro každý nástroj, který chtěla používat. Chcete, aby vaše AI četla soubory? Napište vlastní kód. Dotazovat databázi? Více vlastního kódu. Publikovat na Slack? Další integrace.

To vytvořilo problém N×M: N AI aplikací, z nichž každá potřebovala M vlastních integrací, což vedlo k duplicitnímu úsilí a fragmentovaným ekosystémům.

MCP to řeší jediným protokolem, který může jakýkoli AI klient použít ke komunikaci s jakýmkoli MCP serverem:

Základní koncepty

MCP má tři základní primitivy:

1. Nástroje (Tools)

Nástroje jsou funkce, které AI může volat. Představují akce jako "vytvoř soubor", "dotáž databázi" nebo "pošli zprávu". Každý nástroj má název, popis a JSON Schema pro své parametry.

{
  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. Zdroje (Resources)

Zdroje jsou data, která AI může číst. Představují soubory, záznamy databáze, odpovědi API nebo jakýkoli jiný datový zdroj. Zdroje jsou identifikovány pomocí URI.

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

3. Prompty (Prompts)

Prompty jsou znovupoužitelné šablony, které pomáhají strukturovat interakce. Mohou obsahovat dynamické parametry a jsou užitečné pro standardizaci běžných pracovních postupů.

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

Architektura

MCP sleduje architekturu klient-server:

• Hostitel: AI aplikace (Claude Desktop, Cursor, vaše vlastní aplikace)
• Klient: Udržuje spojení 1:1 s MCP serverem
• Server: Zpřístupňuje nástroje, zdroje a prompty klientovi
• Transport: Komunikace probíhá přes JSON-RPC 2.0 přes stdio (lokálně) nebo Server-Sent Events (vzdáleně)

Vytvoření MCP serveru

Pojďme vytvořit praktický MCP server, který pracuje se seznamem úkolů uloženým v JSON souboru.

Nastavení

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

Implementace serveru

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

Konfigurace

Pro použití tohoto serveru s Claude Desktop ho přidejte do vaší konfigurace:

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

Vytvoření MCP klienta

Můžete také vytvořit vlastního klienta, který se připojí k jakémukoli MCP serveru:

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

Populární MCP servery

Ekosystém MCP rychle rostl. Zde jsou některé z nejpopulárnějších serverů:

MCP vs A2A (Agent-to-Agent)

Zatímco MCP zpracovává komunikaci agent-nástroj, Googlem vytvořený protokol A2A (Agent-to-Agent) zpracovává komunikaci agent-agent. Jsou komplementární:

• MCP: Jak AI agent používá nástroje (vertikální integrace)
• A2A: Jak AI agenti spolupracují (horizontální integrace)

Osvědčené postupy

1. Udržujte servery zaměřené: Jeden server na doménu (GitHub server, Slack server atd.). Nestavte monolitické servery.
2. Validujte vstupy pomocí Zod: Vždy validujte vstupy nástrojů správnými schématy.
3. Zpracovávejte chyby elegantně: Vracejte smysluplné chybové zprávy, ne stack traces.
4. Používejte zdroje pro data pouze ke čtení: Pokud AI potřebuje pouze číst data, zpřístupněte je jako zdroj, ne jako nástroj.
5. Přidejte vhodné popisy: Dobré popisy nástrojů a parametrů pomáhají AI pochopit, kdy a jak každý nástroj použít.
6. Testujte pomocí MCP Inspector: Použijte npx @modelcontextprotocol/inspector k interaktivnímu testování vašeho serveru.

Začínáme

# 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

Závěr

MCP se v roce 2026 stal de facto standardem pro používání AI nástrojů. Ať už vytváříte vlastní AI agenty, rozšiřujete Claude Code nebo vytváříte integrace pro stávající platformy, pochopení MCP je nezbytné. Protokol je dostatečně jednoduchý na naučení za jedno odpoledne, ale dostatečně výkonný pro vytváření produkčních AI workflow.

Další kroky:

• Prozkoumejte Specifikaci MCP
• Prohlédněte si existující MCP servery pro inspiraci
• Vytvořte svůj první server s TypeScript nebo Python SDK
• Otestujte ho s Claude Desktop nebo MCP Inspector