MCP (Model Context Protocol) の内部仕様を深掘り：JSON-RPC 2.0とStreamable HTTPを用いたClient-Server通信の実践 This article dives into the internal specifications of the Model Context Protocol (MCP), e…

As LLMs move from research into production, integrating them with external APIs, databases, and tools has become a central engineering challenge. The traditional approach — wiring each model directly to each external system — creates tight coupling that quickly becomes a maintenance burden. The Model Context Protocol (MCP), introduced by Anthropic, attempts to solve this with a standardized protocol layer sitting between AI clients and the tool servers they consume.

At the heart of MCP's communication design is JSON-RPC 2.0, a lightweight remote procedure call specification that defines a consistent structure for requests, responses, and error handling. By adopting this well-understood standard rather than inventing a proprietary wire format, MCP ensures that clients and servers can be implemented in any language without needing to negotiate message structure. The simplicity of JSON-RPC also makes debugging and logging straightforward — a meaningful advantage when building AI systems where observability is still an open problem.

The transport layer has evolved alongside the protocol. Earlier MCP implementations relied on Server-Sent Events (SSE) for streaming, but the newer Streamable HTTP transport is gaining traction as the preferred approach. Streamable HTTP allows a single HTTP connection to carry both standard request-response exchanges and streaming responses from server to client, making it well-suited for tool calls that produce incremental or long-running results. This matters in practice when, for example, an MCP server wraps a code execution environment or a slow external API.

The communication lifecycle follows a clear pattern: the client and server perform an initialization handshake, the client retrieves the server's tool definitions (expressed as JSON Schema), and from there the LLM host can build tool-aware context for the model. When the model decides to invoke a tool, the client dispatches a JSON-RPC request to the appropriate MCP server, receives the result, and feeds it back into the model's context. This loop can repeat multiple times within a single agent turn.

The broader MCP ecosystem has grown considerably since the specification's release. Claude Desktop, Cursor, and several VS Code extensions now function as MCP clients, and official SDKs for Python and TypeScript lower the barrier for building compliant servers. The open specification has also sparked a wave of community-built MCP servers covering everything from web search to database access to code execution. Other major AI providers have their own tool-use and function-calling conventions, but MCP's open, transport-agnostic design gives it a reasonable shot at becoming a de facto interoperability layer — though how broadly it will be adopted outside the Anthropic ecosystem remains to be seen.

For engineers building production AI agents, understanding MCP's internal mechanics — how initialization works, how tool schemas are validated, and how errors propagate over JSON-RPC — is becoming a practical necessity rather than a niche curiosity. Articles like this one serve as a useful reference for anyone moving beyond "hello world" MCP integrations toward systems that need to be robust, debuggable, and maintainable.