code-review-mcp
Click on "Install 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., "@code-review-mcpReview https://github.com/facebook/react/pull/12345"
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.
Code Review MCP Server
English | δΈζ
MCP (Model Context Protocol) server for code review. Enables AI assistants to review GitHub/GitLab Pull Requests and Merge Requests.
Keywords: MCP server, AI code review, GitHub pull request review, GitLab merge request, Cursor IDE, Claude Desktop, Model Context Protocol, automated PR comments.
β¨ Features
π Multi-platform: Supports both GitHub and GitLab (including self-hosted)
π Multiple Transports: Supports stdio, SSE, and WebSocket protocols
π¦ Easy Install: Quick install via
uvxorpipπ³ Containerized: Docker image available
βοΈ Cloud Deploy: One-click Smithery deployment
π Security First: Environment variable configuration, no data persistence
Related MCP server: GitHub Code Review Assistant
π Quick Start
Option 1: Using uvx (Recommended)
# Run directly, no installation needed
uvx code-review-mcpOption 2: Using pip
pip install code-review-mcp
# Run the server
code-review-mcp
# (Optional) Install Cursor rules to your project
code-review-mcp init-rulesOption 3: From Source
git clone https://github.com/OldJii/code-review-mcp.git
cd code-review-mcp
pip install -e .
code-review-mcpπ§ Configuration
Environment Variables
Variable | Description | Required |
| GitHub personal access token | When using GitHub |
| GitLab personal access token | When using GitLab |
| GitLab host URL | For self-hosted (default: gitlab.com) |
Getting Tokens
GitHub
# Option 1: Using gh CLI (Recommended)
brew install gh
gh auth login
# Option 2: Manual Token Creation
# Visit https://github.com/settings/tokens
# Create Personal Access Token with 'repo' scope
export GITHUB_TOKEN="your-token-here"GitLab
# Option 1: Using glab CLI (Recommended)
brew install glab
glab auth login
# For self-hosted GitLab
glab auth login --hostname gitlab.yourcompany.com
# Option 2: Manual Token Creation
# Visit GitLab -> Settings -> Access Tokens
# Create token with 'api' scope
export GITLAB_TOKEN="your-token-here"
export GITLAB_HOST="gitlab.yourcompany.com" # For self-hostedπ± Client Configuration
Cursor
Edit ~/.cursor/mcp.json:
{
"mcpServers": {
"code-review": {
"command": "uvx",
"args": ["code-review-mcp"],
"env": {
"GITHUB_TOKEN": "your-github-token",
"GITLAB_TOKEN": "your-gitlab-token"
}
}
}
}Claude Desktop
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"code-review": {
"command": "uvx",
"args": ["code-review-mcp"],
"env": {
"GITHUB_TOKEN": "your-github-token",
"GITLAB_TOKEN": "your-gitlab-token"
}
}
}
}SSE Mode (Remote Deployment)
# Start SSE server
code-review-mcp --transport sse --port 8000Client configuration:
{
"mcpServers": {
"code-review": {
"url": "http://your-server:8000/sse"
}
}
}WebSocket Mode (Remote Deployment)
# Start WebSocket server
code-review-mcp --transport websocket --port 8000Client configuration:
{
"mcpServers": {
"code-review": {
"url": "ws://your-server:8000/ws"
}
}
}π³ Docker Deployment
Build Image
docker build -t code-review-mcp .Run Container
stdio mode
docker run -i --rm \
-e GITHUB_TOKEN="your-token" \
code-review-mcpSSE mode
docker run -d --rm \
-e GITHUB_TOKEN="your-token" \
-p 8000:8000 \
code-review-mcp --transport sseπ¨ MCP Tools
Rules
Tool | Description |
| Get review rules (builtin + custom project rules) |
Information Retrieval
Tool | Description |
| Get PR/MR details (title, description, branches) |
| Get code changes (diff), supports file type filtering |
| Extract related PR/MR links from description |
Adding Comments
Tool | Description |
| Add inline comment to specific code line |
| Add general comment |
| Batch add comments (inline + general) |
π¬ Usage Examples
Chat with Cursor or Claude:
Review GitHub PR
Review https://github.com/facebook/react/pull/12345Review GitLab MR
Review https://gitlab.com/group/project/-/merge_requests/678Review Self-hosted GitLab MR
Review https://gitlab.yourcompany.com/team/project/-/merge_requests/90Review Only Specific File Types
Review this PR, only check .py and .js files:
https://github.com/owner/repo/pull/123π§ͺ Debugging & Testing
Using MCP Inspector
# Run with MCP Inspector
npx @modelcontextprotocol/inspector uvx code-review-mcpThis launches a web interface where you can:
View all available tools
Manually call tools and inspect results
Debug parameters and responses
Local Development
# Clone repository
git clone https://github.com/OldJii/code-review-mcp.git
cd code-review-mcp
# Install dev dependencies
pip install -e ".[dev]"
# Run tests
pytest
# Debug with Inspector
npx @modelcontextprotocol/inspector python -m code_review_mcp.serverπ Project Structure
code-review-mcp/
βββ src/
β βββ code_review_mcp/
β βββ __init__.py # Package entry
β βββ cli.py # CLI commands (init-rules, etc.)
β βββ server.py # MCP server main logic
β βββ providers.py # GitHub/GitLab providers
β βββ rules/ # Bundled Cursor rules
β βββ code-review.mdc
β βββ code-review-en.mdc
βββ pyproject.toml # Project config & PyPI publishing
βββ Dockerfile # Docker build file
βββ smithery.yaml # Smithery deployment config
βββ CHANGELOG.md # Changelog
βββ CONTRIBUTING.md # Contributing guide
βββ README.md # Documentationπ― Cursor Rules (Recommended)
This package includes built-in code review rules for Cursor IDE. Install them to your project with one command:
# Install rules to current project
code-review-mcp init-rules
# Install to a specific directory
code-review-mcp init-rules --target /path/to/project
# Overwrite existing rules
code-review-mcp init-rules --force
# List available rules
code-review-mcp list-rulesAfter installation, the rules will be available in your project's .cursor/rules/ directory:
code-review.mdc- Chinese versioncode-review-en.mdc- English version
Custom Project Rules
You can define project-specific review rules that the MCP server loads at runtime. This allows each project to enforce its own coding standards during reviews.
Quick Setup:
# Generate a custom rules template
code-review-mcp init-rules --customThis creates .code-review-rules/project-rules.md in your project. Edit it with your project-specific conventions, then configure the MCP server to load it:
{
"mcpServers": {
"code-review": {
"command": "uvx",
"args": ["code-review-mcp"],
"env": {
"GITHUB_TOKEN": "your-token",
"CODE_REVIEW_RULES_DIR": "/absolute/path/to/project/.code-review-rules"
}
}
}
}How It Works:
Set
CODE_REVIEW_RULES_DIRto a directory containing.mdor.mdcfilesOr simply place a
.code-review-rules/directory in your project root (auto-discovered)The
get_review_rulestool returns both builtin and custom rulesAI assistants use these rules when performing reviews
Custom rules supplement (not replace) the builtin review guidelines
Environment Variable:
Variable | Description | Required |
| Path to custom rules directory | No (optional) |
π€ Contributing
Contributions welcome! See CONTRIBUTING.md for details.
π License
β FAQ
What is code-review-mcp?
An MCP server that lets AI assistants (Cursor, Claude, etc.) fetch PR/MR diffs and post inline or general review comments on GitHub and GitLab.
How do I install it?
Fastest: uvx code-review-mcp. Or pip install code-review-mcp. See Quick Start.
Does it work with self-hosted GitLab?
Yes. Set GITLAB_TOKEN and GITLAB_HOST=gitlab.yourcompany.com.
Which AI clients are supported?
Any MCP client β Cursor, Claude Desktop, and custom integrations via stdio, SSE, or WebSocket.
Can I add project-specific review rules?
Yes. Run code-review-mcp init-rules --custom or set CODE_REVIEW_RULES_DIR.
Is my code stored on a server?
No persistent storage. Tokens are read from environment variables; diffs are fetched on demand from GitHub/GitLab APIs.
Where can AI assistants read a structured summary?
See llms.txt in this repository.
π Related Links
Available Tools
7 toolsadd_inline_commentA
Add inline comment to a specific code line in PR/MR
| Name | Required | Description | Default |
|---|---|---|---|
| provider | Yes | Code hosting provider | |
| repo | Yes | Repository path | |
| pr_id | Yes | PR/MR number | |
| file_path | Yes | Path to the file | |
| line | Yes | Line number to comment on | |
| line_type | Yes | Line type: 'old' for deleted line, 'new' for added line | |
| comment | Yes | Comment content | |
| host | No | GitLab host for self-hosted instances |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate non-readonly, non-destructive behavior. The description adds no extra behavioral details beyond the core action. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single, clear sentence with no redundant words. Efficiently conveys the purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 8 parameters and no output schema, the description is minimal. It omits details like return values, permissions, or limitations, but the schema covers parameters fully.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description does not add any additional meaning beyond the schema's parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Add inline comment to a specific code line in PR/MR' uses a specific verb ('Add') and resource ('inline comment to a specific code line'), clearly distinguishing it from siblings like 'add_pr_comment' which targets general PR comments.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives such as 'add_pr_comment' or 'batch_add_comments'. The description lacks context on prerequisites or scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
add_pr_commentB
Add a general comment to PR/MR
| Name | Required | Description | Default |
|---|---|---|---|
| provider | Yes | Code hosting provider | |
| repo | Yes | Repository path | |
| pr_id | Yes | PR/MR number | |
| comment | Yes | Comment content | |
| host | No | GitLab host for self-hosted instances |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint=false and destructiveHint=false, but the description does not elaborate on behavioral traits beyond stating the action. It lacks information about side effects, authorization needs, or idempotency. With no output schema, more detail on what happens after adding would help.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short and to the point, but it omits useful context that could be included without bloating. It achieves conciseness but at the cost of completeness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters and no output schema, the description does not address what happens after a successful add, such as confirmation or potential limitations. It lacks completeness for a tool with moderate complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with each parameter having a clear description. The tool description adds no extra meaning beyond what is already in the schema, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description 'Add a general comment to PR/MR' clearly specifies the action (add) and resource (comment on PR/MR). It differentiates from sibling tools like 'add_inline_comment' and 'batch_add_comments' by indicating it's a general comment.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions for using this tool over others like 'batch_add_comments' or 'extract_related_prs'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
batch_add_commentsA
Batch add multiple inline comments and optionally a general comment
| Name | Required | Description | Default |
|---|---|---|---|
| provider | Yes | Code hosting provider | |
| repo | Yes | Repository path | |
| pr_id | Yes | PR/MR number | |
| inline_comments | Yes | List of inline comments to add | |
| pr_comment | No | Optional general PR/MR comment | |
| host | No | GitLab host for self-hosted instances |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate a non-read-only, non-destructive operation. The description confirms it is a write operation ('add'), which aligns. However, no extra behavioral details (e.g., side effects, error handling) are provided beyond the annotations. The description does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence that efficiently conveys the tool's primary function. No unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the complexity of a batch operation and the lack of output schema, the description is minimal. It does not address partial success, error scenarios, or prerequisites like authentication. More context is needed for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% description coverage, so each parameter is already documented. The description adds no additional parameter semantics beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs a batch operation for adding inline comments and optionally a general comment. This verb+resource combination (batch_add_comments) is specific and distinguishes it from sibling tools like add_inline_comment and add_pr_comment which are single operations.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for multiple inline comments but does not explicitly state when to use this tool versus alternatives. It lacks guidance on when not to use it (e.g., for a single comment) or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_pr_changesARead-only
Get PR/MR code changes (diff) with optional file extension filtering
| Name | Required | Description | Default |
|---|---|---|---|
| provider | Yes | Code hosting provider | |
| repo | Yes | Repository path | |
| pr_id | Yes | PR/MR number | |
| host | No | GitLab host for self-hosted instances | |
| file_extensions | No | Filter files by extensions (e.g., ['.py', '.js']) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, so the description's 'Get... changes' is consistent. The description adds that it returns a diff and supports file filtering, but does not disclose behavior for errors, pagination, or performance. Some value added over annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence, efficient and front-loaded with the core functionality. However, it could benefit from slightly more structure or elaboration without becoming verbose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, so the description should explain the return format (e.g., unified diff, list of changed files). It does not. With 5 parameters and no output context, the description is incomplete for effective use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% coverage with descriptions for all 5 parameters. The description only reiterates the filtering capability already present in the schema. No additional semantic value provided beyond the structured schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get PR/MR code changes (diff)' with optional file extension filtering, specifying the exact verb and resource. It is distinct from sibling tools like get_pr_info (metadata) and add_inline_comment (commenting).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit guidance on when to use this tool versus alternatives such as get_pr_info or extract_related_prs. The description implies usage for viewing diffs, but does not provide contextual or exclusionary advice.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_pr_infoARead-only
Get PR/MR detailed information including title, description, author, and branches
| Name | Required | Description | Default |
|---|---|---|---|
| provider | Yes | Code hosting provider (github or gitlab) | |
| repo | Yes | Repository path (e.g., owner/repo or group/project) | |
| pr_id | Yes | PR/MR number | |
| host | No | GitLab host for self-hosted instances (optional, default: gitlab.com) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already set readOnlyHint=true and openWorldHint=true. The description adds no further behavioral traits (e.g., error handling, pagination), but it does not contradict annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Single sentence is direct and complete, front-loading the purpose and output fields without any superfluous words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple retrieval tool with good schema coverage and annotations, the description sufficiently conveys what the tool returns. Minor gap: no mention of error cases or response format, but acceptable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema covers all 4 parameters with 100% description coverage. The description adds no additional meaning beyond what the schema already provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it retrieves detailed PR/MR information including specific fields (title, description, author, branches), distinguishing it from sibling tools like add_pr_comment or extract_related_prs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for fetching PR details but does not explicitly state when to use versus alternatives like get_pr_changes or add_inline_comment. However, the read-only annotation and result content provide enough context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_review_rulesARead-only
Get code review rules (builtin + custom project rules). Call this before starting a review to load all applicable rules. Custom rules are loaded from CODE_REVIEW_RULES_DIR env var, or auto-discovered from .code-review-rules/ in the working directory.
| Name | Required | Description | Default |
|---|---|---|---|
| lang | No | Language filter for builtin rules (optional). 'zh' for Chinese, 'en' for English. If omitted, all builtin rules are returned. | |
| include_builtin | No | Whether to include builtin rules (default: true) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already provide readOnlyHint=true, indicating no mutation. The description adds behavioral context about custom rule loading (from env var or .code-review-rules/ directory), which is valuable beyond what annotations convey. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences: first states purpose, second provides usage context and custom rule discovery. No wasted words. Front-loaded with purpose.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read tool with two optional parameters and good annotations, the description covers usage and custom rule sources adequately. Missing return format description, but not critical given the tool's simplicity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with both parameters fully described. The description does not add parameter-specific meaning beyond the schema. Baseline of 3 is appropriate since schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool gets code review rules (both builtin and custom). This is distinct from sibling tools that deal with comments, PR extraction, and changes, so the agent can easily differentiate.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly advises calling this 'before starting a review to load all applicable rules'. This provides clear context for when to use. Does not enumerate alternatives or explicitly exclude usage cases, but the guidance is sufficient for a simple tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
7 tool updates
v1.2.2- First observed
add_inline_comment - First observed
add_pr_comment - First observed
batch_add_comments - First observed
extract_related_prs - First observed
get_pr_changes - First observed
get_pr_info - First observed
get_review_rules
TDQS
Each tool has a clearly distinct purpose: inline comments, general comments, batch comments, extracting PR links, getting PR changes, PR info, and review rules. No ambiguity.
All tool names follow a consistent verb_noun pattern (e.g., add_inline_comment, get_pr_changes), making them predictable and easy to understand.
Seven tools is well-scoped for a code review server, covering commenting, information retrieval, and rule loading without unnecessary bloat.
The tool set covers core review operations (viewing info, changes, adding comments, rules), but lacks edit/delete comment functionality, which is a minor gap.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Connect AI assistants to GitHub - manage repos, issues, PRs, and workflows through natural language.
AI-native git hosting β repos, PRs, issues, CI gates, and AI code review over MCP (60 tools).
AI code review for GitHub PRs with an MCP autofix loop for Claude Code and Cursor
Git-native policy layer for AI agents: check_action verdicts against rules approved via PR.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables automated GitHub Pull Request reviews using local Ollama, Cursor CLI, or Gemini CLI as AI providers. Supports customizable review prompts, comprehensive PR analysis, and optional auto-posting of reviews to GitHub.135MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI assistants to perform comprehensive GitHub pull request code reviews, including analysis of code patterns, complexity, and security issues, while managing review comments and ensuring compliance with team coding standards.2MIT
- AlicenseBqualityCmaintenanceConnects LLMs to GitHub and GitLab to analyze pull and merge requests for logic, security, and architectural alignment. It provides tools for fetching diffs, file contents, and project metadata, alongside guided prompts for professional code reviews.1013ISC
- FlicenseAqualityCmaintenanceEnables LLM clients to list, read, review, and comment on GitHub pull requests, turning an AI assistant into a fully capable code reviewer.61-
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/OldJii/code-review-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server