MCP podle specifikace: co server opravdu je

Než půjdeme na drát, počítejme. Máte $N$ AI aplikací a $M$ věcí, na které by měly dosáhnout — kalendář, ticketovací systém, databázi skladu, návrhový nástroj. Bez sdílené smlouvy někdo napíše $N \times M$ integrací a každá z nich je schema plus endpoint plus příběh autentizace plus údržbová zátěž. S ní napíše dodavatel nástroje server, dodavatel aplikace napíše klienta a celkový počet je $N + M$.

To není nová myšlenka a specifikace říká, čí nápad to byl:

MCP takes some inspiration from the Language Server Protocol, which standardizes how to add support for programming languages across a whole ecosystem of development tools. In a similar way, MCP standardizes how to integrate additional context and tools into the ecosystem of AI applications.¹

Berte to srovnání doslova, ne jako kompliment. Před tímto protokolem znamenala podpora jazyka v editoru plugin pro každý editor; potom tým jazyka dodal jeden server a každý editor ho dostal. Měřítkem úspěchu nebyla elegance, ale to, že se počet integrací přestal násobit. Totéž platí tady: hodnota je v počtu implementací, ne v návrhu. Protokol, kterým mluví dva produkty, je datový formát s extra ceremonií.

Zprávy MCP jsou JSON-RPC 2.0. Požadavek je objekt s jsonrpc, id, method a volitelným params; odpověď nese stejné id a buď result, nebo error; notifikace je požadavek bez id a nedostává odpověď. Specifikace navrch přidává tři omezení: id musí být řetězec nebo číslo a nesmí být null, nesmí kolidovat s jiným požadavkem, který je stále rozpracovaný, a každý výsledek musí nést pole resultType.²

Na transportu stdio — tom, který použil příkaz výše — je pravidlo rámování jeden řádek na zprávu:

Messages are delimited by newlines, and MUST NOT contain embedded newlines. […] The server MUST NOT write anything to its stdout that is not a valid MCP message.³

Ta poslední klauzule je nejčastější způsob, jak se domácí server rozbije, a rozbije se potichu: zatoulané console.log, progress bar, varování o deprecaci ze závislosti, a řádkový parser klienta narazí na něco, co není JSON. Úniková cesta je ve stejném oddílu — server může psát cokoli chce do stderr a klient by to neměl brát jako chybu. Referenční server výše při každém spuštění vypisuje Starting default (STDIO) server... na stderr, proto pipe stále fungovala.

Druhý standardní transport je Streamable HTTP: každá zpráva je POST na jeden endpoint a odpověď je buď JSON objekt, nebo stream Server-Sent Events omezený na daný požadavek — wire formát, který kapitola 14 rozebrala ručně. Sémantika je na obou stejná, protože transport je vazba: definuje rámování a doručení, ne význam.⁴

Příkaz výše poslal tools/list a nic dalšího. Podle současné revize je tento požadavek chybný a vyhovující server ho musí odmítnout.

Od 2026-07-28 je MCP bezstavový protokol a specifikace to říká bez kličkování:

The Model Context Protocol (MCP) is a stateless protocol: all the information needed to process a request is contained in the request itself. A server processes each request independently; no state should be inferred from previous requests, even those on the same connection or stream.²

Každý požadavek tedy nese vlastní verzi protokolu a vlastní schopnosti klienta v rezervovaném objektu _meta uvnitř params. Dvě z těchto polí jsou povinná v úplně každém požadavku; požadavek, kterému některé chybí, je chybný a server musí odpovědět -32602:²

Rozepsaný správný tools/list vypadá takto — a je to naposledy, kdy tato kapitola ukazuje metadata celá, protože odteď jsou v každém požadavku:

{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{"_meta":{
  "io.modelcontextprotocol/protocolVersion":"2026-07-28",
  "io.modelcontextprotocol/clientCapabilities":{"elicitation":{"form":{}}},
  "io.modelcontextprotocol/clientInfo":{"name":"bare-hands","version":"0.0.1"}}}}

Objekt schopností je vyjednávání. Už neexistuje samostatný krok vyjednávání: klient v každém požadavku deklaruje, co umí, server ve výsledku deklaruje, co umí, a ani jedna strana nesmí použít funkci, kterou druhá nepřiznala. Server, který potřebuje schopnost, již klient nedeklaroval, musí odpovědět -32021 a v data.requiredCapabilities pojmenovat chybějící schopnost. Server, který nemluví požadovanou verzí, musí odpovědět -32022 a vypsat verze, kterými mluví.²

Klienti, kteří chtějí odpověď dopředu, si o ni mohou říct: server/discover je povinné RPC, které v jednom kole vrací podporované verze, schopnosti, identitu a volitelný blok instructions.⁵ Volat ho je volitelné. Implementovat ho není.

Příkaz fungoval. Podle současné revize neměl, a důvod, proč fungoval, stojí spíš za měření než za odstavec, protože v jednom řádku ukazuje stav celého ekosystému.

Otestujte referenční server tak, jak specifikace modernímu klientovi říká, že má testovat:

echo '{"jsonrpc":"2.0","id":1,"method":"server/discover","params":{"_meta":{
  "io.modelcontextprotocol/protocolVersion":"2026-07-28",
  "io.modelcontextprotocol/clientCapabilities":{}}}}' \
  | npx @modelcontextprotocol/server-everything stdio

{"jsonrpc":"2.0","id":1,"error":{"code":-32601,"message":"Method not found"}}

To je třetí větev pravidla kompatibility: DiscoverResult znamená moderní, rozpoznaná moderní chyba znamená moderní, ale špatná verze, a cokoli jiného — včetně -32601 — znamená legacy, vraťte se na handshake initialize.³ Tak to udělejte a požádejte o současnou revizi:

→ {"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2026-07-28",
   "capabilities":{},"clientInfo":{"name":"bare-hands","version":"0.0.1"}}}

← {"result":{"protocolVersion":"2025-11-25","capabilities":{"tools":{"listChanged":true},
   "prompts":{"listChanged":true},"resources":{"subscribe":true,"listChanged":true},
   "logging":{},"tasks":{…},"completions":{}},"serverInfo":{"name":"mcp-servers/everything",
   "title":"Everything Reference Server","version":"2.0.0"},"instructions":"…"}}

Klient požádal o 2026-07-28 a server odpověděl 2025-11-25. Dne 7. září 2026 oficiální referenční server — npm balíček @modelcontextprotocol/server-everything, verze 2026.8.31, publikovaný 31. srpna 2026 — neimplementuje současnou revizi. Podle dat ji neimplementuje ani TypeScript SDK, na kterém je postavený: release 1.30.0 vyšel 27. července 2026, den před danou revizí.

Čtěte důsledek, ne drby. Skoro všechno, co se o MCP píše, popisuje protokol s handshake initialize, session, požadavkem roots/list, který server posílá klientovi, a transportem HTTP+SSE. Všechny čtyři jsou pryč nebo na odchodu. Když čtete cokoli o MCP, včetně této stránky, první věc, kterou hledat, je číslo revize.

A důvod, proč úplně první příkaz fungoval, je ve specifikaci uveden jako riziko, ne jako funkce:

some legacy servers do not validate that a request arrives after initialize and would process an era-ambiguous method (such as tools/call) under legacy semantics. Probing yields a deterministic failure instead.³

Naměřeno: odeslání tools/list na tento server úplně bez handshake vrací celý katalog. Metoda, která měla být odmítnuta, byla obsloužena, což je přesně důvod, proč specifikace říká nejdřív sondovat pomocí server/discover, i když podporujete jen moderní verze.

MCP má tři strany a rozdíl mezi prvními dvěma je ten, který lidé slévají dohromady:

Server. Proces nebo služba, která vystavuje zdroje, nástroje a prompts. Může být lokální nebo vzdálený, funguje nezávisle a jeho celý úkol je jedna soustředěná oblast.⁶

Pravidlo „přesně jeden server“ není účetnictví. Právě ono umožňuje implementovat níže uvedený princip návrhu, a pokud si ze specifikace odnést jen jednu větu, je to tahle:

Servers should not be able to read the whole conversation, nor "see into" other servers. Servers receive only necessary contextual information. Full conversation history stays with the host. Each server maintains isolation. Cross-server interactions are controlled by the host.⁶

To převrací mentální model, se kterým většina lidí přichází. Weather server, který připojíte ke svému asistentovi, nevidí, na co jste se zeptali. Vidí tools/call s argumenty, které model zvolil, a nic dalšího — ne předchozí tahy, ne váš system prompt, ne výsledky, které před chvílí vrátil calendar server. Pokud dva servery potřebují spolupracovat, host přenese hodnotu z jednoho do druhého, záměrně, protože si o to model řekl. Proto je izolace bezpečnostní vlastnost, o kterou se opírá kapitola 30: kompromitovaný server má malý, definovaný dosah škody a jeho rozšíření vyžaduje spolupráci hostu.

První příkaz požádal tento server o nástroje a dostal třináct. Zeptejte se na další dvě otázky a odpoví i na ně: resources/list vrátí sedm, prompts/list vrátí čtyři. Žádné se neobjevilo, protože se nikdo nezeptal. Tím se dostáváme k pedagogické páteři MCP, která ve specifikaci leží jako tabulka, již téměř nikdo necituje:

Ne „tři způsoby, jak vystavit schopnost“. Tři odpovědi na otázku kdo rozhoduje, že se to stane. Model rozhoduje o zavolání nástroje. Aplikace rozhoduje o připojení zdroje. Člověk rozhoduje o spuštění prompt. Když to pochopíte špatně, funkce stále funguje, ale funguje ve špatný okamžik a ze špatného důvodu.

Nejjasněji to ucítíte na kalendáři. Tady je server, který vystavuje stejný kalendář třikrát, jednou jako každé primitivum, ve stovce řádků čistého Node bez závislostí:

const TOOL = {
  name: "create_event",
  description: "Create a calendar event. Writes to the calendar.",
  inputSchema: {
    type: "object",
    properties: {
      title:    { type: "string", description: "Event title." },
      startsAt: { type: "string", format: "date-time", description: "Start, ISO 8601 UTC." },
    },
    required: ["title"],
  },
};

switch (method) {
  case "resources/read":                                          
    return ok(id, { contents: [{ uri: "calendar://week",
      mimeType: "application/json", text: JSON.stringify(EVENTS) }],
      ttlMs: 60000, cacheScope: "private" });

  case "prompts/get":                                             
    return ok(id, { description: PROMPT.description, messages: [{ role: "user",
      content: { type: "text", text: `Read calendar://week and draft a plan. ` +
        `Focus: ${params.arguments?.focus ?? "balance"}.` } }] });

  case "tools/list":                                              
    return ok(id, { tools: [TOOL], ttlMs: 300000, cacheScope: "public" });
}

Spusťte ho a zeptejte se všemi třemi způsoby. Skutečný výstup, jedna zpráva na řádek na drátu, tady zalomený pro stránku, s vynechaným požadavkem _meta a blokem identity serveru:

→ resources/read  {"uri":"calendar://week"}
← {"resultType":"complete","contents":[{"uri":"calendar://week",
   "mimeType":"application/json","text":"[{\"id\":\"e1\",\"title\":\"Standup\",
   \"startsAt\":\"2026-09-07T09:00:00Z\"},{\"id\":\"e2\",\"title\":\"Design review\",
   \"startsAt\":\"2026-09-09T15:00:00Z\"}]"}],"ttlMs":60000,"cacheScope":"private"}

→ prompts/get    {"name":"prepare_week","arguments":{"focus":"deep work"}}
← {"resultType":"complete","description":"Read the week and draft a plan.",
   "messages":[{"role":"user","content":{"type":"text",
   "text":"Read calendar://week and draft a plan. Focus: deep work."}}]}

→ tools/call     {"name":"create_event","arguments":{"title":"Dentist",
                  "startsAt":"2026-09-10T08:30:00Z"}}
← {"resultType":"complete","content":[{"type":"text",
   "text":"Created e3: Dentist at 2026-09-10T08:30:00Z"}],
   "structuredContent":{"id":"e3","title":"Dentist","startsAt":"2026-09-10T08:30:00Z"},
   "isError":false}

Tři metody, tři tvary, jeden kalendář. Teď pointa:

Skoro všichni z těchto tří věcí udělají nástroje. Výsledkem je katalog, kde čtení, které měla aplikace tiše připojit, soutěží o attention modelu se zápisem, který potřebuje schválení, a kde jediná věc, na kterou člověk chtěl tlačítko, leží zahrabaná ve schema. Udělat to správně nic nestojí a rozhoduje se o tom dřív, než napíšete jediný řádek.

Kalendářový nástroj má jeden povinný argument, title, a volitelný startsAt. Požádejte ho o vytvoření události bez data a vrátí se něco zajímavého:

→ tools/call {"name":"create_event","arguments":{"title":"Dentist"}}

← {"resultType":"input_required",
   "inputRequests":{"when":{"method":"elicitation/create","params":{"mode":"form",
     "message":"When should \"Dentist\" start?",
     "requestedSchema":{"type":"object",
       "properties":{"startsAt":{"type":"string","format":"date-time"}},
       "required":["startsAt"]}}}},
   "requestState":"eyJ0aXRsZSI6IkRlbnRpc3QifQ=="}

Server neposlal požadavek. Odpověděl na ten, který dostal, pomocí resultType: "input_required" a popisu toho, co ještě potřebuje. Klient získá odpověď od člověka a potom znovu pošle původní volání — s novým id, které nese inputResponses a zpět opakuje neprůhledné requestState:

→ tools/call {"name":"create_event","arguments":{"title":"Dentist"},
   "inputResponses":{"when":{"action":"accept",
     "content":{"startsAt":"2026-09-10T08:30:00Z"}}},
   "requestState":"eyJ0aXRsZSI6IkRlbnRpc3QifQ=="}

← {"resultType":"complete","content":[{"type":"text",
   "text":"Created e3: Dentist at 2026-09-10T08:30:00Z"}],"isError":false}

To jsou Multi Round-Trip Requests, zavedené v současné revizi, a nahradily starší návrh, ve kterém servery posílaly JSON-RPC požadavky zpět klientům. Specifikace transportu teď pravidlo říká přímo: „servers do not initiate JSON-RPC requests and clients do not send JSON-RPC responses“.⁴ Existuje jeden směr iniciativy a patří hostu.

Na tomto mechanismu jedou dvě klientské funkce a jedna z nich má název, o který zakopnete.

Elicitation je server, který žádá člověka o něco: formulář se záměrně omezeným JSON Schema — ploché objekty, primitivní vlastnosti, žádné vnořování — aby ho každý klient mohl vykreslit bez layout enginu. Nese tvrdé pravidlo: servery nesmějí používat režim formuláře k vyžádání „passwords, API keys, access tokens, or payment credentials“ a musejí pro ně použít režim URL, který pošle uživatele na stránku, kterou klient nikdy nečte.⁷

Sampling je server, který žádá model hostu o generování, takže server může být inteligentní, aniž drží API key. A tady je terminologické varování, protože tohle slovo už v tomto kurzu znamená něco jiného: tohle není sampling z kapitoly 17. Tady nejde o temperature, top-p ani tvar pravděpodobnostního rozdělení. Je to vnořené volání modelu, které cestuje protokolem zpátky.

Je tu i druhý důvod po tom nesahat: od této revize je sampling deprecated, společně s roots a logging, pod SEP-2577, s přímočarou doporučenou migrací — „integrate directly with LLM provider APIs instead of Sampling“.⁸ Myšlenka neselhala technicky; neobhájila svou plochu v protokolu, a protokol, který umí věci odstraňovat, je zdravější než ten, který to neumí.

Bezstavovost zní jako detail wire formátu, dokud ji neotestujete. Vezměte třízprávovou výměnu výše a spusťte každou zprávu v samostatném procesu — čerstvý node calendar.mjs, žádná sdílená paměť, nic nepřenesené:

process A   tools/call (no date)   → resultType: input_required
                                     requestState: eyJ0aXRsZSI6IkRlbnRpc3QifQ==
process B   tools/call (with the answer, same requestState)
                                   → resultType: complete
                                     "Created e3: Dentist at 2026-09-10T08:30:00Z"
process C   resources/read calendar://week
                                   → events: 2  (Standup, Design review)

Proces B, který nikdy neviděl otázku, dokončil multi-round-trip volání, které proces A začal. To je smysl requestState: pokračování cestuje ve zprávě, takže nic nezávisí na tom, že proces je tentýž.

Proces C je selhání. Událost byla vytvořena a není tam — protože toy server drží EVENTS v poli na úrovni modulu a pole na úrovni modulu je stav připojení. Poznámka ve specifikaci chybu pojmenovává přesně:

an open connection, such as a STDIO process, is not a conversation or session: clients may interleave unrelated requests on the same transport, and a server must not treat connection or process identity as a proxy for conversation or session continuity.²

Předepsaná oprava není session. Je to explicitní handle: nástroj pro vytvoření vrátí neprůhledný identifikátor a každé pozdější volání ho bere jako obyčejný argument. Protokol pro něj nemá žádný koncept — „from the wire's perspective a handle is an ordinary string in a tool result and an ordinary argument to subsequent tool calls“.⁹ Tím dává modelu odpovědnost ho nést a serveru odpovědnost v každém jednotlivém volání ověřit, že tento volající ho smí použít, protože handle je název, ne oprávnění.

Každý nástroj, který server vystavuje, je schema, které jde do vašeho prompt při každém požadavku, a kapitola 24 změřila, co to dělá s oknem. MCP přidává druhou položku, kterou je snadné přehlédnout, takže stojí za to spočítat obě na referenčním serveru výše.

13 tool definitions (name + description + inputSchema):  1,307 tokens
  cheapest tool, get-tiny-image                              52
  costliest tool, gzip-file-as-resource                     235
server `instructions`, returned by discovery:               312 tokens
                                                          ------
one server, connected, before it is used:                 1,619 tokens

Dvě pozorování. První je aritmetika: připojte pět serverů této velikosti a zhruba osm tisíc tokenů vašeho okna je obsazeno v každém tahu, navždy, ať model některý z nich použije, nebo ne — což je mechanismus za snížením ze 150 000 na 2 000, které citovala kapitola 24, a důvod, proč existuje just-in-time objevování nástrojů.

Druhé je bezpečnostní poznámka v účetním kostýmu. instructions je text v přirozeném jazyce, napsaný autorem serveru, který přistane v prompt hostu, a popisy nástrojů vedle něj jsou totéž. Specifikace ve svých bezpečnostních principech říká, co s tím dělat: anotace a popisy nástrojů „should be considered untrusted, unless obtained from a trusted server“ a hosté „must obtain explicit user consent before invoking any tool“.¹ Připojení MCP serveru není přidání závislosti. Je to udělení cizímu člověku 1 619 tokenů vašeho system prompt a práva být volán. Kapitola 30 je to, co se stane, když je ten cizí člověk nepřátelský.

Všechno v tomto oddílu platí pro revizi protokolu 2026-07-28, současnou revizi, čtenou 7. září 2026. Revize jsou datované YYYY-MM-DD a datum je poslední okamžik, kdy byla provedena zpětně nekompatibilní změna.¹⁰ Normativní dokument je TypeScript soubor, schema/2026-07-28/schema.ts; JSON Schema vedle něj se z něj generuje, proto se zde specifikace čte v TypeScriptu a proto učit MCP z čehokoli jiného znamená učit překlad.

Změna řízení pod touto tabulkou je důležitější než kterýkoli jednotlivý řádek. Tato revize přijala feature lifecycle and deprecation policy: funkce jsou Active, Deprecated nebo Removed, deprecated funkce dokumentuje migrační cestu a zůstává ve specifikaci alespoň dvanáct měsíců, než se stane způsobilou k odstranění, a existuje registr se seznamem všeho, co je aktuálně ve stavu Deprecated.⁸ Před touto politikou znamenalo „deprecated“ v AI protokolu cokoli, co tvrdil poslední blog post. Teď to znamená datum.

Tady je slovník celého bloku na jednom místě.

Dvě z těchto položek si zaslouží po jedné větě, protože právě tam se zmatek opravdu nachází.

MCP vůči A2A není rivalita a obě specifikace to říkají. Dokumentace A2A kreslí hranici podle toho, co je na druhém konci: MCP „defines how an AI agent interacts with and utilizes individual tools and resources, such as a database or an API“, kde nástroj provádí „specific, often stateless, functions“; A2A řeší agenty, „more autonomous systems“, které „reason, plan, use multiple tools, maintain state over longer interactions, and engage in complex, often multi-turn dialogues“. Její vlastní shrnutí je věta k zapamatování: „A2A is about agents partnering on tasks, while MCP is more about agents using capabilities.“¹¹ Ty dvě věci se vnořují — aplikace používá A2A, aby dosáhla na jiné agenty, a každý agent používá MCP, aby dosáhl na vlastní nástroje. Kapitola 25 nakreslila tuto hranici uvnitř jednoho procesu, mezi tím, kdy se ptáte sub-agent, a tím, kdy mu předáváte konverzaci; A2A ji kreslí mezi organizacemi.

MCP vůči ACP je srovnání se zastaralým předpokladem, a právě proto stojí za odpověď. Agent Communication Protocol byl samostatný otevřený standard pro zprávy mezi agenty. Jeho vlastní dokumentace teď začíná upozorněním: „ACP is now part of A2A under the Linux Foundation!“¹² Poctivá odpověď na „MCP nebo ACP?“ v září 2026 je, že otázka má o jednu možnost méně, než naznačují stránky, které se na ni umisťují.

A srovnání, na které se lidé ptají nejčastěji, mcp vs api, má nejméně zajímavou odpověď: MCP je API. Nepřidává sílu, ale konvence — pevnou sadu názvů metod, discovery call, hierarchii řízení nad primitivy a izolační model. Vzdáváte se svobody navrhnout vlastní rozhraní a získáváte každého hosta, který protokolem mluví, což je směna, kterou nabízel každý protokol v historii.

Teď už můžete číst specifikaci bez překladatele, rozeznat zdroj od nástroje od prompt podle toho, kdo ho řídí, napsat požadavek ručně, když vám klientská knihovna lže, a datovat každý článek o MCP podle toho, které deprecated funkce stále učí jako současné.

Co jste neudělali, je dodat jeden do produkce. Kapitola 27 napíše stejný server dvakrát — TypeScript a Python vedle sebe, protože MCP je v tomto kurzu jediné opravdu dvojjazyčné území a čísla to říkají oběma směry. Pokryje oba živé transporty pořádně, inspector, balení a tu polovinu protokolu, kterou tato kapitola záměrně nechala stranou: authorization. Protože ve chvíli, kdy je váš server vzdálený, a ne subprocess na vašem vlastním notebooku, předloží klient cizího člověka token a pravidlo specifikace o tom, co s ním smíte udělat, je neobvykle přísné.

Tím vzniká otázka, na kterou musí odpovědět další kapitola, a není přátelská: když na váš server dorazí token vydaný pro audience někoho jiného, co přesně vám brání ho přeposlat dál?

Každá citace, název metody, chybový kód a pravidlo v této kapitole byly přečteny ze specifikace Model Context Protocol, revize 2026-07-28, dne 7. září 2026. Každý trace byl vytvořen lokálně na Node 22: toy calendar server má 101 řádků bez závislostí a referenční server je níže uvedený publikovaný npm balíček. Při psaní této kapitoly nebylo zavoláno žádné placené API — nic tady nepotřebuje model, což je samo o sobě pointa.

Měření: @modelcontextprotocol/server-everything@2026.8.31, publikováno 31. srpna 2026, postaveno na @modelcontextprotocol/sdk@1.30.0, publikovaném 27. července 2026 — jeden den před revizí, kterou tato kapitola popisuje. Na server/discover odpovídá -32601, vyjedná 2025-11-25 při žádosti o 2026-07-28 a servíruje tools/list úplně bez handshake. Jeho katalog má 13 nástrojů v 7 663 bytech; počty tokenů jsou o200k_base přes tiktoken, přes name, description a inputSchema každé definice, což je to, co provider vykreslí do vašeho prompt, ne kolik váží JSON-RPC rámec.

Anthropic, Code execution with MCP: building more efficient agents, 4. listopadu 2025, je zdrojem čísla 150 000 na 2 000, citovaného a použitého v kapitole 24 a zde jen odkazovaného.