better-code-review-graph
This MCP server builds and queries a local code knowledge graph to support token-efficient code review, impact analysis, and security scanning.
Build, update, inspect, embed, export/import, and summarize a codebase graph.
Query call relationships, imports, inheritance, tests, file summaries, and large functions.
Search code entities by keyword or semantic similarity, including temporal snapshots by SHA.
Analyze change impact/blast radius and compare graph changes between commits.
Generate token-efficient review context or refactor deltas from git changes.
Run heuristic or Semgrep security scans, emit JSON/SARIF reports, and manage suppressions.
Inspect/configure server state, model credentials, embeddings cache, and setup status.
Access full documentation for tools and recipes through the help tool.
Better Code Review Graph
Knowledge graph for token-efficient code reviews -- semantic search and call-graph resolution across your codebase.
Renamed: repo is
crg, PyPI distribution isn24q02m-crg(formerlybetter-code-review-graph, kept as a legacy command alias) — CLI-first (crgcommand); MCP server is a secondary surface.
mcp-name: io.github.n24q02m/crg
Project | Tagline | Tag |
Drop-in python-semantic-release fork with built-in release-safety guards (orp... | Tooling | |
Claude Code plugin marketplace for the n24q02m MCP servers -- install web sea... | Marketplace | |
Knowledge graph for token-efficient code reviews -- semantic search and call-... | MCP | |
IMAP/SMTP email for AI agents -- read, send, organize folders, and manage att... | MCP | |
Fast multi-model retrieval runtime: ONNX and GGUF embeddings, reranking, and ... | Tooling | |
hull is the shared monorepo core for the wet, crg and mnemo self-hosted stack | MCP | |
Chrome Extension for bulk operations on Jules tasks via batchexecute API -- a... | Tooling | |
Persistent AI memory with hybrid search. Open, free, unlimited. | MCP | |
Markdown-first Notion for AI agents -- pages, databases, blocks, and comments... | MCP | |
Pure-Rust multimedia, hashing, and array suite | Tooling | |
Secrets without the server. | CLI | |
A self-distilling neuro-symbolic cascade that amortises LLM cost across knowl... | Tooling | |
Telegram for AI agents -- messages, chats, media, and contacts across both bo... | MCP | |
Docs portal for the n24q02m open-source tool stack (skret, MCP plugins, hull,... | Tooling | |
Open-source MCP server for AI agents: web search, content extraction, and lib... | MCP | |
Google Workspace MCP server (Docs/Drive/Calendar/Gmail/Sheets/Slides/Tasks/Ch... | MCP |
An MCP server that parses your codebase with Tree-sitter, builds a structural graph of functions/classes/imports, and gives Claude (or any MCP client) precise context so it reads only what matters instead of the whole tree. Semantic search runs through the local ONNX model registry from fastretrieval by default (zero config, no API key), with an optional cloud embedding chain. Fork of code-review-graph with fixed multi-word search, qualified call resolution, dual-mode embeddings, output pagination, and production CI/CD.
v2.0 migration (BREAKING)
v2.0 adds temporal columns (valid_from_sha / valid_to_sha on every node + edge) and an opt-in security scanner. The schema migration is auto-applied on first GraphStore open, and a backup of the pre-2.0 DB is saved to <graph_db>.pre-2.0.bak so you can roll back. See BREAKING_CHANGES.md for the full schema-change list, behavior changes, environment requirements, and the downgrade procedure (CRG_DOWNGRADE_TO_1_X=1 uv run crg).
Related MCP server: mcp-reposkein
Table of contents
Install
For OMP and other local coding harnesses, the primary surface is the package CLI
plus the bundled skills/ workflows. The skills invoke the CLI directly and do
not require an MCP server mapping.
# Run without a persistent install (short `crg` script; the PyPI distribution is
# n24q02m-crg, so `uvx` needs the explicit --from form for the `crg` name)
uvx --python 3.13 --from n24q02m-crg crg graph build --full-rebuild \
--repo-root /path/to/repo
uvx --python 3.13 --from n24q02m-crg crg graph stats \
--repo-root /path/to/repo
# Or install the console scripts (installs both `crg` and the legacy long name)
pip install n24q02m-crg
crg query search --search-query "authentication" \
--repo-root /path/to/repoThe optional Semgrep engine for deeper security scans is a separate extra:
pip install 'n24q02m-crg[security]'MCP stdio remains a secondary protocol adapter for clients that require it:
{
"mcpServers": {
"crg": {
"command": "uvx",
"args": ["--python", "3.13", "n24q02m-crg"],
"env": { "MCP_TRANSPORT": "stdio" }
}
}
}Install matrix (stdio unless noted; the CLI-first usage above stays the primary surface):
Client | Install |
Claude Code (plugin) |
|
Claude Code (stdio) |
|
Codex | register stdio command |
Gemini CLI | add the |
Cursor / Windsurf | add the |
Any client (HTTP self-host) | point the client at |
Install with an AI agent -- paste this to your AI coding agent:
Install MCP server
crgfollowing the steps at https://raw.githubusercontent.com/n24q02m/claude-plugins/main/plugins/crg/setup-with-agent.md
Full CLI usage is in CLI. Optional per-client MCP setup is at docs.n24q02m.com/servers/crg/setup/.
Usage
Two ways to run the server, plus the surfaces to consume it.
Dev: uv, no auth (loopback only)
# instance config lives at $CRG_CONFIG_DIR or ~/.crg (same schema as hull's
# config.toml); a default no-auth template is fine for local dev
uv run n24q02m-crg server start
# -> http://127.0.0.1:8000/mcp (no-auth is refused on any off-loopback bind)Always-on: docker (token auth)
cp docker-config/config.example.toml docker-config/config.toml
# mint a token + hash (hull CLI ships with crg's dependency tree):
# TOKEN=$(python -c "import secrets; print(secrets.token_urlsafe(32))")
# hull token hash "$TOKEN" # paste output into token_hash in config.toml
docker compose up -dThe compose file builds the Dockerfile's http target (image crg:http),
publishes the container on host loopback only
(127.0.0.1:${CRG_PORT:-8772}:8080), and mounts
./docker-config/config.toml read-only at the container's config dir
(CRG_CONFIG_DIR=/data/config); graph state persists in the crg-data
named volume. All state stays on your machine.
Consuming: CLI or MCP
CLI (local graphs, no server needed):
crg graph build --full-rebuild --repo-root /path/to/repo
crg query search --search-query "authentication" --repo-root /path/to/repoMCP over HTTP (remote/always-on): point any MCP client at
http://127.0.0.1:8772/mcp with Authorization: Bearer <token>:
{
"mcpServers": {
"crg": {
"url": "http://127.0.0.1:8772/mcp",
"headers": { "Authorization": "Bearer <token>" }
}
}
}Per-task model configuration
Each task (embed / rerank / chat / jev_score) resolves its own OpenAI-spec
provider cell from [models.<task>] in the instance config: an independent
base_url + api_key + model. Cloud or local is purely a config choice —
point base_url at OpenRouter, a vendor, or your own local gateway
(e.g. http://host.docker.internal:11434/v1). API keys are host-only
material: keep them in config.toml (gitignored under docker-config/) or
supply via HULL_<TASK>_API_KEY env; they are never end-user supplied.
Keys live in hull's provider credential pool (~/.hull/hull.db, sealed by
hull's crypto), so a provider can hold several keys and named accounts. Every
provider call rotates: 401/403 disables the key, 429 cools it down for the
provider's Retry-After, 5xx retries once, and a pool that is fully disabled
or cooling raises a redacted error carrying the remaining cooldown. An
existing single key keeps working unchanged — it is migrated into the pool on
first use, and the env var / config.toml value is never modified. Two
optional keys per cell select the pool:
[models.chat]
provider = "openrouter" # optional: pool identity (default: derived from base_url)
account = "openrouter:work" # optional: named account (default: the provider's default pool)Additional keys and accounts are added through hull_core.credentials
(CredentialStore.add_credential, CredentialStore.accounts().add), and
config(action="setup_status") reports which tasks are configured without
ever printing a key.
Local-first boundary
CRG is local-first for coding workflows:
CLI and bundled Skills are the primary surfaces for graph build/query, impact analysis, review context, security scans, and repository onboarding.
MCP stdio is the secondary protocol adapter over the same local domain services; it does not maintain a separate graph implementation.
Graph state stays in
<repo>/.crg/graph.dbunless an explicit multi-user/self-host configuration selects another data directory.PyPI, CI, security scanning, GitHub releases, and eligible stable MCP Registry publication remain active. Historical public OCI tags are retained, but new public Docker Hub/GHCR images are no longer published.
CRG has no hosted Cloudflare runtime in the target topology.
Smithery
The repo ships a smithery.yaml so the server can be built and
run through Smithery. It deploys over stdio and needs
no startup configuration -- the config schema is empty, and any optional cloud
embedding/summary keys are supplied at runtime through the server's own config
flow (see Configuration below). The launch command is the same
uvx invocation as a local install:
startCommand:
type: stdio
commandFunction: |-
(config) => ({ command: 'uvx', args: ['--python', '3.13', 'crg'] })Configuration
Everything works out of the box with zero configuration -- semantic search
uses the local ONNX registry from fastretrieval
(Qwen3-Embedding-0.6B is the current built-in reference entry, ~570 MB
downloaded on first graph embed). This reference entry is not a Qwen-only
boundary: any built-in registry ID or valid non-Qwen artifact manifest follows
the same resolver. All environment variables below are optional and only needed
for cloud embeddings, LLM summaries, or an explicit BYO local artifact.
Model selection
Embeddings select the first provider/model entry in EMBEDDING_MODELS; later
entries are retained as configuration but are not runtime fallbacks. The summary
model comes from the model field of the [models.chat] cell (an unconfigured
cell disables summaries). Transport always comes from the per-task
[models.<task>] cell (OpenRouter pre-wired default) — model-name prefixes
only select wire details, never keys.
Variable | Purpose | Empty (default) |
| Cloud embedding selection; the first entry is active | Local fastretrieval registry |
| Completion model selection for | Summaries disabled |
Cohere embed-v4.0 and Voyage voyage-4-lite request and store 1024 dimensions; other backends retain
768-dimensional storage. CRG never slices, pads, or silently accepts a different
provider width. The embedding row's model and byte width must match before reuse.
Run graph(action="embed") after changing models or upgrading an old 768-wide
Cohere index. Searches reject incompatible widths before a provider call; graph
nodes are retained and re-embedding replaces only stale vectors.
Provider API keys
The key lives in the per-task cell's api_key (host-only; see the table below).
Keys alone never select models: an empty embedding chain stays local, and an empty summary
chain stays disabled. A configured cloud error does not fall back to local or
another provider. Summarizers require a chat-completion model.
Every credential is served from hull's provider key pool (see Per-task model configuration): one pool per provider, rotated per call, with named accounts selectable per cell.
Task | Config cell | Notes |
Embedding |
| Plain OpenAI-spec HTTP through hull-core; OpenRouter pre-wired default. |
Summarizer |
| Requires a chat-completion model; OpenRouter default. |
Vendor-specific key env vars (JINA_AI_API_KEY, GEMINI_API_KEY,
OPENAI_API_KEY, GOOGLE_VERTEX_EXPRESS_API_KEY, …) are not read by
crg; the removed per-vendor dispatch lived in the pre-de-host stack.
Advanced
Variable | Purpose |
| Comma-separated embedding model chain; the first entry is the cloud model (host-owned; keys never select a model). Legacy |
| Skip the local ONNX download; embedding is unavailable unless a cloud chain is configured |
| Fastretrieval |
| Required dimension for an external model ID without a manifest |
| ONNX file path inside a manifest-backed artifact directory |
| Explicit pooling for an external ID without a manifest: |
| Explicit L2 normalization for an external ID without a manifest |
| Override the per-user data directory (default |
| Override the credential pool database (default |
| Deprecated singular vars, honored one release with a warning -- migrate to |
When LOCAL_RERANK_MODEL is configured, semantic vector search retrieves a
bounded candidate pool of min(max(limit * 4, limit), 100) rows, applies the
existing kind, repo, and live-row filters, then reranks that pool and returns
at most limit rows. The response uses search_mode="semantic_reranked" and
adds rerank_score while preserving similarity_score. Blank keeps the
existing limit * 2 vector path and search_mode="semantic". Configured
reranker failures return an explicit error; CRG does not silently fall back to
vector or keyword results. Keyword searches, including as_of snapshots, do
not invoke the reranker.
Example -- cloud embeddings + summaries
~/.crg/config.toml (write by hand, or start from hull config init which
pre-wires OpenRouter defaults):
[models.embed]
base_url = "https://openrouter.ai/api/v1"
api_key = "sk-or-..."
model = "cohere/embed-v4.0"
[models.chat]
base_url = "https://openrouter.ai/api/v1"
api_key = "sk-or-..."
model = "minimax/minimax-m3:free"Equivalent env surface for the MCP server entry (keys override the cells;
model names still come from EMBEDDING_MODELS / the model field):
{
"mcpServers": {
"crg": {
"command": "uvx",
"args": ["--python", "3.13", "n24q02m-crg"],
"env": {
"MCP_TRANSPORT": "stdio",
"EMBEDDING_MODELS": "cohere/embed-v4.0",
"HULL_EMBED_API_KEY": "sk-or-...",
"HULL_CHAT_API_KEY": "sk-or-..."
}
}
}
}Cohere embedding is paid. Authorize a bounded budget before a live index/query;
the Minimax-free completion choice does not make embeddings free. Model-name
prefixes (cohere/…, openrouter/…) select wire details only — transport and
credentials come from the [models.*] cells, which the host owns.
CRG currently has no cloud rerank call: LOCAL_RERANK_MODEL is its only
reranking path. Setting RERANK_MODELS or RERANK_API_BASE does not enable one.
Tools
Six tools, each grouping related actions to keep the tool surface small.
graph -- Graph lifecycle
Actions: build | update | stats | embed | export | summarize
Action | Description |
| Full or incremental graph build. Set |
| Alias for |
| Graph size, languages, node/edge breakdown, embedding count. |
| Compute vector embeddings for semantic search. Dual-mode: local ONNX or cloud chain. |
| Export the graph as |
| LLM-generated one-paragraph docstrings for |
query -- Graph queries
Actions: query | search | impact | large_functions | spot_check | renamed_in_diff | diff
Action | Description |
| Predefined patterns: |
| Search code entities by name/keyword or semantic similarity. |
| Blast radius of changed files. Auto-detects from git diff. Paginated with |
| Find functions/classes exceeding a line-count threshold. |
| Random callsite snippets from the last |
| Symbols whose callsite line shifted versus a base ref. |
| Nodes added/removed/modified between two commit SHAs ( |
Most read actions accept as_of=<sha> for temporal (point-in-time) snapshots
and repo=<repo_id> to scope a federated multi-repo graph.
review -- Code review context
Actions: context (default) | delta
Token-optimized review context with structural summary, impacted nodes, source
snippets, and review guidance. context auto-detects changed files from the
git diff; delta (with from_sha/to_sha, optional show_line_shifts)
surfaces refactor moves between two commits.
config -- Server configuration and credential setup
Actions: status | set | cache_clear | setup_status | setup_start | setup_skip | setup_reset | setup_complete
Action | Description |
| Server info: version, graph path, node/edge counts, embedding backend, embeddings count. |
| Update a runtime setting ( |
| Remove all computed embeddings. |
| Show current credential state and which model cells have keys. |
| Explain where the host configures API keys (host-owned model cells). |
| Set local mode (local ONNX embedding, no cloud cells). |
| Reset state to local; host config re-resolves on next call. |
| Re-resolve credential state from host config. |
security -- Security scanning
Actions: scan | report | suppress | rule_list
Action | Description |
| Run a security scan ( |
| Re-emit cached findings as JSON ( |
| Suppress a finding by |
| List available rules for an engine. |
The semgrep engine requires the [security] extra and runs Semgrep's
p/auto registry pack plus a 3-rule curated overlay.
help -- Full documentation
Topics: graph | query | review | config | security | recipes
Returns complete documentation for each tool. Use when the compressed descriptions above are insufficient.
CLI
The package installs two console scripts: crg (primary) and
crg (legacy long name). Running either with no
arguments starts the MCP server over stdio; a leading positional argument
routes to a local CLI subcommand that calls the same domain services used by
the MCP adapter. Run them directly after pip install, or without a
persistent install via uvx --python 3.13 --from n24q02m-crg crg ....
# Start the MCP server over stdio (default -- no subcommand)
crg
# Build, inspect, and embed the local graph
crg graph build
crg graph stats
crg graph embed
# Query relationships and impact
crg query query \
--pattern callers_of --target "path/to/module.py::function"
crg query search --search-query "authentication"
crg query impact --changed-files src/app.py
# Produce review context and run a local security scan
crg review context --base HEAD~1
crg security scan --engine heuristiccrg --help lists every subcommand with its actions and flags;
crg <subcommand> --help prints one subcommand's full flag list. A missing
action names the values it accepts: crg graph ends in
the following arguments are required: graph action (choose one of: build, embed, stats, export, import, summarize) instead of the bare internal name.
Command | Description |
| Full or incremental graph build. |
| Compute vector embeddings using local ONNX or the configured cloud chain. |
| Inspect, export/import a portable |
| Run relationship patterns or keyword/semantic search. |
| Analyze changed-file blast radius or find oversized nodes. |
| Inspect callsites, line shifts, or commit-to-commit graph changes. |
| Generate review context or diff buckets for a code change. |
| Run and manage heuristic/Semgrep security findings. |
CLI subcommands print structured JSON and exit non-zero on an error.
Features
What this fork fixes versus the upstream code-review-graph:
Feature | code-review-graph | crg |
Multi-word search | Broken (literal substring) | AND-logic word splitting |
callers_of/callees_of | Empty results (bare name targets) | Qualified name resolution + bare fallback |
Embedding | sentence-transformers + torch (1.1 GB) | fastretrieval ONNX + cloud (200 MB), dual-mode |
Output size | Unbounded (500K+ chars) | Paginated (max_results, truncated flag) |
Tool design | 9 individual tools | 6 grouped tools: graph + query + review + config + security + help |
Plugin hooks | Invalid PostEdit/PostGit | Valid PostToolUse |
Comparison
How crg stacks up against direct competitors in each pillar:
Capability | crg | Greptile | Sourcegraph (Cody / MCP) | CodeGraph (colbymchenry) |
Codebase knowledge graph | Yes (Tree-sitter, 14 langs, SQLite) | Yes (functions/classes/deps) | Yes (precise code indexing) | Yes (Tree-sitter, 20+ langs, SQLite) |
Persistent incremental updates | Yes (git-diff + file-hash re-parse) | ? | Yes (continuous indexing) | Yes (OS file-watcher debounced) |
Qualified call resolution (callers/callees) | Yes (same-file bare-call resolution + fallback) | ? | Yes (go-to-def / find-references) | Yes (callers / callees / impact) |
Semantic search / embeddings | Yes (fastretrieval local registry + cloud Jina/Gemini/OpenAI/Cohere) | ? | Yes (semantic + keyword + regex) | No (FTS5 full-text only) |
Token-optimized review context | Yes ( | Yes (PR review comments) | No (code-context assistant) | No (context layer, not review) |
Security scanning | Yes (Semgrep | ? | ? | No |
Self-hostable | Yes (stdio default, machine-bound) | Yes (Docker / K8s / air-gapped) | Yes (self-hosted instance) | Yes (100% local, no API keys) |
Free / open source | Yes (Apache-2.0) | No (proprietary SaaS; free OSS tier) | No (Enterprise license, source private) | Yes (MIT) |
Sources: Greptile · Greptile pricing · Sourcegraph MCP · CodeGraph. Cells marked ? are capabilities the competitor does not publicly document, not confirmed absences.
Security
Explicit selection -- Cloud embedding errors are reported; the runtime does not silently switch models or fall back to local ONNX.
Error handling -- Tools return error strings with fix suggestions, never crash.
Read-only mount -- Docker mode mounts the repo as
:ro(read-only).SSRF-guarded endpoints -- Custom
[models.*]cellbase_urlvalues are validated before any outbound call.
To report a vulnerability, see SECURITY.md.
Build from source
git clone https://github.com/n24q02m/crg
cd crg
uv sync --group dev
uv run pytest
uv run crgRequirements: Python 3.13, uv.
Trust model
This plugin implements TC-Local (machine-bound, single trust principal), the classification defined by the shared MCP foundation trust model.
Mode | Graph DB | Cloud credentials | Who can read your data? |
stdio (default) |
|
| Only your OS user |
HTTP self-host (multi-user) | Per-user | Per-user | Only the authenticated user |
Migration & changelog
Graph, security scan cache, and suppression state now use the package-owned
.crg/ directory. Run graph(action="build", full_rebuild=true)
once after upgrading, followed by graph(action="embed") if semantic search is
needed. The old .better-code-review-graph/ state directory plus the ambiguous
.code-review-graph/ and .code-review-graph.db paths and their SQLite
sidecars are left untouched, not migrated. Review and reapply any desired
suppression rules explicitly.
The v2.0 release added temporal columns (valid_from_sha / valid_to_sha
on every node and edge) plus an opt-in security scanner. The schema migration
is auto-applied on first GraphStore open, and a backup of the pre-2.0 DB is
written to <graph_db>.pre-2.0.bak. To downgrade and restore it:
CRG_DOWNGRADE_TO_1_X=1 uvx n24q02m-crgFull schema-change list, behavior changes, and rollback procedure: BREAKING_CHANGES.md. Release-by-release history: CHANGELOG.md.
Documentation
Full docs at docs.n24q02m.com/servers/crg/setup/:
Setup -- install methods for Claude Code, Codex, Gemini CLI, Cursor, Windsurf, mcp.json
Modes overview -- stdio / http
Multi-user setup -- per-JWT-sub credential model
Use the help tool from any MCP client for inline per-tool reference.
License
Apache-2.0 -- See LICENSE.
Available Tools
6 toolsconfigConfigAIdempotent
Server configuration, status, and model-cell setup. Actions: status (show state), set (key, value -- keys: log_level), cache_clear (wipe embeddings), setup_status (state + configured model cells), setup_start (where the host configures keys), setup_skip (local mode), setup_reset (reset to local), setup_complete (re-resolve from host config). Use help tool for full docs.
Inputs: action (required), key, force, value, +1 more. Returns: object
graphGraphC
Build and manage the code knowledge graph. Actions: build (full_rebuild, base, repo_root), update (base, repo_root), stats (repo_root), embed (repo_root), export (format, output_path, repo_root), import (import_path, repo_root), summarize (max_nodes, repo_root). Use help tool for full docs.
Inputs: action (required), base, roots, format, +5 more. Returns: object
helpHelpARead-onlyIdempotent
Get full documentation for any tool. Topics: graph | query | review | config | security | recipes. Use when compressed descriptions are insufficient.
Inputs: topic. Returns: result
queryQueryBRead-onlyIdempotent
Query the code knowledge graph for relationships, search, and impact analysis. Actions: query (pattern, target), search (search_query), impact (changed_files|base), large_functions (min_lines), spot_check (n -- random callsite snippets from last callers_of/callees_of/inheritors_of/importers_of result), renamed_in_diff (base -- symbols whose callsite line shifted vs base ref), diff (from_sha, to_sha -- nodes added/removed/modified between two commit SHAs). Use help tool for full docs.
Inputs: action (required), n, base, kind, +17 more. Returns: object
reviewReviewARead-onlyIdempotent
Generate token-efficient review context for code changes. Actions: context (default — auto-detects changed files from git diff, returns structural summary, impacted nodes, source snippets, and review guidance), delta (from_sha, to_sha — wraps the query.diff buckets and, when show_line_shifts=true, surfaces qualified_names whose line_start moved between the two commits for refactor auditing). Context params: changed_files (auto), max_depth=2, include_source=true, max_lines_per_file=200, base='HEAD~1', repo_root (auto). Delta params: from_sha, to_sha, show_line_shifts=false, repo, repo_root. Use help tool for full docs.
Inputs: base, repo, action, to_sha, +8 more. Returns: object
securitySecurityA
Security scanning over the code knowledge graph. Actions: scan (engine='heuristic'|'semgrep', repo_root), report (format='json'|'sarif', repo_root), suppress (rule_id, remove=false, repo_root), rule_list (engine='heuristic'|'semgrep'). Use help tool for full docs.
Inputs: action, engine, format, remove, +2 more. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
Each tool covers a distinct functional area: graph management, querying, review generation, security scanning, configuration, and documentation. The action lists within each tool reinforce these boundaries, so an agent can reliably select the right tool for the job.
All six tool names are single lowercase tokens (graph, help, config, query, review, security), following a consistent and predictable style. The naming convention is uniform and immediately understandable.
Six tools is a well-scoped set that covers the server's domain without bloat. Each tool consolidates a meaningful set of related actions, keeping the surface area manageable while still being powerful.
The toolset covers graph building/updating, querying, diff analysis, review context generation, and security scanning. Minor gaps exist, such as no direct tool for managing review comments or code ownership, but the core workflow of producing code-review intelligence is complete.
Maintenance
Related MCP Connectors
Shared context for your codebase: a hosted code knowledge graph over MCP. Free plan, OAuth sign-up.
Codebase intelligence for AI coding agents: graph, git history, docs, decisions, code health.
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Related MCP Servers
- AlicenseAqualityCmaintenanceCode graph context engine that parses codebases with tree-sitter (170+ languages), builds structural dependency graphs, and provides 24 MCP tools for code intelligence. One prepare_context call gives your AI agent the right files for any task. Includes focus, blast radius, hotspots, dead code detection, and hybrid search.241AGPL 3.0

mcp-reposkeinofficial
AlicenseAqualityBmaintenanceDeterministic code-graph (GraphRAG) over your repo for LLM agents — local-first, git-native, zero-infra, served via MCP. Python, TS/JS, Rust, Go, Java, C#.813Apache 2.0- AlicenseNot gradedqualityDmaintenanceProvides a semantic understanding of your codebase by parsing with tree-sitter and building a graph of symbols and dependencies. Enables AI assistants to navigate code, analyze changes, and discover architecture using 18 tools with minimal context overhead.38 npm1MIT
- AlicenseNot gradedqualityDmaintenanceAI-powered codebase intelligence tool that builds a dependency graph of a git repo for structural Q&A and pre-PR code review. It exposes MCP tools for blast radius, review sessions, and static analysis, running locally over stdio with no LLM or network dependencies.MIT