10 MCP — 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 — the Model Context Protocol, an open standard from Anthropic — does exactly that for AI. It's a universal connector between models and the outside world: tools, data, and services. It went from a late-2024 idea to something the whole industry standardized on through 2025–26.
The USB moment
Here's the mess MCP was built to end. Say you have a handful of AI models and a handful of services you want them to reach. Without a standard, every model needs a bespoke integration for every service — that's N × M custom connectors, none of them reusable. Add one new service and you rewrite it for every model. Press the button and watch the tangle collapse into one shared hub.
How it's structured
MCP splits the connection into three clean roles. The host is the app you're actually using. The client lives inside it and speaks the protocol on the model's behalf. And the server is the little program on the other end that exposes a real capability. One host can hold many clients, and each client talks to one server — so a single app can plug into dozens of servers at once.
The app a person uses that wants AI power — a desktop AI assistant, an IDE, or your own product. It hosts the model and decides which servers to connect to.
The connector inside the host that pairs one-to-one with a server. It's how the AI model actually speaks MCP — discovering what a server offers and relaying calls.
A standalone program that exposes a capability — read a database, search a repo, post a message. Write it once and any MCP host can use it.
Every MCP server can expose three kinds of things — and the client discovers them automatically the moment it connects.
Functions the AI can call to take action — send_email(), run_query(). This is the verb: things that do something.
Data the AI can read — a file, a table row, a wiki page. Context pulled in on demand, without a side effect.
Reusable templates the server offers — a pre-written "summarize this ticket" flow the user can invoke with one click.
The ecosystem
This is why MCP caught fire so fast: the moment it landed, people started publishing servers for the things they work with every day — and each one is instantly usable by any MCP-compatible model. You don't rebuild a Slack integration per model. Someone builds the Slack server once, and every host in the ecosystem gets it for free.
Build one integration once, and it works with every MCP-compatible model — today's and tomorrow's. The M × N problem becomes M + N.
In real code
Here's the thing that surprises builders: an MCP server is tiny. With a FastMCP-style helper, you decorate a plain Python function, give it a docstring so the model knows what it does, and start listening. That's a real, working server. Any MCP-compatible model can now discover and call get_member_role on its own.
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-compatible model can now call this
MCP turns the N×M integration nightmare into build once, use everywhere. It's the shared wiring that lets the whole agent ecosystem — every model, every tool — snap together instead of being hand-soldered pair by pair.
Chapter 10 in one breath
MCP is the USB port for AI: an open standard where hosts hold clients that talk to servers, and each server exposes tools, resources, and prompts. Build a connector once and every compatible model can use it. The N×M tangle becomes a clean hub — and that hub is what lets agents reach the real world.
A free Google Colab notebook — write an MCP server and connect a client to it, live.
A matching slide deck with speaker notes — press S for notes, F for fullscreen.