What the hell is an MCP, actually?.

MCP stands for Model Context Protocol. If that tells you nothing, good. Acronyms are gatekeeping. Let me explain it like you're a smart human who's never heard of it.

The two-sentence version

MCP is a standard way for AI models to plug into external tools and data. Think USB-C, but for AI, instead of every app inventing its own weird cable, they all use the same one.

The analogy

Imagine Claude is a very smart new employee on their first day. They have general knowledge , they know how the world works, but they don't know anything about your company. They can't see your files. They don't know your customers. They've never looked at your calendar.

You have two options.

1. Every time you chat, paste in everything they need to know. Slow. Error-prone.
2. Give them a set of keycards. One opens the files. One checks the calendar. One pulls customer data. They swipe the card when they need the thing.

MCP is option 2. Each "keycard" is an MCP server. The server exposes a set of tools the AI can call, things like search_files, list_events, create_ticket. The AI decides when to swipe the card based on what you're asking for.

Why this is a big deal

Before MCP, every AI product had to build its own way of connecting to every tool.

ChatGPT's way of talking to Notion was different from Claude's way of talking to Notion, which was different from how some other AI agent talked to Notion. Everyone re-built the wheel. Tool makers had to pick a side.

MCP is an attempt to agree on one wheel. Anthropic published the spec, open-sourced the reference implementations, and other AI companies are adopting it too.

MCP is the thing that lets your AI read your files, check your calendar, and send your emails, without every app having to do it a different way.

What an MCP server actually is

Technically, an MCP server is just a small program. It exposes some tools, and speaks the MCP protocol over a connection (either locally, like a socket, or over the internet via HTTP).

A minimal MCP server in Python might look like this:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("My Tools")

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers."""
    return a + b

if __name__ == "__main__":
    mcp.run()

That's it. That's a working MCP server. Claude can now call the add tool and get the result. You can make tools that read files, query APIs, hit your database, anything a Python function can do.

The mental model I use

Three pieces:

• The model (Claude, GPT, whatever), the brain.
• The client (Claude Desktop, Cursor, a custom agent), what you talk to.
• The MCP server, a small program offering tools the brain can call.

The client knows about the model and the server. It introduces them. When you ask the model to do something, it decides whether to call a tool, calls it via the client, gets the answer, and folds it into its reply.

Where to see it working

The fastest way to feel what MCP does:

• Install Claude Desktop.
• Add the filesystem MCP server (it comes as an npm package you add to a config file, the docs walk you through it).
• Ask Claude "what's in my downloads folder?".
• Watch it call the tool, read your folder, and tell you.

That "holy crap, it actually did the thing" moment is what got me hooked. I wrote my own MCP server a few weeks later, it's called HIKI, and it gave Claude a memory of me.

The one-line summary, now that you have context

MCP is a protocol that lets AI models call external tools in a standardised way, so every tool only has to be built once, and every AI that supports MCP can use it.

Does that make more sense now?

Questions welcome, matt@matthitchman.com.

Matt