What Is Model Context Protocol (MCP) and How It Transforms LLM Applications

What Is Model Context Protocol (MCP)?

Model Context Protocol (MCP) is a new open protocol designed to standardize the way large language models (LLMs) receive application context and data from external sources. It can be thought of as the "USB‑C" of AI, providing a uniform interface for models to connect to tools, APIs, and resources.

Why Use MCP?

Before MCP, each LLM application had to implement its own prompt‑wrapping and tool‑calling logic, which made extending functionality cumbersome. MCP abstracts this engineering layer, allowing developers to focus on the model’s capabilities and the external functions they need, while the protocol handles prompt construction, function calling, and data flow.

How MCP Works

MCP consists of three main components: MCP host , MCP client , and MCP server . The host initiates calls, the client formats requests, and the server provides three types of services:

Resources : data such as API responses or file contents that the client can read.

Tools : functions that the LLM can invoke (with user approval).

Prompts : pre‑written templates that guide the model to complete specific tasks.

The host uses the client to invoke server‑provided tools, and the model’s function_call capability automatically generates the required arguments based on context.

Implementation Example (Python)

Below is a minimal Python example that demonstrates a simple MCP server for querying 12306 train tickets. The server defines tools such as local_time and query_train_tickets, and uses the FastMCP library to expose them.

from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("12306")

@mcp.tool()
async def local_time() -> str:
    """Get the local time of the machine."""
    import datetime
    return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")

@mcp.tool()
async def query_train_tickets(train_date: str, from_station: str, to_station: str, purpose_codes: str) -> Any:
    """Query train tickets for a given date and stations."""
    if not purpose_codes:
        purpose_codes = "ADULT"
    url = "https://kyfw.12306.cn/otn/leftTicket/queryR"
    params = {
        "leftTicketDTO.train_date": train_date,
        "leftTicketDTO.from_station": from_station,
        "leftTicketDTO.to_station": to_station,
        "purpose_codes": purpose_codes,
    }
    async with httpx.AsyncClient() as client:
        resp = await client.get(url, params=params)
        resp.raise_for_status()
        data = resp.json()
        # ...process and return simplified ticket info...
        return data

if __name__ == "__main__":
    mcp.run(transport='stdio')

The server can be started with mcp.run(), and the host configuration is a simple JSON mapping that tells the MCP host which server command to execute.

{
  "mcpServers": {
    "12306": {
      "command": "uv",
      "args": ["--directory", "<path-to-server>", "run", "12306.py"]
    }
  }
}

Benefits and Trade‑offs

MCP reduces the complexity of building AI agents by separating the concerns of calling external APIs and implementing those APIs . Developers only need to write the server‑side functions once; any agent can reuse them via the standard protocol. The trade‑off is that the ecosystem relies on multiple vendors providing compatible MCP servers.

Comparison with Other Standards

Unlike the Language Server Protocol (LSP), which is passive and driven by IDE requests, MCP is designed for autonomous AI workflows. It lets the model decide which tools to use, in what order, and allows human approval for sensitive actions.

Future Outlook

Originally created by Anthropic, MCP is now an open protocol adopted by many companies. As more MCP servers become available, end users will be able to install them like apps, while agent developers focus on optimizing host‑side orchestration.