In November 2024, Anthropic quietly released an open standard called the Model Context Protocol (MCP). It was a specification for how AI systems should connect to external tools and data sources — essentially, a universal plug for AI applications. Fourteen months later, MCP has 97 million+ monthly SDK downloads, support from OpenAI, Google, Microsoft, and AWS, governance under the Linux Foundation, and has become the de facto standard for building AI integrations.
No other technical standard in recent memory has gone from launch to industry-wide adoption this quickly. Here is how it happened, what MCP actually does, and why developers should care.
The Problem MCP Solves
Before MCP, every AI integration was a custom job. If you wanted Claude to access your database, you wrote a custom tool. If you wanted GPT to read your CRM, you wrote a different custom tool. If you wanted Gemini to query your analytics, you wrote yet another custom tool. Each integration was bespoke, fragile, and locked to a specific model provider.
Before MCP: The Integration Nightmare
├── Your App + Claude
│ └── Custom tool code for Claude's API format
├── Your App + GPT
│ └── Different custom tool code for OpenAI's format
├── Your App + Gemini
│ └── Yet another custom integration for Google's format
└── Result: 3x the code, 3x the maintenance, 0x the portability
After MCP: Universal Connectivity
├── Your App → MCP Server (write once)
│ ├── Claude connects via MCP
│ ├── GPT connects via MCP
│ ├── Gemini connects via MCP
│ └── Any future model connects via MCP
└── Result: 1x the code, universal compatibilityMCP standardized the interface between AI models and the outside world. Write an MCP server once, and any MCP-compatible AI client can use it.
The Timeline
| Date | Event |
|---|---|
| November 2024 | Anthropic releases MCP as open standard with Python and TypeScript SDKs |
| December 2024 | Claude Desktop ships with MCP support |
| March 2025 | OpenAI adopts MCP across Agents SDK, Responses API, and ChatGPT desktop |
| April 2025 | Google DeepMind confirms MCP support for Gemini |
| Mid-2025 | VS Code ships MCP integration; ecosystem hits 10,000+ community servers |
| November 2025 | Major spec update: async operations, statelessness, server identity, official extensions |
| December 2025 | Anthropic donates MCP to the Agentic AI Foundation under the Linux Foundation |
| January 2026 | MCP Apps ship — the first official extension, enabling interactive UI in AI conversations |
| February 2026 | 97M+ monthly SDK downloads, 75+ official connectors in Claude's directory |
How MCP Works
MCP borrows the client-server architecture from the Language Server Protocol (LSP) — the standard that lets VS Code provide IntelliSense for any programming language. If LSP is "any editor, any language," MCP is "any AI model, any tool."
Architecture
┌─────────────┐ JSON-RPC 2.0 ┌──────────────┐
│ MCP Client │◄──────────────────►│ MCP Server │
│ (AI model │ │ (Your tool/ │
│ or app) │ │ data source)│
└─────────────┘ └──────────────┘
Client examples: Server examples:
├── Claude ├── Database connector
├── ChatGPT ├── GitHub integration
├── Gemini ├── Slack/Email access
├── VS Code ├── File system access
├── Cursor ├── Web scraping
└── Any MCP client └── Any custom toolCore Concepts
MCP defines three primitives that cover most AI-tool interactions:
1. Tools — Functions the AI can call
{
"name": "query_database",
"description": "Run a SQL query against the production database",
"inputSchema": {
"type": "object",
"properties": {
"query": { "type": "string" },
"database": { "type": "string", "enum": ["users", "orders", "analytics"] }
}
}
}2. Resources — Data the AI can read
{
"uri": "file:///project/src/main.ts",
"name": "Main application entry point",
"mimeType": "text/typescript"
}3. Prompts — Reusable prompt templates
{
"name": "code_review",
"description": "Review code for bugs and improvements",
"arguments": [
{ "name": "code", "required": true },
{ "name": "language", "required": true }
]
}Why MCP Won
Several factors explain MCP's rapid adoption:
1. Anthropic Made It Truly Open
Anthropic did not just open-source the spec — they donated it to a neutral foundation. The Agentic AI Foundation (AAIF), a directed fund under the Linux Foundation, was co-founded by Anthropic, Block, and OpenAI, with support from Google, Microsoft, AWS, Cloudflare, and Bloomberg.
This governance model gave competitors the confidence to adopt MCP without fear of Anthropic controlling the standard. OpenAI's adoption in March 2025 — just four months after launch — was the tipping point.
2. The Developer Experience Was Excellent
The SDKs for Python and TypeScript were well-documented, easy to use, and production-ready from day one. Building an MCP server takes minutes, not days.
3. LSP Familiarity
Developers already understood the LSP model. MCP's architecture was immediately familiar to anyone who had worked with language servers, reducing the learning curve.
4. The Timing Was Right
The AI industry in 2024-2025 was drowning in custom integrations. Every company building AI features was writing and maintaining dozens of bespoke tool connectors. MCP arrived at exactly the moment the pain was greatest.
MCP Apps: The Latest Extension
The newest addition to MCP is MCP Apps — an official extension that lets MCP servers return interactive UI components directly in AI conversations. Instead of just text responses, tools can now render:
- Dashboards with live data
- Forms for user input
- Data visualizations and charts
- Multi-step workflows with progress indicators
This is significant because it moves MCP beyond text-in/text-out interactions into rich, interactive experiences — all within the AI client's interface.
Security is handled through iframe sandboxing, pre-declared templates, auditable messages, and user consent requirements.
Building Your First MCP Server
Here is a minimal MCP server that exposes a weather API:
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: "weather-server",
version: "1.0.0",
});
server.tool(
"get_weather",
"Get current weather for a city",
{
city: z.string().describe("City name"),
units: z.enum(["celsius", "fahrenheit"]).default("celsius"),
},
async ({ city, units }) => {
const response = await fetch(
`https://api.weather.example/current?city=${city}&units=${units}`
);
const data = await response.json();
return {
content: [
{
type: "text",
text: `Weather in ${city}: ${data.temperature}° ${units}, ${data.condition}`,
},
],
};
}
);
const transport = new StdioServerTransport();
await server.connect(transport);This server can be used by Claude, ChatGPT, Cursor, VS Code, or any other MCP-compatible client without modification.
The Ecosystem in 2026
The MCP ecosystem has grown rapidly:
- 75+ official connectors in Claude's directory (databases, APIs, dev tools, productivity apps)
- 10,000+ community-built servers on GitHub
- 97M+ monthly SDK downloads across Python and TypeScript
- SDKs available in Python, TypeScript, Java, Go, Rust, C#, and more
- Major integrations: VS Code, Cursor, Claude Desktop, ChatGPT Desktop, Goose
What Developers Should Do
If you are building AI-powered applications, MCP should be part of your architecture:
Build MCP servers for your internal tools. Instead of writing custom integrations for each AI model, expose your tools via MCP once.
Use existing MCP servers. Check the community registry before building from scratch. Database connectors, API integrations, and common tool patterns are already available.
Design for MCP from the start. If you are building a new API or tool, consider shipping an MCP server alongside it. This makes your tool instantly accessible to every AI client in the ecosystem.
Follow the spec updates. MCP is evolving. The November 2025 spec added async operations, statelessness, and server identity. MCP Apps just shipped. Stay current with the spec to take advantage of new capabilities.
MCP is one of those rare technical standards that achieved adoption through genuine utility rather than corporate mandate. It solved a real problem at the right time, with the right governance model, and the right developer experience. For AI development in 2026, it is not optional — it is foundational.
Comments