Model Context Protocol: What MCP Is and Why Every AI Platform Now Supports It

Before Model Context Protocol, building an AI agent that could query your database, read from Notion, and push code to GitHub meant writing three separate custom integrations - and rewriting all three when you switched models. Anthropic published MCP in November 2024 to fix that. Sixteen months later, OpenAI, Google, Microsoft, and AWS all support the Model Context Protocol natively, over 10,000 public servers list on the official registry, and the Python and TypeScript SDKs pull 97 million combined downloads per month.

Before MCP, Every AI-Tool Integration Had to Be Built Twice

Pre-MCP, AI integrations belonged to the client. If you wanted Claude to call your internal API, you wrote a function tied to that specific model. Switching to GPT-4 meant rewriting it. Build a second agent for a different team and you wrote a third version from scratch. Developers call this the N×M problem: N AI models multiplied by M external tools produces N×M custom integration points that every engineer touching either side has to understand and maintain.

MCP flips that math. Write the database connector once as an MCP server, and every MCP-compatible client - Claude, GPT-4o, Gemini, or whatever ships next year - can use it without modification. Write the GitHub MCP server once and every AI agent on your team connects to it, before and after the next model upgrade.

MCP Defines Three Primitives - Tools, Resources, and Prompts

An MCP server exposes three types of objects. Tools are callable functions - the AI model invokes them with arguments and gets results back, exactly like calling an API endpoint. Resources are readable data sources: files, database rows, and API responses the model can read without executing any side effects. Prompts are reusable message templates a server can expose for common workflows, so clients can discover and surface them automatically.

Communication runs over one of two transports. Local MCP servers run as subprocesses and exchange messages with the host over standard input/output - no network required, latency near zero. Remote servers use Streamable HTTP (replacing the original HTTP+SSE transport as of the 2025-06-18 spec), which allows a cloud-hosted MCP server to stream results back to a client without polling.

A working MCP server in Python looks like this - the FastMCP library handles the protocol mechanics, so what remains is just normal business logic:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("user-db-server")

@mcp.tool()
def search_users(query: str) -> list[dict]:
    """Search users by name or email address."""
    return db.execute(
        "SELECT id, name, email FROM users WHERE name ILIKE %s OR email ILIKE %s",
        (f"%{query}%", f"%{query}%")
    ).fetchall()

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

Any MCP-compatible client can discover and call this tool automatically after connecting to the server - no bespoke adapter code required on the client side. A three-tool MCP server covering the most common agent operations typically fits in 60 to 80 lines of Python.

OpenAI Adopted MCP in April 2025 - and the Download Numbers Tell the Rest

Anthropic launched MCP in November 2024. Monthly downloads sat at about two million. OpenAI added MCP support to its Agents SDK in April 2025, and downloads jumped to 22 million almost immediately. Microsoft integrated MCP into Copilot Studio in July 2025, pushing the figure to 45 million. AWS followed in November 2025 with native integration across its AI services. By March 2026, combined Python and TypeScript SDK downloads reached 97 million per month.

In December 2025, Anthropic donated the protocol to the Agentic AI Foundation - a new standards body formed under the Linux Foundation and co-founded by Anthropic, Block, and OpenAI, with Google, Microsoft, AWS, and Cloudflare among the supporting members. Ceding control of the spec was probably the single decision that convinced competing platforms to adopt rather than fork - a standard fully owned by Anthropic would always carry commercial risk for OpenAI and Google. 10,000 public MCP servers now list on the official community registry.

VS Code, Cursor, Claude Desktop, and Claude Code all ship with MCP support built in. IDEs represent the largest category of MCP clients today, followed by internal enterprise tooling and cloud provider AI platforms. The language model sitting inside these tools calls MCP servers the same way a developer calls a function - by name, with typed arguments, expecting a structured result.

MCP Servers Run With Your Process Permissions - Read That Carefully

Building an MCP server is fast. Nothing more. What takes time is thinking through permissions before deploying. An MCP server runs with the permissions of the host process that launches it - if that process can read files, write to the database, and make outbound network requests, any tool the server exposes inherits those same capabilities.

A misconfigured or malicious MCP server can do anything the host process can do. In production deployments, teams typically run each MCP server in its own isolated process with the minimum permissions the tools actually require, treat third-party MCP servers with at least as much scrutiny as any other external dependency, and review tool schemas before connecting them to agents with write access to anything real.

MCP connects agents to tools. What MCP does not define is how an agent reasons, plans, or decides which tool to call - that logic lives inside the model and the orchestration layer above it. Most production architectures pair MCP servers with a retrieval layer for accessing stored knowledge and an agentic loop for deciding when to retrieve versus when to act directly. The Model Context Protocol handles the last-mile connection to external systems; everything above that is up to the application.

New spec versions ship roughly every quarter. The November 2025 release added asynchronous operations, stateless server support, and a formal server identity model - and the community-maintained registry now lets agents discover available servers at runtime rather than relying on hard-coded configuration. MCP's adoption problem is solved. What the spec needs next is a standardised security model that works across all the environments it now runs in.