MCP jest wszędzie. Każde ogłoszenie narzędzia AI na początku 2026 o nim wspomina. Każdy artykuł o "nowoczesnym stacku AI" go wymienia. Ale jak zapytasz ludzi, czym MCP właściwie jest, dostajesz albo pracę doktorską, albo pitch marketingowy.
Wersja w jednym zdaniu: MCP to port USB dla agentów AI.
To cały opis. OK dobra, reszta poniżej. 😼
Świat przed standardem
Wyobraź sobie swój setup z końca 2024. Budujesz agenta AI — program, który używa dużego modelu językowego (LLM — mózg stojący za ChatGPT, Claude, Gemini) do podejmowania decyzji i samodzielnego wykonywania akcji. Twój agent musi odpytywać bazę PostgreSQL, przeszukiwać web, zarządzać issues na GitHubie i czytać lokalne pliki.
Dla każdego narzędzia piszesz custom kod integracji:
# Każde narzędzie wymaga własnego kodu klejącego
from custom_postgres import query_db
from custom_github import create_issue
from custom_search import web_search
from custom_files import read_file
# Każda integracja ma inne:
# - Metody autoryzacji
# - Formaty odpowiedzi
# - Obsługę błędów
# - Zarządzanie połączeniami
Każdy vendor AI budował własny system integracji. Claude miał "tool use". OpenAI miał "function calling". LangChain miał "tools". Wszystkie robiły to samo w niekompatybilny sposób. Zbudowałeś integrację dla jednego? Buduj od nowa dla drugiego.
To era portów szeregowych, równoległych i własnościowych ładowarek w AI toolingu. Pamiętasz? Zanim pojawił się USB, każde urządzenie miało własny kabel. Jak pudełko z kablami, które trzymasz "na wszelki wypadek" od 15 lat. 😹
Luka, którą trzeba było wypełnić
Problem nie polegał na tym, że integracje były trudne. Problem polegał na tym, że były trudne za każdym cholernym razem. Nowe narzędzie — piszesz kolejne 200 linii custom integracji. Pomnóż to przez każdego klienta AI na rynku. Matematyka jest brutalna.
Ktoś musiał zdefiniować uniwersalną wtyczkę.
Wchodzi MCP
Anthropic wprowadził MCP (Model Context Protocol) pod koniec 2024 jako otwarty standard — uniwersalny standard wtyczek dla narzędzi AI, jak USB, ale dla danych. Do marca 2026 stał się domyślnym sposobem, w jaki agenci AI łączą się ze światem zewnętrznym.
Tak wygląda podłączenie czterech narzędzi z MCP:
{
"mcpServers": {
"postgres": { "command": "npx", "args": ["-y", "@mcp/server-postgres", "..."] },
"github": { "command": "npx", "args": ["-y", "@mcp/server-github"] },
"search": { "command": "npx", "args": ["-y", "@mcp/server-brave-search"] },
"files": { "command": "npx", "args": ["-y", "@mcp/server-filesystem", "/home"] }
}
}
Cztery narzędzia. Cztery linijki konfiguracji. Zero custom kodu. Każdy serwer mówi tym samym protokołem — zestawem reguł komunikacji między programami — a każdy klient go rozumie.
Architektura: trzech aktorów, zero magii
MCP ma dokładnie trzy ruchome części:
┌──────────────────┐
│ HOST │ (Claude Code, Cursor, twoja appka)
│ │
│ ┌────────────┐ │
│ │ CLIENT │──── MCP Protocol ──── SERVER (Postgres, GitHub)
│ └────────────┘ │
│ │
│ ┌────────────┐ │
│ │ CLIENT │──── MCP Protocol ──── SERVER (Search, Files)
│ └────────────┘ │
└──────────────────┘
Host — aplikacja AI, z którą wchodzisz w interakcję. Claude Code, Claude Desktop, Cursor, Windsurf albo twoja własna appka.
Client — żyje wewnątrz hosta. Zarządza połączeniem z jednym serwerem. Host może uruchomić wielu klientów podłączonych do wielu serwerów jednocześnie.
Server — dostarcza narzędzia i dane. Działa jako osobny proces — samodzielny program — albo na twojej maszynie, albo na zdalnym serwerze.
Żadnej warstwy orkiestracji. Żadnej kolejki wiadomości. Żadnego service mesha. Tylko klient gadający z serwerem po standardowym protokole. To wszystko. 😸
Co płynie przez rurę
Serwery MCP mogą dostarczać trzy typy rzeczy:
1. Tools — akcje, które AI może wykonać
Tools to funkcje — samodzielne operacje — które AI może wywołać. Na przykład "uruchom zapytanie SQL" albo "utwórz issue na GitHubie".
{
"name": "query",
"description": "Run a read-only SQL query against the database",
"inputSchema": {
"type": "object",
"properties": {
"sql": { "type": "string", "description": "The SQL query to execute" }
},
"required": ["sql"]
}
}
Kiedy serwer startuje, mówi klientowi: "Oto narzędzia, które dostarczam, oto co każde robi, oto parametry". Model AI czyta te opisy i sam decyduje, kiedy ich użyć — tak jak ty decydujesz, którą appkę otworzyć na telefonie.
2. Resources — dane, które AI może czytać
Resources to kawałki danych, które serwer udostępnia. Zawartość pliku, schemat bazy danych (struktura twoich tabel), konfiguracja.
Rozróżnienie ma znaczenie: tools robią rzeczy, resources dostarczają kontekst. AI czyta resources, żeby zrozumieć środowisko przed podjęciem akcji. Pomyśl o tym jak o przeczytaniu menu w restauracji przed zamówieniem.
3. Prompts — gotowe szablony
Gotowe szablony, które serwer oferuje, typu "przeanalizuj tę tabelę" albo "zrób review tego pull requesta". To skróty, które wiedzą, jak skutecznie użyć narzędzi serwera.
Większość ludzi ignoruje prompty i po prostu rozmawia z AI normalnie. I dobrze. Są opcjonalne.
Śledzenie prawdziwego requestu
Prześledźmy, co się dzieje, gdy wpisujesz "Pokaż mi wszystkich użytkowników, którzy zarejestrowali się dzisiaj" w Claude Code z podłączonym serwerem MCP Postgres:
1. TY wpisujesz: "Pokaż mi wszystkich użytkowników,
którzy zarejestrowali się dzisiaj"
2. CLAUDE widzi, że narzędzia Postgres MCP są dostępne
(query, list_tables, describe_table)
3. CLAUDE najpierw wywołuje 'describe_table', żeby
zrozumieć strukturę tabeli users
4. CLIENT wysyła do SERVERA:
{ "method": "tools/call",
"params": { "name": "describe_table",
"arguments": { "table": "users" } } }
5. SERVER odpytuje PostgreSQL, zwraca schemat
6. CLAUDE pisze zapytanie SQL na podstawie schematu:
SELECT * FROM users WHERE created_at >= CURRENT_DATE
7. CLIENT wysyła zapytanie do SERVERA, SERVER je wykonuje
8. CLAUDE formatuje wyniki i pokazuje ci je
Całość zajmuje 1-2 sekundy. Zapytałeś po polsku, AI ogarnął SQL, serwer MCP go wykonał i dostałeś wyniki. Żadnego ręcznego pisania zapytań. To jest ten moment "aha" dla większości ludzi. 😻
Warstwa transportowa — jak podróżują bity
MCP działa na dwóch metodach transportu:
STDIO (serwery lokalne) — serwer działa jako proces potomny na twojej maszynie. Komunikacja odbywa się przez stdin/stdout — te same tekstowe potoki, których używa twój terminal. To najczęstszy setup:
{
"mcpServers": {
"my-server": {
"command": "node",
"args": ["server.js"],
"env": { "DB_URL": "..." }
}
}
}
Prosto, szybko, bez sieci.
Streamable HTTP (serwery zdalne) — dla serwerów na innych maszynach. Hostowane w chmurze, współdzielone w zespole albo usługi firm trzecich:
{
"mcpServers": {
"remote-server": {
"url": "https://mcp.example.com/sse",
"headers": { "Authorization": "Bearer your-token" }
}
}
}
Requesty lecą jako zwykły HTTP POST. Odpowiedzi streamują się w czasie rzeczywistym. Tak działają wdrożenia enterprise — scentralizowane serwery, do których podłącza się wielu deweloperów.
Zbuduj własny w 20 linijkach
Oto najprostszy działający serwer MCP, jaki możesz napisać, używając oficjalnego SDK TypeScript:
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
const server = new McpServer({
name: "my-tool",
version: "1.0.0"
});
server.tool(
"hello",
"Says hello to someone",
{ name: { type: "string", description: "Person to greet" } },
async ({ name }) => ({
content: [{ type: "text", text: `Hello, ${name}!` }]
})
);
const transport = new StdioServerTransport();
await server.connect(transport);
Instalujesz SDK (npm install @modelcontextprotocol/sdk), definiujesz swoje narzędzia, podłączasz transport. SDK obsługuje negocjację protokołu — handshake, w którym klient i serwer uzgadniają, co obaj obsługują — parsowanie wiadomości i obsługę błędów.
Praktyczny przykład — API pogodowe
server.tool(
"get_weather",
"Get current weather for a city",
{
city: { type: "string", description: "City name" },
units: { type: "string", description: "celsius or fahrenheit", default: "celsius" }
},
async ({ city, units }) => {
const response = await fetch(
`https://wttr.in/${encodeURIComponent(city)}?format=j1`
);
const data = await response.json();
const current = data.current_condition[0];
const temp = units === "fahrenheit"
? current.temp_F + "°F"
: current.temp_C + "°C";
return {
content: [{ type: "text", text: `${city}: ${temp}, ${current.weatherDesc[0].value}` }]
};
}
);
Teraz twój agent AI może sprawdzić pogodę. Co ważniejsze, zauważ wzorzec: pobierasz dane z dowolnego API (interfejsu programistycznego — sposobu, w jaki programy ze sobą gadają), opakowujesz je w MCP tool i każdy klient kompatybilny z MCP na świecie może tego użyć.
Handshake capabilities
Kiedy klient pierwszy raz łączy się z serwerem, negocjują:
Client: "Obsługuję tools, resources i prompts. Co masz?"
Server: "Dostarczam 3 tools i 2 resources. Oto one."
Client: "Mam. Gotowy."
To oznacza, że klienty nie muszą z góry wiedzieć, co serwer dostarcza. Serwery mogą dodawać i usuwać funkcje bez psucia czegokolwiek. Różni klienci mogą używać tego samego serwera na różne sposoby. To elegancka ewolucja, nie kruche sprzężenie.
Co nie jest idealne
Nie udawajmy, że to jest bez wad. Stan na marzec 2026:
Bezpieczeństwo to twój problem. Serwer MCP może zrobić wszystko, na co mu pozwolisz. Złośliwy serwer mógłby wykraść dane przez wywołania narzędzi. Nie ma wbudowanego sandboxingu — żadnej automatycznej izolacji od reszty twojego systemu. Ufasz każdemu serwerowi tak, jak ufasz każdemu pakietowi npm, który instalujesz. Pomyśl o tym przez sekundę.
Discovery to bałagan. Znalezienie odpowiedniego serwera MCP do twojego przypadku użycia oznacza przeglądanie rejestrów takich jak mcpservers.org albo glama.ai/mcp/servers. Nie ma jeszcze scentralizowanego, zweryfikowanego marketplace'u. Jakość jest bardzo zróżnicowana.
Debugowanie boli. Kiedy wywołanie narzędzia failuje, komunikaty o błędach często przechodzą przez wiele warstw — klient, protokół, serwer, API pod spodem — i wychodzą z drugiego końca jako papka. Poprawia się, ale wciąż jest bolesne.
Narzut wydajnościowy istnieje. Każde wywołanie narzędzia to round trip JSON-RPC — request-response w formacie JSON. Dla lokalnych serwerów STDIO jest to pomijalny. Dla zdalnych serwerów po HTTP, latencja się kumuluje, gdy AI chainuje wiele wywołań.
Co to oznacza dla ciebie
Jeśli używasz narzędzi AI do kodowania jak Claude Code czy Cursor: MCP oznacza, że twoje AI dostaje nowe umiejętności bez aktualizacji oprogramowania. Pojawia się nowy serwer MCP do Jiry? Zainstaluj go i twoje AI zarządza twoimi ticketami. Nowy serwer do AWS? Twoje AI zarządza twoją infrastrukturą. Nie czekasz, aż vendor narzędzia zbuduje integracje — community je buduje.
Jeśli budujesz narzędzia lub API: MCP oznacza, że piszesz jedną integrację i działa z Claude, Cursor, Windsurf, Cline i każdym przyszłym klientem kompatybilnym z MCP. Jeden serwer, dziesiątki klientów. To jest ta matematyka USB.
Jeśli jesteś founderem: zbudowanie serwera MCP dla twojego produktu staje się table stakes, tak jak zbudowanie REST API było 10 lat temu. Jeśli twoje narzędzie deweloperskie nie ma serwera MCP, twoi użytkownicy zapytają dlaczego.
Ekosystem na marzec 2026
- Oficjalne serwery od Anthropic: PostgreSQL, GitHub, Filesystem, Brave Search, Puppeteer, Google Maps, Slack i więcej — zobacz repozytorium serwerów MCP
- Serwery enterprise od AWS, Cloudflare, Sentry
- Serwery community do Docker, Kubernetes, Notion, Linear, Figma, Stripe — setki i rośnie
- Roadmapa 2026 skupia się na komunikacji agent-to-agent, skalowaniu horyzontalnym i mechanizmie discovery
.well-known, żeby serwery mogły się automatycznie ogłaszać
USB zabiło własnościowe ładowarki. MCP zabija custom integracje.
MCP to najważniejsza rzecz, jaka przydarzyła się AI toolingowi od czasu, gdy okna kontekstowe — pamięć robocza AI — stały się wystarczająco duże, żeby zmieścić prawdziwą bazę kodu. To nie jest sexy. To protokół JSON-RPC po stdio. Ale USB też nie było sexy, a zabiło każdy własnościowy konektor na swojej drodze.
Najmądrzejsza rzecz, jaką możesz teraz zrobić: przestań czytać dokumentację specyfikacji. Zainstaluj serwer MCP Postgres, podłącz go do Claude Code i zapytaj o swoją bazę danych. Zrozumiesz MCP w 30 sekund.
Specyfikacja jest dla ludzi budujących protokół. Ty go używasz. 😹
