MCP Crossed 97 Million Installs — The Protocol Quietly Becoming AI's TCP/IP
From 2M downloads at launch to 97M monthly. How the Model Context Protocol became the universal standard for connecting AI to tools.
Published by GitIntel Research
TLDR
- • 97 million monthly SDK downloads in March 2026, up from 2M at launch in November 2024.
- • 10,000+ active MCP servers across the ecosystem.
- • Every major AI provider ships MCP support: Claude, ChatGPT, Gemini, Copilot, Cursor, VS Code.
- • Gartner predicts 40% of enterprise apps will include AI agents by end of 2026. MCP is how they'll connect.
What MCP Actually Is
The Model Context Protocol is a standard for connecting AI models to external tools and data. Before MCP, every AI tool built its own integration layer. Claude had one way to read files. ChatGPT had another. Cursor had a third. Every new integration meant writing N adapters for N tools.
MCP replaced that with one protocol. Build an MCP server once, and every MCP-compatible client can use it. It's the same leap that TCP/IP made for networking: agree on the protocol, and everything can talk to everything.
Anthropic open-sourced MCP in November 2024 with roughly 2 million downloads. Sixteen months later, it crossed 97 million monthly SDK downloads. That growth curve makes Kubernetes look sluggish — Kubernetes took nearly four years to reach comparable deployment density.
The Governance Move That Locked It In
On December 9, 2025, Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation. OpenAI and Block joined as co-founders. AWS, Google, Microsoft, Cloudflare, and Bloomberg signed on as platinum members.
This matters because it removed the "Anthropic's protocol" risk. When your competitor's protocol is also backed by Linux Foundation governance with your own name on the member list, the rational move is to adopt it rather than fight it. That's exactly what happened. OpenAI shipped MCP support in ChatGPT. Google added it to Gemini. Microsoft integrated it into Copilot and VS Code.
The protocol war ended before it started.
What 10,000 MCP Servers Look Like
An MCP server exposes three types of primitives to AI clients:
- Tools — Functions the AI can call (run a query, send an email, deploy code)
- Resources — Data the AI can read (files, database schemas, API docs)
- Prompts — Reusable prompt templates for common tasks
The ecosystem as of April 2026: 10,000+ active servers covering databases (Postgres, MySQL, MongoDB), communication (Slack, email, Telegram), development (GitHub, GitLab, Jira), cloud infrastructure (AWS, GCP, Azure), and hundreds of SaaS products.
Forrester predicts 30% of enterprise app vendors will launch their own MCP servers in 2026. The incentive is clear: if your product doesn't have an MCP server, AI agents can't use it. That's the new "no API" — a deal-breaker for technical buyers.
Building Your First MCP Server
An MCP server in Python takes under 50 lines. Here's a working example — a server that exposes stock price lookups:
from mcp.server import Server
from mcp.types import Tool, TextContent
import httpx
app = Server("stock-price")
@app.tool()
async def get_stock_price(symbol: str) -> list[TextContent]:
"""Get the current stock price for a given ticker symbol."""
async with httpx.AsyncClient() as client:
resp = await client.get(
f"https://api.example.com/quote/{symbol}"
)
data = resp.json()
return [TextContent(
type="text",
text=f"{symbol}: ${data['price']:.2f} ({data['change']:+.2f}%)"
)]
if __name__ == "__main__":
app.run()
To connect it to Claude Code, add it to your settings:
{
"mcpServers": {
"stock-price": {
"command": "python",
"args": ["stock_server.py"]
}
}
}
Now any Claude Code session can call get_stock_price("AAPL") as naturally as it calls any built-in tool. The AI sees the tool's name, description, and parameters — it decides when to use it based on the conversation context.
The Architecture That Enables This
MCP uses a client-server model over JSON-RPC. The key design decisions:
Transport-agnostic. MCP works over stdio (local processes), HTTP with Server-Sent Events (remote servers), or WebSocket. This means the same server code works whether it's running as a local subprocess or a cloud service.
Capability negotiation. Client and server exchange capabilities during initialization. A server can declare it supports tools but not resources. A client can declare it supports sampling (asking the AI to generate text). This keeps the protocol extensible without breaking backwards compatibility.
Stateful sessions. Unlike REST APIs, MCP connections maintain state. A database MCP server can hold a connection pool. A Git MCP server can maintain a checkout. This enables multi-step workflows without passing context back and forth.
┌─────────────┐ JSON-RPC ┌─────────────┐
│ AI Client │ ◄──────────────► │ MCP Server │
│ (Claude Code,│ stdio / HTTP │ (your tools) │
│ ChatGPT, │ │ │
│ Cursor...) │ │ │
└─────────────┘ └─────────────┘
│ │
│ "Call get_stock_price('AAPL')" │
│ ──────────────────────────────► │
│ │
│ {"price": 234.50, "change": 1.2} │
│ ◄────────────────────────────── │
What MCP Changes for Developers
Three shifts that are already happening:
SaaS products now compete on AI accessibility. If Postgres has an MCP server and your database doesn't, AI agents will default to Postgres. Gartner's prediction that 40% of enterprise apps will include AI agents by end of 2026 means MCP server availability becomes a product requirement, not a feature.
Integration work shrinks. The traditional pattern — read API docs, write an adapter, handle auth, manage errors — gets replaced by installing an MCP server. The developer's job shifts from "build the plumbing" to "orchestrate the tools."
AI agents become composable. An agent that can discover and use MCP servers dynamically doesn't need its capabilities hardcoded. Point it at a new MCP server, and it gains new abilities. This is the foundation for general-purpose AI agents that adapt to their environment.
Where MCP Falls Short (For Now)
Honesty about limitations:
- Auth is still evolving. OAuth 2.0 support landed recently, but multi-tenant auth patterns for enterprise deployments need more work.
- Discovery is fragmented. There's no universal registry for MCP servers. You find them through GitHub, npm, or word of mouth.
- Performance overhead. JSON-RPC over stdio adds latency compared to direct function calls. For high-throughput use cases (processing thousands of records), native integrations still win.
- Security surface. Every MCP server you connect is a tool your AI can call. Teams need policies around which servers are approved, what permissions they have, and who can add new ones.
The MCP roadmap for 2026 addresses most of these: a registry protocol, improved auth flows, and enterprise governance features. The foundation is solid. The finish work is ongoing.
What to Build
If you maintain a SaaS product, the highest-value thing you can build right now is an MCP server for it. Your users' AI agents need access to your product. The official SDK documentation covers Python, TypeScript, Java, and Go.
If you're building AI agents, MCP is the integration layer you should default to. Writing custom API adapters is technical debt now. Build on MCP, and your agent works with every client that supports the protocol — today and in the future.
97 million monthly downloads in 16 months. Every major AI provider on board. Linux Foundation governance. MCP isn't becoming the standard. It already is.