Why did MCP pick JSON-RPC 2.0 as its wire format instead of REST or gRPC?

Flashcard·Easy·4.0 · 0·~30s·Asked atCopy Ai Doordash Typeface·Relevant atAnthropic

Attempt it

JSON-RPC 2.0 is a minimal RPC protocol where every message is a JSON object with jsonrpc: "2.0", a method string, a params payload, and (for requests) an id for correlation. MCP chose it because it is transport-independent (the same messages work over stdio and streamable HTTP), human-readable for debugging, trivial to implement in any language, and already has clean request/response/notification semantics. MCP then layers its AI-specific concerns on top: the method set (initialize, tools/list, tools/call, resources/read, prompts/get), the lifecycle, capability negotiation, and the security model.

Your answer

**JSON-RPC 2.0** is a small, text-based remote procedure call protocol where every message is a JSON object. The full spec is short enough to memorize. A request has four fields: `jsonrpc: "2.0"` (the version string), `method` (a string naming the operation), `params` (the arguments), and `id` (a string or number the receiver echoes back in the response so the sender can match it). A response has `jsonrpc: "2.0"`, the matching `id`, and either `result` (success) or `error` (failure with a numeric code and message). A notification looks like a request but drops the `id`, meaning no reply is expected. MCP picked JSON-RPC 2.0 as its wire format rather than inventing a new one. Every MCP operation is a JSON-RPC method. `initialize` is a request. `tools/list` is a request. `tools/call` is a request. `notifications/initialized` is a notification. The split of responsibilities is clean. JSON-RPC defines the message envelope, the request/response/notification pattern, and the standard error codes. MCP defines what methods exist, what each one does, what params and results look like, the initialize then negotiate lifecycle, and the security model. MCP reused a well-established wire format and focused its original work on the AI-specific concerns.

**JSON-RPC 2.0** is a lightweight RPC protocol where every message is a JSON object with a fixed shape: `jsonrpc: "2.0"`, a `method` string, a `params` payload, and (for requests) an `id` for correlating responses. Responses carry the matching `id` plus a `result` on success or an `error` object on failure. Notifications omit the `id` and signal that no reply is expected. MCP chose JSON-RPC 2.0 because it is transport-independent, human-readable, trivially implementable in any language, and already provides clean semantics for requests, responses, and one-way signals. This let the MCP designers skip wire-format design entirely and focus on the AI-specific contract. The method set MCP layers on top includes `initialize`, `tools/list`, `tools/call`, `resources/list`, `resources/read`, `prompts/list`, `prompts/get`, `ping`, and notifications like `notifications/initialized`, `notifications/tools/list_changed`, and `notifications/progress`. The slash-based naming is convention; JSON-RPC imposes no naming rules. JSON-RPC supplies the envelope, the `id` correlation mechanism, the success/error/notification semantics, and the numeric error codes (`-32601` method not found, `-32602` invalid params). MCP supplies the methods, the lifecycle (initialize first, then capabilities exchange, then operate), the content-block result shape, and the security model. JSON-RPC also gives MCP transport independence for free: the same messages flow over stdio for local subprocess servers and over streamable HTTP for remote servers without changing the protocol. The practical line for interviews: MCP is JSON-RPC 2.0 plus a defined method set plus a lifecycle plus capability negotiation plus transports. The wire format is borrowed; the AI-specific contract is what MCP contributes.

TL;DR

JSON-RPC 2.0 gives MCP a lightweight, transport-independent message envelope with built-in request/response/notification semantics. MCP layers its method set and lifecycle on top.

Memory aid

Easy to grasp

Imagine sending a sticky note to a coworker asking them to do something. The note has a fixed layout: a version number, a verb (what you want done), a details section, and a tracking number so the reply can be matched back. JSON-RPC 2.0 is that sticky-note format, written as JSON. MCP is a set of agreed-upon verbs written on those notes: 'list the tools you have,' 'call this tool with these arguments,' 'read this resource.' The note format is JSON-RPC. The verbs are MCP.

Key concepts

JSON-RPC 2.0 Wire Format Remote Procedure Call

Concept explanation~2 min read

Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.

JSON-RPC 2.0 is a plain-text remote procedure call standard published in 2010, over a decade before MCP existed. MCP picked it as its wire format and layered an AI-specific method set, lifecycle, and capability model on top.

Understanding this layering is the difference between debugging an MCP issue at the correct level and chasing the wrong layer. This explanation pins down what JSON-RPC 2.0 is, what fields appear in each message, what role each plays in MCP, and where the boundary between the two specs runs.

JSON-RPC 2.0 in five fields

The entire spec fits on one page. Every message is a JSON object.

Requests carry four fields: jsonrpc: "2.0" (version string, always required), method (string naming the operation), params (arguments as an object or array), and id (string or number for correlating the response). The id is the correlation mechanism. A client can have many requests in flight simultaneously; responses come back with the matching id and the client routes each one to the right caller.

Responses carry three fields: jsonrpc: "2.0", the matching id, and either result on success or error on failure. Exactly one of result or error is present. The error object has a numeric code, a string message, and an optional data field. JSON-RPC defines five standard codes: -32700 parse error, -32600 invalid request, -32601 method not found, -32602 invalid params, -32603 internal error. Servers can define additional codes outside the reserved range.

Notifications are requests without an id. The sender does not expect a reply and the receiver does not send one. They are fire and forget, useful for one-way signals where confirmation is unnecessary.

Three message shapes, five required fields across them, five standard error codes. That is everything JSON-RPC contributes to MCP: an envelope, a correlation mechanism, and an error vocabulary.

What MCP layers on top of JSON-RPC

Transport independence inherited from JSON-RPC

Debugging at the right layer

Situations where this technique stops working.

2–4 min · Everything important, quickly.

Real products, models, and research that use this idea.

MCP Inspector and the @modelcontextprotocol/inspector CLI show raw JSON-RPC frames so you can verify the version field, method name, id correlation, and result/error split while debugging a server.
Stdio MCP servers (filesystem, sqlite, git) emit newline-delimited JSON-RPC 2.0 messages on stdout, which you can pipe through jq to read by hand during development.

What an interviewer would ask next. Try answering before peeking at the approach.

QWalk through a JSON-RPC 2.0 error object. How does it differ from an MCP tool error?

JSON-RPC error: numeric code, string message, optional data. Standard codes include -32700 parse, -32601 method not found, -32602 invalid params. MCP tool error: a successful JSON-RPC response whose result.content describes a failure and result.isError is true. The model sees tool errors and can react; JSON-RPC errors mean the host and server are out of contract.

2 more follow-ups an interviewer would ask next. Sign in to reveal them.

Red flags & common mistakes

The phrases that signal junior thinking. Click to expand.

Most common mistake

Describing MCP as a brand new protocol built from scratch. MCP reuses JSON-RPC 2.0 as its wire format and layers an AI-specific method set, lifecycle, and capability model on top.

60 second bullets to scan on the way to the call.

State that JSON-RPC 2.0 is the wire format MCP uses.
List the required request fields: jsonrpc, method, params, id.

Primary sources. Browse if you want the original framing.