代码审查工具

Optional task context: read the task from a board and check requirement compliance.

One-click install prompt

Copy and paste into any AI coding assistant (Claude Code, Cursor, Gemini CLI, Mimo Code, OpenCode, Kimi Code, Codex, Copilot…):

Set up the rag-reviewer MCP server in this AI tool.

Rules:
- Use `uvx --from rag-reviewer@latest reviewer-mcp` to run the server — do NOT pip install, do NOT clone the repo.
- The `bash -lc` wrapper is required on macOS/Linux so uvx is found by GUI tools: command="/bin/bash", args=["-lc", "uvx --from rag-reviewer@latest reviewer-mcp"]. On Windows use command="uvx", args=["--from","rag-reviewer@latest","reviewer-mcp"].
- Detect which AI tool you are running in, then write the MCP entry to the correct config file:
  - Claude Code / generic: .mcp.json in project root ({"mcpServers":{"reviewer":{"command":"/bin/bash","args":["-lc","uvx --from rag-reviewer@latest reviewer-mcp"]}}})
  - Cursor: ~/.cursor/mcp.json (same format)
  - Gemini CLI: ~/.gemini/settings.json ({"mcpServers":{"reviewer":{"command":"/bin/bash","args":["-lc","uvx --from rag-reviewer@latest reviewer-mcp"]}}})
  - Antigravity: ~/.gemini/antigravity/mcp_config.json (same mcpServers format)
  - Windsurf: ~/.codeium/windsurf/mcp_config.json (same mcpServers format)
  - Claude Desktop: ~/Library/Application Support/Claude/claude_desktop_config.json on macOS, %APPDATA%\Claude\claude_desktop_config.json on Windows (same mcpServers format)
  - Mimo Code: ~/.config/mimocode/mimocode.json ({"mcp":{"reviewer":{"type":"local","command":["/bin/bash","-lc","uvx --from rag-reviewer@latest reviewer-mcp"],"enabled":true}}})
  - OpenCode: ~/.config/opencode/opencode.json ({"mcp":{"reviewer":{"type":"local","command":["/bin/bash","-lc","uvx --from rag-reviewer@latest reviewer-mcp"]}}})
  - Kimi Code: ~/.kimi-code/mcp.json ({"mcpServers":{"reviewer":{"command":"/bin/bash","args":["-lc","uvx --from rag-reviewer@latest reviewer-mcp"]}}})
  - Codex CLI: ~/.codex/config.toml ([mcp_servers.reviewer] command="/bin/bash" args=["-lc","uvx --from rag-reviewer@latest reviewer-mcp"])
  - VS Code: ~/Library/Application Support/Code/User/mcp.json (key is "servers" not "mcpServers": {"servers":{"reviewer":{"command":"/bin/bash","args":["-lc","uvx --from rag-reviewer@latest reviewer-mcp"]}}})
- After writing the config, run: uvx --from rag-reviewer reviewer check
- Report what config file was written and whether the check passed.

---

Installation

The MCP server is published on PyPI as rag-reviewer and runs via uvx — no clone of this repo required.

Requirements: Docker, uv (includes uvx), a Voyage API key, a GitHub token.

Quick setup (recommended, all platforms)

```bash

0) Install the reviewer CLI — once, globally

uv tool install rag-reviewer

uv and uvx are the same binary; installing uv gives you both.

or a specific one: reviewer install cursor|vscode|claude-code|windsurf|gemini|antigravity|mimo|opencode|kimi|trae|codex

3. Install skills globally (optional)

Skills (reviewer_review-pr, reviewer_solve-task, reviewer_sync-codebase, reviewer_sync-tasks, reviewer_performance-review, reviewer_maintainability-review, reviewer_ask) let you invoke the full review workflow with a single command. Without them you can still call MCP tools directly, but the skills wrap them into a guided flow.

reviewer install already installs them for clients that support file-based skills (Gemini, Mimo, Kimi). To (re)install just the skills — or pick a specific client — use:

uvx --from rag-reviewer reviewer install-skills --all     # all detected skills-capable clients
uvx --from rag-reviewer reviewer install-skills gemini    # a specific one
uvx --from rag-reviewer reviewer install-skills --list    # show targets + directories

It downloads the skills from GitHub (no repo clone) and unpacks them into each client's global skills directory, with a path-traversal guard. Manual fallback (equivalent):

curl -sL https://github.com/mimfort/rag_for_git/archive/refs/heads/main.tar.gz -o /tmp/rag-reviewer.tgz
mkdir -p ~/.gemini/skills
tar xz -C ~/.gemini/skills --strip-components=3 -f /tmp/rag-reviewer.tgz 'rag_for_git-main/plugin/skills'
rm /tmp/rag-reviewer.tgz

---

That's it. Build the base index (recommended — see CLI) and review a PR (see Plugin usage).

Register the MCP server (and skills) in installed AI clients automatically (cross-platform).

--all auto-detects installed clients; or name one: cursor, claude-desktop, claude-code,

Skills are installed for clients that support them (Gemini/Mimo/Kimi); --no-skills to skip.

Install only the skills into a client's global skills directory (Gemini/Mimo/Kimi).

Build/update the base index of the target branch from a local clone (vectors + graph).

Build the index for a second tracked branch (isolated index, same deployment).

uvx --from rag-reviewer reviewer index /path/to/repo --ref master --repo owner/name

Plugin usage

With the plugin installed (see Installation) and Claude Code open at the repo root, call a skill:

/rag-reviewer:reviewer_review-pr owner/repo#42     # review a PR (prepare_review → subagents → publish_review)
/rag-reviewer:reviewer_sync-codebase               # build/update vector store + code graph from local clone
/rag-reviewer:reviewer_sync-tasks                  # warm the task graph & vector store (server-side ETL via sync_board)
/rag-reviewer:reviewer_solve-task <key | free text>  # gather disciplined context for a task, then hand off to dev

A typical end-to-end run:

```bash git clone https://github.com/ORG/REPO /tmp/REPO reviewer index /tmp/REPO --ref main # build base index + graph for main reviewer index /tmp/REPO --ref master # optionally index a second branch (REVIEW_BRANCHES=main,master)

2) Configure keys and settings interactively

reviewer init

Interactive wizard: fills VOYAGE_API_KEY, GITHUB_TOKEN, and optional groups

(stores, multi-repo, task board). Re-run any time to update settings.

Create ~/.config/rag-reviewer/.env from template (fill in VOYAGE_API_KEY + GITHUB_TOKEN).

Check environment readiness: keys, Postgres, Neo4j, GitHub. Prints ✓/✗ per item;

or DEFAULT_REPO is set in .env.

uvx --from rag-reviewer reviewer index /path/to/repo --ref main --repo owner/name

Update CLI later:

uv tool upgrade rag-reviewer ```

reviewer install is cross-platform (Windows / macOS / Linux). It injects the absolute path to uvx automatically — no bash -lc wrapper needed. The manual JSON configs below use bash -lc for macOS/Linux only; on Windows use reviewer install or set "command": "uvx" with `"args": ["--from", "rag-reviewer@latest", "reviewer-mcp"]` directly.

Claude Code: tools work out of the box. reviewer install claude-code also writes an allowlist rule mcp__reviewer__* into your global ~/.claude/settings.json (permissions.allow), so the reviewer MCP tools run in every project without hitting the auto-mode safety classifier — no manual settings edits. Being global, it also covers the plugin (marketplace) install, where the server is available everywhere but ships no permission grants.

Where keys are read from. The reviewer resolves its .env from a fixed location, not the current working directory — MCP clients launch the server with an arbitrary CWD, so a project-local .env is unreliable. Lookup order: $REVIEWER_ENV_FILE → $XDG_CONFIG_HOME/rag-reviewer/.env (default ~/.config/rag-reviewer/.env) → ./.env (handy when running from a repo clone). Real environment variables always win over the file, so you can instead pass keys via an "env": { "VOYAGE_API_KEY": "…", "GITHUB_TOKEN": "…" } block in your MCP client config — works in every client.

- Voyage (VOYAGE_API_KEY): https://dashboard.voyageai.com/ — free token pool; attach a card to lift the 3 RPM / 10K TPM limit (charged only beyond the free pool). - GitHub (GITHUB_TOKEN): a PAT with Pull requests: Read and write + Contents: Read (fine-grained) or the repo scope (classic). Quick option: gh auth token.

All other settings have defaults (documented in .env.example). DEFAULT_REPO (optional) sets the default owner/name for single-repo deployments. REVIEW_BRANCHES (optional, CSV, default main) lists the branches to track — each gets its own isolated base index; PRs targeting a branch outside this list are silently skipped by prepare_review. TASK_BOARD_TYPE / TASK_BOARD_MCP / TASK_BOARD_KEY_PATTERN / TASK_BOARD_URL_TEMPLATE (optional) configure the task board once for the whole deployment, so it need not be repeated in every repo's .review.yml (see Per-repo policy below).

MCP server (stdio transport) — started automatically by the plugin.

uvx --from rag-reviewer@latest reviewer-mcp ```

Reviewing works even without a prior index — context is then limited to the diff and the overlay (RAG/graph are "thin"). For full whole-repo impact analysis, run index against the target branch.

The board (MCP) is connected by the user on the Claude Code side; the plugin does not bundle it.

task_board: type: yougile # yougile | jira — selects the skill playbook mcp: yougile # name of the connected board MCP server (tools are mcp<mcp>*) key_pattern: "[A-Z]+-\\d+" # optional; matches Yougile PRI-34/ID-34 and Jira PROJ-123 ```

The task_board block is a deploy-wide default, not a per-repo requirement. A board connection is the same for every repo of one team, so configure it once in the reviewer .env (TASK_BOARD_TYPE / TASK_BOARD_MCP / TASK_BOARD_KEY_PATTERN / TASK_BOARD_URL_TEMPLATE) and every repo inherits it — no .review.yml needed just for the board. A task_board block in a repo's .review.yml overrides that default for that repo; an explicit empty task_board: disables the board for it. review-pr reads this through the policy; solve-task reads it via the get_board_config MCP tool (and the board-MCP, LLM-side) as a fallback when the local .review.yml has no block.

Bulk task sync is server-side, not LLM (sync_board). The sync-tasks skill is a thin trigger: it calls one MCP tool, sync_board(board, limit, purge_orphaned, keep_with_prs), and the reviewer server enumerates the board over REST itself (reviewer/tasks/boards/, behind a TaskBoardProvider interface — Yougile is the reference), normalizes each task into a TaskBrief in Python, and indexes it via the existing batch indexer. The LLM passes no task text, so a sync costs O(1) tokens regardless of board size. It is incremental via a per-board timestamp watermark in index_meta (ref="tasks:<board>"): a repeat sync touches ~0 tasks; --limit disables purge and the watermark advance. The board REST credentials live only in the reviewer-mcp environment (TASK_BOARD_API_KEY / TASK_BOARD_API_BASE). This inverts the "reviewer Python never touches the board" rule for bulk sync only — single-task reads in solve-task / review-pr still go through the board-MCP on the LLM side.

Manual setup (alternative)

If you prefer to configure your client config by hand rather than using reviewer install:

Each AI coding tool has its own config file. Pick yours:

Files marked ✓ are already present in this repo — if you open rag_for_git as a project in that tool, the MCP server auto-connects. For a global install (works from any project), add the entry to the corresponding global config file.

The MCP entry format by tool (macOS/Linux — use reviewer install on Windows):

Mimo Code (mimocode.json):

{
  "$schema": "https://mimo.xiaomi.com//config.json",
  "mcp": {
    "reviewer": {
      "type": "local",
      "command": ["/bin/bash", "-lc", "uvx --from rag-reviewer@latest reviewer-mcp"],
      "enabled": true
    }
  }
}

OpenCode (opencode.json):

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "reviewer": {
      "type": "local",
      "command": ["/bin/bash", "-lc", "uvx --from rag-reviewer@latest reviewer-mcp"]
    }
  }
}

Kimi Code / Cursor / Gemini CLI / Codex CLI / Trae / Claude Desktop / Windsurf / Antigravity (standard mcpServers JSON):

{
  "mcpServers": {
    "reviewer": {
      "command": "/bin/bash",
      "args": ["-lc", "uvx --from rag-reviewer@latest reviewer-mcp"]
    }
  }
}

VS Code (mcp.json — note: key is servers, not mcpServers):

{
  "servers": {
    "reviewer": {
      "command": "/bin/bash",
      "args": ["-lc", "uvx --from rag-reviewer@latest reviewer-mcp"]
    }
  }
}

Codex CLI (~/.codex/config.toml):

[mcp_servers.reviewer]
command = "/bin/bash"
args = ["-lc", "uvx --from rag-reviewer@latest reviewer-mcp"]

After adding, restart the tool — reviewer will appear alongside other MCP servers.

Claude Code

Two commands, from any project:

/plugin marketplace add mimfort/rag_for_git
/plugin install rag-reviewer@rag-reviewer-marketplace

You get:

- Skills: /rag-reviewer:reviewer_review-pr, /rag-reviewer:reviewer_solve-task, /rag-reviewer:reviewer_sync-codebase, /rag-reviewer:reviewer_sync-tasks (plus /rag-reviewer:reviewer_maintainability-review, /rag-reviewer:reviewer_performance-review, and /rag-reviewer:reviewer_ask). - MCP server reviewer exposing: prepare_review, publish_review, search_code, get_related_symbols, read_file, get_definition, find_callers, get_changed_file_diff, index_task, search_tasks, get_task_context, search_codebase. Alongside search_codebase, session-less graph tools related_symbols/callers/definition (graph traversal without a PR session) are available — used by the /rag-reviewer:reviewer_ask skill for grounded codebase Q&A.

Run /plugin to confirm rag-reviewer is installed and enabled.