D2 · Tool Design & MCP › Cluster 5 · MCP Fundamentals

5.1 · What MCP Is & Why It Exists

The USB-C port for AI

CONCEPT An open standard for connecting LLM apps to the world

The Model Context Protocol (MCP) is an open standard for connecting AI applications to external systems — data sources (files, databases), tools (search, calculators), and workflows (specialized prompts). The official docs put it plainly: "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."

Before MCP, every AI app wired up every integration by hand: this chatbot's GitHub connector, that IDE's database connector, each a bespoke one-off. MCP replaces that N×M tangle with a single wire format. Build a server once, and any MCP-compatible host — Claude Desktop, Claude Code, VS Code, Cursor, ChatGPT — can use it.

🔑 MCP is a protocol, not a product or an SDK. It defines the messages two programs exchange. SDKs (Python, TypeScript, …) are convenience wrappers over that protocol.

CONCEPT Built on JSON-RPC 2.0

Under the hood, MCP is a JSON-RPC 2.0 exchange. Clients and servers send each other requests (which expect a response, carrying an id), responses (matched to a request by that id), and notifications (fire-and-forget, no id, no response). That's the entire message vocabulary — everything MCP does rides on those three shapes.

What MCP isWhat MCP is not
An open, versioned protocol specA specific product or vendor API
A JSON-RPC 2.0 message formatA new network transport it invented
A way to expose tools, resources, promptsA rule for how the LLM must use them
Reusable across any compatible hostTied to one app or one model vendor
The spec is explicit about its narrow scope: "MCP focuses solely on the protocol for context exchange — it does not dictate how AI applications use LLMs or manage the provided context." MCP delivers the tools; the host decides what to do with them.

DIAGRAM One protocol replaces N×M wiring

flowchart LR subgraph BEFORE["❌ Before MCP: hand-wired N×M"] A1["Chatbot"] --> G1["GitHub glue"] A2["IDE"] --> G2["GitHub glue #2"] A3["Agent"] --> G3["GitHub glue #3"] end subgraph AFTER["✅ With MCP: one server, reused"] H1["Claude Desktop"] --> S["GitHub
MCP server"] H2["Claude Code"] --> S H3["VS Code / Cursor"] --> S end classDef ok fill:#d4edda,stroke:#28a745,color:#155724; classDef bad fill:#f8d7da,stroke:#dc3545,color:#721c24; class S ok; class G1,G2,G3 bad;

CODE A JSON-RPC 2.0 request / response pair

MCP's whole wire language is JSON-RPC. Here a client discovers the tools a server exposes — a tools/list request, answered by a matching response (note the shared "id": 1).

// Client → Server : a JSON-RPC 2.0 request (expects a response)
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list"
}

// Server → Client : the matching response (same id)
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      { "name": "get_weather",
        "description": "Get current weather for a location",
        "inputSchema": { "type": "object", "properties": { "location": { "type": "string" } } } }
    ]
  }
}

TRADE-OFFS Adopting a protocol vs. rolling your own glue

✅ MCP (shared protocol)

  • Write a server once → reuse across every compatible host
  • Standard discovery, framing, and lifecycle — no bespoke wire format
  • Growing ecosystem of ready-made servers to drop in

⚠️ Custom per-app integrations

  • Total control, zero external dependency
  • But: every host × every tool is a fresh integration to build & maintain
  • No interoperability — your glue works only in your app
Reach for MCP when a capability should be reusable across hosts or shared with others. Keep a private in-process function when it's a one-off that only your single app will ever call.

EXAM TRAPS

Trap: "MCP is an Anthropic-only feature." → MCP is an open standard supported across many hosts (Claude, ChatGPT, VS Code, Cursor, …). Any compatible client can use any compliant server.
Trap: "MCP replaces the model's tool-use ability." → It doesn't. MCP standardizes how tools/data are exposed; the host still runs the LLM and decides when to call them. The spec explicitly does not dictate how the app uses the model.
Trap: "MCP defines its own network protocol." → No — it's JSON-RPC 2.0 over standard transports (stdio, Streamable HTTP). MCP reuses existing plumbing.
Trap: "USB-C" means MCP moves bytes like a cable. → The analogy is about a standardized connector: one shape that lets many devices interoperate — not a physical link.

PRACTICE

Q1 · In one sentence, what problem does MCP solve?

It replaces the N×M explosion of bespoke per-app, per-tool integrations with a single open standard, so a tool/data server built once can be reused by any MCP-compatible host.

Q2 · What RPC protocol is MCP built on, and what are its three message shapes?

JSON-RPC 2.0. The shapes are requests (have an id, expect a response), responses (matched by that id), and notifications (no id, no response expected).

Q3 · Explain the "USB-C for AI" analogy precisely.

Like USB-C is a standardized connector that lets many devices interoperate without a custom cable per pair, MCP is a standardized way to connect AI applications to external systems — build to the standard once and everything that speaks it can plug in.