Model Context Protocol (MCP): The Standard Reshaping How AI Connects to Everything

The Problem Before MCP

Every AI integration used to be a bespoke engineering project. Connect Claude to your CRM? Write a custom tool definition. Connect it to Slack? Different code. Connect it to your database? Different again. Each integration had to be rebuilt for every new model, every new app, every new use case. The combinatorial explosion — N models × M tools — meant most integrations never got built.

Anthropic released the Model Context Protocol (MCP) in November 2024 as an open standard to fix this. MCP is a protocol — like HTTP for web pages, or USB for hardware — that standardises how AI models communicate with external tools, data sources, and services. Any MCP-compatible model can connect to any MCP-compatible server, instantly, without custom integration code.

By early 2025, MCP had been adopted by OpenAI, Google DeepMind, Microsoft Copilot, and hundreds of open-source tool builders. It is rapidly becoming the foundational protocol of the agentic AI stack.

The Architecture: Hosts, Clients, and Servers

MCP has three roles:

• MCP Host: The AI application — Claude Desktop, Cursor, your custom agent. It orchestrates the conversation and decides when to call tools.
• MCP Client: The protocol client embedded in the host. It manages connections to one or more MCP Servers and translates between the host's needs and the protocol.
• MCP Server: A lightweight process that exposes tools, resources, and prompts to any MCP client. It can wrap a database, an API, a file system, a web browser — anything.

The communication is JSON-RPC 2.0 over stdio (for local servers) or HTTP with Server-Sent Events (for remote servers). The protocol is deliberately simple — the complexity lives in the servers, not the protocol itself.

Three Primitives: Tools, Resources, Prompts

MCP Servers expose three types of capabilities:

1. Tools (Model-Controlled Actions)

Tools are functions the AI model can call to take action or retrieve live data. They are the equivalent of function calling, but defined once in the MCP Server and available to any compatible model. A postgres MCP server might expose tools like query, list_tables, describe_table. A github MCP server exposes create_issue, list_prs, merge_pr.

2. Resources (Application-Controlled Data)

Resources are data sources the application (host) exposes to the model as context — files, database records, API responses. Unlike tools (which the model requests on demand), resources are typically injected into context by the host application. A resource might be file:///project/src/main.py or postgres://db/customers/42.

3. Prompts (User-Controlled Templates)

Prompts are reusable, parameterised prompt templates stored in MCP Servers. Users can invoke them by name: "Use the code_review prompt on this PR." The server returns a structured prompt with the arguments filled in, which the host sends to the model.

Building Your First MCP Server (Python)

The official mcp Python SDK makes server creation trivial:

from mcp.server.fastmcp import FastMCP
import psycopg2

mcp = FastMCP("CRM Database")

@mcp.tool()
def get_contact(email: str) -> dict:
    """Retrieve a CRM contact record by email address."""
    conn = psycopg2.connect(DATABASE_URL)
    cur = conn.cursor()
    cur.execute("SELECT * FROM contacts WHERE email = %s", (email,))
    row = cur.fetchone()
    return {"id": row[0], "name": row[1], "company": row[2], "score": row[3]}

@mcp.tool()
def update_lead_score(contact_id: int, score: float, reason: str) -> dict:
    """Update the AI lead score for a contact."""
    # update logic here
    return {"success": True, "contact_id": contact_id, "new_score": score}

if __name__ == "__main__":
    mcp.run()  # starts the stdio server

That's a complete MCP server. Run it, add it to Claude Desktop's config, and Claude can now query and update your CRM using natural language — with zero custom integration code on the Claude side.

MCP vs Function Calling: Key Differences

• Portability: Function calling definitions live in your application code — tied to one model API. MCP servers are standalone processes compatible with any MCP client. Write once, use with Claude, GPT-4o, Gemini, Cursor, and any future model.
• Discovery: MCP clients can query servers to discover available tools dynamically — no hardcoded tool lists in your app.
• Security: MCP servers run as separate processes with their own permissions boundary. The AI model cannot directly access your database — it goes through the MCP server, which enforces its own authorisation logic.
• Ecosystem: Hundreds of pre-built MCP servers exist — for GitHub, Postgres, Slack, Stripe, Notion, Google Drive, Brave Search, filesystem access. Your agent can use any of them without writing integration code.

The Ecosystem: Pre-Built MCP Servers

As of early 2025, the MCP ecosystem includes servers for:

• Data: PostgreSQL, MySQL, SQLite, MongoDB, Redis
• Developer tools: GitHub, GitLab, Linear, Jira, Sentry
• Productivity: Notion, Google Drive, Google Docs, Obsidian, Slack
• Web: Brave Search, Puppeteer (browser automation), Fetch
• Finance: Stripe, QuickBooks
• AI: Memory (persistent agent memory), Sequential Thinking, EverArt

The implication: a single AI agent with access to the right MCP servers can search the web, read your Notion wiki, query your database, create GitHub issues, charge a Stripe customer, and send a Slack message — all through a standardised protocol, with no custom integration code.

MCP in Production: What It Means for AI Development

MCP fundamentally changes the economics of AI integration. Instead of every company building custom tool integrations for every model they use, tool providers build one MCP server and it works everywhere. This is the "USB moment" for AI — when the interface standardises, the ecosystem explodes.

For businesses building AI systems today, the practical implication is clear: build your internal tools as MCP servers. Your CRM MCP server, your ERP MCP server, your document management MCP server — expose them once via MCP, and they become instantly accessible to any AI model, any agent framework, any AI-powered IDE your team uses. The investment compounds over every future AI integration.