GitHub Copilot was the first major IDE assistant to ship MCP — Agent mode rolled out to all VS Code users in April 2025, with JetBrains, Visual Studio, Xcode, Eclipse, the CLI, and the cloud agent following through 2026. Cross-IDE MCP without the gaps.
Copilot's built-in tools cover your repo: file read, terminal, lint errors, the GitHub MCP
server. What they don't cover — the ADRs your team agreed on, the customer
interviews behind the spec, the retros nobody re-reads but everybody references —
that's Knovya. One .vscode/mcp.json entry, every IDE
Copilot supports.
mcp.json. Every Copilot surface that supports MCP.
VS Code, JetBrains, Visual Studio, Xcode, Eclipse, and Copilot CLI all read MCP servers
the same way. Two things to know: the file is mcp.json
(not settings.json), and the root key is servers
(not mcpServers like Cursor and Claude Desktop).
{
"servers": {
"knovya": {
"type": "http",
"url": "https://mcp.knovya.com/mcp"
},
"github": {
"type": "http",
"url": "https://api.githubcopilot.com/mcp"
}
}
}
// Note: VS Code uses "servers", NOT "mcpServers".
// User-level: Cmd+Shift+P → MCP: Open User Configuration
// Workspace: .vscode/mcp.json (committed to repo). Cmd+Shift+P → MCP: Open User Configuration, paste the
servers block above. Open Copilot Chat, switch the dropdown to
Agent, click the tools icon — Knovya appears. Agent mode required:
MCP tools are invisible in Ask and Edit.
GitHub Copilot ships MCP across IntelliJ, PyCharm, WebStorm, Visual Studio 17.14+, Xcode, and Eclipse. The IDE has its own GUI flow for adding remote MCP servers — same Knovya URL, similar result. This is where Copilot beats Gemini Code Assist, which doesn't yet support JetBrains MCP.
gh copilot in your terminal supports both local and remote MCP servers
— GitHub MCP is built in. Copilot's cloud agent reads MCP config at the repository
level, so async background tasks reach the same Knovya archive. One config, every Copilot
context.
Copilot Agent mode reaches into Discovery first when you ask "refactor this using past decisions". Read tools fire when it cites the ADR. Write tools save the outcome as a structured retro — with your confirmation. The same 34 tools that Claude and Cursor use; Copilot reads them the same way.
Where am I, what's here. Read-only orientation tools Copilot calls before guessing — workspace scope, schema, context for a topic. The first tools Agent mode reaches for when planning.
pingworkspacehomepersonacontextsearchschema Open the note. Trace a link. Pull an attachment. Where Copilot's repo-wide context shines — pull a whole ADR chain alongside the actual source files, ask the agent to find the inconsistency, instead of summarizing it lossily.
readexperiencememoryfoldershistorylinksattachments Capture, edit, organize, archive. Save the agent session as a structured ADR, tag it, file it. Agent mode confirms before destructive ops — your archive doesn't change without you seeing the plan first.
writeeditorganizedelete When more than one model is in the room. Copilot's Agent in VS Code hands off a research finding to Claude in the next window — presence, channels, shared attention, consensus voting. Multi-model workflows without losing context.
presencechannelscoordinateattentionthoughtscommitteeagentseventsmesh_adminpipelinenotifications Shape the archive. Convert an Agent mode session into a structured ADR. Apply your team's template. Export to Markdown for review. Where Knovya itself becomes a tool Copilot can wield mid-task.
aitemplatesexportimportshare Copilot's built-in tools have your code. Knovya has why your team wrote it.
Agent mode shipped with a powerful default toolset — file read and write, terminal commands, lint error capture, the GitHub MCP server for issues and PRs. Plus Playwright for browser tests, Context7 for library docs, and a growing GitHub MCP Registry full of well-built servers. The repo is covered.
What the toolset doesn't cover: the architecture decision your team made six months ago that the code now reflects. The customer interview that flipped the spec. The retro from the last incident that explains why the timeout is 30 seconds and not 10. The reasoning behind the code lives somewhere else — usually a wiki the IDE doesn't index, a markdown file in another repo, a Slack thread that decayed.
Knovya is the part Copilot reads about your team's decisions. Same archive every Copilot surface reaches into — VS Code Agent mode, JetBrains, Visual Studio, Xcode, the CLI, the cloud agent. The repo holds the code; Knovya holds the why.
↳ §5 Lineage · How Copilot got an MCP layer, in five steps
Five steps from "Copilot is autocomplete" to "Copilot is an agent platform that reads any MCP server, in every IDE."
An open spec for AI ↔ tools — any client to any server, the same way browsers talk to web servers. Initially Claude-only, but the protocol is open from day one. Microsoft and GitHub take notice.
GitHub becomes the first major IDE assistant to ship MCP across an entire user base — Agent mode rolls out to all VS Code Copilot users, complete with MCP server support and a new open-source GitHub MCP server. Premium request budget introduced for multi-model access (Claude, Gemini, OpenAI).
MCP support expands beyond VS Code: JetBrains IDEs (IntelliJ, PyCharm, WebStorm), Visual Studio 17.14+, Xcode, and Eclipse all gain remote and/or local MCP server support. Cross-IDE parity — what you configure in one editor works in the others.
MCP reaches Copilot's terminal (gh copilot) and its cloud agent. The cloud agent reads MCP config at the repository level, so background tasks reach the same servers your IDE does. The GitHub MCP Registry launches as a curated gallery of vetted servers.
One .vscode/mcp.json, seven Copilot surfaces (VS Code · JetBrains · Visual Studio · Xcode · Eclipse · CLI · cloud agent), one archive of what your team decided. Copilot reads the repo; Knovya holds the reasoning.
VS Code's contributed tools — file read, file edit, terminal commands, fetch, lint error capture. Cover the loop of “read code, edit code, run code, see what broke”. Don't reach outside the IDE.
Repo-localBuilt-in, zero-config — issues, pull requests, repos, code search, Copilot cloud agent triggers. The most-used MCP server in any Copilot stack. Doesn't read what's outside GitHub.
GitHub-scopedMicrosoft-maintained — drives a browser headlessly to take screenshots, fill forms, run e2e checks. Essential for web testing; doesn't help with reasoning that lives outside the browser.
Browser testsPublic library documentation, kept up-to-date. Stops Copilot inventing library APIs. Useful, but it's the world's documentation, not your team's decisions.
Public docsYour team's database MCP, your internal API MCP, your CI MCP. Operationally useful — point Copilot at the same systems your engineers use day-to-day. Reactive, not reflective.
OperationalStructured archive — decisions, retros, ADRs, customer interviews, postmortems — exposed as MCP. Copilot reads it from VS Code, JetBrains, the CLI, and the cloud agent. Same archive Claude, ChatGPT, Cursor, and Gemini read from. Travels with your team across every IDE and model.
ReasoningThey stack. Built-in tools handle the code. GitHub MCP handles the issues. Playwright handles the browser. Context7 handles the public docs. Custom MCPs handle the operational systems. Knovya handles the reasoning that doesn't fit in any of them — the decisions you wrote down so future-you (or future-Copilot) could find them.
Where Knovya actually shows up across the Copilot stack — the editor chat, the JetBrains panel, the CLI, the config that wires them all together.
Agent mode required — Ask and Edit modes don't see MCP
tools. Switch the dropdown, then watch tool calls show up live.
One of Copilot's strongest advantages over Gemini Code Assist — JetBrains MCP support shipped. PyCharm, WebStorm, GoLand, RubyMine: same Knovya, same archive.
The Copilot CLI supports both local and remote MCP servers. The cloud agent reads MCP config at the repository level — same Knovya in your terminal as in your IDE as in the background task.
{
"servers": { // not "mcpServers"
"knovya": {
"type": "http",
"url": "https://mcp.knovya.com/mcp"
},
"github": {
"type": "http",
"url": "https://api.githubcopilot.com/mcp"
},
"playwright": {
"command": "npx",
"args": ["-y", "@microsoft/mcp-server-playwright"]
}
}
}
Cursor, Claude Desktop, and Gemini CLI all use "mcpServers". VS Code Copilot
uses "servers". Get it wrong, and your servers silently fail to load.
The same Knovya Copilot reads from is also one paste away in Cursor, Claude, Gemini, and any custom integration via REST. Whichever IDE-pair-programming tool catches your next thought, it's reading from the same archive.
The other AI IDE. Composer Agent reads the same archive — different editor, same Knovya.
Claude Code in your terminal, Claude Desktop on your laptop. Anthropic-certified install path.
Gemini CLI + Code Assist Agent Mode. Long-context analysis written back to the same archive.
REST + webhooks. For internal tools, custom CI scripts, anything that doesn't speak MCP yet.
.vscode/mcp.json in your workspace). Add Knovya under the servers block:{ "servers": { "knovya": { "type": "http", "url": "https://mcp.knovya.com/mcp" } } }.vscode/mcp.json is a standalone file (or user-level mcp.json via MCP: Open User Configuration), and the root key is servers (note: not mcpServers like Cursor, Claude Desktop, and Gemini CLI use).mcpServers there, VS Code silently ignores it and your servers never load. Knovya's docs always show the VS Code-specific shape so you don't lose an evening to that. The same Knovya URL works across every client; only the wrapper differs.
VS Code for the morning refactor, JetBrains for the afternoon Java work, the Copilot CLI
for the script you'll cron tonight. One .vscode/mcp.json
entry, same archive on the other side.
Or jump to the install moment, then see pricing.
VS Code Agent mode · JetBrains · Visual Studio · Xcode · Eclipse · Copilot CLI · cloud agent · Free tier 50 calls/month · 14-day Pro trial.