MCP — the protocol that connects
AI to every tool in the world

What is MCP and why does it matter?

Before MCP, anyone who wanted to connect AI to an external tool — Slack, GitHub, a database, files — had to write an integration from scratch, custom for each model and each service. Endless duplicate work, hard maintenance, and incompatibility.

MCP solves this elegantly: a uniform communication protocol (JSON-RPC over stdio or SSE) that defines how AI Clients (like Claude Desktop, Cursor, Windsurf) talk to MCP Servers that expose tools, resources and prompts.

MCP vs Function Calling

Function Calling (found in OpenAI and Anthropic) lets AI invoke functions — but those functions are defined in the prompt and run on the client side. MCP is a layer above that: the tools live in a separate server, are managed separately, and can be connected to any AI client that supports the protocol.

How MCP works — under the hood

The three primitives of MCP

Transport Layers — how the Client and Server communicate

• stdio — the most common. The server runs as a subprocess, communicating via stdin/stdout. Fast and simple, suited to local servers.
• SSE (Server-Sent Events) — for remote servers running over HTTP. Allows remote connection and sharing a server between multiple clients.
• Streamable HTTP — the next generation of SSE. Supports bidirectional signals and is improved for performance.

Connecting MCP to Claude Desktop

Claude Desktop is Anthropic's official MCP client. Configuring MCP servers is done through a single JSON file.

The config file location

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

The file structure

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/yourname/Documents"
      ]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_..."
      }
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA..."
      }
    }
  }
}

5 servers worth adding right away

MCP with Cursor and Windsurf

Both Cursor and Windsurf support MCP and let the code editors access external tools directly from Agent Mode. This is especially powerful when developing — Claude in Cursor can send metrics to Datadog, open tickets in Jira, and check Supabase — all without leaving the IDE.

Configuration in Cursor

In Cursor, go toSettings → Features → MCP and click "Add new MCP server". You can also directly edit ~/.cursor/mcp.json:

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server-supabase@latest",
               "--supabase-url", "https://xxx.supabase.co",
               "--supabase-service-role-key", "eyJ..."]
    }
  }
}

MCP servers worth knowing

Development and DevTools

Management and operations

Building your own MCP server

Building an MCP server is surprisingly simple. Anthropic provides an SDK for Python and TypeScript. In 30 lines of code you can create a server that exposes tools to Claude.

A basic server in Python (FastMCP)

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("my-server")

@mcp.tool()
def get_weather(city: str) -> str:
    """Get the weather forecast for a city"""
    # in practice — a call to an API
    return f"The weather in {city}: 25°C, partly cloudy"

@mcp.tool()
def calculate(expression: str) -> float:
    """Evaluate a math expression"""
    return eval(expression)  # for example only!

@mcp.resource("docs://readme")
def get_readme() -> str:
    """Read the project's README"""
    with open("README.md") as f:
        return f.read()

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

A server in TypeScript

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

const server = new McpServer({ name: "my-server", version: "1.0.0" });

server.tool(
  "search_database",
  { query: z.string(), limit: z.number().optional() },
  async ({ query, limit = 10 }) => {
    // an actual DB call
    const results = await db.search(query, limit);
    return {
      content: [{ type: "text", text: JSON.stringify(results) }]
    };
  }
);

const transport = new StdioServerTransport();
await server.connect(transport);

Connecting the server you built to Claude Desktop

{
  "mcpServers": {
    "my-server": {
      "command": "python",
      "args": ["/path/to/my_server.py"]
    }
  }
}

Examples from the field — what people build with MCP

MCP isn't just a technical tool — it's a paradigm shift. AI moves from a "conversation assistant" to an "active player" connected to your environment. The moment you connect Claude to the tools you work with every day, you'll understand why it's the most important thing that happened in AI in 2025.