VS Code Copilot MCP Server for Codebase Context

Copilot's agent mode in VS Code can run a genuinely multi-step task: read a few files, edit several more, run a command, check the result. What it reasons over while doing that is retrieval plus whatever you have open, not a map of the codebase. Ask it who calls a shared method, or what a schema change breaks three services downstream, and it is pattern-matching on text and open tabs, then presenting a guess with full confidence. Symvanta's MCP server gives agent mode the actual code graph, callers, dependencies, blast radius, resolved in one tool call instead of inferred from a grep. It sits alongside Copilot's own retrieval, not instead of it: use Copilot for the fast, file-local stuff, and hand agent mode a Symvanta tool the moment the question is structural.

Setting up Symvanta in VS Code

1. Create a free Symvanta account at symvanta.com.
2. Connect GitHub. Install the Symvanta GitHub App and grant it access to the repositories you want indexed.
3. Index your repos. Symvanta builds the graph on first index, then a webhook reindexes automatically on every push, so agent mode is never working off a stale snapshot. Plans start at $15/month, with a 7-day trial on the Pro tier if you want branch-aware indexing and higher repo limits before you commit.
4. Add the MCP server in VS Code. Per the official VS Code MCP docs, the fastest path is a workspace config file at .vscode/mcp.json:

{
  "servers": {
    "symvanta": {
      "type": "http",
      "url": "https://mcp.symvanta.com/mcp"
    }
  }
}

Commit this file if you want the whole team wired up the same way; it takes precedence over any user-level entry with the same name for that workspace.

Prefer a guided flow instead of hand-editing JSON: open the Command Palette and run MCP: Add Server, pick HTTP as the server type, paste https://mcp.symvanta.com/mcp as the URL, and choose Workspace to scope it to this repo or Global to make it available across every project you open. Global setup goes through MCP: Open User Configuration instead of .vscode/mcp.json.

5. Authenticate once. The first time agent mode calls a Symvanta tool, VS Code opens a browser window for an OAuth 2.0 login with PKCE. There is no API key to generate or paste into the config; approve the login once and VS Code holds the session for you.
6. Confirm the tools are live. Open Copilot Chat, switch to agent mode, and click Configure Tools in the chat input. Symvanta's tools show up grouped under the server name, each with an on/off toggle if you want to trim the set the model can reach for a given session.

If your organization manages Copilot centrally, VS Code's chat.mcp.access setting can restrict which MCP servers are allowed at all; if Symvanta doesn't show up as an option, that's an admin-side allowlist, not a Symvanta-side block.

What Copilot gets

Once the server is connected, agent mode can reach for any of these instead of guessing from an open file:

That's 10 of the 25 tools the server exposes; relate alone covers five traversal modes (callers, dependencies, blast_radius, implementers, chain). Coverage spans TypeScript, JavaScript, Python, Java, Kotlin, C#, Go, Rust, Swift, PHP, and Ruby, so a polyglot repo gets one consistent graph instead of a different tool per language.

Using it in agent mode

The pattern that matters most is asking agent mode to check the graph before it edits, not after. Take "rename this service method safely": tell agent mode to rename processPayment on PaymentService and update every call site. A prompt-only agent will grep for the name and hope it caught every call site, including the ones that go through an interface or a differently-named override. With Symvanta connected, a good agent-mode instruction is closer to: "Before renaming, call relate with kind: callers on PaymentService.processPayment, call list_tests_for on the same symbol, then make the rename and update every caller and test you found." The graph traversal happens in one tool call each, and the edit that follows is grounded in an actual call list instead of a text match.

This is the same failure mode we walk through in more detail in why AI coding agents fail on large codebases: a bigger context window doesn't tell the agent which files call which other files, and grep on a shared symbol name returns a mix of real call sites, comments, and unrelated matches with the same name. A graph turns "who calls this" into a direct lookup instead of a guess dressed up as an answer.

For a broader look at how the graph itself is structured, module boundaries, dependency direction, the shape of a codebase before you start asking it questions, see the architecture pages, which walk several well-known open-source repos through their real module maps.

Frequently asked questions