Model Context Protocol (MCP)

Model Context Protocol (MCP) is an open standard, introduced by Anthropic in late 2024, that solves one of the most practical friction points in building AI-powered systems: getting the model to talk to everything else.

Before MCP, connecting an AI assistant to your database, your CRM, your file system, or your internal APIs meant writing a custom integration for every combination. With MCP, any compliant AI client can talk to any compliant server through a single, well-defined protocol — the same way HTTP lets any browser talk to any web server.

The Problem MCP Solves

Building production AI systems involves connecting a model to many external systems: databases, APIs, file systems, SaaS tools, internal services. Each connection historically required:

• A bespoke connector written specifically for that AI client + data source pair
• Re-implementation if you switched models or frameworks
• No standardisation around authentication, error handling, or capability discovery

This creates an M×N integration problem — M AI applications multiplied by N data sources equals an explosion of one-off connectors that are expensive to build and maintain.

MCP collapses this to M + N: build one MCP client per AI application, one MCP server per data source, and every client works with every server.

Architecture

MCP follows a client–server model with three roles:

MCP Host

The AI application (e.g. Claude, an IDE extension, a custom agent) that wants to use external context or tools. The host manages connections to one or more MCP servers.

MCP Client

A component within the host that speaks the MCP protocol — establishing connections, sending requests, and receiving responses from MCP servers.

MCP Server

A lightweight service that exposes a specific system’s capabilities over the MCP protocol. A Postgres MCP server exposes database queries; a GitHub MCP server exposes repo operations; a Slack MCP server exposes messaging.

The Three Primitives

MCP defines three types of capabilities a server can expose:

Tools

Executable functions the model can call to take action. Examples: run a SQL query, send a Slack message, create a GitHub issue, execute a shell command. Tools are the most commonly used primitive and are what power agentic workflows.

Resources

Read-only data sources the model can pull context from. Examples: a file’s contents, a database record, a document from Google Drive. Resources let the model ground its responses in current, accurate data without the model needing to know the specifics of how to fetch it.

Prompts

Pre-defined prompt templates or workflows the server exposes for the client to invoke. Useful for encoding domain-specific interaction patterns — for example, a legal review prompt or a code review checklist — in a reusable, server-side definition.

How a Request Flows

1. The AI model decides it needs external context or wants to take an action
2. The MCP client sends a structured request to the relevant MCP server (tool call, resource read, or prompt invocation)
3. The MCP server executes the request against the underlying system and returns a structured response
4. The model receives the result and incorporates it into its reasoning

The protocol handles capability discovery (the client can ask a server what tools/resources/prompts it offers), authentication, and error signalling in a standardised way.

Adoption and Ecosystem

MCP grew rapidly after its open-source release:

• 97 million monthly SDK downloads by December 2025
• 10,000+ active MCP servers in production
• Supported natively by Claude, ChatGPT, Cursor, VS Code, and most major AI platforms
• Pre-built official servers for Google Drive, Slack, GitHub, Git, PostgreSQL, and Puppeteer

In December 2025, Anthropic donated MCP governance to the Agentic AI Foundation under the Linux Foundation, with founding members including OpenAI, AWS, Google, Microsoft, and Block — cementing it as a community-owned infrastructure standard rather than a single-vendor protocol.

MCP vs. Function Calling / Tool Use

Function calling (as implemented by OpenAI, Anthropic, etc.) defines how a model invokes tools within a single API. MCP defines how any AI client connects to any tool server, making the two complementary rather than competing — MCP servers often surface their capabilities via a model’s native function-calling interface.

Why MCP Matters for AI Teams

• Build once, use everywhere: An MCP server for your internal knowledge base works with Claude, a custom agent, and any IDE that adds MCP support — without rewriting the connector.
• Security boundary: MCP servers control what the model can and cannot do with a system. Permissions, scoping, and audit logging happen at the server layer, not inside the model.
• Faster agent development: Teams composing agentic workflows pick from a growing catalogue of community-built MCP servers rather than writing integrations from scratch.
• Auditability: Every tool call goes through a defined interface, making it straightforward to log, replay, and inspect model actions against external systems.

# server.py — run with: python server.py
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather")

@mcp.tool()
def get_weather(city: str) -> dict:
    """Return current temperature and conditions for a city."""
    # Replace with a real weather API call
    mock_data = {"London": {"temp_c": 14, "condition": "Cloudy"}}
    return mock_data.get(city, {"error": "City not found"})

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


# client.py — connect Claude to the MCP server and call the tool
import asyncio
import anthropic
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    server_params = StdioServerParameters(command="python", args=["server.py"])

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()

            # List available tools
            tools_result = await session.list_tools()
            mcp_tools = [
                {"name": t.name, "description": t.description, "input_schema": t.inputSchema}
                for t in tools_result.tools
            ]

            client = anthropic.Anthropic()
            response = client.messages.create(
                model="claude-opus-4-8",
                max_tokens=512,
                tools=mcp_tools,
                messages=[{"role": "user", "content": "What's the weather in London?"}],
            )

            # If Claude calls a tool, execute it via MCP
            for block in response.content:
                if block.type == "tool_use":
                    result = await session.call_tool(block.name, block.input)
                    print(f"Tool result: {result.content}")

asyncio.run(main())