MCP Dijelaskan Berdasarkan Spesifikasi: Apa Sebenarnya Server Itu

Sebelum wire, hitungannya dulu. Kamu punya $N$ aplikasi AI dan $M$ hal yang harus bisa dijangkaunya — kalender, ticket tracker, database warehouse, tool desain. Tanpa kontrak bersama, seseorang menulis $N \times M$ integrasi, dan masing-masing adalah schema plus endpoint plus cerita autentikasi plus beban pemeliharaan. Dengan kontrak bersama, vendor tool menulis server, vendor aplikasi menulis client, dan totalnya menjadi $N + M$.

Itu bukan observasi baru, dan spesifikasi mengatakan dari mana idenya berasal:

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

Ambil perbandingan itu secara harfiah, bukan sebagai pujian. Sebelum protokol itu, mendukung sebuah bahasa di editor berarti satu plugin per editor; setelahnya, tim bahasa mengirimkan satu server dan setiap editor mendapatkannya. Ukuran keberhasilannya bukan elegansi, melainkan jumlah integrasi berhenti berlipat ganda. Hal yang sama berlaku di sini: nilainya ada pada jumlah implementasi, bukan pada desainnya. Protokol yang hanya dipakai dua produk adalah format data dengan seremoni tambahan.

Pesan MCP adalah JSON-RPC 2.0. Request adalah objek dengan jsonrpc, sebuah id, sebuah method, dan params opsional; response membawa id yang sama dan salah satu dari result atau error; notification adalah request tanpa id dan tidak mendapat balasan. Spesifikasi menambahkan tiga batasan di atasnya: id harus berupa string atau number dan tidak boleh null, tidak boleh bertabrakan dengan request lain yang masih berjalan, dan setiap result harus membawa field resultType.²

Pada transport stdio — yang dipakai perintah di atas — aturan framing-nya adalah satu baris per pesan:

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

Klausul terakhir itu adalah cara paling umum server buatan sendiri rusak, dan rusaknya diam-diam: console.log yang tersesat, progress bar, peringatan deprecation dari dependency, lalu line parser client menabrak sesuatu yang bukan JSON. Jalan keluarnya ada di bagian yang sama — server boleh menulis apa pun yang ia suka ke stderr, dan client seharusnya tidak memperlakukannya sebagai error. Server referensi di atas mencetak Starting default (STDIO) server... setiap kali launch, di stderr, sehingga pipe tetap bekerja.

Transport standar lainnya adalah Streamable HTTP: setiap pesan adalah POST ke satu endpoint, dan balasannya adalah objek JSON atau stream Server-Sent Events yang scoped ke request — wire format yang Chapter 14 parse secara manual. Semantics identik pada keduanya, karena transport adalah binding: ia mendefinisikan framing dan delivery, bukan makna.⁴

Perintah di atas mengirim tools/list dan tidak ada yang lain. Di bawah revisi saat ini, request itu malformed, dan server yang conformant harus menolaknya.

Sejak 2026-07-28, MCP adalah protokol stateless, dan spesifikasi menyatakannya tanpa ragu:

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

Jadi setiap request membawa versi protokolnya sendiri dan client capabilities-nya sendiri, di objek reserved _meta di dalam params. Dua field tersebut wajib ada di setiap request; request yang kehilangan salah satunya malformed dan server harus menjawab -32602:²

Jika ditulis penuh, tools/list yang benar seperti ini — dan ini terakhir kalinya bab ini menampilkan metadata secara penuh, karena metadata itu ada di setiap request mulai dari sini:

{"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"}}}}

Objek capability adalah negosiasinya. Tidak ada lagi langkah negosiasi terpisah: client menyatakan apa yang bisa dilakukannya pada setiap request, server menyatakan apa yang bisa dilakukannya di result, dan tidak satu pihak pun boleh memakai fitur yang belum diklaim pihak lain. Server yang membutuhkan capability yang tidak dideklarasikan client harus menjawab -32021 dan menyebut capability yang hilang di data.requiredCapabilities. Server yang tidak memahami versi yang diminta harus menjawab -32022 dan mencantumkan versi yang ia dukung.²

Client yang ingin mendapat jawabannya di awal bisa memintanya: server/discover adalah RPC wajib yang mengembalikan versi yang didukung, capabilities, identity, dan blok opsional instructions dalam satu round trip.⁵ Memanggilnya opsional. Mengimplementasikannya tidak.

Perintah tadi berhasil. Di bawah revisi saat ini seharusnya tidak, dan alasan mengapa berhasil lebih layak diukur daripada diparafrasekan, karena itu adalah kondisi seluruh ekosistem dalam satu baris.

Probe server referensi seperti yang diminta spesifikasi kepada client modern:

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"}}

Itulah cabang ketiga dari aturan kompatibilitas: DiscoverResult berarti modern, error modern yang dikenali berarti modern-tapi-versi-salah, dan apa pun selain itu — termasuk -32601 — berarti legacy, fallback ke handshake initialize.³ Jadi lakukan itu, sambil meminta revisi saat ini:

→ {"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":"…"}}

Client meminta 2026-07-28 dan server menjawab 2025-11-25. Pada 7 September 2026, server referensi resmi — npm package @modelcontextprotocol/server-everything, versi 2026.8.31, dipublikasikan 31 Agustus 2026 — belum mengimplementasikan revisi saat ini. Begitu pula, berdasarkan tanggalnya, TypeScript SDK yang membangunnya: release 1.30.0 keluar pada 27 Juli 2026, sehari sebelum revisi itu.

Baca konsekuensinya, bukan gosipnya. Hampir semua tulisan tentang MCP menjelaskan protokol dengan handshake initialize, session, request roots/list yang dikirim server ke client, dan transport HTTP+SSE. Keempatnya sudah hilang atau sedang menuju hilang. Saat kamu membaca apa pun tentang MCP, termasuk halaman ini, hal pertama yang perlu dicari adalah nomor revisi.

Dan alasan perintah paling pertama tadi berhasil dinyatakan di spesifikasi sebagai hazard, bukan fitur:

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

Terukur: mengirim tools/list ke server itu tanpa handshake sama sekali mengembalikan seluruh katalog. Method yang seharusnya ditolak justru dilayani, persis mengapa spesifikasi mengatakan untuk probe dengan server/discover terlebih dahulu bahkan ketika kamu hanya mendukung versi modern.

MCP memiliki tiga pihak, dan perbedaan antara dua yang pertama adalah yang sering diruntuhkan orang:

Server. Proses atau layanan yang mengekspos resources, tools, dan prompts. Ia bisa lokal atau remote, beroperasi secara independen, dan seluruh tugasnya adalah satu area yang terfokus.⁶

Aturan "tepat satu server" itu bukan pembukuan. Itulah yang membuat prinsip desain di bawah ini bisa diimplementasikan, dan inilah kalimat yang perlu kamu ambil dari spesifikasi jika hanya mengambil satu:

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

Itu membalik model mental yang dibawa kebanyakan orang. Server cuaca yang kamu hubungkan ke assistant kamu tidak melihat apa yang kamu tanyakan. Ia melihat tools/call dengan arguments yang dipilih model, dan tidak ada yang lain — bukan turn sebelumnya, bukan system prompt kamu, bukan result yang dikembalikan server kalender beberapa saat sebelumnya. Jika dua server perlu bekerja sama, host membawa nilai dari satu ke yang lain, secara sengaja, karena model memintanya. Itulah mengapa isolasi adalah properti keamanan yang menjadi sandaran Chapter 30: server yang compromised memiliki blast radius kecil dan terdefinisi, dan memperbesarnya menuntut host ikut bekerja sama.

Perintah pertama meminta tools dari server itu dan mendapat tiga belas. Tanyakan dua hal lainnya dan ia juga menjawab: resources/list mengembalikan tujuh, prompts/list mengembalikan empat. Tidak satu pun muncul, karena tidak ada yang meminta. Ini membawa kita ke tulang punggung pedagogis MCP, tersimpan di spesifikasi sebagai tabel yang hampir tidak pernah dikutip siapa pun:

Bukan "tiga cara untuk mengekspos capability". Melainkan tiga jawaban untuk siapa yang memutuskan bahwa ini terjadi. Model memutuskan untuk memanggil tool. Aplikasi memutuskan untuk melampirkan resource. Orang memutuskan untuk menjalankan prompt. Salah memahami ini dan fiturnya tetap bekerja, tetapi bekerja pada momen yang salah dan untuk alasan yang salah.

Cara paling jelas untuk merasakannya adalah kalender. Berikut server yang mengekspos kalender yang sama tiga kali, masing-masing sebagai satu primitive, dalam seratus baris Node polos tanpa dependency:

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

Jalankan dan tanyakan dengan ketiga cara. Output nyata, satu pesan per baris di wire, dibungkus di sini untuk halaman, dengan request _meta dan blok identity server dihilangkan:

→ 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}

Tiga method, tiga bentuk, satu kalender. Sekarang intinya:

Hampir semua orang membuat ketiganya sebagai tools. Hasilnya adalah katalog tempat read yang seharusnya dilampirkan aplikasi secara senyap bersaing untuk attention model dengan write yang membutuhkan approval, dan tempat satu hal yang diinginkan orang sebagai tombol terkubur di dalam schema. Tidak ada biaya untuk membetulkannya, dan keputusan itu diambil sebelum kamu menulis satu baris pun.

Tool kalender punya satu argument wajib, title, dan satu startsAt opsional. Minta ia membuat event tanpa tanggal, dan sesuatu yang menarik kembali:

→ 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 tidak mengirim request. Ia menjawab request yang diberikan kepadanya, dengan resultType: "input_required" dan deskripsi tentang apa yang masih ia butuhkan. Client mengumpulkan jawaban dari orangnya, lalu mengirim ulang call asli — dengan id baru, membawa inputResponses dan menggemakan kembali requestState yang opaque:

→ 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}

Ini adalah Multi Round-Trip Requests, diperkenalkan di revisi saat ini, dan menggantikan desain lama ketika server mengirim JSON-RPC requests balik ke client. Spesifikasi transport sekarang menyatakan aturannya secara tegas: "servers do not initiate JSON-RPC requests and clients do not send JSON-RPC responses".⁴ Hanya ada satu arah inisiatif, dan itu milik host.

Dua fitur sisi-client menumpang pada mekanisme itu, dan salah satunya punya nama yang akan menjegal kamu.

Elicitation adalah server meminta sesuatu kepada orang: form dengan JSON Schema yang sengaja dibatasi — objek flat, properti primitive, tanpa nesting — sehingga client mana pun bisa merendernya tanpa layout engine. Ia membawa aturan keras: server tidak boleh memakai mode form untuk meminta "passwords, API keys, access tokens, or payment credentials", dan harus memakai mode URL untuk itu, yang mengirim pengguna ke halaman yang tidak pernah dibaca client.⁷

Sampling adalah server meminta generation kepada model milik host, sehingga server bisa cerdas tanpa memegang API key. Dan inilah peringatan kosakata, karena kata ini sudah berarti hal lain dalam course ini: ini bukan sampling dari Chapter 17. Tidak ada di sini yang membahas temperature, top-p, atau bentuk probability distribution. Ini adalah nested model call yang bergerak mundur melalui protokol.

Ada alasan kedua untuk tidak buru-buru memakainya: pada revisi ini, sampling sudah deprecated, bersama roots dan logging, di bawah SEP-2577, dengan migrasi yang disarankan secara blak-blakan — "integrate directly with LLM provider APIs instead of Sampling".⁸ Idenya tidak gagal secara teknis; ia gagal membenarkan surface area-nya, dan protokol yang bisa menghapus sesuatu lebih sehat daripada protokol yang tidak bisa.

Statelessness terdengar seperti detail wire-format sampai kamu mengujinya. Ambil pertukaran tiga pesan di atas dan jalankan setiap pesan dalam proses terpisah — node calendar.mjs baru, tanpa shared memory, tidak ada yang dibawa:

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)

Process B, yang tidak pernah melihat pertanyaannya, menyelesaikan multi-round-trip call yang dimulai Process A. Itulah inti requestState: continuation berjalan di dalam pesan, sehingga tidak ada yang bergantung pada proses yang sama.

Process C adalah kegagalannya. Event dibuat dan tidak ada di sana — karena toy server menyimpan EVENTS di array level modul, dan array level modul adalah connection state. Catatan spesifikasi menamai kesalahan itu dengan tepat:

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

Perbaikan yang ditentukan bukan session. Melainkan handle eksplisit: tool creation mengembalikan identifier opaque, dan setiap call berikutnya menerimanya sebagai argument biasa. Protokol sama sekali tidak punya konsep tentang itu — "from the wire's perspective a handle is an ordinary string in a tool result and an ordinary argument to subsequent tool calls".⁹ Itu menempatkan model sebagai pihak yang membawa handle, dan server sebagai pihak yang memvalidasi bahwa caller ini boleh memakainya pada setiap call, karena handle adalah nama, bukan permission.

Setiap tool yang diekspos server adalah schema yang masuk ke prompt kamu pada setiap request, dan Chapter 24 mengukur dampaknya pada window. MCP menambahkan item biaya kedua yang mudah terlewat, jadi keduanya layak dihitung pada server referensi di atas.

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

Dua observasi. Yang pertama adalah aritmetika: hubungkan lima server sebesar ini dan sekitar delapan ribu token dari window kamu sudah terpakai di setiap turn, selamanya, baik model memakai salah satunya atau tidak — inilah mekanisme di balik pengurangan 150.000-ke-2.000 yang dikutip Chapter 24, dan alasan just-in-time tool discovery ada.

Yang kedua adalah catatan keamanan yang menyamar sebagai akuntansi. instructions adalah teks natural-language, ditulis oleh penulis server, yang mendarat di prompt host, dan deskripsi tool di sebelahnya sama. Spesifikasi mengatakan apa yang harus dilakukan terhadap itu dalam prinsip keamanannya sendiri: tool annotations dan descriptions "should be considered untrusted, unless obtained from a trusted server", dan host "must obtain explicit user consent before invoking any tool".¹ Menghubungkan server MCP bukan menambahkan dependency. Itu memberi orang asing 1.619 token dari system prompt kamu dan hak untuk dipanggil. Chapter 30 adalah apa yang terjadi ketika orang asing itu hostile.

Semua di bagian ini benar untuk revisi protokol 2026-07-28, yang saat ini berlaku, dibaca pada 7 September 2026. Revisi diberi tanggal YYYY-MM-DD dan tanggalnya adalah terakhir kali perubahan backwards-incompatible dibuat.¹⁰ Dokumen normatifnya adalah file TypeScript, schema/2026-07-28/schema.ts; JSON Schema di sebelahnya dihasilkan darinya, itulah mengapa spesifikasi dibaca di sini dalam TypeScript dan mengapa mengajarkan MCP dari hal lain berarti mengajarkan terjemahan.

Perubahan governance di bawah tabel itu lebih penting daripada baris mana pun. Revisi ini mengadopsi feature lifecycle and deprecation policy: fitur berstatus Active, Deprecated, atau Removed, fitur deprecated mendokumentasikan jalur migrasinya dan tetap berada di spesifikasi setidaknya dua belas bulan sebelum eligible untuk dihapus, dan ada registry yang mencantumkan semua yang saat ini berada dalam status Deprecated.⁸ Sebelum policy itu, "deprecated" dalam protokol AI berarti apa pun yang dikatakan blog post terakhir. Sekarang artinya tanggal.

Ini kosakata untuk seluruh blok itu dalam satu tempat.

Dua di antaranya layak mendapat satu kalimat masing-masing, karena di situlah kebingungan sebenarnya terjadi.

MCP dibanding A2A bukan rivalitas, dan kedua spesifikasi mengatakannya begitu. Dokumentasi A2A menarik garis berdasarkan apa yang ada di ujung lain: MCP "defines how an AI agent interacts with and utilizes individual tools and resources, such as a database or an API", ketika tool menjalankan "specific, often stateless, functions"; A2A membahas agents, "more autonomous systems" yang "reason, plan, use multiple tools, maintain state over longer interactions, and engage in complex, often multi-turn dialogues". Ringkasannya sendiri adalah kalimat yang perlu diingat: "A2A is about agents partnering on tasks, while MCP is more about agents using capabilities."¹¹ Keduanya bersarang — aplikasi memakai A2A untuk menjangkau agents lain, dan setiap agent memakai MCP untuk menjangkau tool-nya sendiri. Chapter 25 menggambar garis itu di dalam satu proses, antara meminta sub-agent dan menyerahkan percakapan kepadanya; A2A menggambarnya di antara organisasi.

MCP dibanding ACP adalah perbandingan dengan premis yang sudah basi, dan justru itulah mengapa layak dijawab. Agent Communication Protocol dulunya standar terbuka terpisah untuk messaging agent-to-agent. Dokumentasinya sendiri sekarang dibuka dengan pemberitahuan: "ACP is now part of A2A under the Linux Foundation!"¹² Jawaban jujur untuk "MCP atau ACP?" pada September 2026 adalah bahwa pertanyaannya punya satu opsi lebih sedikit daripada yang disiratkan halaman-halaman yang ranking untuknya.

Dan perbandingan yang paling sering diminta orang, mcp vs api, punya jawaban paling tidak menarik: MCP adalah API. Yang ditambahkannya bukan power, melainkan conventions — kumpulan tetap method names, discovery call, hierarki kontrol atas primitive, dan model isolasi. Kamu menyerahkan kebebasan untuk mendesain interface sendiri dan mendapatkan setiap host yang berbicara protokol tersebut, trade yang selalu ditawarkan setiap protokol.

Sekarang kamu bisa membaca spesifikasi tanpa penerjemah, membedakan resource dari tool dari prompt berdasarkan siapa yang memegang kendali, mengetik request secara manual ketika client library berbohong, dan memberi tanggal pada artikel MCP mana pun yang kamu baca berdasarkan fitur deprecated mana yang masih diajarkannya sebagai current.

Yang belum kamu lakukan adalah mengirimkannya ke production. Chapter 27 menulis server yang sama dua kali — TypeScript dan Python, berdampingan, karena MCP adalah satu wilayah yang benar-benar bilingual dalam course ini dan angkanya mengatakan begitu di dua arah. Bab itu membahas dua transport live dengan benar, inspector, packaging, dan separuh protokol yang sengaja ditinggalkan bab ini: authorization. Karena begitu server kamu remote, bukan subprocess di laptop kamu sendiri, client milik orang asing akan menyodorkan token, dan aturan spesifikasi tentang apa yang boleh kamu lakukan dengannya luar biasa ketat.

Yang memunculkan pertanyaan yang harus dijawab bab berikutnya, dan ini bukan pertanyaan yang ramah: jika token tiba di server kamu dan token itu diterbitkan untuk audience milik orang lain, apa tepatnya yang menghentikan kamu untuk meneruskannya?

Setiap kutipan, method name, error code, dan aturan dalam bab ini dibaca dari spesifikasi Model Context Protocol, revisi 2026-07-28, pada 7 September 2026. Setiap trace diproduksi lokal di Node 22: toy calendar server adalah 101 baris tanpa dependency, dan server referensi adalah npm package yang dipublikasikan dengan nama di bawah. Tidak ada API berbayar yang dipanggil untuk menulis bab ini — tidak ada di sini yang membutuhkan model, dan itu sendiri adalah intinya.

Pengukuran: @modelcontextprotocol/server-everything@2026.8.31, dipublikasikan 31 Agustus 2026, dibangun di atas @modelcontextprotocol/sdk@1.30.0, dipublikasikan 27 Juli 2026 — satu hari sebelum revisi yang dijelaskan bab ini. Ia menjawab server/discover dengan -32601, menegosiasikan 2025-11-25 ketika diminta 2026-07-28, dan melayani tools/list tanpa handshake sama sekali. Katalognya berisi 13 tools dalam 7.663 byte; token count adalah o200k_base via tiktoken, atas name, description, dan inputSchema dari setiap definition, yaitu apa yang dirender provider ke prompt kamu dan bukan bobot JSON-RPC frame.

Anthropic, Code execution with MCP: building more efficient agents, 4 November 2025, adalah sumber angka 150.000-ke-2.000, dikutip dan digunakan di Chapter 24 dan hanya dirujuk di sini.