Dual Model MCP Server

An MCP server that queries multiple LLMs (default: Claude Fable 5.1 and OpenAI GPT-6 Astra, reasoning effort high) in parallel via OpenRouter and returns side-by-side responses, optionally with an automatic synthesis step that compares them. A second tool, ask_gpt, asks a single cheap model (default GPT-5.6 Sol) for an everyday second opinion.

Runs locally over stdio (Claude Code, Claude Desktop, Cherry Studio) and remotely over Streamable HTTP – so you can use it from claude.ai on the web and in the mobile apps as a custom connector.

The Problem

Sometimes a single AI model gets stuck in a particular perspective or reasoning pattern. You ask a question, get a good answer, but you know there's another angle, another approach that might be equally valuable (or better). Switching between different models, waiting for separate responses, losing context. It's tedious.

Related MCP server: cognition-wheel

The Solution

Dual Model MCP Server sends your prompt to multiple models simultaneously, giving you independent, high-quality responses side-by-side. Compare, contrast, combine, all in one go. Perfect for:

• Decision-making: See technical/medical/business/research/legal questions from multiple angles

• Quality assurance: Spot blind spots in reasoning or missed edge cases

• Creative work: Get diverse perspectives on problems

• Validation: Cross-check facts and arguments between models

Features

• Parallel queries – All models respond simultaneously, not sequentially

• Resilient – If one model fails, you still get the others' answers instead of a total error

• Synthesis step (optional) – A third, cheap model compares the answers: convergences, contradictions, unique points

• Token usage reporting – Every response includes per-model and total token counts

• Configurable without rebuild – Models, reasoning effort, max_tokens, temperature, timeout via .env; per-call overrides via tool parameters

• N models, not just two – Configure any number of OpenRouter models

• Structured responses – Default system prompt produces 6-8 concise paragraphs (analysis, context, evidence, arguments, alternatives, reflection, conclusion); custom system prompts supported

• Easy integration – Works with Claude Code, Claude Desktop, Cherry Studio, or any MCP client

• Remote access – Optional HTTP mode serves the same tool over HTTPS for claude.ai (web/mobile) via custom connector, secured by a secret URL path

Quick Start

Installation

git clone https://github.com/Firnschnee/dual-model-mcp.git
cd dual-model-mcp
npm install

npm install builds the server automatically (via the prepare script).

Setup

1. Get an OpenRouter API key:

   • Go to openrouter.ai

   • Create an account / sign in

   • Copy your API key from settings

2. Create .env file (copy the template):

   cp .env.example .env

   Then edit .env and paste your key:

   OPENROUTER_API_KEY=your_actual_api_key_here

   .env is gitignored, so your key never lands in version control. The server loads .env relative to its own location, so it works no matter which working directory your MCP client uses.

3. Verify:

   npm start

   You should see:

   ✅ Server läuft! Warte auf MCP-Anfragen via STDIO...

   Stop it with Ctrl+C. You do not need to keep it running: MCP clients start the server themselves as a child process whenever they need it.

Usage

With Claude Code

claude mcp add --scope user dual-model -- node C:/path/to/dual-model-mcp/build/index.js

Or add it to a single project via .mcp.json in the project root:

{
  "mcpServers": {
    "dual-model": {
      "command": "node",
      "args": ["C:/path/to/dual-model-mcp/build/index.js"]
    }
  }
}

Then ask Claude Code to use the query_dual_models tool, e.g. "Frag beide Modelle: ... und synthetisiere die Antworten."

With claude.ai (web & mobile)

claude.ai talks to remote MCP servers over Streamable HTTP. The HTTP entry point serves exactly that; you need a server with a public HTTPS domain and a reverse proxy.

1. On your server: clone, install, and configure:

   git clone https://github.com/Firnschnee/dual-model-mcp.git
   cd dual-model-mcp && npm ci

   In .env (or a systemd EnvironmentFile), set your API key plus:

   MCP_PATH_SECRET=$(openssl rand -hex 24)

2. Run the HTTP entry point (ideally as a systemd service):

   npm run start:http

   It binds to 127.0.0.1:3777 and serves MCP at /<MCP_PATH_SECRET>/mcp. Requests to any other path get a bare 404.

3. Route it through your reverse proxy. Caddy example:

   your-domain.example {
       handle /<MCP_PATH_SECRET>/mcp {
           reverse_proxy 127.0.0.1:3777
       }
   }

4. Add the connector in claude.ai: Settings → Connectors → Add custom connector → https://your-domain.example/<MCP_PATH_SECRET>/mcp. The tool then works in web chats and the mobile apps.

Security model: the secret path is the only authentication – anyone who knows the URL can spend your OpenRouter credit. Keep the URL private, set a spending limit in the OpenRouter dashboard as a backstop, and rotate the secret (env file + proxy + connector URL) if it ever leaks. For anything beyond personal use, put proper OAuth in front instead.

With Cherry Studio

1. Open Cherry Studio

2. Settings → MCP Servers → Add

3. Fill in:

   • Name: Dual Model MCP

   • Command: node

   • Arguments: C:\path\to\dual-model-mcp\build\index.js

4. Save & restart Cherry Studio

5. Choose the MCP server in the chat window, ask a question, and all models respond

Tool parameters

query_dual_models accepts:

ask_gpt is the everyday variant: one cheap model (default GPT-5.6 Sol at effort high), no synthesis, same output format. It accepts prompt, system_prompt, max_tokens and effort. Keeping it as a separate tool means a caller that wants a quick second opinion does not accidentally trigger the expensive escalation tool.

Configuration

All settings live in .env (see .env.example):

No rebuild needed after changing .env; the MCP client restarts the server on demand.

Stack & Dependencies

Cost & Token Usage

This is an escalation tool, not a daily driver: the default models are the most expensive tier of both vendors (roughly $10 in / $50 out per million tokens each), and max_tokens defaults to 32000 per model so that effort: high has room to think and still answer. Reasoning tokens count against max_tokens on every provider; if the budget runs out before the answer starts, the tool says so instead of reporting an empty response, and a truncated answer is flagged as such. A single hard question can cost a dollar or two.

Note on claude.ai: the web client gives up on a tool call after roughly four minutes. Calls that run longer are billed by OpenRouter but never reach the chat. The HTTP entry point aborts in-flight model calls when the client disconnects, and ask_gpt defaults to effort high rather than xhigh for that reason. Claude Code over stdio has no such limit. Every response reports actual token usage per model and in total, so you can see what a query cost. For quick factual questions, pass a smaller max_tokens per call.

Testing

npm test

Runs a minimal smoke test: starts the built server, sends one short prompt with a one-sentence system prompt, prints the response. Costs a few hundred tokens.

Contributing

Found a bug? Have an idea? Fork & submit a PR!

License

MIT License – See LICENSE file