**JSON-RPC 2.0** is a tiny, generic standard for sending a request and getting a reply. It defines the shape of a message: a method name, some parameters, and an id so the reply can be matched to the request. That is all it does. It has no idea what an LLM is, what a tool is, or who is allowed to do what.
**MCP** (Model Context Protocol) uses JSON-RPC as its envelope, then adds the parts you would otherwise have to invent yourself. It defines a startup handshake where client and server tell each other what they support. It defines three typed things a server can offer: tools you can run, resources you can read, and prompts you can reuse.
MCP also defines a consent model, the host asks the user before running a risky tool. And it created a shared ecosystem, so one server works across many apps.
So MCP is not 'just RPC'. RPC is the wire format. MCP is the full contract for how AI apps and tool servers cooperate.
JSON-RPC 2.0 is only a message-framing standard. It defines how to dispatch a method and correlate a reply with a request. It says nothing about AI, tools, permissions, or discovery.
MCP reuses JSON-RPC as transport, then adds the layers that make it a real protocol. First, a lifecycle: an `initialize` and `initialized` handshake where the client and server negotiate capabilities and versions. Second, a typed primitive model. A server exposes tools (side-effectful calls), resources (read-only data by URI), and prompts (reusable templates), each with defined semantics. Third, a security and consent model, where the host gates tool calls behind user approval. Fourth, an interoperable ecosystem of thousands of servers and many clients.
Those four additions are the answer. Bare JSON-RPC gives you method dispatch and nothing else. You would still hand-build the handshake, the primitive types, the permission flow, and every integration.
The framing that lands in an interview is simple. JSON-RPC is the envelope; MCP is the etiquette, vocabulary, and trust model written on top. The transport is commodity. The contract is the product.
Quick reference
TL;DR
JSON-RPC is only the envelope. MCP adds a lifecycle handshake, typed Tools/Resources/Prompts primitives, a consent model, and a shared server ecosystem.
JSON-RPC is like the postal system: a standard way to put a request in an envelope, mail it, and get a reply back. That is useful, but it tells you nothing about what is inside the letters or how two strangers should start a conversation. MCP is the etiquette and shared vocabulary layered on top. It says how a client and server introduce themselves and agree on what each can do. It defines three kinds of things a server offers: actions to run, data to read, and templates to reuse. It says the user must approve risky actions. And because everyone follows the same etiquette, one server you build works with many different apps without rewiring.
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.
A closed single-app backend talking to its own internal services If there is no third-party tool story, plain JSON-RPC or REST avoids the lifecycle and primitive overhead MCP imposes.
A non-LLM service to service API with fixed, known endpoints MCP's discovery and consent layers exist for AI tool use; a conventional RPC contract is simpler when no model is choosing calls.
Ultra-low-latency in-process calls with a tight millisecond budget The handshake, process boundary, and JSON-RPC hop add overhead that a direct in-process function dispatch avoids.
Quick scan · 2–4 min
Everything important, quickly.
5 min: separate transport from protocol, then walk the four additions (lifecycle handshake, typed primitives, consent model, ecosystem) and close with the M+N integration payoff.
Real products, models, and research that use this idea.
1Claude Code, Cursor, and Zed all run the same community MCP servers unchanged because they share one wire contract.
2Anthropic's reference servers for filesystem, GitHub, Postgres, and Slack each speak the initialize handshake before exposing tools.
3The mcp.so directory and similar registries list thousands of MCP servers, which only interoperate because the protocol fixes lifecycle and primitive semantics.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhat exactly is negotiated during the initialize handshake, and why does it matter for compatibility?
Sign in or go Pro to see the approach for this follow-up.
QHow does the resources primitive let a host avoid a tool round-trip that bare RPC would force?
Sign in or go Pro to see the approach for this follow-up.
QWhere does MCP's consent model sit, and what threats does it try to contain?
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
Calling MCP a thin wrapper over JSON-RPC. The transport is reused, but the lifecycle, typed primitives, consent model, and ecosystem are what make it a protocol.