Skip to main content
Glama
nicobailon

Gemini Code Review MCP

by nicobailon
OverviewSchemaSourceRelated ServersScoreDiscussionsAdmin
Python
Local

Gemini Code Review MCP

PyPI version License: MIT Python MCP Gemini

Gemini Code Review MCP

🚀 AI-powered code reviews that understand your project's context and development progress

Transform your git diffs into actionable insights with contextual awareness of your project guidelines, task progress, and coding standards.

📚 Table of Contents

Related MCP server: grippy-code-review

Why Use This?

  • 🎯 Context-Aware Reviews: Automatically includes your CLAUDE.md guidelines and project standards

  • 📊 Progress Tracking: Understands your task lists and development phases

  • 🤖 AI Agent Integration: Seamless MCP integration with Claude Code and Cursor

  • 🔄 Flexible Workflows: GitHub PR reviews, project analysis, or custom scopes

  • ⚡ Smart Defaults: Auto-detects what to review based on your project state

🚀 Claude Code Installation

Option A: Install the MCP server to Claude Code as user-scoped MCP server:

claude mcp add-json gemini-code-review -s user '{"command":"uvx","args":["gemini-code-review-mcp"],"env":{"GEMINI_API_KEY":"your_key_here","GITHUB_TOKEN":"your_key_here"}}'

(-s user installs as user-scoped and will be available to you across all projects on your machine, and will be private to you. Omit -s user to install the as locally scoped.)

Option B: Install the MCP server to Claude Code as project-scoped MCP server:

claude mcp add-json gemini-code-review -s project /path/to/server '{"type":"stdio","command":"npx","args":["gemini-code-review"],"env":{"GEMINI_API_KEY":"your_key_here","GITHUB_TOKEN":"your_key_here"}}'

The command above creates or updates a .mcp.json file to the project root with the following structure:

{
  "mcpServers": {
    "gemini-code-review": {
      "command": "/path/to/server",
      "args": ["gemini-code-review"],
      "env": {"GEMINI_API_KEY":"your_key_here","GITHUB_TOKEN":"your_key_here"}
    }
  }
}

Get your Gemini API key: https://ai.google.dev/gemini-api/docs/api-key

Get your GitHub token: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token

Docs for setting up MCP for Claude Code: https://docs.anthropic.com/en/docs/claude-code/tutorials#set-up-model-context-protocol-mcp

Troubleshooting MCP Installation

If the MCP tools aren't working:

  1. Check your installation: claude mcp list

  2. Verify API key is set: claude mcp get gemini-code-review

  3. If API key shows empty, remove and re-add:

    claude mcp remove gemini-code-review
claude mcp add-json gemini-code-review -s user '{"type":"stdio","command":"npx","args":["@modelcontextprotocol/server-gemini-code-review"],"env":{"GEMINI_API_KEY":"your_key_here","GITHUB_TOKEN":"your_key_here"}}'

    (Make sure you replace /path/to/server with the path to your server executable)

  4. Always restart Claude Desktop after any MCP configuration changes

📋 Available MCP Tools

Tool

Purpose

Key Options

generate_ai_code_review

Complete AI code review

project_path, model, scope

generate_pr_review

GitHub PR analysis

github_pr_url, project_path

ask_gemini

Generate context and get AI response

user_instructions, file_selections

AI Code Review

// Quick project review (uses default model: gemini-2.0-flash)
{
  tool_name: "generate_ai_code_review",
  arguments: {
    project_path: "/path/to/project"
  }
}

// With advanced model
{
  tool_name: "generate_ai_code_review",
  arguments: {
    project_path: "/path/to/project",
    model: "gemini-2.5-pro",  // Uses alias for gemini-2.5-pro-preview-06-05
    thinking_budget: 15000    // Optional: thinking tokens (when supported)
  }
}

GitHub PR Review

// Analyze GitHub pull request
{
  tool_name: "generate_pr_review",
  arguments: {
    github_pr_url: "https://github.com/owner/repo/pull/123",
    thinking_budget: 20000    // Optional: thinking tokens
  }
}

// With reference documentation
{
  tool_name: "generate_pr_review",
  arguments: {
    github_pr_url: "https://github.com/owner/repo/pull/123",
    url_context: ["https://docs.api.com/v2/guidelines"]  // Optional: Reference docs for the review
  }
}

Ask Gemini (NEW!)

// Generate context from files and get AI response in one step
{
  tool_name: "ask_gemini",
  arguments: {
    user_instructions: "Review for security vulnerabilities and suggest fixes",
    file_selections: [
      { path: "src/auth.py" },
      { path: "src/database.py", line_ranges: [[50, 100]] }
    ],
    project_path: "/path/to/project",
    model: "gemini-2.5-pro"
  }
}

// Simple query without files
{
  tool_name: "ask_gemini",
  arguments: {
    user_instructions: "Explain the security implications of the current authentication approach",
    include_claude_memory: true  // Includes project guidelines
  }
}

Common Workflows

Quick Project Review

Human: Generate a code review for my project

Claude: I'll analyze your project and generate a comprehensive review.

[Uses generate_ai_code_review with project_path]

GitHub PR Review

Human: Review this PR: https://github.com/owner/repo/pull/123

Claude: I'll fetch the PR and analyze the changes.

[Uses generate_pr_review with github_pr_url]

Custom Model Review

Human: Generate a detailed review using Gemini 2.5 Pro

Claude: I'll use Gemini 2.5 Pro for a more detailed analysis.

[Uses generate_ai_code_review with model="gemini-2.5-pro"]

File-Specific Review with AI

Human: Review auth.py and database.py lines 50-100 for security issues

Claude: I'll analyze those specific files for security vulnerabilities.

[Uses ask_gemini with file_selections and security-focused instructions]

Quick Code Question

Human: What are the performance implications of the current caching strategy?

Claude: I'll analyze your caching implementation and provide insights.

[Uses ask_gemini with user_instructions only, leveraging project context]

⚙️ Configuration

Environment Variables

Variable

Required

Default

Description

GEMINI_API_KEY

✅

-

Your Gemini API key

GITHUB_TOKEN

⬜

-

GitHub token for PR reviews (create one)

GEMINI_MODEL

⬜

gemini-2.0-flash

AI model selection

GEMINI_TEMPERATURE

⬜

0.5

Creativity (0.0-2.0)

THINKING_BUDGET

⬜

Auto

Thinking tokens (Pro: 128-32768, Flash: 0-24576)

Model Configuration

Default Models

  • Primary Model: gemini-2.0-flash - Fast, efficient model for code reviews

  • Summary Model: gemini-2.0-flash-lite - Used internally for quick summaries

Model Aliases

For convenience, you can use these short aliases instead of full model names:

Alias

Full Model Name

Features

gemini-2.5-pro

gemini-2.5-pro-preview-06-05

Advanced reasoning, thinking mode, URL context

gemini-2.5-flash

gemini-2.5-flash-preview-05-20

Fast, thinking mode, URL context

Available Models

All models support code review, with varying capabilities:

With Thinking Mode + URL Context:

  • gemini-2.5-pro (alias) / gemini-2.5-pro-preview-06-05

  • gemini-2.5-flash (alias) / gemini-2.5-flash-preview-05-20

With URL Context Only:

  • gemini-2.0-flash (default)

  • gemini-2.0-flash-live-001

Basic Models:

  • gemini-1.5-pro

  • gemini-1.5-flash (used for integration tests - cost-effective)

Usage Examples

// Using default model (gemini-2.0-flash)
{ tool_name: "generate_ai_code_review", arguments: { project_path: "/path" } }

// Using alias for advanced model
{ tool_name: "generate_ai_code_review", arguments: { 
  project_path: "/path",
  model: "gemini-2.5-pro"  // Automatically resolves to gemini-2.5-pro-preview-06-05
} }

// Using full model name
{ tool_name: "generate_ai_code_review", arguments: { 
  project_path: "/path",
  model: "gemini-2.5-pro-preview-06-05"
} }

Automatic Configuration Discovery

When enabled with flags, the tool discovers and includes:

  • 📁 CLAUDE.md files at project/user/enterprise levels (use --include-claude-memory)

  • 📝 Cursor rules (.cursorrules, .cursor/rules/*.mdc) (use --include-cursor-rules)

  • 🔗 Import syntax (@path/to/file.md) for modular configs

Configuration in pyproject.toml

You can set default values in your pyproject.toml:

[tool.gemini]
temperature = 0.5
default_prompt = "Your custom review prompt"
default_model = "gemini-1.5-flash"
include_claude_memory = true
include_cursor_rules = false
enable_cache = true
cache_ttl_seconds = 900  # 15 minutes

Configuration precedence: CLI flags > Environment variables > pyproject.toml > Built-in defaults

✨ Key Features

  • 🤖 Smart Context - Optionally includes CLAUDE.md (use --include-claude-memory), task lists (use --task-list), and project structure

  • 🎯 Flexible Scopes - Review PRs, recent changes, or entire projects

  • ⚡ Model Selection - Choose between Gemini 2.0 Flash (speed) or 2.5 Pro (depth)

  • 🔄 GitHub Integration - Direct PR analysis with full context

  • 📊 Progress Aware - Understands development phases and task completion

  • 🔗 URL Context - Gemini automatically fetches and analyzes URLs in prompts (or use --url-context flag)

  • 🏗️ Project Scaffolding - Initialize projects with recommended structure via gemini-code-review-init

  • 🚀 Performance Optimized - Built-in caching layer for faster repeated operations

  • 🎨 Clear Mode Indication - Explicit feedback about Task-Driven vs General Review modes

🖥️ CLI Usage

Alternative: Command-line interface for development/testing

Installation

# Quick start with uvx (no install needed)
uvx gemini-code-review-mcp /path/to/project

# Or install globally
pip install gemini-code-review-mcp

Commands

# Initialize a new project with recommended structure
gemini-code-review-init

# Basic review (current directory)
generate-code-review

# Review specific project
generate-code-review /path/to/project

# Advanced options
generate-code-review . \
  --scope full_project \
  --model gemini-2.5-pro

# Use specific task list (overrides auto-discovery)
generate-code-review \
  --task-list tasks/tasks-feature-x.md \
  --scope specific_phase \
  --phase-number 2.0

# With thinking budget (current directory)
generate-code-review --thinking-budget 20000 --temperature 0.7

# With URL context for framework-specific review
generate-code-review \
  --file-instructions "Review my async implementation against the official docs" \
  --url-context https://docs.python.org/3/library/asyncio.html

# File-based context generation (for debugging - does not call AI)
generate-file-context -f src/main.py -f src/utils.py:10-50 \
  --user-instructions "Review for performance issues" \
  -o context.md

# Meta-prompt only (current directory)
generate-meta-prompt --stream

Review Modes

The tool operates in one of three modes:

  1. 🔍 General Review Mode: Default mode (no --task-list flag)

    • Comprehensive code quality analysis

    • Focuses on best practices and improvements

    • Best for: Maintenance, refactoring, or exploratory reviews

  2. 📝 Task-Driven Mode: When --task-list flag is used (opt-in)

    • Enable with: generate-code-review . --task-list tasks-feature.md

    • Or auto-select latest: generate-code-review . --task-list

    • Contextualizes review based on your current development phase

    • Tracks progress against planned tasks

    • Best for: Active development with defined milestones

  3. 🐙 GitHub PR Mode: When --github-pr-url is provided

    • Analyzes specific pull request changes

    • Includes PR context and discussions

    • Best for: Code review workflows

Supported File Formats

  • 📋 Task Lists: /tasks/tasks-*.md - Track development phases

  • 📄 PRDs: /tasks/prd-*.md - Project requirements

  • 📦 Configs: CLAUDE.md, .cursorrules - Coding standards

🆘 Troubleshooting

  • Missing API key? → Get one at ai.google.dev

  • MCP not working? → Run claude mcp list to verify installation

  • Old version cached? → Run uv cache clean

📦 Development

# Setup
git clone https://github.com/nicobailon/gemini-code-review-mcp
cd gemini-code-review-mcp
pip install -e ".[dev]"

# Testing commands
python -m pytest tests/    # Run all tests in venv
make lint                  # Check code style
make test-cli             # Test CLI commands

Testing Configuration

The test suite includes both mocked unit tests and real API integration tests:

Unit Tests (Default)

  • Fast execution: Mock all external API calls

  • No API key required: Run without any setup

  • Model configuration: Tests use gemini-2.0-flash defaults

  • Run with: pytest or python -m pytest tests/

Integration Tests (Optional)

  • Real API calls: Uses gemini-1.5-flash for cost-effective testing

  • API key required: Set GEMINI_API_KEY environment variable

  • Limited features: Tests only features supported by gemini-1.5-flash (no thinking mode/URL context)

  • Run with: pytest -m integration or pytest tests/integration/

Running Tests

# Run only unit tests (default, fast)
pytest

# Run only integration tests (requires API key)
export GEMINI_API_KEY=your_key_here
pytest -m integration

# Run all tests including integration
pytest -m ""

# Run specific integration test
pytest tests/integration/test_gemini_real.py::TestGeminiRealAPI::test_basic_code_review_generation

# Verbose output with integration tests
pytest -v -m integration

Test Features

  • Model verification: Ensures gemini-1.5-flash is used for integration tests

  • Capability testing: Validates that unsupported features are properly handled

  • Error handling: Tests graceful degradation with invalid inputs

  • Temperature testing: Verifies model parameter effects

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request. See CONTRIBUTING.md for development setup and guidelines.

Release Process

This project uses a manual release process. For maintainers:

  • Run ./scripts/check-release-readiness.sh to verify readiness

  • Follow MANUAL_RELEASE_GUIDE.md for detailed steps

  • Or use ./scripts/release.sh for guided release process

📏 License

MIT License - see LICENSE file for details.

👥 Credits

Built by Nico Bailon.

Available Tools

3 tools
ask_geminiC

Generates context from files and sends it to Gemini for a response.

This tool combines context generation with a direct call to the Gemini API.

ParametersJSON Schema
NameRequiredDescriptionDefault
user_instructionsNoThe primary query or instructions for Gemini.
file_selectionsNoOptional list of files/line ranges to include in the context.
project_pathNoOptional project root for relative paths.
include_claude_memoryNoInclude CLAUDE.md files in context.
include_cursor_rulesNoInclude Cursor rules files in context.
auto_meta_promptNoIf no user_instructions, generate a meta-prompt.
temperatureNoAI temperature for generation.
modelNoSpecific Gemini model to use.
thinking_budgetNoOptional token budget for thinking mode.
text_outputNoIf True, return the response as a string. If False, save it to a file.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

C2.9/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It mentions combining context generation with an API call but fails to disclose behavioral traits like file reading, potential mutations (none), or authentication needs. Insufficient transparency for a tool with 10 parameters.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences, both informative. First sentence states primary function, second adds context. No fluff, front-loaded. Could include a brief usage hint, but overall efficient.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite 10 parameters and output schema, description is minimal. Missing explanation of tool's workflow (context generation then API call), order of operations, or how parameters interact. Incomplete for a complex tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so baseline is 3. Description adds minimal extra meaning beyond schema—just 'context from files' which aligns with file_selections. No additional parameter semantics or examples provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it generates context from files and sends to Gemini, specifying a verb ('generates context') and resource ('Gemini'). It differentiates from sibling tools (code review, PR review) by focusing on general AI query with file context.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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. The description lacks explicit context for appropriate usage, such as when to choose this over direct Gemini calls or other context-generation tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_ai_code_reviewC

Generate AI-powered code review from context file, content, or project analysis.

ParametersJSON Schema
NameRequiredDescriptionDefault
context_file_pathNoPath to existing code review context file (.md)
context_contentNoDirect context content (for AI agent chaining)
project_pathNoProject path for direct analysis (generates context internally)
scopeNoReview scope when using project_path - 'recent_phase', 'full_project', 'specific_phase', 'specific_task'recent_phase
phase_numberNoPhase number for specific_phase scope
task_numberNoTask number for specific_task scope
task_listNoSpecific task list file to use (overrides automatic discovery)
default_promptNoCustom default prompt when no task list exists
output_pathNoCustom output file path for AI review. If not provided, uses default timestamped path
modelNoOptional Gemini model name (e.g., 'gemini-2.0-flash-exp', 'gemini-1.5-pro')
temperatureNoTemperature for AI model (default: 0.5, range: 0.0-2.0)
custom_promptNoOptional custom AI prompt to override default instructions
text_outputNoReturn review directly as text (default: true - for AI agent chaining)
auto_meta_promptNoAutomatically generate and embed meta prompt (default: true)
include_claude_memoryNoInclude CLAUDE.md files in context (default: true)
include_cursor_rulesNoInclude Cursor rules files in context (default: false)
thinking_budgetNoOptional token budget for thinking mode (if supported by model)
url_contextNoOptional URL(s) to include in context - can be string or list of strings

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

C2.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full responsibility for behavioral transparency. It only states the tool generates a code review without disclosing any side effects, state changes, or security implications. For a tool with 18 parameters and multiple execution modes, this is insufficient.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is concise but lacks important context for a complex tool. It is front-loaded with the verb and resource, but the brevity sacrifices completeness. Every word earns its place, but the sentence could be expanded to include key usage notes.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite high schema coverage and an output schema, the description fails to explain the output nature (e.g., a markdown report) or guide the agent on selecting the appropriate input mode. For a tool with 18 parameters and multiple sources, the description is too sparse to be fully complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 100% parameter description coverage, so the schema already documents each parameter. The description adds no extra meaning beyond what the schema provides, such as parameter interactions (e.g., precedence when multiple sources are given) or defaults interplay.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool generates AI-powered code reviews from three sources: context file, content, or project analysis. However, it does not explicitly differentiate from sibling tools like 'ask_gemini' and 'generate_pr_review', missing an opportunity to clarify when to use this tool over others.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus alternatives, nor does it specify when to choose one input source over another (context_file_path vs context_content vs project_path). No exclusions or prerequisites are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_pr_reviewC

Generate code review for a GitHub Pull Request with configuration discovery.

ParametersJSON Schema
NameRequiredDescriptionDefault
github_pr_urlNoGitHub PR URL (e.g., 'https://github.com/owner/repo/pull/123')
project_pathNoOptional local project path for context (default: current directory)
temperatureNoTemperature for AI model (default: 0.5, range: 0.0-2.0)
enable_gemini_reviewNoEnable Gemini AI code review generation (default: true)
include_claude_memoryNoInclude CLAUDE.md files in context (default: true)
include_cursor_rulesNoInclude Cursor rules files in context (default: false)
auto_meta_promptNoAutomatically generate and embed meta prompt in user_instructions (default: true)
use_templated_instructionsNoUse templated backup instructions instead of generated meta prompt (default: false)
create_context_fileNoSave context to file and return context content (default: false)
raw_context_onlyNoReturn raw context content without AI processing (default: false)
text_outputNoReturn content directly without saving (default: false - saves to timestamped .md file)
thinking_budgetNoOptional token budget for thinking mode (if supported by model)
url_contextNoOptional URL(s) to include in context - can be string or list of strings

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

C2.4/5.0
Behavior1/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must disclose behavioral traits. It only states 'Generate code review... with configuration discovery' without explaining side effects, authentication needs, rate limits, or output format. This is a critical gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, which is concise, but it lacks structure and front-loads no key information beyond the tool name. It is not optimally organized for an AI agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness1/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (13 parameters, multiple flags), the description is severely incomplete. It omits prerequisites (e.g., GitHub access), output details, and ignores the output schema. The agent cannot judge completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

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 adds minimal value beyond the schema, only mentioning 'configuration discovery' vaguely. It does not enhance parameter understanding.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: generating a code review for a GitHub Pull Request. However, it does not differentiate from the sibling tool 'generate_ai_code_review', preventing a top score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 the siblings 'ask_gemini' or 'generate_ai_code_review'. The description lacks any context for appropriate usage.

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.

  1. 3 tool updatesv0.5.0
    • First observedask_gemini
    • First observedgenerate_ai_code_review
    • First observedgenerate_pr_review
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3/5.0

Scored across 3 tools

Disambiguation3/5

While ask_gemini is a general-purpose query tool, generate_ai_code_review and generate_pr_review are more specialized for code review, leading to potential overlap where an agent might choose the wrong tool for a review task. Descriptions help differentiate, but ambiguity remains.

Naming Consistency4/5

All tool names use snake_case and follow a verb_noun pattern consistently. The only minor deviation is the use of 'ask' versus 'generate' as verbs, but overall the naming is predictable and clear.

Tool Count4/5

With three tools, the server covers the core functionality of generating code reviews and querying Gemini, which is appropriate for a focused code review assistant. The count is slightly low but not unreasonable for its scope.

Completeness4/5

The tool set covers the main use cases: general query, AI code review from context, and PR-specific review. Minor gaps like review history or configuration management are absent but not critical for the server's stated purpose.

Maintenance

ActivityInactive
ResponsivenessNo issues

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

Related MCP Servers

Latest Blog Posts

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/nicobailon/gemini-code-review-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server