revisión de código de Claude MCP

Un servidor MCP (Protocolo de Contexto de Modelo) que proporciona funciones de revisión de código mediante modelos OpenAI, Google y Anthropic. Sirve como herramienta de segunda opinión para la revisión de código y puede utilizarse con cualquier cliente MCP, como Claude Code, Claude Desktop, Cursor y Windsurf.

Características

Soporte de múltiples proveedores : aprovecha los modelos OpenAI, Gemini de Google y Claude de Anthropic para revisiones de código
Dos tipos de revisión : elija entre una revisión estructurada (con comentarios categorizados) o una revisión narrativa de formato libre.
Consciente del contexto : incluye la estructura del proyecto, los archivos relacionados, los mensajes de confirmación y las dependencias para revisiones más relevantes
Procesamiento de código inteligente : detecta automáticamente lenguajes de programación, maneja archivos grandes y formatea la salida adecuadamente.
Manejo robusto de errores : incluye lógica de reintento para fallas de API y recuperación de errores elegante
Compatible con MCP : funciona con cualquier cliente MCP (Claude Code, Claude Desktop, Cursor, Windsurf)
Fácil configuración : configuración sencilla mediante variables de entorno

Related MCP server: Deep Thinking Assistant

Instalación

Instalación global

npm install -g claude-code-review-mcp

Uso con npx (sin instalación)

# Set environment variables separately export OPENAI_API_KEY=<key> npx -y claude-code-review-mcp # Or use inline environment setting OPENAI_API_KEY=<key> npx -y claude-code-review-mcp # Or with Google API key GOOGLE_API_KEY=<key> npx -y claude-code-review-mcp # Or with Anthropic API key ANTHROPIC_API_KEY=<key> npx -y claude-code-review-mcp # Or use multiple API keys for more model options OPENAI_API_KEY=<key> GOOGLE_API_KEY=<key> ANTHROPIC_API_KEY=<key> npx -y claude-code-review-mcp

Configuración

El servidor requiere al menos una de las siguientes claves API:

OPENAI_API_KEY : Su clave API de OpenAI
GOOGLE_API_KEY : Su clave API de Google Gemini
ANTHROPIC_API_KEY : Su clave de API antrópica

Configuración opcional:

PORT : Puerto del servidor (predeterminado: dinámico - se elegirá un puerto disponible)
HOST : Host del servidor (predeterminado: 127.0.0.1)
LOG_LEVEL : Nivel de registro (0=DEBUG, 1=INFO, 2=WARN, 3=ERROR; valor predeterminado: 1)

Modelos disponibles

Modelos OpenAI (requiere OPENAI_API_KEY)

gpt-4.1 - OpenAI GPT-4.1
o4-mini - OpenAI O4 Mini
o3-mini - OpenAI O3 Mini

Modelos de Google (requiere GOOGLE_API_KEY)

gemini-2.5-pro-preview-05-06 - Google Gemini 2.5 Pro
gemini-2.5-flash-preview-04-17 - Google Gemini 2.5 Flash

Modelos antrópicos (requiere ANTHROPIC_API_KEY)

claude-3-opus-20240229 - Claude 3 Opus antrópico
claude-3-sonnet-20240229 - Soneto antrópico de Claude 3
claude-3-haiku-20240307 - Haiku antrópico de Claude 3

Herramientas disponibles

El servidor MCP proporciona tres herramientas:

1. revisiónCódigoEstructurado

Proporciona una revisión de código detallada y estructurada con las siguientes secciones:

Resumen general
Calidad del código (fortalezas y debilidades)
Errores (con gravedad y soluciones sugeridas)
Sugerencias de mejora
Problemas de seguridad (si los hay)

2. revisiónCódigoFormaLibre

Proporciona una revisión del código narrativo en formato de texto libre, adecuado para impresiones generales y comentarios conversacionales.

3. listModels

Enumera todos los modelos disponibles según las claves API proporcionadas, incluidos los identificadores de modelo y los nombres legibles por humanos.

Integración con Claude Code

Para agregar este servidor MCP a Claude Code:

# Use environment variables properly (recommended approach) claude mcp add code-review -s user -e OPENAI_API_KEY=<key> -e GOOGLE_API_KEY=<key> -e ANTHROPIC_API_KEY=<key> -- npx -y claude-code-review-mcp # Alternative: Export the variables before adding the MCP export OPENAI_API_KEY=<key> export GOOGLE_API_KEY=<key> export ANTHROPIC_API_KEY=<key> claude mcp add code-review -s user -- npx -y claude-code-review-mcp

También puedes crear un comando de barra personalizado creando un archivo en .claude/commands/review-with.md :

I'll review your code using alternative LLM models. Model to use: $ARGUMENTS

Claude Code admite comandos de barra personalizados que puedes crear para interactuar fácilmente con el servidor MCP. Crea estos comandos en el directorio .claude/commands/ de tu proyecto para habilitar flujos de trabajo de revisión de código eficaces.

Configuración básica

Primero, crea el directorio de comandos si no existe:

mkdir -p .claude/commands

Comando de listado de modelos

Crea un comando para enumerar los modelos disponibles:

# Create the list-review-models.md file cat > .claude/commands/list-review-models.md << 'EOF' I'll check which alternative code review models are available through our MCP server. First, I'll use the MCP server to list all available models for code review. After that, I'll present the models in a clear table format with: - Model ID (what you'll use when requesting a review) - Provider (OpenAI or Google) - Description (size and capabilities) - Speed (relative performance) This will help you choose the right model for your code review needs. EOF

Comando básico de revisión de código

Cree un comando de revisión simple que acepte un nombre de modelo:

# Create the review-with.md file cat > .claude/commands/review-with.md << 'EOF' I'll review the code I've just worked on using an alternative LLM model to provide a second opinion. First, I'll identify the code changes or file you want reviewed. If you don't specify a file, I'll look at recent changes. Then, I'll send this code to be reviewed by the specified model through our MCP server. Available models (run /project:list-review-models to see all options): - OpenAI models (if configured): "gpt-4.1", "o4-mini", "o3-mini" - Google models (if configured): "gemini-2.5-pro-preview-05-06", "gemini-2.5-flash-preview-04-17" Model to use (leave blank for default): $ARGUMENTS EOF

Comando de revisión estructurada

Crea un comando específico para revisiones estructuradas:

# Create the structured-review.md file cat > .claude/commands/structured-review.md << 'EOF' I'll perform a structured code review using an alternative LLM model. This review will be organized into clear sections: 1. Overall summary 2. Code quality assessment (strengths and weaknesses) 3. Potential bugs with severity ratings (Low/Medium/High) 4. Specific improvement suggestions 5. Security considerations (if applicable) If you don't specify a model, I'll use the default available model. Model to use (optional): $ARGUMENTS EOF

Comando de revisión de forma libre

Crear un comando para reseñas de estilo narrativo:

# Create the freeform-review.md file cat > .claude/commands/freeform-review.md << 'EOF' I'll provide a conversational, narrative-style code review using an alternative LLM model. This will be a more holistic assessment of your code with flowing paragraphs rather than structured categories. This style works well for: - General impressions - High-level feedback - More nuanced commentary on code style and approach If you don't specify a model, I'll use the default available model. Model to use (optional): $ARGUMENTS EOF

Revisar comando de archivo específico

Crea un comando para revisar un archivo específico:

# Create the review-file.md file cat > .claude/commands/review-file.md << 'EOF' I'll review a specific file using an alternative LLM model. Please provide the file path to review and optionally the model to use. Format: [file_path] [model_name] For example: - "src/utils.js gemini-2.5-pro-preview-05-06" - Reviews utils.js with Gemini Pro - "lib/auth.ts" - Reviews auth.ts with the default model Input: $ARGUMENTS EOF

Comandos de revisión específicos del enfoque

Crear comandos para revisiones especializadas:

# Create security review command cat > .claude/commands/security-review.md << 'EOF' I'll perform a security-focused code review using an alternative LLM model. This review will specifically examine: - Potential security vulnerabilities - Input validation issues - Authentication/authorization flaws - Data protection concerns - Injection vulnerabilities - Secure coding best practices If you don't specify a model, I'll use a model recommended for security analysis. Model to use (optional): $ARGUMENTS EOF

# Create performance review command cat > .claude/commands/performance-review.md << 'EOF' I'll perform a performance-focused code review using an alternative LLM model. This review will specifically examine: - Algorithm efficiency - Memory usage - Unnecessary computations - Loop optimizations - Data structure choices - Caching opportunities - Async/parallel processing considerations If you don't specify a model, I'll use a model that's good at performance analysis. Model to use (optional): $ARGUMENTS EOF

Comando de Revisión Integral del Proyecto

Cree un comando para revisar el código con el contexto completo del proyecto:

# Create the project-review.md file cat > .claude/commands/project-review.md << 'EOF' I'll perform a comprehensive code review with full project context using an alternative LLM model. This review will: 1. Analyze the code structure and organization 2. Consider related files and dependencies 3. Evaluate consistency with project patterns 4. Assess integration with existing components 5. Check alignment with project architecture I'll gather project context, including directory structure and related files, to ensure a thorough, context-aware review. Format: [file_to_review] [model_name] Example: "src/components/Button.jsx gemini-2.5-pro-preview-05-06" Input: $ARGUMENTS EOF

Comando de revisión antes y después

Crea un comando para comparar cambios de código:

# Create the diff-review.md file cat > .claude/commands/diff-review.md << 'EOF' I'll review the changes you've made to a file using an alternative LLM model. This will: 1. Identify what was changed between versions 2. Evaluate if the changes address the intended purpose 3. Check for any new issues introduced 4. Suggest potential improvements to the changes I'll need to know which file to examine. If you've been working on a file with Claude Code, I'll automatically find the changes. Model to use (optional): $ARGUMENTS EOF

Uso de comandos de barra personalizados

Una vez creados estos comandos, puedes usarlos en Claude Code escribiendo /project: seguido del nombre del comando. Por ejemplo:

/project:list-review-models /project:review-with gemini-2.5-pro-preview-05-06 /project:structured-review o4-mini /project:security-review /project:review-file src/utils.js gemini-2.5-flash-preview-04-17

Consejos para comandos personalizados

Descubrimiento de comandos : Escriba /project: en Claude Code para ver una lista de comandos disponibles
Modelos predeterminados : si no especifica un modelo, el comando utilizará el modelo predeterminado (normalmente o4-mini si está disponible)
Revisiones múltiples : puedes obtener múltiples perspectivas al ejecutar revisiones con diferentes modelos
Contexto del proyecto : para las revisiones más relevantes, utilice comandos que incluyan el contexto del proyecto
Enfoque especializado : utilice los comandos específicos de enfoque cuando tenga inquietudes particulares sobre seguridad, rendimiento, etc.

Ejemplo de flujo de trabajo

Un flujo de trabajo típico podría verse así:

Trabaja en código con Claude Code
Ejecute /project:list-review-models para ver las opciones disponibles
Ejecute /project:structured-review gemini-2.5-pro-preview-05-06 para obtener una revisión estructurada del modelo de Google
Comparar con las sugerencias de Claude
Realizar mejoras basadas en ambas perspectivas
Ejecute /project:diff-review para revisar los cambios

Estos comandos personalizados permiten una integración fluida entre Claude Code y el servidor claude-code-review-mcp, proporcionando "segundas opiniones" valiosas para su código.

Ejemplo de uso

Iniciar el servidor MCP

# Start with OpenAI API key (using exports, recommended) export OPENAI_API_KEY=<key> npx -y claude-code-review-mcp # Or with inline environment variables OPENAI_API_KEY=<key> npx -y claude-code-review-mcp # Start with Google Gemini API key export GOOGLE_API_KEY=<key> npx -y claude-code-review-mcp # Start with Anthropic Claude API key export ANTHROPIC_API_KEY=<key> npx -y claude-code-review-mcp # Use multiple API keys for more model options export OPENAI_API_KEY=<key> export GOOGLE_API_KEY=<key> export ANTHROPIC_API_KEY=<key> npx -y claude-code-review-mcp # Use custom port and host export OPENAI_API_KEY=<key> export PORT=8080 export HOST=0.0.0.0 npx -y claude-code-review-mcp

Uso con clientes MCP

Una vez que el servidor esté en funcionamiento, puede conectarse a él desde cualquier cliente MCP, como Claude Code, Claude Desktop, Cursor o Windsurf, usando la URL del servidor. El servidor mostrará la URL y el puerto en sus registros de inicio (usando un puerto asignado dinámicamente para evitar conflictos).

Esquema de entrada

Todas las herramientas de revisión aceptan la siguiente entrada:

{ code: string; // Required: The code to review filename?: string; // Optional: The filename with extension language?: string; // Optional: Programming language model: string; // Required: Model ID to use for review projectContext?: { // Optional: Additional context projectStructure?: string; // Directory structure relatedFiles?: Array<{ // Related code files name: string; // Filename with path language?: string; // File language content: string; // File content }>; commitMessage?: string; // Purpose of changes dependencies?: Record<string, string>; // Project dependencies } }

Esquema de salida

Resultado de la revisión estructurada

{ review?: { // Present on success summary: string; // Overall assessment quality: { strengths: string[]; // Good aspects weaknesses: string[]; // Areas for improvement }; bugs: Array<{ description: string; // Issue description severity: "Low" | "Medium" | "High"; // Impact level suggestion: string; // How to fix }>; improvements: string[]; // Enhancement suggestions securityIssues?: string[]; // Security concerns if any }; modelUsed: string; // Human-readable model name error?: string; // Present on error availableModels?: Record<string, string>; // Present on error or listModels }

Salida de revisión de formato libre

{ reviewText?: string; // Present on success modelUsed: string; // Human-readable model name error?: string; // Present on error availableModels?: Record<string, string>; // Present on error or listModels }

Salida de modelos de lista

{ availableModels: Record<string, string>; // Model ID to name mapping modelUsed: string; // Always "None" for this tool }

Integración de clientes MCP

Claude Code

Agregue el servidor MCP:

claude mcp add code-review -s user npx -y claude-code-review-mcp

Uso en el Código Claude:

/code-review:reviewCodeStructured --model o4-mini

Escritorio de Claude

En la configuración de Claude Desktop, configure el MCP de la siguiente manera:

"claude-code-review-mcp": { "command": "npx", "args": ["-y", "claude-code-review-mcp"], "env": { "OPENAI_API_KEY": "your-openai-key", "GOOGLE_API_KEY": "your-google-key", "ANTHROPIC_API_KEY": "your-anthropic-key" } }

El servidor utiliza una desinfección avanzada de salida JSON para lograr una compatibilidad total con todos los clientes MCP, incluido Claude Desktop.

Cursor y Windsurf

Siga las pautas de configuración de MCP específicas para su cliente, utilizando el mismo comando y variables de entorno.

Solución de problemas

Problemas con la clave API

"El modelo X no está disponible" : asegúrese de haber proporcionado la clave API adecuada para el modelo.
No se proporcionan claves API : debe proporcionar al menos una de las siguientes: OPENAI_API_KEY, GOOGLE_API_KEY o ANTHROPIC_API_KEY.
Modelo sugerido : el servidor sugerirá modelos alternativos si el modelo solicitado no está disponible.

Limitación de velocidad y errores de API

Si encuentra límites de velocidad o errores de API, el mensaje de error indicará el problema.
Considere utilizar un modelo diferente si un proveedor está experimentando problemas.

Consideraciones de seguridad

Las claves API nunca se registran ni se exponen
El contenido del código se registra mínimamente para garantizar la privacidad.
Las dependencias se mantienen mínimas para reducir la superficie de seguridad.
El manejo de solicitudes incluye la validación y desinfección de entradas.
Los mensajes de error están diseñados para evitar la filtración de información confidencial.

Compatibilidad

Requiere Node.js 18.0.0 o posterior
Funciona en Linux, macOS y Windows (a través de WSL si es necesario)
Compatible con todos los clientes MCP (Claude Code, Claude Desktop, Cursor, Windsurf)
Manejo elegante de archivos de código grandes y contextos de proyecto
Mecanismo de reintento automático para fallas transitorias de API

Desarrollo

# Install dependencies npm install # Start in development mode npm run dev # Build for production npm run build # Start in production mode npm run start

Licencia

Instituto Tecnológico de Massachusetts (MIT)

Colaboradores

Praney Behl (@praneybehl)