MCP Fundamentals

Goal

Understand the Model Context Protocol (MCP) architecture to solve the "$N \times M$" integration problem, decoupling AI models from the specific implementation details of external tools.

Core Architectural Components

1. The Host (The Application)

• Definition: The container application (e.g., a desktop app, IDE, or agent platform) that manages the user experience and orchestrates tool usage.
• Responsibilities:

Creating and managing MCP clients. Enforcing security policies and content guardrails. * Managing the user interaction lifecycle.

2. The Client (The Connector)

• Definition: A software component embedded within the Host that maintains a 1:1 connection with a specific Server.
• Responsibilities:

Issuing commands to the server. Receiving and processing responses or notifications. * Managing the session lifecycle.

3. The Server (The Provider)

• Definition: A standalone program that exposes capabilities (Tools, Resources, Prompts) to the AI application.
• Responsibilities:

Tool Discovery: Advertising what tools are available. Execution: Receiving commands and running the actual logic/API calls. * Formatting: Returning standardized results to the client.

The Communication Layer

Protocol: JSON-RPC 2.0

All communication is text-based and language-agnostic, relying on four standard message types:

1. Requests: Calls expecting a response (e.g., tools/call).
2. Results: Successful responses containing data.
3. Errors: Failure messages with codes and descriptions.
4. Notifications: One-way messages requiring no response (e.g., logging).

Transport Mechanisms

• stdio (Standard Input/Output):

Use Case: Local, private tools. Mechanism: The Host spawns the Server as a subprocess and communicates via standard I/O pipes. Best for accessing local files or scripts.

• Streamable HTTP (SSE):

Use Case: Remote or distributed tools. Mechanism: Uses Server-Sent Events (SSE) for streaming responses, allowing connections to remote services over standard HTTP.