GitHub Copilot isn't one MCP client. It's at least six: VS Code, Visual Studio, the JetBrains/Eclipse/Xcode plugins, Copilot CLI, the cloud agent that works on issues, and code review. Each one reads MCP servers from a different place, and each draws the line in a different spot on OAuth, approvals and which parts of the protocol it supports. A server that works fine in VS Code can be invisible in the CLI and refused outright in the cloud agent.
We run DialMCP, a remote MCP server that places phone calls and signs users in with OAuth, so we get to see these differences up close. This guide maps every Copilot surface: where its config lives, what format it expects, whether a remote OAuth server will work there, and what the org policies change. Everything below was checked against GitHub's, Microsoft's and VS Code's documentation on November 13, 2026, and the Copilot CLI parts against a real install of version 1.0.111. For click-by-click VS Code setup, use our VS Code docs page; this post covers everything around it.
Copilot MCP support by surface
| Surface | Where servers are configured | Root key | Remote server with OAuth |
|---|---|---|---|
| VS Code (Copilot harness, the default) | ~/.copilot/mcp-config.json, or .mcp.json at the workspace root | mcpServers | Yes |
| VS Code (Local harness, deprecated) | .vscode/mcp.json or the profile mcp.json | servers | Yes |
| Visual Studio 2022 17.14+ and 2026 | %USERPROFILE%\.mcp.json, then .vs\mcp.json, .mcp.json, .vscode\mcp.json or .cursor\mcp.json in the solution | servers | Yes, any OAuth provider |
| JetBrains, Eclipse, Xcode | The Copilot plugin's MCP settings (an mcp.json editor in JetBrains and Xcode, a preferences page in Eclipse) | servers | Yes, in preview |
| Copilot CLI | ~/.copilot/mcp-config.json, plus .mcp.json or .github/mcp.json in the repo | mcpServers | Yes |
| Cloud agent and code review | Repository Settings → Copilot → MCP servers | mcpServers | No; connectors cover some services, in sandbox sessions only |
The key name matters more than it looks. Copilot CLI, for example, won't read a file with servers at the top, and the cloud agent requires mcpServers. Our guide to mcp.json, settings.json and config.toml covers the same split across non-Copilot clients.
VS Code: the Copilot harness changed the config file
Most tutorials still say VS Code reads .vscode/mcp.json. That was true for a year, and it's now the legacy path. On October 28, 2026, GitHub made the Copilot harness the default for new chat sessions in VS Code. It's the same agent runtime that powers Copilot CLI and the Copilot app. VS Code's docs now call the old one the Local harness and say it "is deprecated and will be removed in February 2027."
The Copilot harness reads MCP servers from two files, both with a top-level mcpServers object:
~/.copilot/mcp-config.json(or$COPILOT_HOME/mcp-config.json) for servers you want everywhere. Copilot CLI uses this same file, so one entry covers both..mcp.jsonat the workspace root for servers you want to commit and share with the team.
VS Code's configuration reference is blunt about the old files: they "use the deprecated Local harness's editor-managed servers format," and the new harness "doesn't read those files directly." Some existing entries get forwarded, but not all of them. A server in .vscode/mcp.json that uses ${input:...} variables (the prompt-for-a-secret feature) isn't forwarded, so its tools just don't appear in a Copilot harness session. If a server that used to work has vanished, check for that first. The portable format uses plain ${NAME} environment references instead.
A minimal remote entry looks like this:
{
"mcpServers": {
"dialmcp": {
"type": "http",
"url": "https://mcp.dialmcp.com/mcp"
}
}
}
For a remote server that uses OAuth, VS Code's docs say Copilot sessions support it, using Dynamic Client Registration or a pre-registered client ID (oauthClientId in the portable format). Leave out headers and secrets for a server like ours: VS Code registers itself and opens a browser sign-in on first use. How that discovery works is explained in our MCP authorization guide.
Protocol coverage changed with the harness too. VS Code announced "complete" MCP spec support in June 2025, but that was the Local harness. In the Copilot harness, tools, sampling, elicitation and authorization work, and MCP Apps are experimental. The editor's /mcp.<server>.<prompt> slash commands for server prompts aren't exposed in Copilot sessions, though; VS Code's docs suggest skills instead (see skills vs MCP). Resources are read for MCP Apps, and native servers don't show up in the editor's resource browser.
One limit predates the harness and still applies: VS Code allows at most 128 enabled tools per chat request, and going over shows the error "Cannot have more than 128 tools per request." A few large servers can hit that. Deselect what you don't need in the tools picker, or let VS Code group tools with the github.copilot.chat.virtualTools.threshold setting.
Visual Studio
Visual Studio (2022 version 17.14 or later, or Visual Studio 2026) still uses the servers format. It's also the most generous reader of other tools' files. It checks, in order:
%USERPROFILE%\.mcp.json, for every solution.vs\mcp.jsonin the solution, for you only.mcp.jsonin the solution, for source control.vscode\mcp.jsonin the solution.cursor\mcp.jsonin the solution
Microsoft's docs say Visual Studio "supports authentication for remote servers by using any OAuth provider, in accordance with the MCP authorization specification." After you save a remote entry, a CodeLens in the file reads "Authentication Required"; click it to sign in. Two behaviors are worth knowing. Tools from a new server are disabled by default, so you have to switch them on in the tool picker. And if a server sends notifications/tools/list_changed, Visual Studio resets your earlier approvals for it, which Microsoft says is there "to prevent rug-pull attacks." Visual Studio also exposes MCP prompts and resources (through + Add Reference) and supports sampling, so it covers more of the protocol than VS Code's new harness does.
JetBrains, Eclipse and Xcode
The Copilot plugins for JetBrains IDEs, Eclipse and Xcode got MCP as a GA feature on August 14, 2025. All three use the same servers JSON, and all three hide the file behind a UI. In JetBrains, open Copilot Chat in Agent mode, click the tools icon, then Add MCP Tools. In Eclipse, go to Preferences → GitHub Copilot → MCP. In Xcode, it's the Copilot for Xcode app's Settings → MCP tab → Edit Config. GitHub's docs don't give an on-disk path for any of them.
One formatting difference catches people who paste from VS Code. In these three, a remote server with a static token puts its headers under requestInit:
{
"servers": {
"github": {
"url": "https://api.githubcopilot.com/mcp/",
"requestInit": {
"headers": { "Authorization": "Bearer YOUR_PAT_HERE" }
}
}
}
}
For servers that use OAuth, these plugins first try Dynamic Client Registration; if the identity provider doesn't support it, GitHub's November 2025 changelog says Copilot "falls back to a client-credentials workflow." That OAuth support was announced as a preview, and we couldn't find a later note promoting it. JetBrains plugin users should also know about two newer settings: since October 2026 the plugin needs a 2025.2 or later IDE, and a new MCP setting stops servers from starting automatically.
Copilot CLI: copilot mcp add and mcp-config.json
The terminal agent has its own config file and its own command. We installed Copilot CLI 1.0.111 from npm and added DialMCP:
$ copilot mcp add --transport http dialmcp https://mcp.dialmcp.com/mcp
Added server "dialmcp"
dialmcp
Type: http
URL: https://mcp.dialmcp.com/mcp
Tools: * (all)
Source: User
That wrote this to ~/.copilot/mcp-config.json (or $COPILOT_HOME/mcp-config.json if you've moved the home directory):
{
"mcpServers": {
"dialmcp": {
"tools": ["*"],
"type": "http",
"url": "https://mcp.dialmcp.com/mcp"
}
}
}
A local server goes after --, as in copilot mcp add context7 -- npx -y @upstash/context7-mcp. Inside a session, /mcp add opens a form that does the same thing, and /mcp list shows each server's live status (connected, connecting, failed, disabled). In a shell, copilot mcp list shows configuration only, not whether the server actually connects.
Four things in the CLI's built-in help (copilot help mcp and copilot help permissions) are easy to miss:
- It doesn't read
.vscode/mcp.json. Workspace servers come from.mcp.jsonor.github/mcp.json, searched from the working directory up to the repository root, and only once you've trusted the folder. If both sit in one directory,.mcp.jsonwins. - OAuth works. When a remote server needs it, the CLI opens a browser or tells you to run
/mcp auth <server-name>. Tokens go in the OS keychain, or under~/.copilot/mcp-oauth-config/when there's no keychain, and refresh on their own. - The GitHub MCP server is already there. Signed in, the CLI starts a built-in
github-mcp-serverthat's read-only and offers a subset of tools. Adding toolsets with--add-github-mcp-toolsetor--enable-all-github-mcp-toolsmakes it read-write. To turn it off, run/mcp disable github-mcp-server, or start with--disable-builtin-mcpsto skip every built-in server. - Approvals are per tool.
--allow-tool='dialmcp(get_call)'pre-approves one tool,--deny-toolblocks one, and--allow-all-toolsapproves everything. In non-interactive mode (-p) the CLI can't ask, so anything not pre-approved is denied.
The cloud agent and code review
The agent you assign issues to on GitHub.com (GitHub now calls it the Copilot cloud agent) reads MCP servers from the repository, not from your machine. A repository admin opens Settings → Copilot → MCP servers and pastes JSON into the "MCP configuration" box. Copilot code review and Automations use that same configuration.
The format is mcpServers again, but stricter than the CLI's: type and tools are both required, and secrets come from Agents secrets whose names start with COPILOT_MCP_:
{
"mcpServers": {
"sentry": {
"type": "local",
"command": "npx",
"args": ["@sentry/mcp-server@latest", "--host=$SENTRY_HOST"],
"env": {
"SENTRY_HOST": "https://contoso.sentry.io",
"SENTRY_ACCESS_TOKEN": "$COPILOT_MCP_SENTRY_ACCESS_TOKEN"
},
"tools": ["get_issue_details", "search_issues"]
}
}
}
(That's an illustration adapted from GitHub's Sentry sample, with a tools list added. Sentry now calls the npx package its legacy route, so check Sentry's current docs and tool names before copying.) The limits that matter, quoted from GitHub's docs:
- Tools only. The cloud agent and code review "do not currently support resources or prompts provided by the MCP server."
- No OAuth for remote servers. For servers set in repository settings or custom agent profiles, they "do not currently support remote servers that use OAuth for authentication and authorization." Key-based servers work, since a header can carry a
COPILOT_MCP_secret. - No approval prompts. "Copilot will be able to use the tools provided by the server autonomously, and will not ask for your approval before using them." That's why GitHub tells you to allowlist specific read-only tools instead of
"*". Our MCP security checklist explains why that matters with untrusted issue text in the loop. - Code review needs read-only hints. Code review only calls tools whose
annotations.readOnlyHintistrue; anything without the annotation is skipped. See MCP tools for how annotations are declared.
The GitHub and Playwright MCP servers are on by default. The built-in GitHub server uses a token scoped to read-only access on the current repository; you widen it by adding your own github-mcp-server entry with a PAT stored as COPILOT_MCP_GITHUB_PERSONAL_ACCESS_TOKEN.
GitHub's route around the OAuth gap is Copilot connectors, which went to public preview on October 28, 2026. These are GitHub-verified MCP servers (26 at launch, including Slack, Figma, Notion, Sentry and Linear) that you connect once and that GitHub authenticates for you across the Copilot app, CLI, VS Code and cloud sessions. Two catches: the list is fixed, so a server that isn't a connector can't use this route, and connectors work in sessions running in a cloud sandbox, but "are not yet supported in sessions that run on GitHub Actions, such as when you assign an issue to Copilot."
Org and enterprise controls
If MCP doesn't work at all on a work account, look at policy before config. Three controls apply.
The "MCP servers in Copilot" policy. It's an on/off switch for MCP across Copilot surfaces, and it only applies to people who get Copilot Business or Enterprise through an organization. Free, Pro, Pro+ and Max users aren't governed by it. GitHub's docs say it's disabled by default. But a global-default setting that rolled out between October 22 and 26, 2026 lets an enterprise set unconfigured policies to Enabled, so whether it's on in your org depends on what your admins chose. In Visual Studio, turning it off also blocks agent mode.
A registry allowlist. Admins can point Copilot at an MCP registry (anything that implements the registry's v0.1 API, such as Azure API Center) and choose "Registry only," so only servers listed there can run. That also blocks connectors. Copilot CLI reports it as N MCP servers were blocked by policy with a reason like "Not found in registry." GitHub now marks this option as public preview and "not the recommended method," because enforcement matches server names and "can be bypassed by editing configuration files." If you're publishing a server and want it on approved lists, a record in the official registry helps; we walked through that in publishing to the MCP Registry.
Enterprise managed settings. The method GitHub recommends is allowedMcpServers and deniedMcpServers in the enterprise's managed-settings.json, matched by server URL or command. It's been generally available since August 6, 2026. Not every client enforces it: GitHub's managed-settings reference has a per-client table, which when we checked covered Copilot CLI, VS Code, the Copilot app, JetBrains IDEs and cloud sessions that run in a sandbox. It doesn't apply to servers defined in custom agent profiles. An empty allowlist blocks everything except the built-in servers.
The GitHub MCP server
The server most people add first is GitHub's own. The remote endpoint is https://api.githubcopilot.com/mcp/, with a /readonly variant and an X-MCP-Toolsets header to choose toolsets such as repos, issues or pull_requests. There's also a public Docker image, ghcr.io/github/github-mcp-server, with a --read-only flag that wins over any tool you request explicitly. GitHub says the server "is available to all GitHub users regardless of plan type," but each tool needs whatever plan its feature needs, so the tools that hand work to the cloud agent need a paid Copilot license. In the CLI and on GitHub.com it's built in, so you don't need to add it there.
Troubleshooting by symptom
| What you see | Likely cause |
|---|---|
Copilot CLI ignores the server in .vscode/mcp.json | The CLI never reads that file. Move it to .mcp.json or .github/mcp.json with an mcpServers key, and trust the folder. |
| A VS Code server disappeared after an update | The session is on the Copilot harness, and the entry uses ${input:...}, so it wasn't forwarded. Move it to .mcp.json or ~/.copilot/mcp-config.json, replacing the input with a ${NAME} environment reference (or OAuth, if the server supports it). |
| Server prompts are missing from VS Code's slash menu | The Copilot harness doesn't expose the /mcp.<server>.<prompt> commands. |
| "MCP servers were blocked by policy" | Your org restricts servers to a registry or a managed allowlist. Ask an admin. |
| No MCP option at all on a work account | The "MCP servers in Copilot" policy is off for your organization. |
| Cloud agent never connects to a remote server | The server needs OAuth, which repository config doesn't support. Use a key-based server, or a connector if one exists and the session runs in a sandbox. |
| Code review never calls your tool | The tool isn't annotated readOnlyHint: true. |
| "Cannot have more than 128 tools per request" in VS Code | Too many tools enabled. Deselect servers you aren't using, or turn on virtual tools. |
Example: DialMCP in Copilot, and where it doesn't fit
DialMCP is a good test case because it's remote, OAuth-only and capable of real-world side effects: its place_call tool dials a phone from your own verified number. In VS Code, Visual Studio, the JetBrains plugin and Copilot CLI, you add the URL https://mcp.dialmcp.com/mcp and sign in through the browser. There's no API key (the OAuth docs explain why). We'd pre-approve only the read tools, for example --allow-tool='dialmcp(get_call)' in the CLI, and leave place_call on manual approval. The tool reference lists what each one does.
It doesn't work in the cloud agent, and that's on both sides. Repository MCP config can't do OAuth, and DialMCP has no key-based path. Its tools also carry no read-only annotations, so code review would skip them anyway. We think that's the right result for a tool like this. An agent that calls a business on your behalf with no one approving the call is exactly what the cloud agent's "no approval prompts" warning is about. For other clients, see the client setup guide; if you live in the terminal, Claude Code and Codex have their own MCP quirks too.
Further reading
- GitHub Docs: Model Context Protocol (MCP) and Copilot
- VS Code: MCP configuration reference
- Microsoft Learn: Use MCP servers in Visual Studio
- GitHub Docs: Adding MCP servers for Copilot CLI
- GitHub Docs: Configure MCP servers for your repository
- github/github-mcp-server on GitHub
Try a remote MCP server that does real work. DialMCP lets Claude, ChatGPT, Codex, Cursor or VS Code place real phone calls from your own verified number and hand back a transcript and a structured outcome. Add https://mcp.dialmcp.com/mcp as a connector and sign in. US and Canada, free during launch.
FAQ
Does GitHub Copilot support MCP?
Yes, on every major surface: VS Code, Visual Studio, JetBrains IDEs, Eclipse, Xcode, Copilot CLI, the Copilot app, and the cloud agent and code review on GitHub.com. What differs is where each one reads its configuration, whether it supports remote servers that use OAuth, and which MCP features it exposes. The cloud agent and code review, for example, use tools only.
Where is the Copilot MCP config file?
It depends on the surface. VS Code's default Copilot harness and Copilot CLI share ~/.copilot/mcp-config.json, with an mcpServers key, plus a workspace .mcp.json. The CLI also reads .github/mcp.json. VS Code's older .vscode/mcp.json format uses a servers key and is tied to its deprecated Local harness. The cloud agent's configuration lives in repository Settings, under Copilot, then MCP servers.
Does Copilot CLI read .vscode/mcp.json?
No. Copilot CLI reads ~/.copilot/mcp-config.json and, in a trusted folder, .mcp.json or .github/mcp.json from the working directory up to the repository root. Its help text says .vscode/mcp.json is not read. Move the entry to one of those files and change the top-level key from servers to mcpServers.
Can the Copilot cloud agent use remote MCP servers with OAuth?
Not when the server is configured in repository settings or a custom agent profile. GitHub's docs say the cloud agent and code review do not currently support remote servers that use OAuth. Use a server that accepts a key in a header, stored as a COPILOT_MCP_ secret, or a Copilot connector if the service has one. Connectors only work in cloud sandbox sessions, not in sessions that run on GitHub Actions, such as assigning an issue to Copilot.
Do I need a paid Copilot plan to use MCP?
GitHub's plans page lists MCP on every plan, including Free, and its MCP server is available to everyone, though tools tied to paid features, such as handing work to the cloud agent, need a paid license. If you get Copilot Business or Enterprise through an organization, the 'MCP servers in Copilot' policy must also be enabled. Free, Pro, Pro+ and Max users aren't governed by that policy.
Why does Copilot say my MCP server was blocked by policy?
Your organization or enterprise limits which servers can run, either to servers listed in its MCP registry or through an allowlist in enterprise managed settings. Only an administrator can change it. GitHub recommends the managed-settings allowlist; its reference lists which clients enforce it, including Copilot CLI, VS Code, the Copilot app and JetBrains IDEs.