MCP stands for Model Context Protocol. Anthropic published it in late 2024, and within months it became the de facto standard for connecting AI models to external tools, data sources, and services. This is what it is, why it exists, and why it matters.
The problem it solves
Language models are stateless text processors. They read your input, generate output, done. They have no persistent memory. They can't browse your files, query your database, send an email, or check a calendar. They know what they were trained on, and nothing else.
For a year or two, the industry worked around this with function calling — you define a set of functions, the model decides when to call them, your code executes them and passes results back. This worked, but every implementation was bespoke. Every company built their own tool-calling layer, in their own format, incompatible with everyone else's.
MCP is the standardization of that layer.
What MCP actually is
MCP is an open protocol that defines how AI models communicate with external tools and data sources. It specifies:
- How clients (AI applications) discover available tools
- How servers (tool providers) describe their capabilities
- How requests and responses flow between them
- How context — files, memory, state — gets shared
Think of it like HTTP for AI tools. HTTP didn't invent the web, it standardized the communication layer so any browser could talk to any server. MCP does the same for AI-tool communication.
The three components
An MCP setup has three parts:
The host is the application users interact with — Claude Desktop, a custom agent, an IDE plugin. It manages the overall interaction and holds the conversation context.
The client lives inside the host. It speaks the MCP protocol, connects to servers, routes tool calls, and returns results to the model.
The server is a lightweight process that exposes tools, resources, or prompts. A server might give access to your filesystem, your PostgreSQL database, your Slack workspace, or your company's internal API.
The key insight: servers are decoupled from clients. You write a Postgres MCP server once, and it works with any MCP-compatible host. You don't rebuild it for every AI product.
Why it changes things
Before MCP, connecting an AI to your CRM meant:
- Writing custom function definitions
- Building API glue code
- Handling authentication
- Parsing responses
- Doing this again for every new AI product you wanted to use
With MCP, you write the server once. Any MCP-compatible host — Claude, Cursor, your custom agent — can connect to it. The protocol handles discovery, authentication, and request/response formatting.
The ecosystem effect compounds quickly. The community has already built MCP servers for GitHub, Notion, Slack, Postgres, SQLite, Google Drive, Linear, and hundreds more. Most of the connectors you need probably already exist.
What you can build with it
MCP enables three categories of capability:
Tools — functions the model can call. Search a database. Send a message. Create a calendar event. Run a query. These are actions with side effects.
Resources — data the model can read. File contents, database records, API responses, documents. These are context sources without side effects.
Prompts — reusable prompt templates that servers expose. Standardized ways to ask the model to do specific tasks using server-provided context.
The simple version
If you want to understand MCP in one sentence: it's a USB standard for AI tools.
Before USB, every device needed its own port, its own driver, its own cable. USB standardized the connection layer so any device could talk to any computer. MCP does the same for AI integrations — any tool can talk to any model through a common interface.
The businesses that figure this out early are building agent infrastructure that compounds. Every MCP server you build today works with every AI product that adopts the protocol. The integration tax goes from quadratic to linear.
That's the bet. And given the adoption curve, it's looking like a good one.
Published under Field Notes. Not for sale. Share freely.