Coding Agents

MCP config generator for Claude, Cursor and VS Code

Q: Where does the Claude Desktop config file go?

On macOS it’s ~/Library/Application Support/Claude/claude_desktop_config.json, and on Windows %APPDATA%\Claude\claude_desktop_config.json. The easiest way to open it is Settings → Developer → Edit Config. Restart Claude Desktop after saving. Remote servers aren’t added in this file: add them as a custom connector under Customize → Connectors → + Add, where you can also set request headers.

Q: Why is VS Code’s config different?

VS Code’s .vscode/mcp.json uses a top-level servers key instead of mcpServers, and each server has a type of stdio or http. It can also define inputs: VS Code asks for those values the first time a server starts and stores them securely, which is the safest way to handle keys. The generator uses them for every secret.

Q: How do I keep API keys out of my config?

Write keys as ${NAME} in the generator and set NAME as an environment variable. Each app gets its own syntax: ${NAME} for Claude Code’s .mcp.json, ${env:NAME} for Cursor and Devin Desktop, and a hidden prompt for VS Code. Claude Desktop doesn’t document variable support, so its file needs the real value; it lives in your user folder and should never be shared.

Q: Should I use .mcp.json or claude mcp add?

Use .mcp.json in the project root for servers your whole team should have: commit it, and each person sets the variables locally. Use claude mcp add for servers only you need. With --scope local they apply to the current project, and with --scope user to every project; both are stored in ~/.claude.json, not in the repository.

Pick MCP servers once and get the right config for Claude Code, Claude Desktop, Cursor, VS Code and Devin Desktop (Windsurf), with your keys kept out of the files. It runs in your browser.

.mcp.json · Project root. Commit it to share the servers with your team; each person sets the variables in their own shell.

.mcp.json

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${GITHUB_MCP_PAT}"
      }
    },
    "playwright": {
      "command": "npx",
      "args": [
        "-y",
        "@playwright/mcp@latest"
      ]
    }
  }
}

On native Windows (not WSL), the reference servers’ READMEs start npx through `cmd /c`: if a server won’t start, use "command": "cmd" with "args": ["/c", "npx", …].

Terminal · Run in your project. --scope local keeps the servers private to you in this project; use user for every project.

Terminal

claude mcp add --scope local --transport http github https://api.githubcopilot.com/mcp/ --header "Authorization: Bearer ${GITHUB_MCP_PAT}"
claude mcp add --scope local playwright -- npx -y @playwright/mcp@latest

Set GITHUB_MCP_PAT first, e.g. export GITHUB_MCP_PAT=… in your shell. The command saves the value, not the variable.

claude_desktop_config.json · macOS: ~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json (Settings → Developer → Edit Config). Restart Claude after saving.

claude_desktop_config.json

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [
        "-y",
        "@playwright/mcp@latest"
      ]
    }
  }
}

github is a remote server: add it as a custom connector (Customize → Connectors → + Add → Add custom connector; on Team and Enterprise plans an owner adds it under Organization settings → Connectors), with the URL https://api.githubcopilot.com/mcp/.
GitHub’s own guide says its remote server can’t sign in from Claude Desktop yet and recommends its local Docker server there instead.

.cursor/mcp.json · In your project, or ~/.cursor/mcp.json for every project.

mcp.json

{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${env:GITHUB_MCP_PAT}"
      }
    },
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@playwright/mcp@latest"
      ]
    }
  }
}

.vscode/mcp.json · In your workspace. VS Code asks for each secret the first time a server starts and stores it securely.

mcp.json

{
  "inputs": [
    {
      "type": "promptString",
      "id": "github-mcp-pat",
      "description": "GITHUB_MCP_PAT",
      "password": true
    }
  ],
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${input:github-mcp-pat}"
      }
    },
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@playwright/mcp@latest"
      ]
    }
  }
}

mcp_config.json · macOS/Linux: ~/.config/devin/mcp_config.json · Windows: %APPDATA%\devin\mcp_config.json. Read by the default Devin Local agent and by the legacy Cascade agent.

mcp_config.json

{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${env:GITHUB_MCP_PAT}"
      }
    },
    "playwright": {
      "command": "npx",
      "args": [
        "-y",
        "@playwright/mcp@latest"
      ]
    }
  }
}

Devin’s docs confirm ${env:…} references for the legacy Cascade agent; for the default Devin Local agent they only document them in OAuth settings. If a server can’t authenticate, check Devin’s MCP docs.

Everything is generated in your browser. Don’t commit files that contain real keys; use the variables instead.

Steps

How to use the MCP config generator

Tick the servers you want, or add a custom command or URL.
Edit paths and arguments, and write any keys as ${NAME} instead of pasting them.
Open the tab for your app and copy or download the config.
Save it where the tab says, set the variables, and restart the app or run /mcp in Claude Code.

Method

How it works

Every AI coding app supports MCP servers, but each one stores them differently. The file names differ, VS Code uses servers where the others use mcpServers, Claude Desktop takes remote servers only as connectors, and each app has its own way of reading a secret. A config that works in one app is silently ignored by another. This generator writes the same servers in each app’s format.

Local and remote servers

A local (stdio) server is a program the app starts on your computer, usually with npx for Node.js packages or uvx for Python ones. A remote server runs on the internet and the app connects to its URL. Many remote servers from companies like Notion, Linear and Atlassian use OAuth: you add the URL and sign in when the app asks. Others, like GitHub’s, take a token in an Authorization header, and some, like Context7’s, work without signing in.

Keeping keys safe

A key pasted into a config file ends up wherever that file goes: a Git commit, a screenshot, a support ticket. The generator writes every key as a variable reference in the syntax each app understands, so the file only names the variable and the value stays in your environment. VS Code goes further: it prompts for the value once and stores it securely. Claude Desktop is the exception, because variable support isn’t documented for its config; the generator fills in values you type (they never leave this page) or leaves a placeholder and tells you to replace it.

How the formats were checked

Each format follows the app’s own documentation, checked on 2026-10-08. The server list contains only packages that are current and not deprecated on npm or PyPI, and remote servers whose endpoints answered an MCP request on that date. Older servers that have been retired, such as the original GitHub, Brave Search and Postgres reference servers, are left out.

Examples

Worked examples

GitHub (remote, with a token) and Filesystem (local) in four apps

Claude Code: .mcp.json

{
  "mcpServers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${GITHUB_MCP_PAT}"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/folder"
      ]
    }
  }
}

Cursor: .cursor/mcp.json

{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${env:GITHUB_MCP_PAT}"
      }
    },
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/folder"
      ]
    }
  }
}

VS Code: .vscode/mcp.json

{
  "inputs": [
    {
      "type": "promptString",
      "id": "github-mcp-pat",
      "description": "GITHUB_MCP_PAT",
      "password": true
    }
  ],
  "servers": {
    "github": {
      "type": "http",
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${input:github-mcp-pat}"
      }
    },
    "filesystem": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/folder"
      ]
    }
  }
}

Devin Desktop (Windsurf): mcp_config.json

{
  "mcpServers": {
    "github": {
      "url": "https://api.githubcopilot.com/mcp/",
      "headers": {
        "Authorization": "Bearer ${env:GITHUB_MCP_PAT}"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/path/to/allowed/folder"
      ]
    }
  }
}

The token is never written into the file: each app reads GITHUB_MCP_PAT its own way. It has its own name because Claude Code reads some common credential variables as empty in remote server settings.

FAQ

Frequently asked questions

What is an MCP server?

The Model Context Protocol (MCP) is an open standard for connecting AI apps to tools and data. An MCP server exposes tools, such as “search issues” or “read a file”, that an assistant like Claude or Cursor can call. Local servers run on your computer as a command; remote servers run on the internet and are reached by URL.

Where does the Claude Desktop config file go?

On macOS it’s ~/Library/Application Support/Claude/claude_desktop_config.json, and on Windows %APPDATA%\Claude\claude_desktop_config.json. The easiest way to open it is Settings → Developer → Edit Config. Restart Claude Desktop after saving. Remote servers aren’t added in this file: add them as a custom connector under Customize → Connectors → + Add, where you can also set request headers.

Why is VS Code’s config different?

VS Code’s .vscode/mcp.json uses a top-level servers key instead of mcpServers, and each server has a type of stdio or http. It can also define inputs: VS Code asks for those values the first time a server starts and stores them securely, which is the safest way to handle keys. The generator uses them for every secret.

How do I keep API keys out of my config?

Write keys as ${NAME} in the generator and set NAME as an environment variable. Each app gets its own syntax: ${NAME} for Claude Code’s .mcp.json, ${env:NAME} for Cursor and Devin Desktop, and a hidden prompt for VS Code. Claude Desktop doesn’t document variable support, so its file needs the real value; it lives in your user folder and should never be shared.

Should I use .mcp.json or claude mcp add?

Use .mcp.json in the project root for servers your whole team should have: commit it, and each person sets the variables locally. Use claude mcp add for servers only you need. With --scope local they apply to the current project, and with --scope user to every project; both are stored in ~/.claude.json, not in the repository.

Why does my npx server fail on Windows?

On native Windows (not WSL), the official MCP reference servers’ READMEs start npx through cmd /c, for example claude mcp add my-server -- cmd /c npx -y some-package. The generator does this when you choose Windows for the command. In PowerShell, arguments starting with @ also need quotes, which the generator adds.

What happened to Windsurf?

Windsurf was renamed Devin Desktop in June 2026. Its MCP config is ~/.config/devin/mcp_config.json on macOS and Linux and %APPDATA%\devin\mcp_config.json on Windows, read by both the default Devin Local agent and the legacy Cascade agent. Remote servers use url (Cascade also accepts the older serverUrl).

Are MCP servers safe to run?

A local server runs with your user’s permissions, so it can do anything you can on your computer. Only install servers from sources you trust, give file-system servers access to specific folders rather than your whole drive, and review what each tool does when the app asks for approval.

Read