What Is MCP? The Model Context Protocol Developer Guide 2026

The Problem MCP Solves: Every AI Tool Is an Island

Before MCP, connecting an AI model to an external data source required custom code for every combination. Want Claude to read your Notion docs? Write a Notion integration. Want Copilot to query your database? Write a different integration. Want both to work at the same time? Write two integrations and maintain them separately as both APIs change.

This N×M problem scales badly. There are dozens of AI clients and thousands of possible data sources. Every integration is one-off glue code: fragile, non-transferable, and invisible to the AI model itself.

MCP replaces all of that glue code with one protocol: you build an MCP server once and any MCP-compatible AI client can connect to it.

What Is MCP? The Model Context Protocol Explained

MCP (Model Context Protocol) is an open protocol published by Anthropic in late 2024. It defines a standard way for AI models to communicate with external servers that provide tools, data, and instructions. Think of it as a USB-C standard for AI context: one connector, hundreds of compatible devices.

The protocol runs between two sides. The MCP client is the AI application (Claude Desktop, Cursor, VS Code with Copilot, your own app). The MCP server is a process you run locally or remotely that exposes capabilities: file system access, database queries, API calls, custom functions. The client asks the server what it can do, the server lists its tools and resources, and the model decides when and how to call them during a conversation.

MCP is transport-agnostic. The same server can communicate over stdio (a local subprocess pipe), HTTP with Server-Sent Events (SSE), or WebSocket. Clients that run local subprocesses use stdio. Clients that connect to remote or shared servers use HTTP+SSE. This distinction matters when you want more than one machine to share the same MCP server.

🤖 MCP in Claude Desktop

Claude Desktop was the first major MCP client. It supports both stdio servers (local subprocesses) and HTTP+SSE servers (remote URLs). Configuration lives in a single JSON file at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS, or %APPDATA%\Claude\claude_desktop_config.json on Windows.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/you/Documents"]
    },
    "sqlite": {
      "command": "uvx",
      "args": ["mcp-server-sqlite", "--db-path", "/Users/you/data.db"]
    }
  }
}

With stdio servers, the server process starts and stops with Claude Desktop. Only your local machine can use it, and only one Claude Desktop instance at a time. If you want a colleague to access the same MCP server, stdio won't cut it. You need HTTP+SSE, and the server needs a public URL.

{
  "mcpServers": {
    "shared-tools": {
      "url": "https://yourname.localto.net/sse"
    }
  }
}

When you expose your local MCP server through a Localtonet tunnel (covered in detail below), every teammate can add that URL to their own claude_desktop_config.json and use the same tools and resources without running anything locally. No cloud deployment. No Docker registry. The server keeps running on your machine.

⚡ MCP in Cursor

Cursor added MCP support in version 0.43. It works in both Agent mode and normal chat, giving the AI access to any tools your MCP server exposes. Configuration lives in ~/.cursor/mcp.json (global) or .cursor/mcp.json at the root of a project (per-project).

{
  "mcpServers": {
    "my-tools": {
      "command": "node",
      "args": ["/home/you/mcp-servers/my-tools/index.js"]
    },
    "remote-db": {
      "url": "https://yourname.localto.net/sse"
    }
  }
}

In Cursor's Agent mode, the model automatically decides when to call MCP tools based on the task. Ask it to "check the customers table for orders placed in the last 7 days" and it calls run_sql_query on your locally running MCP server, without you writing any query yourself.

The per-project .cursor/mcp.json is particularly useful for team repositories: commit it to your repo and every developer who opens the project in Cursor gets the same MCP tools, pointed at the same remote URL.

💻 MCP in VS Code: GitHub Copilot and Continue.dev

VS Code gained MCP support through two routes. GitHub Copilot (version 1.99+) added native MCP support in its Agent mode. Continue.dev, the open-source AI coding extension, added MCP support in v0.9.

GitHub Copilot (VS Code 1.99+):

Add your MCP servers to VS Code's settings.json under the github.copilot.chat.mcp.servers key. This works in Copilot's Agent mode, where the model can call tools mid-conversation.

{
  "github.copilot.chat.mcp.servers": {
    "my-mcp-server": {
      "type": "sse",
      "url": "https://yourname.localto.net/sse"
    }
  }
}

Continue.dev:

In Continue's config.json (at ~/.continue/config.json), add an mcpServers array. Continue passes the server's tools to whatever model you have configured (GPT-4o, Claude, a local Ollama model).

{
  "mcpServers": [
    {
      "name": "my-tools",
      "transport": {
        "type": "sse",
        "url": "https://yourname.localto.net/sse"
      }
    }
  ]
}

Both extensions reload MCP server connections automatically when you update the config file. No restart required. This is useful during active development of the server itself.

How to Build and Expose an MCP Server: Step-by-Step (2026)

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
import express from "express";

const app = express();
app.use(express.json());

const server = new Server(
  { name: "my-mcp-server", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: "get_time",
    description: "Returns the current server time",
    inputSchema: { type: "object", properties: {} }
  }]
}));

server.setRequestHandler(CallToolRequestSchema, async (req) => {
  if (req.params.name === "get_time") {
    return { content: [{ type: "text", text: new Date().toISOString() }] };
  }
  throw new Error("Unknown tool");
});

let transport;
app.get("/sse", async (req, res) => {
  transport = new SSEServerTransport("/messages", res);
  await server.connect(transport);
});
app.post("/messages", async (req, res) => {
  await transport.handlePostMessage(req, res);
});

app.listen(3000, "0.0.0.0", () => console.log("MCP server on http://0.0.0.0:3000"));

npm install @modelcontextprotocol/sdk express
node server.mjs

curl -N https://mytools.localto.net/sse

🛠 Tips for Running MCP Servers in Production

Frequently Asked Questions