# 🔍 MCP-Powered AI Code Review Agent

An AI-powered code review agent that leverages **Model Context Protocol (MCP)** and **Claude** to provide intelligent, context-aware code reviews.

![Python](https://img.shields.io/badge/Python-3.10+-blue.svg)
![License](https://img.shields.io/badge/License-MIT-green.svg)
![MCP](https://img.shields.io/badge/MCP-1.0-purple.svg)

## ✨ Features

- **🤖 AI-Powered Reviews**: Uses Claude to provide intelligent code analysis
- **🔧 MCP Integration**: Built on Model Context Protocol for tool-augmented LLM reasoning
- **📊 Code Metrics**: Cyclomatic complexity, line counts, maintainability index
- **🎨 Style Checking**: Detects common anti-patterns and style issues
- **📝 Git Integration**: Review diffs, check history, understand context
- **⚡ Streaming Output**: Real-time feedback as the AI analyzes your code

## 🚀 Quick Start

### Installation

```bash
# Clone the repository
git clone https://github.com/geethikakoya/mcp-code-agent.git
cd mcp-code-agent

# Create virtual environment
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install dependencies
pip install -e .
```

### Set up API Key

```bash
# Get your API key from https://console.anthropic.com/
export ANTHROPIC_API_KEY=your_api_key_here
```

### Usage

```bash
# Review a file
mcp-review review src/main.py

# Review with streaming output
mcp-review review --stream src/main.py

# Review git changes
mcp-review diff

# Explain what a file does
mcp-review explain src/utils.py

# Quick analysis (no AI, just metrics)
mcp-review analyze src/main.py
```

## 📖 Architecture

```
┌─────────────────────────────────────────────────────────────┐
│                    Code Review Agent                        │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  ┌──────────┐      ┌──────────────┐      ┌──────────────┐  │
│  │  CLI     │─────▶│  Agent       │─────▶│  Claude API  │  │
│  │  (typer) │◀─────│  (reviewer)  │◀─────│  (LLM)       │  │
│  └──────────┘      └──────────────┘      └──────────────┘  │
│                           │                                 │
│                           ▼                                 │
│                    ┌──────────────┐                        │
│                    │  MCP Tools   │                        │
│                    └──────────────┘                        │
│                           │                                 │
│              ┌────────────┼────────────┐                   │
│              ▼            ▼            ▼                   │
│        ┌─────────┐  ┌─────────┐  ┌─────────┐              │
│        │  File   │  │   Git   │  │  Code   │              │
│        │  Tools  │  │  Tools  │  │ Analysis│              │
│        └─────────┘  └─────────┘  └─────────┘              │
│                                                             │
└─────────────────────────────────────────────────────────────┘
```

## 🔧 MCP Tools

### File Operations
| Tool | Description |
|------|-------------|
| `read_file` | Read file contents with optional line range |
| `list_directory` | List files and directories |
| `search_code` | Regex search across codebase |

### Git Integration
| Tool | Description |
|------|-------------|
| `git_diff` | Get diff of changes |
| `git_log` | Get commit history |
| `get_changed_files` | List modified files |

### Code Analysis
| Tool | Description |
|------|-------------|
| `calculate_complexity` | Cyclomatic complexity (Python) |
| `count_lines` | LOC, comments, blanks |
| `check_code_style` | Style issues and anti-patterns |

## 📝 Example Output

```
🔍 Reviewing: src/api/handler.py

📊 Metrics Summary
• Lines of Code: 142
• Cyclomatic Complexity: 8 (Moderate)
• Maintainability Index: 65.2

🔴 Critical Issues
1. Line 45: SQL injection vulnerability - use parameterized queries

⚠️ Warnings
1. Line 23: Function too long (>50 lines) - consider splitting
2. Line 67: Magic number - extract to constant

💡 Suggestions
1. Add type hints to function parameters
2. Consider using dataclass for UserData

✅ What's Good
• Good error handling in API endpoints
• Consistent naming conventions
```

## 🏗️ Project Structure

```
mcp-code-agent/
├── src/
│   ├── mcp_server/           # MCP Server (exposes tools)
│   │   ├── server.py         # Main MCP server
│   │   └── tools/
│   │       ├── file_tools.py
│   │       ├── git_tools.py
│   │       └── analysis_tools.py
│   │
│   ├── agent/                # AI Agent
│   │   ├── reviewer.py       # Code review logic
│   │   └── prompts.py        # System prompts
│   │
│   └── cli/                  # CLI interface
│       └── main.py
│
├── tests/
├── pyproject.toml
├── requirements.txt
└── README.md
```

## 🔌 Using as MCP Server

You can use this as a standalone MCP server with any MCP-compatible client:

```bash
# Run the MCP server
mcp-review server
```

Configure in your MCP client (e.g., Claude Desktop):

```json
{
  "mcpServers": {
    "code-review": {
      "command": "python",
      "args": ["-m", "src.mcp_server.server"],
      "cwd": "/path/to/mcp-code-agent"
    }
  }
}
```

## 🧪 Development

```bash
# Install dev dependencies
pip install -e ".[dev]"

# Run tests
pytest

# Format code
black src/
ruff check src/
```

## 📄 License

MIT License - see [LICENSE](LICENSE) for details.

## 👤 Author

**Geethika Koya**
- GitHub: [@geethikakoya](https://github.com/geethikakoya)
- LinkedIn: [geethika-koya](https://www.linkedin.com/in/geethika-koya-b3aab821a/)

---

Built with ❤️ using [Model Context Protocol](https://modelcontextprotocol.io/) and [Claude](https://www.anthropic.com/claude)