Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-review-pr Review my current pull request"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An MCP (Model Context Protocol) server for multi-language PR review with deterministic analysis. It provides AI-powered code review tools that automatically detect languages, apply relevant review guidelines, and run quality checks on your pull requests.
Skill-Based Architecture — Modular review skills that auto-activate based on file types, path patterns, and content detection
Deterministic Quality Checks — Run linters and tests as part of the review pipeline, not just AI suggestions
Impact Analysis — Classify changes by architectural layer (UI, domain, infra, shared) and detect breaking changes
Smart Diff Chunking — Automatically splits large PRs into prioritized chunks for incremental review
Result Caching — Cache diff results and guidelines keyed by commit SHA for fast re-runs
Custom Rules — Layer project-specific rules on top of skill-provided guidelines via a simple rules.md file
Configurable — Tune behavior with .mcp.config.json (ignored files, risk thresholds, max diff size, etc.)
Related MCP server: pr-mcp-server
Skill | Priority | Activates On | Linter |
Security | 15 |
| — |
React | 10 |
| ESLint |
TypeScript | 8 |
| ESLint |
Clean Architecture | 7 |
| — |
JavaScript | 5 |
| ESLint |
Skills are activated automatically when PR diffs match their criteria. Multiple skills can be active simultaneously — their guidelines and rules are merged by priority.
The server exposes the following tools via the MCP protocol:
Tool | Description |
| Get structured file diffs with additions, deletions, and change types |
| Classify changes by layer, detect breaking changes, assign risk level |
| List all available skills and which ones are active for the current PR |
| Get merged review guidelines from all active skills + custom rules |
| Load all applicable rules (skill rules + custom repo rules) |
| Run skill linters and test suites, returns lint issues and test results |
| Full structured PR review combining all tools into a comprehensive |
Node.js ≥ 18
npm
npm installnpm run buildStart the server over stdio transport (for integration with MCP-compatible clients):
# Using the compiled output
npm start
# Or during development
npm run devThen configure your MCP client to connect via stdio. For example, in your MCP client config:
{
"mcpServers": {
"review-pr": {
"command": "node",
"args": ["/path/to/mcp-review-pr/dist/server.js"]
}
}
}The CLI provides standalone usage without an MCP client:
# Review the current repository
npx mcp-review
# Compare against a specific branch
npx mcp-review --base develop
# List available skills and which are active
npx mcp-review --mode skills
# Show active guidelines for your PR
npx mcp-review --mode guidelines
# Analyze impact only
npx mcp-review --mode impact
# Output as markdown instead of JSON
npx mcp-review --format markdown
# Use custom skills directory
npx mcp-review --skills-dir ./my-skillsOption | Alias | Description | Default |
|
| Repository path | Current directory |
|
| Base branch to diff against |
|
|
| Custom skills directory | Built-in skills |
|
| Output format: |
|
|
| Mode: |
|
|
| Show help | — |
Create a .mcp.config.json in your repository root to customize behavior:
{
"productionBranches": ["main", "production"],
"maxDiffLines": 5000,
"failOnRiskLevel": "high",
"ignoreFiles": ["package-lock.json", "yarn.lock", "pnpm-lock.yaml"],
"enableCaching": true
}Option | Type | Default | Description |
|
|
| Branches considered production |
|
|
| Max diff lines per review chunk |
|
|
| Risk level threshold to flag |
|
| Lock files | Files to exclude from review |
|
|
| Enable diff/guideline caching |
Add a rules.md file to your repository root with project-specific review rules:
- All API endpoints must validate input with Zod schemas
- Database queries must use parameterized statements
- Components must have display names for debuggingThese rules are merged with skill-provided rules during review.
Skills are directories containing three files. Place them in the skills/ directory (or a custom directory via --skills-dir):
skills/
└── my-skill/
├── skill.json # Manifest (required)
├── guideline.md # Review guidelines
└── rules.md # Checklist rulesskill.json — Manifest{
"name": "my-skill",
"description": "Description of what this skill reviews",
"version": "1.0.0",
"filePatterns": ["**/*.py"],
"activateOn": {
"extensions": [".py"],
"fileContains": ["import django"],
"pathPatterns": ["views/", "models/"]
},
"priority": 8,
"linter": {
"command": "npx",
"args": ["pylint", "--output-format", "json"],
"fileExtensions": [".py"]
}
}Field | Required | Description |
| ✅ | Unique skill identifier |
| — | Human-readable description |
| — | Semantic version |
| — | Glob patterns for relevant files |
| ✅ | Activation criteria (see below) |
| — | Higher = evaluated first (default: 0) |
| — | Optional linter configuration |
Activation criteria (any match triggers activation):
extensions — File extensions in the diff (e.g., [".ts", ".tsx"])
fileContains — Strings found in diff content (e.g., ["from 'react'"])
pathPatterns — Path substrings in changed files (e.g., ["components/"])
guideline.md — Review GuidelinesFree-form markdown that provides context and best practices for the reviewer. This is included in the review context when the skill is active.
rules.md — Review RulesA markdown list of specific, checkable rules:
- Use strict type annotations, avoid `any`
- Prefer `const` over `let` where possible
- All exported functions must have JSDoc commentssrc/
├── server.ts # MCP server — registers all tools
├── cli.ts # CLI entry point with argument parsing
├── config.ts # .mcp.config.json loader
├── types.ts # Shared TypeScript types
├── cache.ts # Diff and guideline caching (SHA-keyed)
├── chunker.ts # Smart diff chunking with priority ordering
├── retry.ts # Exponential backoff utility
├── skills/
│ ├── index.ts # Public API re-exports
│ ├── types.ts # Skill manifest & runtime types
│ ├── loader.ts # Skill discovery, activation, guideline/rule loading
│ └── runner.ts # Skill linter execution
└── tools/
├── diff.ts # Git diff extraction via simple-git
├── impact.ts # Change impact & risk analysis
├── quality.ts # Lint + test orchestration
├── review.ts # Structured review generation
└── rules.ts # Custom rules.md loaderScript | Description |
| Compile TypeScript to |
| Run in development mode (via |
| Start the compiled MCP server |
| Run tests (Vitest) |
| Run tests in watch mode |
| Type-check without emitting |
| Lint source files with ESLint |
MIT
Generate a complete structured PR review. Runs all analysis tools (diff, impact, skills, quality) and produces a comprehensive ReviewOutput.
| Name | Required | Description | Default |
|---|---|---|---|
| repoPath | Yes | Absolute path to the git repository | |
| skillsDir | No | ||
| baseBranch | No |
Load all applicable rules: skill-specific rules for active skills plus custom repo rules from rules.md.
| Name | Required | Description | Default |
|---|---|---|---|
| repoPath | Yes | Absolute path to the git repository | |
| skillsDir | No | ||
| baseBranch | No |
Run deterministic quality checks: skill linters (ESLint, etc.) and test suite. Returns lint issues and test results.
| Name | Required | Description | Default |
|---|---|---|---|
| repoPath | Yes | Absolute path to the git repository | |
| skillsDir | No | ||
| baseBranch | No |
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.0generate_reviewload_rulesrun_quality_checksScored across 3 tools
Each tool has a clearly distinct purpose: load_rules handles loading rules, run_quality_checks performs deterministic checks, and generate_review produces the final review. No overlap or ambiguity.
All tool names follow a consistent verb_noun pattern with snake_case: load_rules, run_quality_checks, generate_review.
Three tools is ideal for a focused PR review server; each tool has a clear role without being too few or too many.
The tool set covers the full workflow: loading rules, running quality checks, and generating a comprehensive review. No obvious gaps for the intended domain.
AI-native git hosting — repos, PRs, issues, CI gates, and AI code review over MCP (60 tools).
A Model Context Protocol (MCP) application for automated GitHub PR analysis and issue management.…
MCP server for building and testing AI agents with multi-model experimentation and insights.
GitHub Copilot MCP: code, repo, PR, workflow tools for AI assistants.
