# religa/multi-mcp [Health: Active]

**Category:** 🤖 Coding Agents  
**Repository:** https://github.com/religa/multi_mcp  
**GitHub Stars:** 35  
**Views:** 3  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/religa-multi-mcp

## Description
Parallel multi-model code review, security analysis, and AI debate with ChatGPT, Claude, and Gemini. Orchestrates multiple LLMs for compare, consensus, and OWASP Top 10 security checks.

## Claude Desktop Quick Installation
Heuristic fallback — verify the package name and runner against the repository README before running it. Uses `npx` (confidence: low):

```json
"mcpServers": {
  "multi-mcp": {
    "command": "npx",
    "args": ["-y","religa-multi-mcp"],
    "env": {
      "OPENAI_API_KEY": "",
      "ANTHROPIC_API_KEY": "",
      "GEMINI_API_KEY": "",
      "OPENROUTER_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GEMINI_API_KEY`, `OPENROUTER_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What religa/multi-mcp MCP server does

religa/multi-mcp MCP server exposes multi-model analysis workflows through the Model Context Protocol. Its main use is coordinating AI-assisted development tasks rather than serving as a general-purpose model API. The available workflows cover interactive chat, code review, comparison of alternatives, and multi-agent debate.

Code review can examine code quality, maintainability, performance, and OWASP Top 10 security concerns. Compare sends a question to multiple configured models to gather separate perspectives. Debate adds an independent-answer and critique process intended to produce a more considered consensus. Chat provides repository-aware development assistance when used from a supported coding client.

The server supports API-backed models from OpenAI, Anthropic, Google, and OpenRouter. It can also run configured command-line models, allowing API and CLI model entries to participate in the same compare or debate workflows.

## How it works

An MCP client connects to the server over a local process. The README documents Claude Code and OpenCode integrations. After installation, a user invokes the tools through natural-language requests such as asking for a code review of a module or comparing approaches for a React application.

Model requests are handled asynchronously, so several models can be queried in parallel. The documented performance model is based on the slowest participating model rather than the sum of all model response times. Conversation threading keeps context available across multi-step reviews.

Models are selected by configured names or aliases. Built-in aliases include examples such as `mini`, `sonnet`, and `gemini`, while user-defined models and aliases can be added through YAML configuration. CLI model definitions specify a command, arguments, and parser so they can be invoked as subprocesses alongside API models.

## Setup and configuration

religa/multi-mcp MCP server requires Python 3.11 or newer and an API key for at least one supported provider. Source installation uses `uv sync`, while the repository's `make install` workflow can install dependencies, create an environment file, update Claude Code or OpenCode configuration, and test the installation.

For manual setup, copy `.env.example` to `.env` and add provider credentials. Environment variables take precedence over a project `.env`; a user-level file at `~/.multi_mcp/.env` is used as a fallback. The configuration supports default model and model-list settings, plus optional Azure OpenAI and AWS Bedrock credentials.

The packaged model definitions can be overridden with `~/.multi_mcp/config.yaml`. User configuration can add models, define aliases, configure CLI commands, or override settings on existing models. Claude Code can also be configured with an allowlist for the MCP tools and longer timeout values.

## Tools and capabilities

The documented MCP tools are:

- `chat` for interactive development assistance.
- `codereview` for code-quality, performance, maintainability, and OWASP-oriented analysis.
- `compare` for parallel responses from multiple models.
- `debate` for independent responses followed by critique.
- `models` for listing available models and aliases.

## Limitations and notes

The server does not provide its own AI models; it depends on configured provider APIs or locally available CLI model commands. At least one provider credential is needed for the documented API-based setup. CLI models may require separate command-line tools and their own configuration.

The supplied setup examples use a local clone path and a Python module entry point, so paths must be replaced with the actual installation location. The README documents Claude Code and OpenCode, not Claude Desktop, Cursor, Windsurf, or Cline. Model names and aliases are configuration-dependent and may change as user overrides are applied.

_Full upstream README: https://allmcps.com/mcp/religa-multi-mcp/readme_