Understanding Model Context Protocol (MCP): Architecture, Core Components, and Practical Guide

Model Context Protocol (MCP) is an open standard introduced by Anthropic in November 2024 that lets large language models (LLMs) communicate safely and controllably with external tools, files, and services, turning AI from a pure conversational agent into an executable assistant.

MCP Overview

MCP acts as a universal translator for AI, providing standardized, bidirectional communication. It consists of three core components:

MCP Host : the application that interacts with the AI (e.g., Claude Desktop).

MCP Server : a small program offering specific capabilities such as file access or API calls.

MCP Client : the bridge that connects the host and server, handling message routing.

Why MCP vs. Traditional API

Feature

API

MCP

MCP Advantage

Security

Developer‑implemented, inconsistent

Standardized access control with explicit user consent

More secure and controllable

Communication

Typically one‑way data fetch

Bidirectional, can manipulate data

Richer functionality

AI Optimization

Raw data, requires extra processing

AI‑friendly tools and prompts

Easier for LLMs to consume

Flexibility

Remote‑service oriented, network dependent

Supports local and remote resources

Broader applicability

Integration Complexity

Custom code per service

Unified protocol, plug‑and‑play

Simpler development

Two‑Way Interaction Example

# MCP tool definition example
@server.call_tool()
async def handle_call_tool(name, args):
    if name == "book_meeting":
        # Step 1: query calendar slots
        slots = get_calendar_slots(args["duration"])
        # Step 2: generate time picker options
        return show_time_picker(slots)
        # Step 3: receive user choice and create meeting
        confirm_selection(args["time"])

Architecture Details

MCP follows a client‑server model with three layers:

1. Protocol Layer

Defines message frames, request/response linking, and advanced communication patterns. Core classes include Protocol , Client , and Server . Example:

class Protocol<Request, Notification, Result> {
  request<T>(request: Request, schema: T): Promise<T>; // send request, await response
  notification(notification: Notification): Promise<void>; // send one‑way notification
}

2. Transport Layer

Supports two mechanisms: standard I/O for local processes and HTTP with Server‑Sent Events (SSE) for remote communication. All transport uses JSON‑RPC 2.0 for uniform message formatting.

3. Message Types

Request : expects a response, e.g., { method: "getWeather", params: { city: "Beijing" } }

Notification : one‑way message, e.g., { method: "logEvent", params: { event: "start" } }

Result : successful response, e.g., { temperature: 25 }

Error : failure response, e.g., { code: -32602, message: "Invalid params" }

Connection Lifecycle

Initialize : client sends initialize request with protocol version and capabilities; server replies with supported features.

Ready : client sends initialized notification, establishing a ready state.

Message Exchange : regular request/response and notifications flow.

Terminate : either side calls close() or drops the transport.

Error Handling

MCP defines standard error codes such as ParseError (-32700) and InvalidRequest (-32600) , with the ability to add custom codes for consistent handling.

Advantages

Standardized JSON‑RPC communication.

Plug‑and‑play servers reduce integration effort.

Resource management enables servers to expose files, tools, and templates.

Practical Applications

Typical use‑cases include file management, information retrieval from local documents, communication assistance (e.g., drafting Slack messages), and accessing web services such as weather or news.

Quick Start Guide

Install Claude Desktop from Claude.ai/download .

Install Node.js from nodejs.org .

Configure an MCP server. Example configuration:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/
/Documents"]
    }
  }
}

Edit claude_desktop_config.json to point to the server, restart Claude Desktop, and test by asking the AI to organize files.

Conclusion

MCP gives AI agents the ability to safely access files, applications, and web services, turning them from talkers into doers. Its standardized, extensible design encourages community contributions, promising smarter and more practical AI assistants in the future.