Core

1. Core Architecture

MCP uses a structured three-tier model to separate the AI's reasoning from the technical execution of tools.

The Three Components:

Host: The primary application (e.g., Claude Desktop, Cursor, or a custom IDE) that the user interacts with.
Client: A component within the Host that manages the connection, security, and protocol negotiation with the server.
Server: A lightweight, specialized service that exposes specific data (Resources), logic (Tools), or context (Prompts) to the AI.

2. Server Implementation (Python)

The FastMCP SDK provides a high-level abstraction for building servers quickly.

Defining a Server and Tool:

Tools allow the LLM to perform actions, such as querying a database or interacting with a local API.

from mcp.server.fastmcp import FastMCP
# 1. Initialize the FastMCP server instance
mcp = FastMCP("SystemManager")
# 2. Define a tool using the @mcp.tool decorator
@mcp.tool()
def get_system_info(category: str) -> str:
\"\"\"Provides system-specific metadata.\"\"\"

return f"Data for {category}"

Tool

3. The Communication Layer: JSON-RPC

MCP relies on JSON-RPC 2.0 for all messaging. This ensures that every request from the client and every response from the server follows a strict, predictable format.

Communication Layer

4. Transport Mechanisms

To move JSON-RPC messages between the Client and Server, MCP defines two primary "pipes" or transport layers:

A. Standard I/O (stdio)

Used primarily for local integrations where the server runs as a subprocess.

No Network Configuration: Ideal for local development and desktop apps.
Subprocess Lifecycle: The server starts when the client connects and terminates when the client exits.

Standard I/O

B. Streamable HTTP (SSE)

Used for remote or networked servers.

Server-Sent Events (SSE): The server sends events to the client.
HTTP POST: The client sends commands back to the server.
Scalability: Allows the AI to connect to tools hosted in the cloud.

SystemManager