Mcp

https://www.youtube.com/watch?v=OoPtezIMQ9Q

You've heard the term. MCP server. Maybe in a Cursor changelog. Maybe in a Slack release. Maybe your team set one up and you nodded along.

Most developers hear those three letters and think the same thing. Another API spec. Another acronym. Another integration to wire up later.

That's the misread. MCP isn't an API. It's the thing that stops you from writing forty different APIs.

The N×M problem

Picture the world before MCP.

You have an LLM client — Claude Desktop, Cursor, your own agent. You want it to talk to GitHub, your filesystem, Postgres, Slack, Google Drive, Linear, Stripe. Eight tools.

That's eight integrations. Annoying, but fine.

Now another LLM client appears. ChatGPT adds tool calling. Cursor wants the same connections. Continue. Cline. Five clients.

Five clients × eight tools = forty wires. Every new tool means five new integrations. Every new client means eight new integrations. Nobody writes them. Most of them never exist.

This isn't theoretical. The same explosion happened to IDEs in the early 2010s. Every editor wrote its own Python support, its own TypeScript support, its own Rust support. Microsoft fixed it with Language Server Protocol. LSP collapsed N×M for IDE/language pairs.

MCP is doing the same trick for AI tools.

What MCP actually is

A client process and a server process. They talk JSON-RPC 2.0 — over standard input/output if the server runs locally, over HTTP if it's remote. Boring on purpose.

What's interesting is what you can ask the server to do. MCP defines exactly three things a server can offer:

• Tools — callable functions. read_file, query_database, send_message. Each named, typed, with a description the model reads.
• Resources — readable data. A file, a database row, a config. Each addressable by URI, like a tiny URL pointing inside the server.
• Prompts — reusable templates the user can invoke. A "summarize this PR" template that fills in the diff. Parameterized starting points.

Three primitives. Tools you call, resources you read, prompts you reuse. That's the whole API surface.

Why three? Because Anthropic looked at LSP and copied the shape. LSP defines a small set of things a language server can offer — hover, go-to-definition, format. Small enough that anyone can implement. Big enough that an editor that speaks LSP gets every language for free.

MCP is the same bet. Three primitives. Small enough to implement in an afternoon. Big enough that a client that speaks them gets every tool for free.

The collapse

Add MCP to the chaos.

Each tool implements the protocol once. Eight implementations. The GitHub team writes the GitHub server. The Postgres team writes the Postgres server.

Each client speaks the protocol once. Five implementations.

Total wires? Eight + five = thirteen.

Forty becomes thirteen. N×M becomes N+M. The same word in the math, a different operation between them. Multiplication collapsed to addition.

Add a ninth tool? One new implementation. Every client gets it for free. Add a sixth client? One new implementation. Every tool already works.

The framing the docs landed on: USB-C for AI. One plug shape. Many devices.

The compose moment

Where it stops feeling like an integration story and starts feeling like an operating system: one client with four MCP servers running. Filesystem. GitHub. Slack. Postgres.

You type one prompt: "Find the bug from yesterday's incident, write a fix, push the PR, post it to the channel."

Watch the agent work. It opens the filesystem server, reads the incident logs. Opens Postgres, runs an EXPLAIN, confirms the missing index. Opens GitHub, branches off main, opens a PR. Opens Slack, posts the link.

Four servers. One sentence. The agent composed them. None of them know about each other. The protocol is what made them composable.

Anthropic has been pushing this further. There's a recent piece from their engineering team on treating MCP servers as code APIs — letting the agent write code that imports them, filters in execution, returns just the answer. In one example, they took a Drive-to-Salesforce workflow and dropped the model's token usage from 150,000 down to 2,000. 98.7% less context for the same result.

That's not an incremental improvement. That's a different kind of program.

The mental model

Lock it in:

• MCP is a protocol. JSON-RPC over stdio or HTTP. Three primitives a server offers — tools, resources, prompts.
• It exists because of N×M. Five clients × eight tools = forty integrations. With MCP, eight + five = thirteen. The same trick LSP played for IDEs.
• It's spreading because every major LLM client picked it up. Anthropic shipped it in November 2024. OpenAI added support. Microsoft. Google. The Linux Foundation took it over in December 2025. Ninety-seven million SDK downloads a month by March 2026.

Next time someone in your team stands up an MCP server, you know what they actually built. Not another API. A plug. Speak the protocol once, and every client in the ecosystem can reach you. That's the deal.