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 Reference Servers​

Anthropic and the community maintain a curated set of reference servers in the modelcontextprotocol/servers repository. The most useful ones for web development teams:

ServerWhat it does
filesystemRead and write local files within a specified directory
githubBrowse repos, read and create issues and PRs, search code
postgresRun read-only SQL queries against a PostgreSQL database
sqliteSame for SQLite databases
fetchMake HTTP requests to any URL — useful for reading docs or live APIs
brave-searchWeb search via Brave's API
memoryPersistent key-value memory across sessions
puppeteerBrowser automation — navigate, screenshot, scrape
playwrightBrowser automation with better cross-browser support
chrome-devtoolsConnect to a running Chrome instance for inspection and automation via DevTools Protocol
figmaRead Figma files and components — useful for design-to-code workflows
tip

The github + fetch + filesystem trio covers the majority of useful AI-assisted developer workflows without requiring any external service accounts beyond a GitHub token.

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 mcp.so and Smithery — community registries of published MCP servers.

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. Put secret values like tokens in your shell environment (not in the file).

.vscode/mcp.json
{
  "servers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "${workspaceFolder}"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${env:GITHUB_TOKEN}"
      }
    }
  }
}
caution

Never commit real tokens or secrets to .vscode/mcp.json. Use ${env:VARIABLE_NAME} to reference values from your shell environment, or add secret values to a .env file that is gitignored.

To activate: open Copilot Chat, switch to Agent mode (the dropdown in the chat input), and the configured servers are available as tools automatically.

Reference: VS Code MCP documentation

Setting Up MCP in Cursor​

Configure servers in Cursor Settings → MCP tab, or via a mcp.json file in the project root. The JSON schema is the same as the VS Code format.

mcp.json (Cursor)
{
  "servers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${env:GITHUB_TOKEN}"
      }
    }
  }
}

Once configured, MCP tools appear in the @ mention menu in Cursor Chat and Composer.

Reference: Cursor MCP documentation

MCP Specification 2026-07-28 Release Candidate​

The MCP specification has a release candidate locked May 21, 2026, with the stable release scheduled for July 28, 2026. The changes are significant for server implementers and integrators.

note

The RC changes below will be finalized July 28, 2026. The current (2025-11-25) specification remains active in all shipping SDKs until then.

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.

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.

Resources​