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.

Quick Start

npx deep-thinker

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

Examples

Features

• 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 consistent `MCPResponse` JSON with `status`, `summary`, `confidence`, `nextSuggested` action
• Session Persistence — Auto-saves thought graph to `~/.deep-thinker/sessions/`; resume across MCP restarts with `reset({ 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

Installation

Global

npm install -g deep-thinker

npx (no install)

npx deep-thinker

MCP Configuration

Claude Desktop

Add to your `claude_desktop_config.json`:

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

Or if installed globally:

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

Other MCP Clients

The server communicates over stdio. Point your MCP client to the `deep-thinker` command or `node path/to/dist/index.js`.

Response Format

All tool responses follow the `MCPResponse` structure:

{
  "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: ..."]
}

The `nextSuggested` field always recommends the next logical step, making it easy to chain tool calls without guessing.

Node Aliases

Instead of looking up cryptic node IDs, use aliases for any `nodeId`, `parentId`, or `targetId` parameter:

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

Session Persistence

Thought graphs are automatically saved after every `think` call. 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" })

Tools

Core Tools

`think`

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

Parameters:

Strategy details:

How `auto` strategy works:

The `auto` strategy 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`

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

Parameters:

`metacog`

Metacognitive operations — monitor and control the thinking process.

Parameters:

The metacognitive engine automatically:

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

`graph`

Query and visualize the thought graph.

Parameters:

`prune`

Prune and optimize the thought graph.

Parameters:

`reset`

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

Parameters:

`conclude`

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

Parameters:

Response includes:

• `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)

`help`

Discover deep-thinker tools and learn usage workflows.

Parameters:

Categories:

• 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

Enhanced Tools (High-IQ Reasoning)

`visualize_thought_graph`

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

Parameters:

`simulate_devils_advocate`

Generate counterarguments and opposing viewpoints for a given thought.

Parameters:

`cross_disciplinary_synthesis`

Combine insights from multiple domains to generate novel perspectives.

Parameters:

`temporal_projection`

Project thoughts into future or past scenarios.

Parameters:

`ethical_framework_evaluation`

Evaluate a thought or decision through multiple ethical frameworks.

Parameters:

`emotional_intelligence_analysis`

Analyze emotional tone, stakeholder emotions, and social dynamics.

Parameters:

`explain_decision`

Generate human-understandable explanation of a decision path.

Parameters:

`social_impact_analysis`

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

Parameters:

`optimize_prompt`

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

Parameters:

Usage Examples

Auto Strategy Selection (New!)

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)

Sequential Reasoning

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" } }

Dialectic Reasoning

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

Using Node Aliases

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

Session Save & Resume

// 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" }

First Principles Reasoning

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

Counterfactual (What-If) Analysis

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

Systems Thinking

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

MCTS (Monte Carlo Tree Search)

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 Analysis

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" }
}

Metacognitive Guidance

metacog: { action: "auto_update" }
→ Stuck detected + suggested action in nextSuggested

metacog: { action: "switch", strategy: "parallel", reason: "Break through impasse" }
→ Strategy switched + next step recommended

Pruning

prune: { action: "analyze" }
→ Dead Ends, Redundant Branches, Total prunable count

prune: { action: "prune" }
→ Nodes pruned + metacog updated + nextSuggested

Getting Help

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

Friendly Error Messages

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"
}

Architecture

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

What's New in v3.0.0

Comparison with sequential-thinking

Development

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

Testing

npm run build
npm test

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

Documentation

• 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

Contributing

See CONTRIBUTING.md for guidelines. PRs welcome — especially new reasoning strategies and MCP tool ideas.

License

MIT