MCP, Explained: What Is the Model Context Protocol?

If you have used an AI assistant in the last year, you have probably asked it to do something: check your calendar, query a database, send a message, or fetch the latest news. The magic behind those actions is a quiet standard called the Model Context Protocol, or MCP for short. It is one of the most important plumbing upgrades in modern software, and most people have never heard of it.

The problem MCP solves

Before MCP, connecting an AI model to a tool or a data source was a custom engineering project every single time. Want the assistant to read your CRM? Write a bespoke integration. Want it to search a company wiki? Build another one. Every vendor built their own adapter for every app, producing what engineers call an M×N problem: M models, N tools, and a tangle of one-off connectors that had to be written, secured, and maintained separately.

MCP replaces that mess with a single, open standard — the same way USB-C standardized how devices charge and connect, or how SMTP standardized email. One protocol, and any model can talk to any tool.

How MCP works

MCP is built on a simple client-server architecture:

• The MCP host is the application you interact with — a chat app, an IDE, or a desktop agent.
• Inside the host, an MCP client maintains connections to servers.
• An MCP server is a small program that exposes capabilities to the model.

Messages flow over the protocol using JSON-RPC. A host can be connected to several servers at once, and each server advertises three kinds of capabilities:

• Tools — actions the model can invoke, like create a ticket or look up a stock price.
• Resources — data the model can read, like a project file or a database record.
• Prompts — reusable templates that package common workflows.

Because the protocol is standardized, a single MCP server can serve Claude, OpenAI, Cursor, and any other MCP-compatible host without rewriting anything. That is the entire point.

Who created it, and who owns it now

Anthropic introduced MCP in late 2024 and open-sourced the specification. Within months it became the industry's default integration layer, adopted across the biggest AI companies and tool vendors. In 2025 the protocol moved into neutral, open governance under the Linux Foundation, alongside projects like Kubernetes and PyTorch — a strong signal that no single company controls it.

Why it matters

Three reasons MCP is more than developer trivia:

1. Interoperability. Your AI tools stop living in silos. One server, many assistants; one integration, many models. This makes it practical to switch or mix AI vendors without rebuilding your tooling.

2. Security and control. MCP servers run with scoped permissions, and hosts can require user approval before a model performs sensitive actions. Access to a company's tools can be governed with the same discipline as access to its APIs — instead of giving a model a free hand.

3. An open ecosystem. Because the standard is open, anyone can build an MCP server. The result is a rapidly growing registry of servers for everything from databases and version control to design tools and file systems.

Getting started

Building on MCP is approachable. Official SDKs exist for TypeScript, Python, Java, and Kotlin. A minimal server is often just a few dozen lines that define a tool, expose it, and start listening over stdio or HTTP. From there you can point any MCP-compatible assistant at it and immediately call your own functions.

The fastest way to learn is to run an existing server first — connect one to a chat app and watch the model use it — then write a tiny server of your own exposing one useful tool.

Example: a minimal MCP server

The TypeScript SDK exposes a small server API. Install it with

npm install @modelcontextprotocol/sdk zod

// server.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "demo-tools", version: "1.0.0" });

server.tool(
  "roll_dice",
  { sides: z.number().int().min(2).max(100) },
  async ({ sides }) => ({
    content: [
      {
        type: "text",
        text: String(1 + Math.floor(Math.random() * sides)),
      },
    ],
  })
);

await server.connect(new StdioServerTransport());

Point an MCP-compatible host at the process, approve the tool, and ask it to roll a die. The same pattern works for a database lookup or an internal API call; keep the tool narrow, validate arguments, and enforce authorization inside the server.

The road ahead

MCP is still young, and the ecosystem is evolving quickly: agent-to-agent communication, richer authorization models, and better tools for discovery and debugging are all active areas. But the direction is clear. The era in which AI assistants are read-only chatbots is ending. The next era — in which they act on your behalf, safely and interoperably — is being built on the Model Context Protocol.