Integrations · GitHub Copilot · Good tier

GitHub Copilot MCP server for full codebase context.

Index the repository with repowise, then run repowise agents add --target=vscode,copilot. Copilot Chat in VS Code gets an MCP server in .vscode/mcp.json, Copilot CLI one in ~/.copilot/mcp-config.json, and both a managed block in .github/copilot-instructions.md: 10 tools over the graph, history, decisions and health.

Setup reference Start free

uv tool install repowise
repowise init --yes --no-prose
repowise agents add --target=vscode,copilot

How do I give GitHub Copilot full context of a large codebase?

Copilot reads .github/copilot-instructions.md, the files you attach, and in VS Code a workspace index for #codebase search. Instructions are static: they say what someone wrote last time. The index finds code that resembles the question.

repowise adds the facts neither holds: what imports a file and what a change reaches, how often a file was bug-fixed, which files change together, who owns them, and the decisions behind a pattern. Copilot's agent mode calls them as MCP tools. get_risk before an edit, get_context for a triage card instead of a whole file, get_why before it changes a pattern.

Is there a GitHub Copilot MCP server for codebase context?

Yes, one server for both surfaces. In VS Code it lives in .vscode/mcp.json under the servers key (VS Code does not use mcpServers), with type stdio, command repowise and args mcp, the repository path and --transport stdio. Copilot CLI has no project MCP file, so repowise writes ~/.copilot/mcp-config.json with the absolute repowise binary, args mcp --transport stdio and tools ["*"]; the server finds the repository from the folder you start copilot in.

Either way it serves the 10 repowise MCP tools.

Setup

Set up repowise for GitHub Copilot

Python 3.11 or later and git. Pick vscode, copilot or both in the --target list.

01
Install the repowise CLI
With uv, pipx or pip.
```
uv tool install repowise
```
02
Index the repository
From the repository root, with no API key and no model calls.
```
repowise init --yes --no-prose
```
03
Wire Copilot
vscode writes the project files; copilot writes the Copilot CLI config in your home directory.
```
repowise agents add --target=vscode,copilot
```
04
Use agent mode
In VS Code, open Copilot Chat in agent mode and check that the repowise tools are listed. With Copilot CLI, start copilot from inside the repository. Ask for a tour of the codebase; Copilot should call get_overview.

What it writes

The files repowise writes

A .vscode/mcp.json written as JSONC with comments is left alone, with a note to paste the entry yourself. repowise agents remove --target=vscode,copilot removes everything listed here.

Files repowise writes
File	Scope	What goes in it
`.vscode/mcp.json`	Project	servers.repowise with type stdio, command repowise and args mcp <repo path> --transport stdio.
`.vscode/extensions.json`	Project	Recommends the repowise VS Code extension to everyone who opens the repository.
`.github/copilot-instructions.md`	Project	A managed block between REPOWISE markers, shared by VS Code and Copilot CLI. It tells Copilot to run noisy commands through repowise distill and to ask get_context for a large file's skeleton. Your own instructions outside the markers stay.
`~/.copilot/mcp-config.json`	User	mcpServers.repowise with type stdio, the absolute repowise binary, args mcp --transport stdio and tools ["*"]. $COPILOT_HOME moves it.

MCP tools

The 10 MCP tools, and when the agent calls each

Copilot calls MCP tools in agent mode, choosing from each tool's description and the instructions file.

MCP tools
Tool	What it returns	When the agent calls it
`get_answer`	One-call cited Q&A over the documentation, with a calibrated confidence score.	A how, where or why question, answered once with citations instead of a chain of greps.
`get_context`	A triage card for files, modules, or symbols: summary, signatures, hotspot bit, governing decisions.	Before opening a file, or with include=["references"] before a rename, to get every caller.
`get_symbol`	Raw source bytes for one indexed symbol with exact, verified line bounds.	When it needs one function's exact lines instead of the whole file.
`search_codebase`	Hybrid full-text and semantic search over the documentation, routed by query shape.	To find a concept, a path or an identifier when it does not know the file name.
`get_why`	Architectural decision archaeology: why the code is shaped this way, with lineage.	Before changing an established pattern: the decision behind it, or git archaeology when none is recorded.
`get_risk`	Hotspot score, dependents, co-change partners, and PR-mode break/test directives.	Before editing a file: what depends on it, how often it broke, which tests reach it.
`get_change_risk`	Pre-merge defect-risk score for a commit or diff range, computed from its shape alone.	Before finishing a multi-file change, on base..HEAD or uncommitted work.
`get_health`	Per-file code-health scores across three pillars, plus ranked refactoring targets.	On the files it touched, or to pick refactoring targets from the fix-first queue.
`get_dead_code`	Unreachable files, unused exports, and zombie packages, tiered by confidence.	On a cleanup task: unreachable files, unused exports and zombie packages, by confidence tier.
`get_overview`	Architecture map, module list, entry points, and tool recipes. First call on any repo.	First call on a repository it has not seen: modules, entry points, layers and the riskiest files.

Comparison

What GitHub Copilot already does, and what repowise adds

Copilot already knows a lot about the code you show it. repowise adds what is only in the history and the graph.

What it does well

Custom instructions: .github/copilot-instructions.md and path-specific .instructions.md files carry conventions. repowise writes a managed block into the first and leaves the rest to you.
Workspace index: #codebase in VS Code searches the open workspace. It finds code by similarity.
Copilot code review: Copilot can review a pull request on GitHub from the diff.
Copilot coding agent: Copilot's cloud agent works from an issue on GitHub, with the MCP servers configured for the repository. The hosted repowise URL is one it can be given.

What repowise adds

The graph: Every caller of what Copilot edits, resolved per language.
History: Hotspots, bug magnets, co-change partners and owners from git.
Decisions: The record behind a pattern, linked to the files it governs.
Health and dead code: Per-file scores from 59 deterministic detectors and unreachable code by confidence tier.
The VS Code extension: Health in the gutter, a change-risk panel for what you are about to push and the dashboard in a tab. It registers the MCP server on its own.

Multi-repo

Context across several repositories

For several repositories, run repowise init . in the parent folder. It finds the git repos up to three levels down, indexes each one, links them through HTTP, gRPC, topic and OpenAPI contracts and cross-repo co-change history, and registers one MCP server that answers for all of them. The workspace server adds list_repos to the 10 MCP tools, and every tool takes a repo argument, or a target written as alias:path. --tools +name adds get_blast_radius, get_architecture and get_conformance for cross-repo impact.

On hosted repowise, one URL answers across a workspace: https://api.repowise.dev/mcp/w/{workspace_id}, with the same API key as the per-repo URL. That shape needs Pro, Teams or Admin.

Tokens

Token use on a large repository

The MCP tools save reads: a triage card instead of a whole file, one symbol's lines instead of the module, one cited answer instead of a chain of searches. In the paired agent-loop benchmark on Codex and Claude Code, the same tools cut output tokens and tool calls.

repowise distill runs through the instructions file Copilot reads. repowise distill, measured with the CLI one command at a time: 89% fewer tokens on git log -50 and 61% on a pytest run with 11 failures, with all 11 failure lines kept.

Code review

Review a change, then fix what the bot finds

Copilot code review and the repowise bot are both GitHub reviewers, and they read different things. Copilot reads the diff. repowise reads the repository's history: files missing from a change that usually travel with it, the tests that import what changed, and the health of the changed files.

The repowise PR bot is a GitHub App. On a pull request it stays silent unless a signal fires: files that usually change together but are missing from the diff, tests that import the changed files, a health drop. Its verdict is the Repowise review check run. The optional AI review on Pro attaches a prompt for your agent to each finding, and the pull request page on repowise.dev has a Copy fix prompt for your agent button. On GitLab, Azure DevOps and Bitbucket there is no bot; indexing and the CI gates (patch coverage, doc drift, new secrets, change risk) still work.

To fix a finding, copy its prompt into Copilot Chat in agent mode or into Copilot CLI. Before you push, get_change_risk scores the uncommitted work against the same history.

Hosted

The remote MCP endpoint

Hosted repowise serves the same tools over Streamable HTTP at https://api.repowise.dev/mcp/{owner}/{repo}, with an API key from Settings, Coding agents (MCP). The per-repo URL works on every plan, Free included (10 answers a month on Free). Claude on the web and desktop connects with a custom connector and sign-in, and ChatGPT takes the same MCP address. For VS Code, the entry goes under servers with type http:

.vscode/mcp.json (hosted)

{
  "servers": {
    "repowise": {
      "type": "http",
      "url": "https://api.repowise.dev/mcp/OWNER/REPO",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

Enterprise

Consistent agent context across an organization

The same context in every repository
A workspace indexes many repositories into one MCP server, so every engineer's agent gets the same graph, history and decisions, whichever agent they use.
Self-hosted
The CLI, the MCP server and the dashboard run on your machines. The analysis makes no model calls and needs no account.
Your own model keys
Prose and answers use the provider you configure: Anthropic, OpenAI, Gemini, OpenRouter, DeepSeek, Kimi, Eden AI, any LiteLLM route, or Ollama. Agent CLIs (Claude Code, Codex, OpenCode, Copilot CLI) can be the writer instead.
Air-gapped
repowise init --yes --no-prose needs no API key. Ollama covers prose and embeddings offline, and repowise grammars fetch stages the COBOL and Apex grammars before the network is cut.
Governance
The commercial license adds SSO, RBAC, audit, on-prem and air-gapped support with an SLA, on top of the AGPL-3.0 core.

repowise for teams and enterprise · Enterprise docs

Questions

What people ask before they try it.

Why does VS Code use servers instead of mcpServers?

That is VS Code's own MCP config format. repowise writes the servers key for the vscode target and the mcpServers key for Copilot CLI, so paste each snippet only where it belongs.

Why is the Copilot CLI config in my home directory?

Copilot CLI keeps its MCP servers in ~/.copilot/mcp-config.json and has no per-project MCP file. The entry names no repository; the server resolves it from the folder you start copilot in.

Can Copilot write the repowise wiki?

Yes. Copilot CLI can be the model that writes the wiki pages, through the copilot_cli provider, on your Copilot subscription instead of an API key. Semantic search still needs an embedder key or Ollama.

Do I need the VS Code extension?

No. The MCP server works without it. The extension adds the gutter heat, the change-risk panel and the dashboard tab, and registers the server for you.

Does it work with Copilot on GitLab or Azure DevOps?

The MCP tools work on any git host, because they read the local index. The repowise PR bot is GitHub only.

How do I remove it?

repowise agents remove --target=vscode,copilot removes the MCP entries and the managed instruction blocks. repowise uninstall removes every agent at once.

Last reviewed: November 2026

Get started

Give your agent the repository.

Index a repository locally in one command, or index a public one free on repowise.dev and connect over a URL.

Start free Book a demo