delphi-mcp

Complex questions deserve multiple perspectives.

Delphi queries diverse AI models, synthesizes their views, and surfaces genuine consensus.

Requirements •
Quick Start •
How It Works •
Example •
Full Docs

---

The Problem

Complex questions rarely have simple answers. A single AI model gives you one perspective shaped by its training data and architecture. For nuanced topics—technical trade-offs, research questions, multi-faceted decisions—one viewpoint isn't enough.

The insight: Different AI models reason differently. When multiple models independently arrive at the same conclusion, you can trust it. When they disagree, you've found genuine complexity worth exploring.

---

Requirements

- Node.js 18+
- OpenRouter API key — Get one at openrouter.ai/keys ($5-10 credit is plenty to start)
- Claude Desktop or any MCP-compatible client

---

Quick Start

``bash
npm install -g delphi-mcp
`

Add to Claude Desktop config:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

`json
{
"mcpServers": {
"delphi": {
"command": "delphi-mcp",
"env": { "OPENROUTER_API_KEY": "sk-or-v1-your-key" }
}
}
}
`

Restart Claude Desktop. Done.

---

How It Works

1. Independent responses — Each model answers without seeing others
2. Revision rounds — Models see the synthesis and can revise or challenge
3. Convergence detection — Stops when 85% agreement is reached
4. Hallucination flagging — Claims from only one model get flagged

---

Example Output

> Question: Should we use microservices or a monolith for a new e-commerce platform?

$3

Round 1 — Initial Positions:
| Model | Position |
|-------|----------|
| Claude | Monolith first, extract services later |
| GPT-5 | Microservices for scalability from day one |
| Gemini | Depends on team size and experience |
| DeepSeek | Modular monolith as middle ground |

Round 2 — After seeing each other's reasoning:
- GPT-5 revised: "Agreed that premature microservices add complexity. Team size matters."
- Claude maintained position but acknowledged: "Microservices make sense if team is 50+ engineers"
- All models converged on team size as the key factor

Round 3 — Final Synthesis:

| Claim | Strength | Agreement |
|-------|----------|-----------|
| Start with monolith for teams < 20 engineers | unanimous | 5/5 |
| Modular boundaries enable future extraction | unanimous | 5/5 |
| Microservices add 3-5x operational overhead | strong | 4/5 |
| Extract services only when team/traffic demands | strong | 4/5 |
| Kubernetes required for microservices | disputed | 2/5 |

Key Disagreement Surfaced:
> "Kubernetes required for microservices" — Claude and DeepSeek disagreed, noting alternatives like ECS, Nomad, or even simple VM deployments. This flags an area where the "conventional wisdom" may be overconfident.

Control Drift: 45% — A single model would have given a more opinionated answer without surfacing the team-size nuance or the Kubernetes debate.

---

Presets

| Preset | Tier | Rounds | Grounding | Cost | Use Case |
|--------|------|--------|-----------|------|----------|
| quick | fast | 2 | off | ~$0.04 | Quick checks |
| balanced | standard | 4 | off | ~$0.20 | General queries |
| research | premium | 6 | on | ~$0.50 | Deep analysis |
| factcheck | standard | 3 | on | ~$0.25 | Verify claims |

---

When to Use Delphi

Use Delphi for:
- Complex technical decisions with trade-offs
- Research questions with multiple valid perspectives
- High-dimensional problems (many factors to weigh)
- Topics where experts genuinely disagree
- Validating important conclusions before acting

Skip Delphi for:
- Simple factual lookups → single model is fine
- Creative writing → diversity unhelpful
- Real-time chat → too slow
- Well-defined problems with clear answers

Decision rule: If the question has genuine complexity and the answer matters, use Delphi.

---

Features

- Multi-Model Consensus — Claude, GPT-5, Gemini, DeepSeek working together
- Dynamic Convergence — Iterates until 85% agreement or surfaces disagreement
- Claim Strength — See which points are unanimous vs genuinely disputed
- Revision Rounds — Models can challenge and refine each other's reasoning
- Expert Personas — Frame panelists as domain experts for deeper analysis
- Diverse Panel Mode — Assign complementary expert roles within a domain
- Web Grounding — Optionally verify claims against live sources
- Budget Controls — Token and cost limits for predictable spend
- Multiple Formats — Markdown, JSON, HTML, plain text

---

Expert Personas

Like a real Delphi study, you can frame panelists as domain experts:

`json
{
"question": "What are the security implications of storing JWTs in localStorage?",
"expertise": "security"
}
`

Available domains:
| Domain | Expert Type |
|--------|-------------|
| security | Security Engineer (15+ years, penetration testing, secure development) |
| finance | Financial Analyst (investment banking, risk management) |
| medical | Medical Researcher (clinical medicine, evidence-based medicine) |
| legal | Legal Expert (corporate law, IP, regulatory compliance) |
| engineering | Software Engineer (system design, architecture patterns) |
| data-science | Data Scientist (ML, statistical analysis) |
| economics | Economist (micro/macro economics, policy analysis) |
| architecture | Systems Architect (distributed systems, cloud platforms) |
| devops | DevOps Engineer (CI/CD, infrastructure automation) |
| product | Product Manager (strategy, user research, go-to-market) |

$3

Add diversePersonas: true to give each panelist a different complementary role within the domain — just like assembling a real expert panel:

`json
{
"question": "Should we migrate to microservices?",
"expertise": "architecture",
"diversePersonas": true
}
`

For architecture, this creates a panel of:
- Cloud architect (AWS/GCP/Azure best practices)
- Platform architect (internal developer platforms)
- Data architect (data modeling, warehousing)
- Integration architect (APIs, messaging)
- Security architect (zero-trust, identity management)
- Solutions architect (customer requirements)

$3

For the most authentic Delphi experience, let the administrator automatically determine what experts are needed based on your question:

`json
{
"question": "Should we implement rate limiting at the API gateway or application layer?",
"autoExpertise": true
}
`

The administrator analyzes your question and dynamically generates an optimal expert panel:

| Expert | Focus | Perspective |
|--------|-------|-------------|
| API Gateway Architect | Rate limiting patterns, edge vs origin | Infrastructure scalability |
| Security Engineer | DDoS protection, abuse prevention | Defensive, assumes adversarial users |
| Backend Developer | Application-level implementation | Developer experience, maintainability |
| SRE/Platform Engineer | Observability, failure modes | Operational reliability |

Why auto-expertise?
- Mimics how real Delphi studies select experts based on the question
- No need to guess which domain fits best
- Gets complementary perspectives without manual configuration
- Shows rationale for why each expert was chosen

---

API

| Tool | Description |
|------|-------------|
| delphi_query | Multi-model consensus query |
| delphi_factcheck | Fact-check a specific claim |
| delphi_list_models | List available models |
| delphi_estimate_cost` | Estimate before running |

---

Documentation

For full technical documentation including:
- All configuration options
- Test results & insights
- Architecture internals
- Cost analysis
- Safety features

See docs/TECHNICAL.md

---

License

MIT — Built by Thor Matthiasson