How do I use Elite Reasoning MCP?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Elite Reasoning MCP Debug the function that calculates Fibonacci numbers" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Elite Reasoning MCP

by Snehgabani

Overview Schema Related Servers Score Discussions

Python

Local

Elite Reasoning MCP

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

License: MIT Python 3.11+ MCP Protocol Tools PRs Welcome

🤔 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. They default to basic tools even when better ones exist. And the quality of output varies wildly between prompts.

Elite Reasoning MCP fixes this by intercepting every prompt and running it through a reasoning pipeline that classifies intent, checks past mistakes, routes to specialized tools, and tracks quality — all before the LLM generates a single token of response.

Related MCP server: Scratchpad MCP Server

✨ What It Does

Every prompt you send goes through a 66-tool reasoning pipeline:

Your Prompt
    ↓
┌─────────────────────────────────────┐
│  🎯 Intent Classifier               │ → debug / build / design / deploy / test (13 types)
│  📊 Complexity Scorer                │ → 1-5 scale, adjusts reasoning depth
│  🧠 Thinking Mode Selector           │ → convergent / divergent / analytical / critical
│  🔍 Anti-Pattern Checker             │ → "You made this mistake before..."
│  🛡️ Prevention Rule Engine           │ → Custom auto-triggered safeguards
│  🗺️ MCP & Skill Router               │ → Routes to the best available tools
│  📋 Pre-flight Checklist             │ → Generated per-task reasoning steps
└─────────────────────────────────────┘
    ↓
Execution Plan → LLM follows it → Better output

🚀 Quick Install

Mac / Linux

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

Windows (PowerShell)

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

Manual Setup (Any IDE)

Clone the repo:

git clone https://github.com/Snehgabani/elite-reasoning-mcp.git ~/.elite-reasoning

Add to your IDE's MCP config:

IDE	Config File
Cursor	`~/.cursor/mcp.json`
Claude Desktop	`~/Library/Application Support/Claude/claude_desktop_config.json` (Mac)
Claude Desktop	`%APPDATA%\Claude\claude_desktop_config.json` (Windows)
VS Code + Continue	`.continue/config.json`
Antigravity	`~/.gemini/config/mcp_config.json`
Windsurf	`~/.codeium/windsurf/mcp_config.json`

Add this to the mcpServers section:

{
  "elite-reasoning": {
    "command": "/path/to/.elite-reasoning/run_elite_mcp.sh"
  }
}

On Windows, use run_elite_mcp.bat instead.

Restart your IDE.

Prerequisites

Requirement	Details
Python	3.11+ (install)
uv	Auto-installed by installer, or: `curl -LsSf https://astral.sh/uv/install.sh \| sh`

🏗️ How It Works

The Orchestrator Pattern

The core idea: one tool fires on every prompt, classifying intent and generating a reasoning plan before the LLM does anything else.

# This runs automatically on every prompt
@mcp.tool()
def orchestrate_request_tool(user_prompt: str):
    # 1. Classify intent (debug/build/design/deploy...)
    # 2. Score complexity (1-5)
    # 3. Check past anti-patterns
    # 4. Fire prevention rules
    # 5. Route to specialized tools
    # 6. Generate pre-flight checklist
    return execution_plan

Persistent Memory

Everything is stored in a local SQLite database — no cloud, no API calls:

Anti-patterns: Mistakes you've made, so you never repeat them
Decisions: Architectural decisions with rationale
Quality scores: Track output quality over time
Calibration log: Prediction accuracy with Brier scores
Prevention rules: Custom auto-triggered safeguards

Key Features

Feature	What It Does	Why It Matters
Anti-Pattern Memory	Stores past mistakes with root cause and fix	Never make the same mistake twice
Decision Council	5-perspective adversarial review	Security, Scalability, Simplicity, User Impact, Future Self
FMEA Risk Analysis	Failure mode analysis before you build	Catch what can go wrong before it does
Confidence Calibration	Tracks prediction accuracy with Brier scores	Know when to trust (or doubt) the LLM
Socratic Challenge	Forces the LLM to challenge its own plan	Prevents confirmation bias
Cross-Session Memory	Knowledge persists across conversations	Build on past context, don't restart
Custom Prevention Rules	Auto-triggered safeguards for your workflow	"Always check X before doing Y"
Quality Tracking	Scores every output on multiple dimensions	Proves quality is improving over time

🧰 All 66 Tools

Tool	Description
`orchestrate_request_tool`	Master routing — fires on every prompt
`reasoning_preflight`	Pre-flight checklist for complex tasks
`assess_confidence`	Score confidence before committing

Tool	Description
`check_anti_patterns`	Check if you've seen this mistake before
`record_mistake`	Log mistakes with root cause and fix
`record_quality_score`	Score output quality on a dimension
`get_quality_trend`	Track quality trajectory over time
`pre_commit_audit`	Audit code before delivering
`bias_scan`	Detect cognitive biases in reasoning
`record_missed_detection`	Log bugs that should have been caught

Tool	Description
`record_decision`	Log architectural decisions with rationale
`search_decisions`	Query past decisions
`decision_council_review`	5-perspective adversarial review
`adopt_vs_build`	Build-vs-buy analysis
`socratic_challenge`	Challenge your own reasoning

Tool	Description
`fmea_analysis`	Failure mode and effects analysis
`fmea_risk_gate`	Risk threshold enforcement
`smoke_test_gate`	Pre-deploy smoke test
`swiss_cheese_audit`	Multi-layer safety audit
`simulate_future_regrets`	Pre-mortem analysis

Tool	Description
`calibration_predict`	Log predictions with confidence level
`calibration_resolve`	Mark prediction outcomes
`calibration_score`	Brier score calibration report

Tool	Description
`ingest_context`	Store cross-session knowledge
`memory_search_context`	Semantic search past context
`memory_sync_decisions`	Persist decisions to long-term memory
`memory_sync_mistakes`	Persist mistakes to long-term memory
`query_temporal_graph`	Knowledge graph queries

Tool	Description
`set_goal`	Define a goal with success criteria
`check_goals`	Review active goals
`update_goal`	Update goal status and notes
`archive_goal`	Archive completed goals
`delete_goal`	Remove a goal

Tool	Description
`record_prompt_intent`	Track prompt patterns
`analyze_prompt_sequence`	Session-level analysis
`get_user_thinking_model`	Understand user's cognitive style
`update_thinking_pattern`	Refine the thinking model
`register_prevention_rule`	Create custom auto-triggered rules
`list_prevention_rules`	List all prevention rules
`delete_prevention_rule`	Remove a prevention rule
`search_thinking_patterns`	Search cognitive patterns

Tool	Description
`benchmark_track`	Track performance benchmarks
`get_tool_usage_stats`	Tool usage analytics
`browse_tool_usage`	Browse recent tool calls
`self_diagnose`	System health check
`get_elite_workflow`	Get workflow recommendations

Tool	Description
`record_hypothesis`	Log testable hypotheses
`resolve_hypothesis`	Mark hypothesis outcomes
`record_prospective_failure`	Log anticipated failure modes
`resolve_prospective_failure`	Mark failure prediction outcomes
`validate_predictions`	Bulk validation of predictions
`predictive_prevention`	Predict and prevent issues

Tool	Description
`calculate_expected_value`	EV calculation for decisions
`bayesian_update`	Update beliefs with new evidence
`compound_growth`	Growth projection modeling

Tool	Description
`five_whys`	Root cause analysis
`after_action_review`	Post-mortem review
`record_missed_detection`	Log detection failures

Tool	Description
`sync_team_memory`	Share knowledge across team
`list_team_users`	List team members
`share_skill`	Share learned patterns
`get_user_profile`	Get user profile and preferences
`update_user_config`	Update user configuration

Tool	Description
`autonomous_scan`	Self-improvement scan
`generate_autonomous_goals`	Generate improvement goals
`get_autonomous_status`	Check autonomous system status

📚 Full tool documentation: docs/TOOLS.md

🏛️ 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    # orchestrate_request_tool
│   │   ├── 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
│   │   └── native_tools.py     # Memory, search, sync
│   └── identity/
│       └── user_profile.py     # Per-user configuration
├── schemas/                    # 66 JSON tool schemas
├── run_elite_mcp.sh           # Mac/Linux launcher
├── run_elite_mcp.bat          # Windows launcher
├── install.sh                 # Mac/Linux installer
└── install.ps1                # Windows installer

📐 Full architecture docs: docs/ARCHITECTURE.md

🤝 Compatible IDEs

IDE	Status	Config
Cursor	✅ Full support	`~/.cursor/mcp.json`
Claude Desktop	✅ Full support	App Settings → MCP
Antigravity	✅ Full support	`~/.gemini/config/mcp_config.json`
VS Code + Continue	✅ Full support	`.continue/config.json`
Windsurf	✅ Full support	`~/.codeium/windsurf/mcp_config.json`
Any MCP client	✅ Full support	stdio transport

📊 Performance

Metric	Value
Package size	132KB
Startup time	< 2 seconds
Per-tool latency	< 50ms
Database	Local SQLite (zero network)
API costs	$0 (everything runs locally)
Memory footprint	~15MB

❓ FAQ

Yes. The pipeline works with any model — GPT-4, Claude, Gemini, Llama, Mistral, etc. Weaker models benefit MORE because the pipeline provides structured reasoning they wouldn't do on their own.

No. Everything runs locally. The entire system is a SQLite database + Python logic. Zero external API calls, zero data sent anywhere.

The orchestrator adds ~50ms per prompt. The reasoning plan it generates saves far more time by preventing wrong approaches and repeated mistakes.

Sequential thinking gives you step-by-step reasoning for one task. Elite Reasoning MCP gives you persistent memory across sessions, anti-pattern prevention, quality tracking, risk analysis, confidence calibration, and 60+ other tools. They're complementary — use both.

🤝 Contributing

We welcome contributions! See CONTRIBUTING.md for guidelines.

Quick ideas for contributions:

Add new reasoning tools
Improve the intent classifier
Add IDE-specific install instructions
Write tests
Add benchmarks comparing output quality with/without the pipeline

📄 License

MIT — use it however you want.

🔒 Security

All data stays local — SQLite database stored on your machine
Zero network calls — The MCP server makes no outbound requests
No telemetry — No usage data is collected or transmitted
Your code stays private — Prompt content is classified locally, never sent anywhere

Found a security issue? Please email snehgabani@users.noreply.github.com instead of opening a public issue.

⭐ Star History

If this makes your LLM smarter, give it a ⭐!

🌍 Listed On

Submit or find this project on:

awesome-mcp-servers mcp.so Smithery Glama

This server cannot be installed

license - permissive license

quality - not tested

maintenance

How are these scores calculated?

Maintenance

–Maintainers

–Response time

–Release cycle

1Releases (12mo)

Commit activity

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Latest Blog Posts

Lightport: Open-Sourcing Glama's AI Gateway
By punkpeye on April 27, 2026.
open source
OpenAI
Tool Definition Quality Score (TDQS)
By punkpeye on April 3, 2026.
mcp
The Hackers Who Tracked My Sleep Cycle
By punkpeye on March 26, 2026.
security

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/Snehgabani/elite-reasoning-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server