MCP Server

🚀 GitHub Code Review Assistant MCP Server

A comprehensive MCP (Model Context Protocol) server that offers intelligent tools for GitHub pull request code reviews. It enables AI assistants to analyze PRs, suggest improvements, check for patterns, and ensure consistency with team standards.

🚀 Quick Start

This MCP server provides intelligent tools for GitHub pull - request code reviews. It allows AI assistants to analyze PRs, suggest improvements, check for patterns, and ensure compliance with team standards.

✨ Features

• Comprehensive PR Analysis: Analyze code patterns, complexity, and potential issues.
• Review Management: Create comments, submit reviews, and manage feedback.
• Smart Suggestions: AI - powered review suggestions based on best practices.
• Standards Compliance: Check PRs against team coding standards.
• File & Diff Analysis: Detailed examination of changes and their impact.
• Workflow Integration: Tools designed for complete review workflows.

📦 Installation

Prerequisites

• Python 3.8 or higher
• GitHub Personal Access Token with repo scope
• MCP - compatible client (e.g., Claude Desktop, or any MCP client)

Setup

1. Install dependencies:

pip install mcp httpx pydantic

2. Set up your GitHub token:
   • Go to GitHub Settings → Developer Settings → Personal Access Tokens.
   • Generate a new token with repo scope.
   • Save the token securely.
3. Run the server:

python github_code_review_mcp.py

Configuration for Claude Desktop

Add to your Claude Desktop configuration file:

{
  "mcpServers": {
    "github - code - review": {
      "command": "python",
      "args": ["/path/to/server.py"]
    }
  }
}

💻 Usage Examples

Example 1: Complete PR Review Workflow

# 1. List open PRs to find ones needing review
github_list_pull_requests(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    state="open",
    sort="created"
)

# 2. Get details about a specific PR
github_get_pr_details(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    pr_number=123
)

# 3. Analyze the PR for issues
github_analyze_pr(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    pr_number=123
)

# 4. Get AI suggestions
github_get_review_suggestions(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    pr_number=123,
    focus_areas=["security", "performance"]
)

# 5. Check team standards
github_check_team_standards(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    pr_number=123
)

# 6. Submit review with comments
github_create_pr_review(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    pr_number=123,
    body="Great work! A few suggestions for improvement...",
    event="APPROVE"
)

Example 2: Focused Code Pattern Analysis

# Get files changed
files = github_get_pr_files(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    pr_number=456
)

# Get diff for specific analysis
diff = github_get_pr_diff(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    pr_number=456,
    file_path="src/api/handler.js"
)

# Analyze for patterns
analysis = github_analyze_pr(
    owner="myorg",
    repo="myrepo",
    github_token="ghp_xxx",
    pr_number=456,
    check_patterns=True,
    check_security=True
)

📚 Documentation

Available Tools

1. github_list_pull_requests

Lists pull requests in a repository with comprehensive filtering options.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• state: Filter by state (open/closed/all)
• sort: Sort by (created/updated/popularity/long - running)
• direction: Sort direction (asc/desc)
• base: Filter by base branch
• head: Filter by head branch
• limit: Maximum results (1 - 100)
• page: Page number for pagination
• response_format: Output format (markdown/json)

Example Usage:

List all open PRs in facebook/react repository

2. github_get_pr_details

Retrieves comprehensive details about a specific pull request.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• include_reviews: Include review information (default: true)
• include_checks: Include status checks (default: true)
• response_format: Output format (markdown/json)

Example Usage:

Get detailed information about PR #123 including reviews and checks

3. github_get_pr_files

Lists all files changed in a pull request with statistics.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• limit: Maximum results per page
• page: Page number
• response_format: Output format (markdown/json)

Example Usage:

Show me all files changed in PR #456

4. github_get_pr_diff

Retrieves the unified diff for a pull request.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• file_path: Filter for specific file (optional)
• context_lines: Number of context lines (0 - 10)

Example Usage:

Get the diff for PR #789, focusing on src/main.js

5. github_analyze_pr

Performs comprehensive analysis of a pull request for code quality.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• check_patterns: Check for code patterns (default: true)
• check_complexity: Analyze complexity (default: true)
• check_security: Basic security checks (default: true)
• response_format: Output format (markdown/json)

Example Usage:

Analyze PR #234 for code patterns, complexity, and security issues

6. github_get_pr_comments

Retrieves all comments on a pull request.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• comment_type: Type of comments (all/issue/review)
• limit: Maximum results
• page: Page number
• response_format: Output format (markdown/json)

Example Usage:

Get all review comments for PR #567

7. github_create_review_comment

Creates a comment on a pull request (general or inline).

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• body: Comment text with markdown support (required)
• commit_id: SHA of commit to comment on (optional)
• path: File path for inline comment (optional)
• line: Line number for inline comment (optional)
• side: Side of diff (LEFT/RIGHT)

Example Usage:

Add a comment to line 42 of src/utils.js suggesting a performance improvement

8. github_create_pr_review

Submits a formal review on a pull request.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• body: Review summary text (optional)
• event: Review action (APPROVE/REQUEST_CHANGES/COMMENT)
• comments: Array of inline review comments (optional)

Example Usage:

Approve PR #890 with a comment about good test coverage

9. github_get_review_suggestions

Generates AI - powered review suggestions for a pull request.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• focus_areas: Areas to focus on (performance/security/readability/tests/documentation)
• response_format: Output format (markdown/json)

Example Usage:

Generate review suggestions for PR #345 focusing on security and performance

10. github_check_team_standards

Checks if a PR complies with team coding standards.

Parameters:

• owner: Repository owner (required)
• repo: Repository name (required)
• github_token: GitHub access token (required)
• pr_number: Pull request number (required)
• standards_file: Path to standards file in repo (default: .github/CODING_STANDARDS.md)
• response_format: Output format (markdown/json)

Example Usage:

Check if PR #678 meets our team's coding standards

Best Practices

For Reviewers

1. Start with Overview: Use github_get_pr_details to understand the PR context.
2. Analyze First: Run github_analyze_pr before manual review.
3. Check Standards: Use github_check_team_standards for consistency.
4. Get Suggestions: Use github_get_review_suggestions for comprehensive feedback.
5. Be Constructive: When creating comments, be specific and suggest improvements.

For PR Authors

1. Self - Review: Use the analysis tools on your own PRs before requesting review.
2. Address Standards: Check standards compliance before submitting.
3. Keep PRs Focused: Analysis tools work better on smaller, focused changes.
4. Include Tests: The tools check for test coverage.
5. Write Good Descriptions: Tools analyze PR descriptions for context.

Security Considerations

1. Token Security: Never hardcode GitHub tokens. Use environment variables or secure credential storage.
2. Permissions: Ensure tokens have appropriate scopes (usually repo is sufficient).
3. Rate Limiting: GitHub API has rate limits. The tools handle this gracefully but be aware of limits.
4. Private Repos: Ensure tokens have access to private repositories if needed.

Pattern Detection

The analysis tools detect various code patterns including:

• Security Issues: Hardcoded secrets, SQL injection risks, XSS vulnerabilities.
• Performance Issues: Nested loops, SELECT *, synchronous operations in async code.
• Code Quality: Console logs, commented code, empty catch blocks.
• Best Practices: Missing tests, large files, missing documentation.

Team Standards Integration

Create a .github/CODING_STANDARDS.md file in your repository with your team's standards. The tool will automatically use this for compliance checking. Example format:

# Coding Standards

## General Rules

- max_file_length: 500
- max_pr_size: 1000
- require_tests: true
- require_documentation: true

## Branch Naming

- Pattern: (feature|bugfix|hotfix|release)/description

## Commit Messages

- Format: type(scope): description
- Types: feat, fix, docs, style, refactor, test, chore

Troubleshooting

Common Issues

1. Authentication Failed

   • Verify your GitHub token is valid.
   • Check token has required scopes.
   • Ensure token hasn't expired.

2. Rate Limiting

   • GitHub limits API calls to 5000/hour for authenticated requests.
   • Tools will report rate limit errors.
   • Consider implementing caching for frequently accessed data.

3. Large PRs

   • Very large PRs may hit response size limits.
   • Use pagination parameters.
   • Filter to specific files when possible.

4. Network Errors

   • Check internet connectivity.
   • Verify GitHub API is accessible.
   • Check for proxy/firewall issues.

Contributing

Contributions are welcome! Areas for improvement:

• Additional pattern detection rules
• Support for GitLab/Bitbucket
• Enhanced security scanning
• Integration with more CI/CD systems
• Custom rule definitions
• Caching layer for improved performance

🔧 Technical Details

Pattern Detection Mechanism

The analysis tools utilize a set of pre - defined rules to detect various code patterns. For security issues, they look for hardcoded secrets by searching for common patterns of keys and passwords. SQL injection risks are identified by analyzing SQL queries for vulnerable input handling. XSS vulnerabilities are detected by checking for unescaped user input in HTML templates.

For performance issues, nested loops are detected by analyzing the code structure, and the use of SELECT * is flagged as it can lead to unnecessary data retrieval. Synchronous operations in async code are identified by analyzing the flow of asynchronous functions.

Code quality issues such as console logs, commented code, and empty catch blocks are detected by simple text matching and code structure analysis. Best practices like missing tests, large files, and missing documentation are checked by looking for the presence or absence of certain files and functions.

Team Standards Checking

The tool reads the .github/CODING_STANDARDS.md file and parses the defined rules. It then compares the PR code against these rules. For example, it checks the file length and PR size against the defined maximum values, and verifies if tests and documentation are present as required.

📄 License

MIT License - See LICENSE file for details

Acknowledgments

Built using:

• MCP (Model Context Protocol)
• GitHub REST API
• FastMCP

Support

For issues, questions, or suggestions:

• Open an issue on GitHub
• Check the documentation
• Review the troubleshooting guide

⚠️ Important Note

This tool is designed to assist with code reviews but should not replace human judgment. Always apply context and domain knowledge when reviewing code.