# Multi-Agent MCP Server

A sophisticated Model Context Protocol (MCP) server that orchestrates multiple AI agents to collaborate on software development projects. This system enables automated, multi-agent workflows for planning, architecture design, implementation, quality assurance, and code review.

## 🚀 Features

### Multi-Agent Collaboration
- **Product Manager**: Analyzes requirements, creates user stories, prioritizes features
- **Software Architect**: Designs system architecture, APIs, and data models
- **Software Engineer**: Implements features with clean, efficient code
- **QA Engineer**: Reviews code for bugs, edge cases, and vulnerabilities
- **Code Reviewer**: Suggests improvements for readability and maintainability

### MCP Tools
- `plan_feature` - Generate detailed feature plans with user stories
- `design_architecture` - Create system architecture and technical specifications
- `implement_code` - Generate production-ready code implementations
- `review_code` - Perform quality assurance and testing reviews
- `suggest_improvements` - Provide code refactoring and optimization suggestions
- `collaborate` - Enable multi-agent discussions and consensus building
- `full_workflow` - Execute complete development lifecycle from planning to review

### Automated Workflows
- **Full Development Cycle**: Planning → Architecture → Implementation → QA → Review
- **Terminal Automation**: Auto-executes build, test, and deployment commands
- **Conversation History**: Maintains context across multi-agent interactions
- **Error Handling**: Robust error recovery and retry mechanisms

## 📋 Prerequisites

- **Node.js** 18+ and **npm**
- **TypeScript** 5.3+
- **VS Code** with GitHub Copilot Chat extension
- **Claude Desktop** (optional, for alternative MCP client)

## 🛠️ Installation

1. **Clone the repository**
   ```bash
   git clone <repository-url>
   cd multi-agent-mcp
   ```

2. **Install dependencies**
   ```bash
   npm install
   ```

3. **Build the project**
   ```bash
   npm run build
   ```

## ⚙️ Configuration

### VS Code Settings (Recommended)

For full automation without terminal prompts, add these settings to your VS Code User Settings:

```json
{
  "chat.tools.terminal.autoApprove": {
    "/.*/": true
  },
  "chat.mcp.autostart": "newAndOutdated"
}
```

### Claude Desktop Configuration

Add to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "multi-agent": {
      "command": "node",
      "args": ["C:\\path\\to\\multi-agent-mcp\\build\\index.js"]
    }
  }
}
```

## 🚀 Usage

### Starting the Server

```bash
npm start
```

### Using with GitHub Copilot

1. **Open VS Code** with GitHub Copilot Chat
2. **Start the MCP server** in a terminal: `npm start`
3. **Use the full workflow tool**:

```
Use the full_workflow tool with:
{
  "requirement": "Create a user authentication system with JWT tokens",
  "language": "typescript"
}
```

### Individual Agent Tools

**Plan a Feature:**
```
Use plan_feature with:
{
  "requirement": "Build a REST API for user management"
}
```

**Design Architecture:**
```
Use design_architecture with:
{
  "feature_plan": "User management API with CRUD operations",
  "tech_stack": "Node.js, Express, PostgreSQL"
}
```

**Implement Code:**
```
Use implement_code with:
{
  "architecture": "REST API with Express router pattern",
  "language": "typescript"
}
```

**Review Code:**
```
Use review_code with:
{
  "code": "your code here",
  "context": "User authentication module"
}
```

**Multi-Agent Collaboration:**
```
Use collaborate with:
{
  "topic": "Database schema design for e-commerce platform",
  "agents": "architect,engineer",
  "rounds": 3
}
```

## 📁 Project Structure

```
multi-agent-mcp/
├── src/
│   └── index.ts          # Main MCP server implementation
├── build/                 # Compiled JavaScript output
├── package.json           # Dependencies and scripts
├── tsconfig.json          # TypeScript configuration
├── OPTIMIZATIONS.md       # Performance optimizations
└── README.md             # This file
```

## 🔧 Development

### Building
```bash
npm run build
```

### Watch Mode
```bash
npm run watch
```

### Testing
```bash
npm test
```

## 🤖 Agent Capabilities

### Product Manager Agent
- Requirements analysis and prioritization
- User story creation with acceptance criteria
- Feature planning and roadmap development
- Success metrics definition

### Software Architect Agent
- System architecture design
- Component and API specification
- Data model design
- Technology stack recommendations
- Scalability and performance considerations

### Software Engineer Agent
- Clean code implementation
- Algorithm optimization
- Error handling and edge cases
- Best practices adherence
- Documentation generation

### QA Engineer Agent
- Code quality assessment
- Bug detection and vulnerability scanning
- Test case recommendations
- Edge case identification
- Performance bottleneck analysis

### Code Reviewer Agent
- Code readability evaluation
- Maintainability improvements
- Refactoring suggestions
- Best practices validation
- Performance optimizations

## 🔄 Workflow Example

```
Input: "Create a task management web app"

1. PM Agent → Analyzes requirements, creates user stories
2. Architect Agent → Designs React + Node.js architecture
3. Engineer Agent → Implements components and API endpoints
4. QA Agent → Reviews code, suggests test cases
5. Reviewer Agent → Recommends code improvements

Output: Complete, production-ready application
```

## 🛡️ Security & Best Practices

- **Terminal Command Safety**: Configurable auto-approval for development commands
- **Error Recovery**: Robust error handling with retry mechanisms
- **Conversation Context**: Maintains state across multi-agent interactions
- **Type Safety**: Full TypeScript implementation with strict typing

## 🤝 Contributing

1. Fork the repository
2. Create a feature branch: `git checkout -b feature/new-agent`
3. Make your changes and test thoroughly
4. Submit a pull request with detailed description

## 📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

## 🆘 Troubleshooting

### Server Won't Start
- Ensure Node.js 18+ is installed: `node --version`
- Check dependencies: `npm install`
- Verify build: `npm run build`

### MCP Tools Not Available
- Restart VS Code after configuration changes
- Check VS Code settings for MCP configuration
- Verify server is running: `npm start`

### Terminal Commands Not Auto-Executing
- Update VS Code settings with terminal auto-approve rules
- Restart VS Code to apply settings changes

## 📊 Performance

- **Response Time**: < 2 seconds for typical requests
- **Concurrent Agents**: Supports multiple simultaneous workflows
- **Memory Usage**: Optimized for long-running sessions
- **Error Recovery**: Automatic retry with exponential backoff

## 🔮 Future Enhancements

- [ ] Additional specialized agents (DevOps, Security, UX/UI)
- [ ] Integration with external APIs and services
- [ ] Custom agent training and fine-tuning
- [ ] Workflow templates and presets
- [ ] Real-time collaboration features
- [ ] Plugin system for extensibility

---

**Built with ❤️ using the Model Context Protocol**