Protocol Details

Understanding how MCP components communicate with each other

MCP Communication Protocol

MCP uses a standard communication format called JSON-RPC 2.0 to enable clients and servers to talk to each other. Don't worry if you're unfamiliar with this - as a user or basic implementer, you won't need to work with these details directly.

This page explains the technical underpinnings of MCP. If you're just getting started, you may want to begin with the Quick Start Guide instead.

How MCP Components Talk to Each Other

At its core, MCP is just a standardized way for different pieces of software to communicate:

Message Types

MCP uses three main types of messages:

1. Requests

Messages sent from a client to a server asking for something, like "list all available tools".

2. Responses

Messages sent from a server back to a client answering a request, like "here are all my available tools".

3. Notifications

One-way messages that don't expect a reply, like "just letting you know a resource has been updated".

Message Format

All MCP messages use JSON format, which is a standard way to structure data. Here's what typical messages look like:

{
  "jsonrpc": "2.0",
  "id": "msg123",
  "method": "tools/list",
  "params": {}
}

This message is asking the server to list all available tools.

Each request has a unique "id" that lets the client match responses to the original requests. Notifications don't have an "id" because they don't expect a response.

Connection Process

When a client connects to an MCP server, they follow this standard handshake:

Initialize

The client introduces itself and shares what capabilities it supports

{
  "jsonrpc": "2.0",
  "id": "init1",
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-04-26",
    "capabilities": {
      "resources": {},
      "tools": {}
    }
  }
}

Server Responds

The server replies with its own information and capabilities

{
  "jsonrpc": "2.0",
  "id": "init1", 
  "result": {
    "protocolVersion": "2025-04-26",
    "serverInfo": {
      "name": "example-server",
      "version": "1.0.0"
    },
    "capabilities": {
      "resources": {
        "supports": ["list", "read"]
      },
      "tools": {
        "supports": ["list", "call"]
      }
    }
  }
}

Begin Communication

After initialization, normal requests and responses can flow between client and server

Transport Methods

MCP can work over different "transport methods" - ways of moving messages between client and server:

Standard I/O (stdio)

  • Used when the server runs as a local process on your computer
  • Messages are passed through the standard input/output streams
  • Ideal for local communication where the client launches the server

Server-Sent Events (SSE) over HTTP

  • Used for network communication over the internet
  • Client sends messages using HTTP requests
  • Server sends responses and notifications using Server-Sent Events
  • Good for remote servers or when the client and server are on different machines

Development Tools

When developing with MCP, these tools can help you understand the protocol better:

  1. MCP Inspector: A tool that helps you connect to and test MCP servers
  2. Browser Developer Tools: For debugging SSE connections
  3. Terminal and Log Files: For monitoring stdio connections

The MCP SDK handles most of these protocol details automatically, so you don't need to craft JSON-RPC messages manually in most cases.

How is this guide?

On this page