Orchestrates multiple AI models to perform automated code reviews, security analysis, and multi-agent debates within development workflows.
Also known as religa/multi_mcp
- Stars
- 37
- Tools
- —
- Downloads, 30 days
- 130
- Latest version
- 0.1.1
- Last commit
- Nov 9, 2026
- License
- MIT
What is Multi MCP?
Multi orchestrates multiple AI models to perform automated code reviews, security analysis, and multi-agent debates within development workflows.
Summary generated from the project's README
About Multi MCP server
Python developers and DevOps teams can automate complex code quality checks and security audits by orchestrating multiple AI models simultaneously. This server integrates with Claude Code CLI and OpenCode to provide systematic workflows for OWASP Top 10 security analysis and performance reviews. By using an asynchronous architecture, it executes multiple models in parallel so that the total response time matches only the slowest model rather than the sum of all parts.
Users can mix API-based models from providers like OpenAI, Anthropic, Google, and OpenRouter with local CLI-based models such as Gemini CLI, Codex CLI, or Ollama. The system supports model aliases like sonnet, gemini, or mini to simplify commands. Beyond simple reviews, it enables multi-agent consensus through debate and comparison workflows, allowing different models to critique each other's architectural decisions or code suggestions directly within the development environment.
What you can do with it
- 1Automated security and quality reviewsPerform a systematic code review that includes OWASP Top 10 security checks and performance analysis.
- 2Multi-model architectural comparisonsRequest parallel analysis from different models to decide on the best architectural approach for a project.
- 3Multi-agent consensus through debateHave multiple AI agents debate a topic to reach a consensus through independent answers and critiques.
- 4Hybrid local and cloud analysisCombine the power of cloud APIs with local models running via CLI tools like Ollama.
Written from the project's README. Every use case is checked against a quote from it.
How to install Multi MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Multi MCP in Claude Code
$ claude mcp add --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'GEMINI_API_KEY=<YOUR_GEMINI_API_KEY>' --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' --env 'OPENROUTER_API_KEY=<YOUR_OPENROUTER_API_KEY>' multi-mcp -- uvx multi-mcpInstall Multi MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"multi-mcp": {
"command": "uvx",
"args": [
"multi-mcp"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"GEMINI_API_KEY": "<YOUR_GEMINI_API_KEY>",
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"OPENROUTER_API_KEY": "<YOUR_OPENROUTER_API_KEY>"
}
}
}
}Install Multi MCP in VS Code
.vscode/mcp.json
{
"servers": {
"multi-mcp": {
"type": "stdio",
"command": "uvx",
"args": [
"multi-mcp"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"GEMINI_API_KEY": "<YOUR_GEMINI_API_KEY>",
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"OPENROUTER_API_KEY": "<YOUR_OPENROUTER_API_KEY>"
}
}
}
}Install Multi MCP in VS Code CLI
$ code --add-mcp '{"name":"multi-mcp","type":"stdio","command":"uvx","args":["multi-mcp"],"env":{"ANTHROPIC_API_KEY":"<YOUR_ANTHROPIC_API_KEY>","GEMINI_API_KEY":"<YOUR_GEMINI_API_KEY>","OPENAI_API_KEY":"<YOUR_OPENAI_API_KEY>","OPENROUTER_API_KEY":"<YOUR_OPENROUTER_API_KEY>"}}'Install Multi MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"multi-mcp": {
"command": "uvx",
"args": [
"multi-mcp"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"GEMINI_API_KEY": "<YOUR_GEMINI_API_KEY>",
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"OPENROUTER_API_KEY": "<YOUR_OPENROUTER_API_KEY>"
}
}
}
}Install Multi MCP in Codex
$ codex mcp add multi-mcp --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'GEMINI_API_KEY=<YOUR_GEMINI_API_KEY>' --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' --env 'OPENROUTER_API_KEY=<YOUR_OPENROUTER_API_KEY>' -- uvx multi-mcpInstall Multi MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.multi-mcp] command = "uvx" args = ["multi-mcp"] [mcp_servers.multi-mcp.env] ANTHROPIC_API_KEY = "<YOUR_ANTHROPIC_API_KEY>" GEMINI_API_KEY = "<YOUR_GEMINI_API_KEY>" OPENAI_API_KEY = "<YOUR_OPENAI_API_KEY>" OPENROUTER_API_KEY = "<YOUR_OPENROUTER_API_KEY>"
Install Multi MCP in Gemini CLI
$ gemini mcp add -s user -e 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' -e 'GEMINI_API_KEY=<YOUR_GEMINI_API_KEY>' -e 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' -e 'OPENROUTER_API_KEY=<YOUR_OPENROUTER_API_KEY>' multi-mcp uvx -- multi-mcpInstall Multi MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"multi-mcp": {
"command": "uvx",
"args": [
"multi-mcp"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"GEMINI_API_KEY": "<YOUR_GEMINI_API_KEY>",
"OPENAI_API_KEY": "<YOUR_OPENAI_API_KEY>",
"OPENROUTER_API_KEY": "<YOUR_OPENROUTER_API_KEY>"
}
}
}
}Configuration
ANTHROPIC_API_KEYSecretAnthropic API key for Claude models (optional - at least one provider required)
GEMINI_API_KEYSecretGoogle API key for Gemini models (optional - at least one provider required)
OPENAI_API_KEYSecretOpenAI API key for GPT models (optional - at least one provider required)
OPENROUTER_API_KEYSecretOpenRouter API key for additional models (optional)
AWS_ACCESS_KEY_IDAWS_REGION_NAMEAWS_SECRET_ACCESS_KEYAZURE_API_BASEAZURE_API_KEYDEFAULT_MODELDefault model to use (defaults to gpt-5-mini)
DEFAULT_MODEL_LISTDefault models for multi-model comparison (comma-separated, defaults to gpt-5-mini,gemini-3-flash)
LOG_LEVELMCP_TIMEOUTMCP_TOOL_TIMEOUT
| Name | Description | |
|---|---|---|
| ANTHROPIC_API_KEY | Anthropic API key for Claude models (optional - at least one provider required) | Secret |
| GEMINI_API_KEY | Google API key for Gemini models (optional - at least one provider required) | Secret |
| OPENAI_API_KEY | OpenAI API key for GPT models (optional - at least one provider required) | Secret |
| OPENROUTER_API_KEY | OpenRouter API key for additional models (optional) | Secret |
| AWS_ACCESS_KEY_ID | — | |
| AWS_REGION_NAME | — | |
| AWS_SECRET_ACCESS_KEY | — | |
| AZURE_API_BASE | — | |
| AZURE_API_KEY | — | |
| DEFAULT_MODEL | Default model to use (defaults to gpt-5-mini) | |
| DEFAULT_MODEL_LIST | Default models for multi-model comparison (comma-separated, defaults to gpt-5-mini,gemini-3-flash) | |
| LOG_LEVEL | — | |
| MCP_TIMEOUT | — | |
| MCP_TOOL_TIMEOUT | — |
Automated checks
Ran Nov 12, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablePass
- Open source license (OSI)Pass
- Commit or release in the last yearPass
- Package name not close to a popular packagePass
- Remote endpoint uses HTTPSNot checked
- Destructive tools are labelledNot checked
- No hidden instructions to the modelPass
- No critical advisory in the package or its dependenciesPass
README
View on GitHubMulti-MCP: Multi-Model Code Review and Analysis MCP Server for Claude Code
A multi-model AI orchestration MCP server for automated code review and LLM-powered analysis. Multi-MCP integrates with Claude Code CLI and OpenCode to orchestrate multiple AI models (OpenAI GPT, Anthropic Claude, Google Gemini) for code quality checks, security analysis (OWASP Top 10), and multi-agent consensus. Built on the Model Context Protocol (MCP), this tool enables Python developers and DevOps teams to automate code reviews with AI-powered insights directly in their development workflow.
Features
- 🔍 Code Review - Systematic workflow with OWASP Top 10 security checks and performance analysis
- 💬 Chat - Interactive development assistance with repository context awareness
- 🔄 Compare - Parallel multi-model analysis for architectural decisions
- 🎭 Debate - Multi-agent consensus workflow (independent answers + critique)
- 🤖 Multi-Model Support - OpenAI GPT, Anthropic Claude, Google Gemini, and OpenRouter
- 🖥️ CLI & API Models - Mix CLI-based (Gemini CLI, Codex CLI) and API models
- 🏷️ Model Aliases - Use short names like
mini,sonnet,gemini - 🧵 Threading - Maintain context across multi-step reviews
How It Works
Multi-MCP acts as an MCP server that Claude Code or OpenCode connects to, providing AI-powered code analysis tools:
- Install the MCP server and configure your AI model API keys
- Integrate with Claude Code or OpenCode automatically via
make install - Invoke tools using natural language (e.g., "multi codereview this file")
- Get Results from multiple AI models orchestrated in parallel
Performance
Fast Multi-Model Analysis:
- ⚡ Parallel Execution - 3 models in ~10s (vs ~30s sequential)
- 🔄 Async Architecture - Non-blocking Python asyncio
- 💾 Conversation Threading - Maintains context across multi-step reviews
- 📊 Low Latency - Response time = slowest model, not sum of all models
Quick Start
Prerequisites:
- Python 3.11+
- API key for at least one provider (OpenAI, Anthropic, Google, or OpenRouter)
Installation
Option 1: From Source
# Clone and install
git clone https://github.com/religa/multi_mcp.git
cd multi_mcp
# Execute ./scripts/install.sh
make install
# The installer will:
# 1. Install dependencies (uv sync)
# 2. Generate your .env file
# 3. Automatically add to Claude Code / OpenCode config (requires jq)
# 4. Test the installation
Option 2: Manual Configuration
If you prefer not to run make install:
# Install dependencies
uv sync
# Copy and configure .env
cp .env.example .env
# Edit .env with your API keys
Add to Claude Code (~/.claude.json) or OpenCode (~/.opencode/opencode.json), replacing /path/to/multi_mcp with your actual clone path:
Claude Code:
{
"mcpServers": {
"multi": {
"type": "stdio",
"command": "/path/to/multi_mcp/.venv/bin/python",
"args": ["-m", "multi_mcp.server"]
}
}
}
OpenCode:
{
"mcp": {
"multi": {
"type": "local",
"command": ["/path/to/multi_mcp/.venv/bin/python", "-m", "multi_mcp.server"],
"enabled": true
}
}
}
Configuration
Environment Configuration (API Keys & Settings)
Multi-MCP loads settings from .env files in this order (highest priority first):
- Environment variables (already set in shell)
- Project
.env(current directory or project root) - User
.env(~/.multi_mcp/.env) - fallback for pip installs
Edit .env with your API keys:
# API Keys (configure at least one)
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=...
OPENROUTER_API_KEY=sk-or-...
# Azure OpenAI (optional)
AZURE_API_KEY=...
AZURE_API_BASE=https://your-resource.openai.azure.com/
# AWS Bedrock (optional)
AWS_ACCESS_KEY_ID=...
AWS_SECRET_ACCESS_KEY=...
AWS_REGION_NAME=us-east-1
# Model Configuration
DEFAULT_MODEL=gpt-5-mini
DEFAULT_MODEL_LIST=gpt-5-mini,gemini-3-flash
Model Configuration (Adding Custom Models)
Models are defined in YAML configuration files (user config wins):
- Package defaults:
multi_mcp/config/config.yaml(bundled with package) - User overrides:
~/.multi_mcp/config.yaml(optional, takes precedence)
To add your own models, create ~/.multi_mcp/config.yaml (see config.yaml and config.override.example.yaml for examples):
version: "1.0"
models:
# Add a new API model
my-custom-gpt:
litellm_model: openai/gpt-4o
aliases:
- custom
notes: "My custom GPT-4o configuration"
# Add a custom CLI model
my-local-llm:
provider: cli
cli_command: ollama
cli_args:
- "run"
- "llama3.2"
cli_parser: text
aliases:
- local
notes: "Local LLaMA via Ollama"
# Override an existing model's settings
gpt-5-mini:
constraints:
temperature: 0.5 # Override default temperature
Merge behavior:
- New models are added alongside package defaults
- Existing models are merged (your settings override package defaults)
- Aliases can be "stolen" from package models to your custom models
Usage Examples
Once installed in your MCP client (Claude Code or OpenCode), you can use these commands:
💬 Chat - Interactive development assistance:
Can you ask Multi chat what's the answer to life, universe and everything?
🔍 Code Review - Analyze code with specific models:
Can you multi codereview this module for code quality and maintainability using gemini-3 and codex?
🔄 Compare - Get multiple perspectives (uses default models):
Can you multi compare the best state management approach for this React app?
🎭 Debate - Deep analysis with critique:
Can you multi debate the best project code name for this project?
Enabling Allowlist
Edit ~/.claude/settings.json and add the following lines to permissions.allow to enable Claude Code to use Multi MCP without blocking for user permission:
{
"permissions": {
"allow": [
...
"mcp__multi__chat",
"mcp__multi__codereview",
"mcp__multi__compare",
"mcp__multi__debate",
"mcp__multi__models"
],
},
"env": {
"MCP_TIMEOUT": "300000",
"MCP_TOOL_TIMEOUT": "300000"
},
}
Model Aliases
Use short aliases instead of full model names:
| Alias | Model | Provider |
|---|---|---|
mini |
gpt-5.6-luna | OpenAI |
nano |
gpt-5.6-luna | OpenAI |
gpt |
gpt-6-astra | OpenAI |
astra |
gpt-6-astra | OpenAI |
sol |
gpt-5.6-sol | OpenAI |
terra |
gpt-5.6-terra | OpenAI |
luna |
gpt-5.6-luna | OpenAI |
codex |
gpt-5.3-codex | OpenAI |
fable |
claude-fable-5-1 | Anthropic |
opus |
claude-opus-5 | Anthropic |
sonnet |
claude-sonnet-5 | Anthropic |
haiku |
claude-haiku-4.5 | Anthropic |
gemini |
gemini-3.1-pro-preview | |
gemini-3 |
gemini-3.1-pro-preview | |
flash |
gemini-3.8-flash | |
flash-lite |
gemini-3.5-flash-lite | |
azure-mini |
azure-gpt-5-mini | Azure |
bedrock-sonnet |
bedrock-claude-4-5-sonnet | AWS |
Run multi:models to see all available models and aliases.
CLI Models
Multi-MCP can execute CLI-based AI models (like Gemini CLI, Codex CLI, or Claude CLI) alongside API models. CLI models run as subprocesses and work seamlessly with all existing tools.
Benefits:
- Use models with full tool access (file operations, shell commands)
- Mix API and CLI models in
compareanddebateworkflows - Leverage local CLIs without API overhead
Built-in CLI Models:
gemini-cli(alias:gem-cli) - Gemini CLI with auto-edit modecodex-cli(alias:cx-cli) - Codex CLI with full-auto modeclaude-cli(alias:cl-cli) - Claude CLI with acceptEdits mode
Adding Custom CLI Models:
Add to ~/.multi_mcp/config.yaml (see Model Configuration):
version: "1.0"
models:
my-ollama:
provider: cli
cli_command: ollama
cli_args:
- "run"
- "codellama"
cli_parser: text # "json", "jsonl", or "text"
aliases:
- ollama
notes: "Local CodeLlama via Ollama"
Prerequisites:
CLI models require the respective CLI tools to be installed:
# Gemini CLI
npm install -g @anthropic-ai/gemini-cli
# Codex CLI
npm install -g @openai/codex
# Claude CLI
npm install -g @anthropic-ai/claude-code
CLI Usage (Experimental)
Multi-MCP includes a standalone CLI for code review without needing an MCP client.
⚠️ Note: The CLI is experimental and under active development.
# Review a directory
multi src/
# Review specific files
multi src/server.py src/config.py
# Use a different model
multi --model mini src/
# JSON output for CI/pipelines
multi --json src/ > results.json
# Verbose logging
multi -v src/
# Specify project root (for CLAUDE.md loading)
multi --base-path /path/to/project src/
Why Multi-MCP?
| Feature | Multi-MCP | Single-Model Tools |
|---|---|---|
| Parallel model execution | ✅ | ❌ |
| Multi-model consensus | ✅ | Varies |
| Model debates | ✅ | ❌ |
| CLI + API model support | ✅ | ❌ |
| OWASP security analysis | ✅ | Varies |
Troubleshooting
"No API key found"
- Add at least one API key to your
.envfile - Verify it's loaded:
uv run python -c "from multi_mcp.settings import settings; print(settings.openai_api_key)"
Integration tests fail
- Set
RUN_E2E=1environment variable - Verify API keys are valid and have sufficient credits
Debug mode:
export LOG_LEVEL=DEBUG # INFO is default
uv run python -m multi_mcp.server
Check logs in logs/server.log for detailed information.
FAQ
Q: Do I need all three AI providers? A: No, just one API key (OpenAI, Anthropic, or Google) is enough to get started.
Q: Does it truly run in parallel?
A: Yes! When you use codereview, compare or debate tools, all models are executed concurrently using Python's asyncio.gather(). This means you get responses from multiple models in the time it takes for the slowest model to respond, not the sum of all response times.
Q: How many models can I run at the same time? A: There's no hard limit! You can run as many models as you want in parallel. In practice, 2-5 models work well for most use cases. All tools use your configured default models (typically 2-3), but you can specify any number of models you want.
Contributing
We welcome contributions! See CONTRIBUTING.md for:
- Development setup
- Code standards
- Testing guidelines
- Pull request process
Quick start:
git clone https://github.com/YOUR_USERNAME/multi_mcp.git
cd multi_mcp
uv sync --extra dev
make check && make test
License
MIT License - see LICENSE file for details
Links
Multi MCP questions
How do I add Multi MCP to Claude Code?
Run claude mcp add --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'GEMINI_API_KEY=<YOUR_GEMINI_API_KEY>' --env 'OPENAI_API_KEY=<YOUR_OPENAI_API_KEY>' --env 'OPENROUTER_API_KEY=<YOUR_OPENROUTER_API_KEY>' multi-mcp -- uvx multi-mcp in your terminal. Add --scope user to make it available in every project.
How do I add Multi MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
Do I need all three AI providers?
No, you only need one API key from OpenAI, Anthropic, or Google to begin using the server.
Does it truly run in parallel?
Yes, tools like codereview, compare, and debate execute models concurrently using asyncio, so response time equals the slowest model rather than the sum of all models.
How many models can I run at the same time?
There is no hard limit to the number of models you can run in parallel, though 2-5 models is typically recommended for most use cases.