What is the Model Context Protocol (MCP)?

MCP (Model Context Protocol) is an open-source standard for connecting AI applications to external systems. MCP introducted by Anthropic in November 2024, adopted by many AI companies including Google, OpenAI, Microsoft, etc. Using MCP, AI application like Claude, ChatGPT, Gemini,etc can connect and access datasources (local files, databases) and tools like (search engines, fetching external, APIs) and workflows (e.g. specialized prompts) enabling them to access key information and perform tasks.

Think of MCP like a USB-C port for AI applications. Just as USB-C provides a standardized way to connect electronic devices, MCP provides a standardized way to connect AI applications to external systems.

What can MCP enable?

1. Agents can access your Google Calendar and Notion, acting as a more personalized AI assistant by using MCP.
2. Enterprise chatbots can connect to multiple databases across an organization, empowering users to analyze data using chat.
3. Access external data — read files, databases, Google Drive, Notion, etc.
4. Use tools — search the web, run code, query APIs
5. Take actions — send emails, create calendar events, manage tasks
6. Connect to local systems — interact with your file system, terminal, or local apps
7. Integrate services — GitHub, Postgres,and social media accounts like whatsapp, instagram, facebook, twitter, etc.

Why does MCP matter?

Depending on where you sit in the ecosystem, MCP can have a range of benefits.

• Developers: MCP reduces development time and complexity when building, or integrating with, an AI application or agent.
• AI applications or agents: MCP enables AI applications or agents to access external systems and tools, allowing them to perform tasks that they would not be able to perform on their own.
• Businesses: MCP enables businesses to integrate their AI applications with their existing systems, allowing them to leverage the power of AI to improve their operations.
• Users: MCP enables users to access the power of AI to improve their lives, allowing them to perform tasks that they would not be able to perform on their own.

MCP Architecture

Concepts of MCP

1. Participants:

MCP follows a client-server architecture where an MCP host establish connection between one or more MCP servers. The MCP host accomplishes this by creating one MCP client for each MCP server. Each MCP client maintains a dedicated connection with its corresponding MCP server. Local MCP servers that use the STDIO (Standard Input/Output) transport typically serve a single MCP client, whereas remote MCP servers that use the Streamable HTTP transport will typically serve many MCP clients.

    - **Key Participants**: 
    The key participants in the MCP architecture are:
    1. **MCP Host**: The AI application that coordinates and manages one or multiple MCP clients
    2. **MCP Client**: A component that maintains a connection to an MCP server and obtains context from an MCP server for the MCP host to use
    3. **MCP Server**: A program that provides context to MCP clients        

2. Layers:

• Data layer(Internal Layer): Defines the JSON-RPC based protocol for client-server communication, including lifecycle management, and core primitives, such as tools, resources, prompts and notifications. Primitives of data layer are tools, resources, prompts and notifications.
• Transport layer(External Layer): Defines the communication mechanisms and channels that enable data exchange between clients and servers, including transport-specific connection establishment, message framing, and authorization.

DATA LAYER

TRANSPORT LAYER

MCP Client

What is an MCP Client?

An MCP Client is a component that lives inside the MCP host and acts as the bridge between the AI application and an MCP server. The host creates one dedicated MCP client per MCP server, and each client maintains a persistent, stateful connection to its corresponding server throughout the session.

Role of the MCP Client

The MCP client is responsible for:

1. Connection management — Initiating, maintaining, and gracefully terminating the connection to the MCP server using the appropriate transport (STDIO for local servers, Streamable HTTP for remote servers).
2. Capability negotiation — During the initialization handshake, the client exchanges capability declarations with the server so both sides know what features (tools, resources, prompts, sampling, etc.) are supported.
3. Message routing — Forwarding requests from the host to the correct server and returning responses back to the host.
4. Context retrieval — Fetching tools, resources, and prompts from the MCP server so the host (AI application) can use them when generating responses.
5. Lifecycle management — Handling connection errors, reconnections, and clean shutdowns.

How the MCP Client Works

When the MCP host starts up, it reads its configuration to discover which MCP servers to connect to. For each server, it spins up a dedicated MCP client that:

1. Establishes a transport-level connection to the server (e.g., spawns a local process via STDIO or opens an HTTP stream to a remote endpoint).
2. Performs an initialization handshake — sends an initialize request containing the client’s protocol version and capabilities, and receives the server’s protocol version and capabilities in return.
3. Sends a notifications/initialized message to signal that the client is ready.
4. Begins sending requests (e.g., tools/list, tools/call, resources/read, prompts/get) on behalf of the host as needed.

MCP Host
   │
   ├── MCP Client A  ──── (STDIO) ────► Local MCP Server (e.g., file system)
   │
   └── MCP Client B  ──── (HTTP) ─────► Remote MCP Server (e.g., GitHub API)

MCP Client Capabilities

During initialization, an MCP client may declare support for:

---

MCP Server

What is an MCP Server?

An MCP Server is a lightweight program that exposes context — tools, resources, and prompts — to MCP clients over the Model Context Protocol. Servers act as the integration point between the AI application and external systems such as databases, APIs, file systems, and third-party services.

A server can be:

• Local — Runs on the same machine as the host, communicates over STDIO.
• Remote — Runs on a separate machine or cloud endpoint, communicates over Streamable HTTP.

Role of the MCP Server

The MCP server is responsible for:

1. Exposing primitives — Declaring and serving the tools, resources, and prompts that MCP clients can discover and use.
2. Handling requests — Processing incoming JSON-RPC requests (e.g., tools/call, resources/read) and returning well-formed responses.
3. Maintaining security boundaries — Each server operates in its own process or environment, isolating access to the external system it wraps.
4. Sending notifications — Proactively notifying connected clients about changes (e.g., a resource has been updated).

MCP Server Primitives

MCP servers expose three core primitives that clients can discover and consume:

How the MCP Server Works

Once the initialization handshake with a client is complete, the server:

1. Responds to tools/list requests by returning a list of available tools with their names, descriptions, and input schemas (JSON Schema).
2. Executes tools/call requests by running the requested tool with the provided arguments and returning the result.
3. Responds to resources/list and resources/read requests by returning available data sources and their contents.
4. Responds to prompts/list and prompts/get requests by returning available prompt templates.
5. Sends notifications to clients when relevant state changes occur (e.g., notifications/tools/list_changed).

MCP Client  ──── tools/list ────────────────► MCP Server
            ◄─── [{ name, description, ... }] ──
            ──── tools/call { name, args } ───►
            ◄─── { result } ──────────────────

MCP Server Capabilities

During initialization, an MCP server may declare support for:

Local vs. Remote MCP Servers