One of the most important — and least hyped — developments in AI tooling in 2025 and 2026 has been the emergence of the Model Context Protocol. MCP is an open standard that defines how AI assistants connect to external tools, data sources, and services. If REST APIs standardised how web services talk to each other, MCP is doing the same for how AI agents talk to the rest of the software world.
The problem MCP solves
Before MCP, every AI tool integration was a custom one-off. If you wanted Claude to read your Jira tickets, you wrote a custom integration. If you wanted Copilot to query your database, you wrote another. If you switched AI providers, you rewrote everything. Each tool vendor and AI vendor maintained their own incompatible plugin system.
MCP standardises this. An MCP server exposes tools and data sources through a consistent interface. Any MCP-compatible AI client can connect to any MCP server — the integration is written once and works everywhere.
How it works
MCP uses a client-server architecture over JSON-RPC. The AI client (Claude, Copilot, Cursor, etc.) connects to one or more MCP servers. Each server exposes:
- Tools — functions the AI can call: search a database, create a calendar event, send a message, run a shell command
- Resources — data the AI can read: a file, a database table, an API response, documentation
- Prompts — reusable prompt templates the AI can use
The AI decides which tools to call and when, based on the task at hand. It calls the tool, receives the result, and uses it in its reasoning — the same loop as any agentic system, but now over a standardised protocol.
# A minimal MCP server in Python (using the official SDK)
from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp.types import Tool, TextContent
app = Server("my-tools")
@app.list_tools()
async def list_tools():
return [Tool(
name="get_weather",
description="Get current weather for a city",
inputSchema={"type": "object", "properties": {
"city": {"type": "string"}
}, "required": ["city"]}
)]
@app.call_tool()
async def call_tool(name: str, arguments: dict):
if name == "get_weather":
city = arguments["city"]
# Call your weather API here
return [TextContent(type="text", text=f"Weather in {city}: 22°C, sunny")]
async def main():
async with stdio_server() as (read, write):
await app.run(read, write, app.create_initialization_options())
import asyncio
asyncio.run(main())What MCP servers exist today
The MCP ecosystem has grown rapidly since Anthropic open-sourced the protocol in late 2024. Official and community servers now exist for:
| Category | Examples |
|---|---|
| Development tools | GitHub, GitLab, VS Code, file system |
| Databases | PostgreSQL, SQLite, MySQL, MongoDB |
| Productivity | Google Drive, Notion, Slack, Linear, Jira |
| Web | Brave Search, Puppeteer, fetch/scrape |
| Cloud | AWS, GCP, Cloudflare |
| Communication | Gmail, Outlook, Twilio |
The full registry is at github.com/modelcontextprotocol/servers. Most are open source and straightforward to run locally or deploy to a server.
Setting up MCP with Claude Desktop
The fastest way to try MCP is with Claude Desktop, which supports MCP servers out of the box. Configuration lives in a JSON file:
// claude_desktop_config.json (macOS: ~/Library/Application Support/Claude/)
{
"mcpServers": {
"filesystem": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Documents"]
},
"github": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-github"],
"env": {
"GITHUB_PERSONAL_ACCESS_TOKEN": "your-token-here"
}
},
"postgres": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://localhost/mydb"]
}
}
}Restart Claude Desktop after saving. Claude will now have access to those tools and will use them automatically when relevant — you can ask it to query your database, create a GitHub issue, or read a file from your documents folder directly in conversation.
MCP vs function calling
If you have used OpenAI’s function calling or Anthropic’s tool use, MCP will feel familiar — it is built on top of the same concept. The difference is that function calling is defined per-request in the API payload, while MCP is a persistent server that any client can connect to. Function calling is for building a specific integration into a specific application; MCP is for building a tool once and making it available to any AI client.
Why this matters for the future
MCP is becoming the de facto standard for AI tool integration. It is already supported by Claude, Cursor, Codeium, and a growing list of tools. As adoption increases, the network effect compounds — more MCP servers means more capable AI clients, which drives more MCP server development.
For developers, the practical implication is clear: if you are building integrations between AI and your internal tools or systems, build them as MCP servers rather than one-off custom integrations. You write it once; it works with every MCP-compatible client, now and in the future.