1~
2**Model Context Protocol (MCP)** to otwarty standard stworzony przez Anthropic, który definiuje sposób komunikacji modeli AI z zewnętrznymi narzędziami, źródłami danych i usługami. Pomyśl o nim jako o "USB-C dla AI"  -  uniwersalnym złączu, które pozwala dowolnemu agentowi AI komunikować się z dowolnym narzędziem przez ustandaryzowany interfejs.
3~
4Od momentu uruchomienia MCP przekroczył **97 milionów miesięcznych pobrań SDK** i został przyjęty przez wszystkich głównych dostawców AI: Anthropic, OpenAI, Google, Microsoft i Amazon. W tym przewodniku poznamy wszystko, co musisz wiedzieć, aby budować z MCP.
5~
6## Dlaczego MCP Istnieje
7~
8Przed MCP każda aplikacja AI musiała budować niestandardowe integracje dla każdego narzędzia, którego chciała używać. Chcesz, żeby twoja AI czytała pliki? Pisz niestandardowy kod. Odpytywanie bazy danych? Więcej niestandardowego kodu. Publikowanie na Slacku? Kolejna integracja.
9~
10To tworzyło **problem N×M**: N aplikacji AI, z których każda potrzebowała M niestandardowych integracji, co prowadziło do zduplikowanego wysiłku i fragmentacji ekosystemów.
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 rozwiązuje to za pomocą **jednego protokołu**, którego dowolny klient AI może użyć do komunikacji z dowolnym serwerem 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## Podstawowe Koncepcje
38~
39MCP ma trzy fundamentalne prymitywy:
40~
41### 1. Narzędzia (Tools)
42Narzędzia to funkcje, które AI może wywoływać. Reprezentują akcje takie jak "utwórz plik", "odpytaj bazę danych" czy "wyślij wiadomość". Każde narzędzie ma nazwę, opis i JSON Schema dla swoich parametrów.
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. Zasoby (Resources)
61Zasoby to dane, które AI może czytać. Reprezentują pliki, rekordy bazy danych, odpowiedzi API lub dowolne inne źródło danych. Zasoby są identyfikowane przez URI.
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. Prompty (Prompts)
72Prompty to szablony wielokrotnego użytku, które pomagają strukturyzować interakcje. Mogą zawierać dynamiczne parametry i są przydatne do standaryzacji typowych przepływów pracy.
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## Architektura
85~
86MCP stosuje architekturę klient-serwer:
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- **Host**: Aplikacja AI (Claude Desktop, Cursor, twoja niestandardowa aplikacja)
105- **Klient**: Utrzymuje połączenie 1:1 z serwerem MCP
106- **Serwer**: Udostępnia narzędzia, zasoby i prompty klientowi
107- **Transport**: Komunikacja odbywa się przez JSON-RPC 2.0 via stdio (lokalnie) lub Server-Sent Events (zdalnie)
108~
109## Budowanie Serwera MCP
110~
111Zbudujmy praktyczny serwer MCP, który współdziała z listą zadań przechowywaną w pliku JSON.
112~
113### Konfiguracja Początkowa
114~
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120~
121### Implementacja Serwera
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### Konfiguracja
208~
209Aby używać tego serwera z Claude Desktop, dodaj go do swojej konfiguracji:
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## Budowanie Klienta MCP
223~
224Możesz również zbudować niestandardowego klienta, który łączy się z dowolnym serwerem 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## Popularne Serwery MCP
251~
252Ekosystem MCP rozrósł się szybko. Oto niektóre z najpopularniejszych serwerów:
253~
254| Serwer | Opis | Przypadek Użycia |
255|--------|------|-----------------|
256| **GitHub** | Tworzenie issues, PR, zarządzanie repo | Przepływy pracy deweloperskie |
257| **Slack** | Wysyłanie wiadomości, zarządzanie kanałami | Komunikacja zespołowa |
258| **PostgreSQL** | Odpytywanie i zarządzanie bazami danych | Dostęp do danych |
259| **Filesystem** | Czytanie, pisanie i wyszukiwanie plików | Lokalne programowanie |
260| **Puppeteer** | Automatyzacja przeglądarki i scraping | Testowanie webowe |
261| **Sentry** | Monitorowanie błędów i debugowanie | Wsparcie produkcyjne |
262| **Supabase** | Baza danych, uwierzytelnianie, storage | Operacje backendowe |
263~
264## MCP vs A2A (Agent-to-Agent)
265~
266Podczas gdy MCP obsługuje komunikację **agent-narzędzie**, protokół **A2A (Agent-to-Agent)** Google obsługuje komunikację **agent-agent**. Są komplementarne:
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**: Jak agent AI używa narzędzi (integracja pionowa)
276- **A2A**: Jak agenci AI współpracują ze sobą (integracja pozioma)
277~
278## Najlepsze Praktyki
279~
2801. **Utrzymuj serwery skoncentrowane**: Jeden serwer na domenę (serwer GitHub, serwer Slack itp.). Nie buduj monolitycznych serwerów.
2812. **Waliduj dane wejściowe za pomocą Zod**: Zawsze waliduj dane wejściowe narzędzi za pomocą odpowiednich schematów.
2823. **Obsługuj błędy elegancko**: Zwracaj znaczące komunikaty o błędach, nie stack trace.
2834. **Używaj zasobów dla danych tylko do odczytu**: Jeśli AI potrzebuje tylko czytać dane, udostępniaj je jako zasób, a nie narzędzie.
2845. **Dodawaj odpowiednie opisy**: Dobre opisy narzędzi i parametrów pomagają AI zrozumieć, kiedy i jak używać każdego narzędzia.
2856. **Testuj za pomocą MCP Inspector**: Użyj `npx @modelcontextprotocol/inspector` do interaktywnego testowania serwera.
286~
287## Rozpoczęcie Pracy
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## Podsumowanie
298~
299MCP stał się de facto standardem wykorzystania narzędzi AI w 2026 roku. Niezależnie od tego, czy budujesz niestandardowych agentów AI, rozszerzasz Claude Code, czy tworzysz integracje dla istniejących platform, zrozumienie MCP jest niezbędne. Protokół jest wystarczająco prosty, aby nauczyć się go w jedno popołudnie, ale wystarczająco potężny, aby budować produkcyjne przepływy pracy AI.
300~
301**Następne kroki:**
302- Poznaj [Specyfikację MCP](https://spec.modelcontextprotocol.io/)
303- Przeglądaj [istniejące serwery MCP](https://github.com/modelcontextprotocol/servers) w poszukiwaniu inspiracji
304- Zbuduj swój pierwszy serwer z TypeScript lub Python SDK
305- Przetestuj go z Claude Desktop lub MCP Inspector
306~