MCP — the Model Context Protocolode

🧩 What MCP actually is

MCP stands for the Model Context Protocol. It's an open standard, introduced by Anthropic in November 2024, that lets any AI application connect to external tools and data sources through one common interface.

The best one-line analogy is the official one:

🔌 MCP is "USB-C for AI." Before USB-C, every device had its own connector. MCP is the universal port: build one integration to the standard, and it works with every MCP-capable AI app.

Developers already know a close cousin: the Language Server Protocol (LSP). Before LSP, every editor needed a custom plugin for every language. LSP standardized it — write one language server, and all LSP editors get support. MCP does the same for connecting AI apps to external systems: write one integration, use it everywhere (Claude Code, Cursor, VS Code, and any other MCP host).

❌ What MCP is not (clearing up two common myths)

This is worth stating plainly, because these errors circulate:

• MCP is not your editor automatically gathering your file tree, linter errors, cursor position, and git info. That's your IDE's built-in context — a completely separate mechanism your editor has always done on its own. MCP is about reaching outside the editor to third-party tools and data.
• Multi-file "Agent mode" is not "only possible because of MCP." Autonomous agents existed before MCP shipped and work fine without it. MCP extends what an agent can reach; it doesn't power the agent loop itself.

Keep the distinction crisp: built-in IDE context = what your editor knows about your open project. MCP = a standard plug for connecting to external servers.

🏗️ The architecture: Host → Client → Server

MCP has three roles, communicating over JSON-RPC:

• Host — the AI application you use (Claude Code, Claude Desktop, Cursor, VS Code…). It's where the model lives.
• Client — the connector inside the host that speaks MCP; one client per server connection.
• Server — an external program that exposes capabilities. Servers are often third-party and run separately from your editor.

[ You ] → [ Host: Claude Code / Cursor / VS Code ]
                     │  (MCP client)
                     ▼   JSON-RPC
          [ MCP Server: GitHub / Postgres / Sentry / ... ]
                     │
                     ▼
             external tools & data

🧰 What a server exposes: Tools, Resources, Prompts

An MCP server offers three kinds of capability:

• Tools — actions the model can call. "Open a GitHub issue," "run this SQL query," "search Sentry errors." This is where an agent gains real reach.
• Resources — data the model can read. Files, records, documents exposed for context.
• Prompts — reusable prompt templates the server provides for common tasks.

Concrete examples of real MCP servers:

• A GitHub server → let the agent read issues/PRs and open them.
• A Postgres server → let the model inspect a schema or run read-only queries.
• A Sentry server → pull recent production errors into context.
• A docs server (e.g. Context7) → fetch current library documentation.

🚀 Why a standard is the point

• Write once, use everywhere. A single MCP server works across every MCP host — no re-integrating per tool.
• Vendor-neutral by design. This is genuinely portable plumbing: the same Postgres server serves Claude Code, Cursor, and VS Code identically. Lean into it — MCP is the course's best example of a standard that outlives any product.
• Composable capability. Add the servers a task needs; the agent gains exactly those tools and no more.

⚠️ But: MCP is also a footgun — trust matters

Installing an MCP server hands a model tools and data access. That's power, and power cuts both ways:

• Untrusted servers can exfiltrate data or take harmful actions.
• Prompt injection through MCP/agents is a leading 2026 threat — an attacker who plants text in an issue, PR, or fetched web page can hijack an over-privileged agent into misusing its tools.

So treat MCP the way you'd treat installing any software with access to your systems: prefer official/first-party servers, scope credentials narrowly, and keep a human in the loop for sensitive actions. This gets its own full treatment in AI Security & Trust.

📚 Learn more (authoritative sources)

• modelcontextprotocol.io — the official spec and docs. Versioned and governed; go here, not to a video, when in doubt.
• github.com/modelcontextprotocol — reference servers and SDKs.

💡 Anchor on the spec and the architecture (Host/Client/Server; Tools/Resources/Prompts), not any one server's feature list — features churn, the protocol is stable.

Next: a concrete, useful MCP server → Context7.