Deep Thinker

Advanced cognitive thinking MCP server with DAG-based thought graph,10 reasoning strategies(including auto-selection),17 tools, node aliases, session persistence, structured responses, and intelligent error handling.

A significant evolution beyond sequential-thinking MCP, providing structured deep reasoning with graph-based thought management, schema validation, and intelligent strategy selection.

{ "mcpServers": { "deep-thinker": { "command": "npx", "args": ["-y", "deep-thinker"] } } }

- DAG-Based Thought Graph— Thoughts form a directed acyclic graph with branching, merging, and cross-edges (not just a linear chain)
- 10 Reasoning Strategies— Sequential, Dialectic (thesis→antithesis→synthesis), Parallel, Analogical, Abductive,First Principles(deconstruct to fundamentals),Counterfactual(what-if with ripple effects),Systems Thinking(feedback loops & leverage points),MCTS(Monte Carlo optimization),Auto(intelligent auto-selection based on content and graph state)
- Node Aliases— Use"last","best","root"instead of cryptic node IDs for any nodeId parameter
- Structured Responses— All tool responses return consistentMCPResponseJSON withstatus,summary,confidence,nextSuggestedaction
- Session Persistence— Auto-saves thought graph to~/.deep-thinker/sessions/; resume across MCP restarts withreset({ resume: "name" })
- Friendly Error Messages— Zod validation errors translated to human-readable hints (e.g.,"confidence 0 ile 1 arasında...")
- Confidence Scoring— Multi-factor confidence evaluation with support/contradiction analysis, depth penalties, and knowledge integration boosts
- Self-Critique— Automatic critique generation with severity levels and confidence adjustments
- Metacognitive Engine— Detects stuck states, stagnation, declining confidence; suggests strategy switches and corrective actions
- Knowledge Integration— Attach external knowledge to thoughts, detect gaps, validate consistency across sources
- Thought Pruning— Dead-end detection, redundancy removal, deep unproductive branch elimination, path optimization
- help Tool— Discover all 17 tools grouped by category (core/advanced/workflow) with quick-start examples
- conclude Tool— Comprehensive graph summary with primaryFinding, actionItems, graphHealth, and nextSuggested
- High-IQ Reasoning Enhancements— 8 advanced tools: visualization, devil's advocate, cross-disciplinary synthesis, temporal projection, ethical evaluation, emotional intelligence analysis, decision explanation, social impact analysis
- Emotional Intelligence— Analyze emotional tone, empathy, persuasion effectiveness, stakeholder emotions
- Ethical Frameworks— Evaluate through deontological, consequentialist, virtue ethics, rights-based perspectives
- Cross-Domain Synthesis— Combine insights from biology, economics, physics, psychology, computer science, art
- Temporal Reasoning— Project thoughts into future/past scenarios with optimistic, pessimistic, realistic, disruptive scenarios
- Social Impact Modeling— Analyze stakeholder emotions, group cohesion, persuasion effectiveness, ethical alignment
- Uncertainty Quantification— Confidence intervals, probability distributions, sensitivity analysis for robust decisions
- Multi-Language Support— Thoughts in English, Turkish, German, French, Spanish, Japanese, Chinese, Russian
- Meta-Cognitive Layers— Recursive reasoning across 5 levels of meta-cognition
- PromptOptimizer (Node Zero)— Entry point that transforms vague prompts into optimized Super Prompts with automatic strategy routing

Add to yourclaude_desktop_config.json:

{ "mcpServers": { "deep-thinker": { "command": "npx", "args": ["-y", "deep-thinker"] } } }

{ "mcpServers": { "deep-thinker": { "command": "deep-thinker" } } }

The server communicates over stdio. Point your MCP client to thedeep-thinkercommand ornode path/to/dist/index.js.

All tool responses follow theMCPResponsestructure:

{ "status": "ok | error | warning", "nodeId": "thought_3", "summary": "sequential stratejisiyle \"Should we use microservices?...\" eklendi", "confidence": 0.75, "data": { "...": "tool-specific data" }, "nextSuggested": { "tool": "evaluate", "params": { "critique": true }, "reason": "Düşük confidence — değerlendirme önerilir" }, "warnings": ["Stuck detected: ..."] }

ThenextSuggestedfield always recommends the next logical step, making it easy to chain tool calls without guessing.

Instead of looking up cryptic node IDs, use aliases for anynodeId,parentId, ortargetIdparameter:

evaluate({ nodeId: "last" }) → evaluates the latest thought simulate_devils_advocate({ nodeId: "best", depth: 2 }) → challenges the strongest thought graph({ action: "path", nodeId: "root", targetId: "best" }) → traces from root to best conclusion

Thought graphs are automatically saved after everythinkcall. Sessions are stored in~/.deep-thinker/sessions/.

// Save current session explicitly reset({ save: true, saveName: "my-analysis" }) // List saved sessions reset({ listSessions: true }) // Resume a saved session after MCP restart reset({ resume: "my-analysis" })

Add a thought to the cognitive graph using a reasoning strategy.

Theautostrategy analyzes your content for keywords and the current graph state:

- Content with "why"/"neden"/"how"/"nasıl" →abductive
- Content with "if"/"eğer"/"what if"/"varsayalım" →counterfactual
- Content with "vs"/"veya"/"compare"/"karşılaştır" →dialectic
- Content with "system"/"sistem"/"loop"/"döngü" →systems_thinking
- Content with "fundamental"/"temel"/"assumption"/"varsayım" →first_principles
- Low avg confidence + many nodes →parallel(break through impasse)
- First thought →sequential
- After 4+ sequential thoughts →dialectic(introduce opposing view)
- Default →sequential

Edge types:derives_from,contradicts,supports,refines,challenges,synthesizes,parallels,abstracts,instantiates

Evaluate the thinking process with confidence scoring, critique, and graph health analysis.

Metacognitive operations — monitor and control the thinking process.

- Detects stagnation (confidence not improving)
- Detects declining confidence trends
- Detects excessive contradictions
- Suggests strategy switches, pruning, backtracking, or concluding

Reset the thought graph and start a fresh session, save, or resume a saved session.

Analyze the entire thought graph and produce a comprehensive summary-conclusion with action items and graph health report.

- primaryFinding— Top conclusion with confidence
- supportingEvidence— Additional high-confidence nodes
- strategiesUsed— Which strategies contributed
- keyInsights— Insight-type nodes from the best path
- actionItems— Prioritized actions derived from conclusions
- graphHealth— Node count, dead ends, avg confidence, recommendation
- nextSuggested— Logical next step (prune if unhealthy, save if done)

Discover deep-thinker tools and learn usage workflows.

- core— 7 daily-use tools (think, evaluate, metacog, graph, prune, reset, conclude)
- advanced— 8 deep-analysis tools (visualization, devil's advocate, cross-disciplinary, temporal, ethical, emotional, explanation, social impact, prompt optimizer)
- workflow— 3 recommended workflows:

- Quick Decision— reset → think parallel → evaluate → conclude
- Deep Analysis— reset → first_principles → counterfactual → devil's advocate → evaluate → metacog → prune → conclude
- Breaking Dead Ends— metacog report → switch strategy → cross-disciplinary → abductive

Generate visual representation of the thought graph as SVG or ASCII.

Generate counterarguments and opposing viewpoints for a given thought.

Combine insights from multiple domains to generate novel perspectives.

Project thoughts into future or past scenarios.

Evaluate a thought or decision through multiple ethical frameworks.

Analyze emotional tone, stakeholder emotions, and social dynamics.

Generate human-understandable explanation of a decision path.

Analyze social impact, stakeholder emotions, group cohesion, and persuasion effectiveness.

PromptOptimizer (Node Zero) — transform vague prompts into optimized Super Prompts with strategy routing.

think: { content: "Eğer mikroservis kullansaydık ne olurdu?" } → Auto-selects strategy: counterfactual (detected "Eğer" = "if" signal) think: { content: "Why is the server crashing?" } → Auto-selects strategy: abductive (detected "why" signal) think: { content: "Monolith vs microservices?" } → Auto-selects strategy: dialectic (detected "vs" comparison signal)

think: "Should we use microservices?" → type: question, confidence: 0.9 think: "Monolith has deployment bottlenecks" → type: analysis, confidence: 0.7 think: "Team lacks DevOps capacity for microservices" → type: evidence, confidence: 0.8 evaluate: { nodeId: "last", critique: true } → { status: "ok", confidence: 0.73, nextSuggested: { tool: "metacog" } }

think: { strategy: "dialectic", dialectic: { thesis: "Microservices improve scalability", antithesis: "But add operational complexity", synthesis: "Use modular monolith as middle ground" }, confidence: 0.75 }

evaluate({ nodeId: "last" }) → evaluate latest thought simulate_devils_advocate({ nodeId: "best", depth: 3 }) → challenge strongest thought graph({ action: "path", nodeId: "root", targetId: "best" }) → trace reasoning path think({ parentId: "root", content: "Alternative..." }) → branch from root

// Work on a problem... think({ content: "Analysis...", strategy: "auto" }) think({ content: "Another insight..." }) // Save before closing reset({ save: true, saveName: "architecture-review" }) // ... MCP restarts ... // Resume exactly where you left off reset({ resume: "architecture-review" }) → { status: "ok", summary: "architecture-review oturumu geri yüklendi — 5 node ile devam ediliyor" }

think: { strategy: "first_principles", firstPrinciples: { problem: "How to improve battery efficiency?", assumptions: ["Batteries must use lithium", "Charging takes hours"], depth: 3, domain: "physics" } } → Creates: Problem → Assumptions Challenged → Fundamental Truths → Reconstructed Solution

think: { strategy: "counterfactual", counterfactual: { currentState: "Office-based work with 5-day commute", variablesToChange: [ { variable: "work_location", currentValue: "office", hypotheticalValue: "remote", impactWeight: 0.9 }, { variable: "commute_days", currentValue: 5, hypotheticalValue: 0, impactWeight: 0.8 } ], timeHorizon: "medium_term", rippleDepth: 3 } } → Creates: Baseline → Variable Changes → Stage 1/2/3 Ripple Effects → Scenarios → Risk Analysis

think: { strategy: "systems_thinking", systemsThinking: { systemDescription: "Software development team dynamics", components: [ { name: "FeatureBacklog", type: "stock", description: "Pending work" }, { name: "DeveloperCapacity", type: "stock", description: "Available developers" }, { name: "CodeReviews", type: "flow", description: "Review process" }, { name: "Quality", type: "converter", description: "Quality gates" } ], focusArea: "feedback_loops" } } → Creates: System Overview → Components → Feedback Loops → Leverage Points → Recommendations

think: { strategy: "mcts", mcts: { problem: "Which architecture pattern to choose?", possibleActions: [ { id: "microservices", description: "Microservices architecture", estimatedReward: 0.7 }, { id: "monolith", description: "Monolithic architecture", estimatedReward: 0.5 }, { id: "modular", description: "Modular monolith", estimatedReward: 0.8 } ], numSimulations: 100, pruningThreshold: 0.2 } } → Creates: Root → Actions → Simulations → Pruning Analysis → Optimal Path

conclude({ detailLevel: "detailed" }) → { status: "ok", summary: "12 dusunce, 3 dal, sequential+counterfactual stratejileriyle analiz tamamlandi", data: { conclusion: { primaryFinding: "...", confidence: 0.85 }, actionItems: [{ action: "Investigate...", priority: "high" }, ...], graphHealth: { totalThoughts: 12, avgConfidence: 0.72, recommendation: "Graf saglikli gorunuyor" } }, nextSuggested: { tool: "reset", params: { save: true }, reason: "Analizi kaydetmeyi unutmayin" } }

metacog: { action: "auto_update" } → Stuck detected + suggested action in nextSuggested metacog: { action: "switch", strategy: "parallel", reason: "Break through impasse" } → Strategy switched + next step recommended

prune: { action: "analyze" } → Dead Ends, Redundant Branches, Total prunable count prune: { action: "prune" } → Nodes pruned + metacog updated + nextSuggested

help() → all tools, all categories, all workflows help({ category: "core" }) → 7 core tools with quick-start examples help({ category: "advanced" }) → 9 advanced tools help({ category: "workflow" }) → 3 recommended workflows

When validation fails, you get human-readable errors instead of raw Zod output:

think({ confidence: 1.5 }) → { status: "error", error: "VALIDATION_ERROR", message: "\"confidence\" parametresinde hata: ...", field: "confidence", hint: "confidence 0 ile 1 arasında bir sayı olmalı. Örnek: confidence: 0.7" } evaluate({ nodeId: "nonexistent" }) → { status: "error", error: "NODE_NOT_FOUND", provided: "nonexistent", hint: "Geçerli alias'lar: \"last\", \"best\", \"root\" veya graph aracıyla node ID alın" }

src/ ├── index.ts MCP server & 17 tool handlers ├── test.ts Core functionality tests (118 tests) ├── test_enhanced_strategies.ts Strategy tests (13 tests) ├── core/ │ ├── types.ts Type definitions, MCPResponse, NextAction │ ├── schemas.ts Zod validation schemas (10 strategies incl. auto) │ ├── node.ts ThoughtNode CRUD operations │ ├── graph.ts DAG-based thought graph + resolveNodeId + aliases │ ├── strategies.ts 10 reasoning strategies + selectStrategy (auto) │ ├── scorer.ts Confidence scoring & self-critique │ ├── metacog.ts Metacognitive engine with smart triggers │ ├── knowledge.ts Knowledge integration & validation │ ├── pruner.ts Dead-end/redundancy detection & pruning │ ├── session.ts Session persistence (save/load/resume) │ └── errors.ts Friendly error formatting (Zod + unknown) └── enhancements/ ├── visualization.ts SVG & ASCII graph visualization ├── devils_advocate.ts Counterargument generation ├── cross_disciplinary.ts Cross-domain analogy engine ├── temporal_projection.ts Future/past thought projection ├── ethical_evaluation.ts 4 ethical frameworks ├── emotional_intelligence.ts Emotion & sentiment analysis ├── explanation.ts Decision explainability └── social_impact.ts Stakeholder & social impact

git clone https://github.com/hubinoretros/deep-thinker.git cd deep-thinker npm install npm run build npm start

131 tests covering all modules: Node, Graph, 10 Strategies (including auto), Scorer, Metacog, Knowledge, Pruner, Integration, Edge Cases, Schema Validation.

- Architecture Deep Dive— how the DAG, scoring, metacog, and pruning work internally
- Strategy Selection Guide— when to use each strategy and how to combine them

SeeCONTRIBUTING.mdfor guidelines. PRs welcome — especially new reasoning strategies and MCP tool ideas.

Self-hosted MCP platform with multiple tools, multi-agent orchestration, web UI, and ML capabilities