elite-reasoning-mcp 1.0.0

66-tool MCP server that makes any LLM think harder, reason better, and never repeat mistakes.

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 [e-mail] — don't open a public issue.

License

MIT — use it however you want.

---

_{Built by @Snehgabani}