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.
**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.
Quick reference
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.
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.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Trying to bypass MCP by speaking raw JSON-RPC to a non-MCP service. JSON-RPC alone gives you no method discovery, no capability negotiation, and no AI-specific semantics. The MCP layer on top exists for those purposes.
Sending JSON-RPC batch requests to an MCP server. MCP discourages batching because it complicates streaming and partial-failure handling. Many servers do not implement it correctly.
Using JSON-RPC notifications for operations that require confirmation. Notifications are fire and forget by definition. If you need to know the operation succeeded, send a request with an id and wait for the response.
Quick scan · 2–4 min
Everything important, quickly.
4 min: define JSON-RPC 2.0 concisely, list the required request fields, name three MCP methods layered on top, explain the split (JSON-RPC owns the envelope, MCP owns the method set and lifecycle), and close with the JSON-RPC error vs MCP tool error distinction.
Real-world examples
Real products, models, and research that use this idea.
1MCP 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.
2Stdio 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.
3Streamable HTTP transport (replaced SSE in 2025) carries the same JSON-RPC 2.0 messages as stdio; the transport changed but the message shape stayed identical.
4Public MCP SDKs (TypeScript, Python, Kotlin, Go) all expose typed wrappers over JSON-RPC and let you intercept or log raw messages for protocol-level debugging.
Interviewer follow-ups
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?
Sign in or go Pro to see the approach for this follow-up.
QWhy did MCP pick JSON-RPC 2.0 instead of REST or gRPC?
Sign in or go Pro to see the approach for this follow-up.
QHow does JSON-RPC's transport independence let MCP support multiple transports without changes?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes 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.