MCP Transport

The MCP specification is decoupled from any specific network protocol. The core protocol—JSON-RPC messages for requests, responses, and notifications—is designed to work over multiple transport layers. This separation allows the same logical operations (e.g., resources/list, tools/call) to be executed whether the server is a local process or a remote web service, ensuring consistent semantics across different deployment environments.

All MCP transports must support full-duplex communication, allowing both the client and server to initiate messages. The client sends requests (e.g., tools/call), and the server sends back responses. Critically, the server can also send unsolicited notifications to the client, such as notifications/resources/updated to signal that a resource's content has changed, enabling real-time context updates without polling.

A local process transport where the client spawns the server as a subprocess. Communication occurs via the standard input (stdin) and standard output (stdout) streams.

• Characteristics: Simple, synchronous, and process-bound. Ideal for integrating with local scripts, command-line tools, and filesystem access.
• Framing: JSON-RPC messages are delimited by newline characters (\n).
• Use Case: A code assistant client connecting to a server that reads project files or runs linters directly on the host machine.

An HTTP-based, streaming transport where the client opens a long-lived HTTP connection to the server. The client sends requests via HTTP POST, and the server pushes messages (responses, notifications) over the SSE channel.

• Characteristics: Enables remote, web-hosted servers. Communication is inherently asynchronous.
• Framing: Uses the standard SSE data: field format to carry JSON-RPC messages.
• Use Case: A cloud-based AI agent connecting to a remote enterprise API gateway server that provides company-specific tools.

Each transport must define a clear framing mechanism to delineate where one JSON-RPC message ends and the next begins, as the underlying stream is continuous.

• Stdio: Uses the newline-delimited JSON (NDJSON) convention (\n).
• SSE: Uses the data: field of an SSE event; a double newline (\n\n) signals the end of an event.
• This framing is crucial for reliable parsing, preventing malformed or concatenated JSON objects.

The transport manages the session lifecycle.

• Initialization: Begins with a handshake (initialize request/response) for capability negotiation.
• Healthy State: A ping/pong exchange may be used for keep-alive checks, especially over network transports.
• Termination: Ends with a shutdown request or transport closure. State (like connection pools) is not preserved across sessions; each new connection is a fresh session.

JSON-RPC is the lightweight remote procedure call protocol that defines the message format for all communication in MCP. Every request, response, and notification is a JSON object with a standard structure, enabling stateless and language-agnostic interoperability.

• Core Structure: Messages contain fields like jsonrpc, method, params, id, and result/error.
• Transport Agnostic: The same JSON-RPC protocol is used over stdio, SSE, or any other transport layer.
• Example: A tool invocation is a JSON-RPC request where the method is tools/call and params contains the tool name and arguments.

Stdio Transport is a communication method where the MCP client and server exchange JSON-RPC messages over standard input (stdin) and standard output (stdout) streams. This is the most common transport for local, script-like integrations.

• Local Execution: The client typically spawns the server as a subprocess, connecting their stdin/stdout pipes.
• Simplicity & Isolation: No network ports are required, providing a simple and secure sandbox for local tools.
• Use Case: Ideal for wrapping command-line utilities, local scripts, or database clients where the server runs on the same machine.

SSE (Server-Sent Events) Transport is a communication method where the client establishes a long-lived HTTP connection to a remote server, which can asynchronously push JSON-RPC messages as discrete events.

• Client-Server Model: The client acts as an HTTP client, connecting to a server running a web service.
• Unidirectional Push: The server can send notifications (e.g., resource updates) to the client at any time without a request.
• Use Case: Essential for web-hosted MCP servers, remote data sources, or scenarios where the server needs to proactively notify the client of changes.

Message Framing is the technique for delimiting individual JSON-RPC messages within a continuous byte stream, ensuring the client and server can reliably parse where one message ends and the next begins.

• Newline-Delimited JSON (NDJSON): Used in stdio transport, where each message is a single JSON object followed by a newline (\n) character.
• SSE Format: Used in SSE transport, where each message is sent as an SSE event with a data field containing the JSON-RPC object.
• Critical Function: Without proper framing, concatenated JSON objects become unparsable, breaking the protocol.

Capability Negotiation is the initial handshake process where an MCP client and server exchange their supported protocol features upon connection, establishing a contract for the session.

• Initialization Exchange: The client sends an initialize request; the server responds with its protocol version and the capabilities it supports (e.g., which resource/tool/prompt methods it implements).
• Client Declaration: The client also declares which capabilities it intends to use.
• Purpose: Ensures compatibility and prevents errors by confirming both parties agree on available functionality before any operations are attempted.

Connection Pooling is a performance optimization where an MCP client maintains a cache of active, reusable connections to MCP servers, avoiding the overhead of establishing a new transport session for each interaction.

• Reduced Latency: Reusing a connection eliminates the cost of process spawning (stdio) or TCP/HTTP handshakes (SSE).
• Resource Management: The pool manages a set number of connections, handling creation, health checks, and graceful teardown.
• Architectural Impact: Critical for high-performance clients that make frequent, rapid calls to the same set of servers, common in production agentic workflows.