Anthropic's MCP standardizes AI tool connections via JSON-RPC 2.0 with three primitives. Over 50 community servers exist, making it the USB for AI.
Anthropic's Model Context Protocol (MCP) standardizes how AI tools connect to external services via JSON-RPC 2.0. The open protocol exposes three primitives — tools, resources, and prompts — with over 50 community servers already available.
Key facts
- MCP is an open standard created by Anthropic.
- Uses JSON-RPC 2.0 over stdio or WebSocket.
- Three primitives: tools, resources, prompts.
- Over 50 community servers exist.
- Hosts include Claude Code, Cursor, Windsurf.
MCP stands for Model Context Protocol. It is an open standard created by Anthropic that lets AI tools — Claude Code, Cursor, Windsurf, and others — connect to external services through a standardized interface, according to the developer guide.
Think of it like USB for AI. Before USB, every device had its own connector. Before MCP, every AI integration was custom-built. MCP gives AI tools a universal way to talk to GitHub, databases, browsers, APIs, and anything else you can build a server for.
Key Takeaways
- Anthropic's MCP standardizes AI tool connections via JSON-RPC 2.0 with three primitives.
- Over 50 community servers exist, making it the USB for AI.
Why MCP Exists
AI coding tools hit a ceiling fast: they can only work with what is in their context window. They cannot check your GitHub issues. They cannot query your database. They cannot browse the web.
MCP removes that ceiling. An MCP server exposes tools (actions the AI can take) and resources (data the AI can read). The AI calls these tools the same way it calls its built-in capabilities — naturally, as part of the conversation.
Without MCP, you copy-paste. With MCP, you just ask.
How the Protocol Works
The architecture has three components:
[AI Tool (Host)] <---> [MCP Client] <---> [MCP Server] <---> [External Service]
Host — The AI application (Claude Code, Cursor, etc.). Client — Built into the host. Manages the connection to MCP servers. Handles capability negotiation and message routing. Server — A lightweight program that exposes tools and resources. Runs locally or remotely.
The Handshake
When Claude Code starts, it reads your MCP configuration and launches each server as a subprocess. The handshake proceeds in three steps: Initialize, Negotiate, and Ready. The client sends an initialize request with protocol version and capabilities. The server responds with its capabilities (which tools it exposes, what resources it has). The client sends an initialized notification. The connection is live.
Message Format
MCP uses JSON-RPC 2.0 over stdio (standard input/output). A tool call looks like this:
{
"jsonrpc": "2.0",
"id": 1,
"method": "tools/call",
"params": {
"name": "create_issue",
"arguments": {
"repo": "owner/repo",
"title": "Fix login redirect bug",
"body": "Users get a 404 after OAuth callback"
}
}
}
The server processes the request, talks to GitHub's API, and returns the result. The AI sees the result and continues the conversation naturally.
The Three Primitives
Every MCP server exposes some combination of these:
1. Tools (Actions)
Things the AI can do. Create a PR, run a query, send a message, take a screenshot. Tools are the most common primitive.
2. Resources (Data)
Things the AI can read. File contents, database schemas, API documentation, configuration. Resources are identified by URIs.
3. Prompts (Templates)
Pre-written prompt templates that help the AI handle common tasks consistently. A "create a new API endpoint" prompt might include boilerplate for authentication, logging, and error handling.
MCP Is the OSI Model for AI Tooling
The parallel to USB is helpful but incomplete. MCP is more accurately the OSI model for AI tooling — a layered abstraction that separates the AI from the service, the service from the transport, and the transport from the protocol. This layered design means any AI host can talk to any MCP server, regardless of whether the server is a local subprocess or a remote service. The industry has already built over 50 community servers for everything from GitHub to Slack to PostgreSQL. The protocol's simplicity — JSON-RPC 2.0 over stdio — means a new server can be written in under 100 lines of code.
The Multi-Agent Workflow Angle
MCP becomes particularly powerful in multi-agent workflows. As noted in a separate guide on Claude Code workflows, the engineers getting the largest gains are running several agents at once, each with a narrow job, coordinated through a plan that a human reviewed before any code was written. One agent explores the codebase and writes a spec. Another implements against that spec. A third reviews the diff with fresh eyes. MCP provides the standardized interface that makes this orchestration possible — each agent can call the same tools without custom integration code.
Anthropic's own guidance is conservative: find the simplest solution possible, and only increase complexity when it demonstrably improves outcomes. Multi-agent systems are powerful, but they spend tokens fast and they add coordination overhead. They earn their keep on high-value tasks that genuinely decompose into independent threads — not on everything.
What to watch
Watch for the MCP specification to reach 1.0 status, likely by mid-2026. The number of community servers will be a key adoption metric — if it crosses 500, MCP becomes the de facto standard. Also watch for OpenAI and Google to either adopt MCP or launch competing protocols.
Source: dev.to
[Updated 25 Jun via devto_mcp]
A developer has demonstrated converting a legacy Spring Boot REST API into an MCP server in just 50 lines of Java code by auto-mapping OpenAPI specs to MCP tools [per dev.to]. The OpenApiMcpAdapter reads SpringDoc OpenAPI documentation and exposes every operation (GET, POST, PUT, DELETE) as an MCP tool without manual rewrites. The author notes this approach solves the maintenance burden of keeping two parallel API descriptions in sync — a problem they learned over six years of maintaining their knowledge base project.
Originally published on gentic.news
Top comments (1)
The USB analogy gets attention, but the OSI model framing is the more useful part for builders: MCP is really about making the integration boundary boring. JSON-RPC 2.0 over stdio/WebSocket, plus the clean split between tools, resources, and prompts, gives teams a way to expose GitHub, PostgreSQL, or internal APIs without inventing a new agent contract every time. The founder/engineer trap is assuming 50+ servers equals readiness; the real leverage comes when permissions, auditability, and versioning are treated as product requirements from day one.