Skip to main content

MCP Servers

Model Context Protocol (MCP) is an open standard for connecting AI models to external data sources and tools. Instead of every AI tool reinventing integrations, MCP provides a single protocol that any client — Copilot, Cursor, Cline, Claude Code — can use to talk to any server: a database, the GitHub API, your file system, a browser.

What Is MCP?​

Introduced by Anthropic in November 2024 and quickly adopted across the ecosystem, MCP standardizes how AI models access context and invoke tools.

Architecture:

  • Host — the AI client (e.g., VS Code with Copilot, Cursor, Claude Desktop). It manages connections to servers and exposes their capabilities to the model.
  • Server — a local or remote process that exposes data or functions. You run one server per integration.
  • Client — the connection layer inside the host that handles the protocol.

A server can provide three things:

TypeDescription
ResourcesStructured data the model can read — file contents, database records, API responses
ToolsCallable functions the model can invoke — run a SQL query, create a GitHub issue, fetch a URL
PromptsReusable prompt templates the host surfaces to the user

Key Servers​

Reference Servers​

The MCP project maintains a small set of reference servers in the modelcontextprotocol/servers repository. They are intended as examples and building blocks; the most useful ones day to day:

ServerWhat it does
filesystemRead and write local files within a specified directory
fetchFetch a URL and convert it to Markdown — useful for reading docs or live APIs
gitRead, search, and manipulate a local Git repository
memoryPersistent knowledge-graph memory across sessions

Several servers that used to live there — including the old github, postgres, sqlite, puppeteer, and brave-search servers — have been archived and no longer receive fixes. Don't use them in new setups.

Vendor-Maintained Servers​

For most integrations, prefer the server maintained by the vendor itself:

ServerMaintainerWhat it does
GitHub MCP ServerGitHubRepos, issues, PRs, Actions, code search. Available as a hosted remote server — no local install
Playwright MCPMicrosoftBrowser automation through accessibility snapshots
Chrome DevTools MCPGoogle Chrome teamInspect and debug a running Chrome instance: network, console, performance traces
Figma MCPFigmaRead Figma designs and components for design-to-code workflows
MDN MCPMozillaMDN documentation and browser compatibility data
tip

GitHub + fetch + filesystem covers the majority of useful AI-assisted developer workflows. Many editors already include file access and web fetch as built-in tools, so you often only need the GitHub server.

MDN Web Docs MCP Server​

Mozilla maintains a remote HTTP MCP server at https://mcp.mdn.mozilla.net/ that gives AI assistants direct access to MDN documentation and browser compatibility data. Unlike most MCP servers, it requires no local installation — just an HTTP connection.

It exposes three tools:

ToolWhat it does
mcp_mdn_searchSearch MDN by keyword; returns summaries, doc paths, and compat-key values
mcp_mdn_get-docFetch full MDN page content as Markdown using a path from search results
mcp_mdn_get-compatRetrieve browser compatibility data by compat-key from search results

This server is already configured in this repository's .vscode/mcp.json:

.vscode/mcp.json
{
  "servers": {
    "mdn": {
      "type": "http",
      "url": "https://mcp.mdn.mozilla.net/"
    }
  }
}

Browser compatibility is where generic AI answers most often go wrong. The mcp_mdn_get-compat tool provides exact, up-to-date support tables instead of relying on a model's stale training data.

See MDN's MCP Server Brings Authoritative Web Docs Into Your Editor for setup instructions covering VS Code, Claude Code, Cursor, and Claude Desktop, plus MDN's benchmark results.

caution

When an AI agent has access to git or the github MCP server, it can commit, push, create PRs, and — if given write permissions — overwrite or delete branches. Always review exactly what repository permissions you have granted and ensure the agent operates with the principle of least privilege. Never give an agent push access to a main or protected branch.

For a broader catalog, see the official MCP Registry and the GitHub MCP Registry, or community directories such as mcp.so and Smithery. Community-listed servers are unvetted — see Agent Security before installing one.

Setting Up MCP in VS Code (Copilot)​

Requires GitHub Copilot with agent mode enabled.

Configure servers in .vscode/mcp.json at the workspace root. Commit this file so the whole team shares the same server configuration.

.vscode/mcp.json
{
  "inputs": [
    {
      "type": "promptString",
      "id": "postgres-url",
      "description": "PostgreSQL connection string (read-only user)",
      "password": true
    }
  ],
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/"
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem@<exact-version>", "${workspaceFolder}"]
    },
    "my-db-server": {
      "command": "npx",
      "args": ["-y", "<db-mcp-package>@<exact-version>"],
      "env": {
        "DATABASE_URL": "${input:postgres-url}"
      }
    }
  }
}
  • Remote servers ("type": "http") like GitHub's sign in with OAuth — VS Code shows an Auth prompt the first time. No token ends up in the file.
  • inputs with "password": true prompt each developer for a secret once and store it securely in VS Code, so the committed file never contains it.
  • Pin local servers to an exact version (package@1.2.3). npx -y package without a version runs whatever was published most recently — the same supply-chain risk as an unpinned dependency.
caution

Never commit real tokens or secrets to .vscode/mcp.json. Use inputs, OAuth, or ${env:VARIABLE_NAME} to reference values from your shell environment.

To activate: open Copilot Chat, switch to Agent mode, and the configured servers are available as tools. Use the tools picker in the chat input to turn individual tools off when you don't need them — every enabled tool's description is sent with each request.

Reference: VS Code MCP documentation

Setting Up MCP in Cursor​

Configure servers in .cursor/mcp.json in the project (or ~/.cursor/mcp.json for all projects). Note that Cursor uses an mcpServers key, not VS Code's servers — the same file won't work in both editors without changing it.

.cursor/mcp.json
{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${env:GITHUB_TOKEN}"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem@<exact-version>", "."]
    }
  }
}

Once configured, MCP tools are available to Cursor's agent; enable or disable them in Cursor Settings → MCP.

Reference: Cursor MCP documentation

note

Claude Code uses a project-level .mcp.json at the repo root, also with an mcpServers key. See Claude Code Customization.

MCP Specification 2026-07-28​

The 2026-07-28 revision of the MCP specification was released on July 28, 2026, with SDK support shipping alongside it. Client support is rolling out across hosts, so check your tool's release notes before relying on the new features. The changes matter mostly for server implementers and integrators.

Stateless core — the largest change. The initialize/initialized handshake and Mcp-Session-Id headers are removed. Protocol version, client info, and capabilities now travel in a _meta field on every request, allowing any server instance to handle any request without sticky routing or shared session stores — so servers can run on serverless and edge infrastructure.

New capabilities:

  • MCP Apps — servers can deliver interactive HTML/JS interfaces rendered in sandboxed iframes inside host environments (Claude Desktop, VS Code Copilot, Microsoft 365 Copilot). See MCP Apps.
  • Tasks extension — a handle-based pattern for long-running work: tools/call returns a task handle, then tasks/get / tasks/update / tasks/cancel manage the lifecycle.
  • Observability headers — Mcp-Method and Mcp-Name HTTP headers for load-balancer routing without parsing JSON-RPC; W3C Trace Context (traceparent, tracestate) for distributed tracing.

Deprecated (12-month sunset, removal no earlier than July 28, 2027):

  • Roots — replaced by tool parameters, resource URIs, or server configuration.
  • Sampling — replaced by direct LLM provider API calls.
  • Logging — replaced by stderr (stdio transports) or OpenTelemetry (structured observability).

See MCP Goes Stateless: Inside the 2026-07-28 Specification Release Candidate for the full breakdown (written at the release-candidate stage).

Resources​