The Model Context Protocol — one open standard that lets any model plug into any tool, data source, or service.
The one-liner
MCP is the Model Context Protocol.
An open standard from Anthropic — a universal connector between AI models and the outside world: tools, data, and services. Instead of every model wiring up every service its own way, they all speak one shared language.
Open
A public standard anyone can implement — not one vendor's private API.
Universal
One protocol between any model and any capability on the other end.
Connective
The shared wiring that lets the agent ecosystem snap together.
The analogy
MCP is the USB port for AI.
Rewind to before USB: every gadget shipped with its own oddball connector, and half your desk was a drawer of adapters. Then one standard plug arrived and everything just worked together. MCP does exactly that for AI.
One plug. Every device. No adapter drawer.
Before the standard
Every device had its own connector.
Printer cable, mouse cable, camera cable — each a different shape, each needing its own port and its own driver. Buy a new gadget, hunt for the right adapter. AI integrations lived in exactly that world before MCP.
Every new pairing was custom work. Nothing you built carried over.
The problem
N models × M tools = a tangle.
Without a standard, every model needs a bespoke integration for every service — N × M custom connectors, none reusable. Add one tool and you rewrite it for every model.
The fix
One hub. Build once, plug in anywhere.
MCP sits in the middle. Each model speaks to the hub; each tool exposes itself to the hub. The N × M tangle becomes N + M.
The whole point
N × M becomes N + M.
Build one integration once, and it works with every MCP-compatible model — today's and tomorrow's. Multiplication was the tax; addition is the reward.
Write the connector once. Everyone plugs in.
How it's structured
Hosts, clients, and servers.
Hosts
The apps a person uses that want AI power — a desktop assistant, an IDE, your own product. The host holds the model and decides which servers to connect to.
Clients
The connector inside the host, on the model's side. It pairs one-to-one with a server, discovers what it offers, and relays the calls.
Servers
Standalone programs that expose a real capability — read a database, search a repo, post a message. Write once; any host can use it.
One host can hold many clients — so a single app plugs into dozens of servers at once.
What a server exposes
Tools, resources, and prompts.
Tools
Functions the AI can call to take action — send_email(), run_query(). The verbs: things that do something.
Resources
Data the AI can read — a file, a table row, a wiki page. Context pulled in on demand, no side effect.
Prompts
Reusable templates the server offers — a pre-written "summarize this ticket" flow invoked with one click.
The client discovers all three automatically the moment it connects.
The ecosystem
Servers already exist for the tools you use.
The moment MCP landed, people published servers for the things they work with every day — each instantly usable by any MCP-compatible model.
GitHub
Google Drive
Notion
Slack
PostgreSQL
Brave Search
Browser automation
AWS
Sentry
Filesystem
Memory / vector store
…dozens more
In real code
A whole server in a dozen lines.
from mcp.server.fastmcp import FastMCP
mcp = FastMCP("team") # name this server
@mcp.tool()
def get_member_role(name: str) -> str:
"""Look up a team member's role by name."""
roles = {"Tyson": "Linux Lead", "Khaja": "AIX Lead"}
return roles.get(name, "Unknown member")
if __name__ == "__main__":
mcp.run(transport="stdio") # any MCP model can now call this
@mcp.tool() turns a function into a discoverable capability — and the docstring is the interface.
Chapter 10 in one breath
One standard plug for the whole toolbox.
MCP is the USB port for AI: hosts hold clients that talk to servers, and each server exposes tools, resources, and prompts. The N×M tangle becomes a clean hub.
Build once, use everywhere.
That's MCP
Build once. Plug in everywhere.
You've seen the tangle, the hub, the three roles, and a server in a dozen lines. That's the connective tissue of the whole agent ecosystem.