Elite Reasoning MCP - MCP Servers

Make any LLM think harder, reason better, and never repeat mistakes.

66 tools · Zero API costs · 132KB · Works with any model

Install · All 66 Tools · Architecture · Contributing

The Problem

AI coding assistants make the same mistakes over and over. They forget context between sessions. They don't stress-test their own reasoning. The quality of output varies wildly between prompts.

Elite Reasoning MCP intercepts every prompt and runs it through a reasoning pipeline — classifying intent, checking past mistakes, routing to the right tools, and tracking quality — before the LLM generates a single token.

How It Works

Your Prompt
    │
    ├── Intent Classifier      →  debug / build / design / deploy (13 types)
    ├── Complexity Scorer      →  1–5, adjusts reasoning depth
    ├── Anti-Pattern Checker   →  "You made this mistake before..."
    ├── Prevention Rules       →  Custom auto-triggered safeguards
    ├── MCP & Skill Router     →  Routes to the best available tools
    └── Pre-flight Checklist   →  Per-task reasoning steps
    │
    ▼
Execution Plan → LLM follows it → Better output

Everything runs locally. No API calls. No cloud. A single SQLite file stores anti-patterns, decisions, quality scores, and calibration data across sessions.

Quick Install

pip (Recommended)

pip install elite-reasoning-mcp

From Source (macOS / Linux)

git clone https://github.com/Snehgabani/elite-reasoning-mcp.git ~/.elite-reasoning
cd ~/.elite-reasoning && bash scripts/install.sh

Windows (PowerShell)

git clone https://github.com/Snehgabani/elite-reasoning-mcp.git $env:USERPROFILE\.elite-reasoning
cd $env:USERPROFILE\.elite-reasoning; .\scripts\install.ps1

Docker

docker run -v elite-brain:/data/brain ghcr.io/snehgabani/elite-reasoning-mcp

Requirements: Python 3.11+ and uv (auto-installed by the installer).

What's Inside

66 Tools, 7 Categories

| Category | Tools | What They Do | |----------|-------|-------------| | Core Pipeline | orchestrate_request_tool assess_confidence reasoning_preflight | Intent classification, complexity scoring, pre-flight checklists | | Quality & Memory | record_mistake check_anti_patterns record_quality_score get_quality_trend | Anti-pattern database, quality tracking, trend analysis | | Decision Making | decision_council_review record_decision search_decisions | 5-perspective adversarial review, decision logging | | Risk Analysis | fmea_analysis swiss_cheese_audit smoke_test_gate bias_scan | Failure mode analysis, defense layer audit, bias detection | | Calibration | calibration_predict calibration_resolve calibration_score | Prediction tracking with Brier scores | | Learning | record_hypothesis five_whys after_action_review socratic_challenge | Root cause analysis, hypothesis testing, self-challenge | | Autonomous | autonomous_scan self_diagnose predictive_prevention | Self-monitoring, proactive issue detection |

Full reference: docs/TOOLS.md

Key Capabilities

Anti-Pattern Memory

Stores every mistake with root cause and fix. The LLM checks this database before acting — so it never makes the same mistake twice.

Decision Council

Five adversarial perspectives review every major decision: Security, Scalability, Simplicity, User Impact, and Future Self.

Confidence Calibration

Tracks prediction accuracy with Brier scores. You learn when to trust the LLM's confidence — and when to doubt it.

Cross-Session Memory

Knowledge persists in a local SQLite database. Context compounds across conversations instead of resetting.

FMEA Risk Analysis

Failure Mode and Effects Analysis before you build. Catch what can go wrong before it does.

Custom Prevention Rules

Auto-triggered safeguards for your workflow. "Always check X before doing Y" — enforced automatically.

IDE Support

Works with any MCP-compatible client via stdio transport:

| IDE | Config File | |-----|------------| | Cursor | ~/.cursor/mcp.json | | Claude Desktop | App Settings → MCP | | VS Code + Continue | .continue/config.json | | Windsurf | ~/.codeium/windsurf/mcp_config.json | | Antigravity | ~/.gemini/config/mcp_config.json |

Manual Configuration

Add to your MCP config:

{
  "mcpServers": {
    "elite-reasoning": {
      "command": "bash",
      "args": ["-c", "cd ~/.elite-reasoning && uv run python -m core.integration.mcp_server"]
    }
  }
}

On Windows, use scripts/run_elite_mcp.bat instead:

{
  "mcpServers": {
    "elite-reasoning": {
      "command": "cmd",
      "args": ["/c", "%USERPROFILE%\\.elite-reasoning\\scripts\\run_elite_mcp.bat"]
    }
  }
}

Architecture

elite-reasoning-mcp/
├── core/
│   ├── integration/
│   │   └── mcp_server.py          # FastMCP server, tool registration
│   ├── memory/
│   │   ├── persistent_store.py    # SQLite — 15 tables, 32 indexes
│   │   ├── graph_store.py         # Knowledge graph
│   │   └── embedding.py           # Semantic search (optional)
│   ├── tools/
│   │   ├── orchestration.py       # Intent classification & routing
│   │   ├── reasoning_amplifier.py # Calibration, council, preflight
│   │   ├── adaptive.py            # Learning & user modeling
│   │   ├── analysis.py            # Risk, FMEA, confidence
│   │   ├── auditing.py            # Quality & anti-patterns
│   │   └── planning.py            # Goals & benchmarks
│   └── identity/
│       └── user_profile.py        # Per-user configuration
├── schemas/                       # 66 JSON tool schemas
├── scripts/                       # Installers & launchers
└── Dockerfile                     # Container support

Full architecture docs: docs/ARCHITECTURE.md

Performance

| Metric | Value | |--------|-------| | Package size | 132KB | | Startup time | < 2s | | Per-tool latency | < 50ms | | Storage | Local SQLite | | API costs | $0 | | Network calls | Zero |

FAQ

Does this work with weak / open-source models?

Yes. The pipeline runs before the model generates output, so even weaker models get structured reasoning plans, anti-pattern checks, and quality tracking. The tools amplify whatever model you're using.

Will it slow down my responses?

No. Each tool call takes < 50ms. The orchestrator adds one tool call per prompt. Total overhead is negligible.

How is this different from sequential-thinking?

Sequential-thinking gives the LLM a scratchpad for multi-step reasoning. Elite Reasoning MCP goes further: it classifies intent, checks past mistakes, routes to specialized tools, tracks quality over time, and builds persistent memory across sessions. They're complementary — use both.

Is my data private?

100%. Everything runs locally. The SQLite database is on your machine. No telemetry, no API calls, no cloud. Your code and prompts never leave your computer.

Contributing

We welcome contributions. See CONTRIBUTING.md for guidelines.

Good first issues:

Add new reasoning tools
Improve the intent classifier
Write tests
Add benchmarks for output quality with/without the pipeline

Security

All data stays local. Zero network calls. No telemetry. See SECURITY.md for the full policy.

Found a vulnerability? Email snehgabani@users.noreply.github.com — don't open a public issue.

License

MIT — use it however you want.

_{Built by @Snehgabani}

MCP Servers