Deep Thinker MCP Server

Advanced cognitive thinking MCP server with DAG-based thought graph, multiple reasoning strategies, metacognition, and self-evaluation.

GitHub

Documentation

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

Example	Strategy	Use Case
Architecture Decision	Dialectic + Parallel	Monolith vs microservices
Debugging Incident	Abductive	Production 500 errors
Feature Prioritization	Parallel + Dialectic	Q3 roadmap planning
Scientific Hypothesis	Analogical + Abductive	LNP delivery for CRISPR
Breaking Dead Ends	Metacognitive switch	Serverless cost analysis

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:

Alias	Resolves To
`"last"`	Most recently added node (insertion order)
`"best"`	Node with highest confidence score
`"root"`	First node with no incoming edges

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:

Parameter	Type	Required	Description
`content`	string	Yes	The thought content
`type`	string	No	Thought type: `hypothesis`, `analysis`, `evidence`, `conclusion`, `question`, `assumption`, `insight`, `critique`, `synthesis`, `observation`
`strategy`	string	No	Strategy: `sequential`, `dialectic`, `parallel`, `analogical`, `abductive`, `first_principles`, `counterfactual`, `systems_thinking`, `mcts`, `auto`
`confidence`	number	No	Initial confidence 0-1 (default: 0.5)
`parentId`	string	No	Parent node ID or alias (default: last leaf)
`branch`	string	No	Branch name for parallel exploration
`tags`	string[]	No	Tags for categorization
`edgeTo`	object	No	Explicit edge: `{ targetId, type }`
`dialectic`	object	No	Dialectic mode: `{ thesis, antithesis?, synthesis? }`
`parallel`	array	No	Parallel mode: `[{ content, type, confidence }]`
`analogical`	object	No	Analogical mode: `{ sourceDomain, mapping, projectedConclusion }`
`abductive`	object	No	Abductive mode: `{ observation, explanations[], bestExplanation? }`
`firstPrinciples`	object	No	First Principles mode: `{ problem, assumptions?, depth?, domain? }`
`counterfactual`	object	No	Counterfactual mode: `{ currentState?, variablesToChange, rippleDepth? }`
`systemsThinking`	object	No	Systems Thinking mode: `{ systemDescription?, components, focusArea? }`
`mcts`	object	No	MCTS mode: `{ problem?, possibleActions, numSimulations? }`
`knowledge`	object	No	Attach knowledge: `{ source, content, relevance }`

Strategy details:

Strategy	Description	Best For
Sequential	Linear chain: each thought derives from the previous	Step-by-step reasoning
Dialectic	Thesis → Antithesis → Synthesis pattern to resolve contradictions	Resolving conflicts
Parallel	Explore multiple independent branches simultaneously	Brainstorming options
Analogical	Map patterns from a known domain to the current problem	Cross-domain insights
Abductive	Generate hypotheses and infer the best explanation	Root cause analysis
First Principles	Deconstruct to fundamental truths, challenge assumptions	Breaking conventions
Counterfactual	"What-if" scenarios with multi-stage ripple effects	Risk/impact analysis
Systems Thinking	Feedback loops, leverage points, emergent properties	Complex systems
MCTS	Monte Carlo Tree Search for optimal decision selection	Optimization problems
Auto	Automatically selects strategy based on content signals and graph context	Hands-off reasoning

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:

Parameter	Type	Required	Description
`nodeId`	string	No	Specific node to evaluate (accepts aliases: `last`, `best`, `root`)
`critique`	boolean	No	Generate self-critique (default: true)
`findGaps`	boolean	No	Find knowledge gaps (default: false)
`validateKnowledge`	boolean	No	Validate knowledge consistency (default: false)

`metacog`

Metacognitive operations — monitor and control the thinking process.

Parameters:

Parameter	Type	Required	Description
`action`	string	Yes	`report` = full state, `switch` = change strategy, `auto_update` = let system analyze
`strategy`	string	No	New strategy (for `switch` action)
`reason`	string	No	Reason for switching (for `switch` action)

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:

Parameter	Type	Required	Description
`action`	string	Yes	`visualize`, `stats`, `path`, `node`, `branches`, `best_path`, `leaves`
`nodeId`	string	No	Node ID or alias (for `path`, `node` actions)
`targetId`	string	No	Target ID or alias (for `path` action)

`prune`

Prune and optimize the thought graph.

Parameters:

Parameter	Type	Required	Description
`action`	string	Yes	`analyze` (report only), `prune` (execute), `optimize_path`, `prune_node`
`nodeId`	string	No	Node to prune — accepts aliases (for `prune_node`)
`reason`	string	No	Reason (for `prune_node`)

`reset`

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

Parameters:

Parameter	Type	Required	Description
`problem`	string	No	New problem statement
`save`	boolean	No	Save current session before resetting (default: false)
`saveName`	string	No	Name for saved session (recommended if save: true)
`resume`	string	No	Resume a previously saved session by name
`listSessions`	boolean	No	List all saved sessions

`conclude`

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

Parameters:

Parameter	Type	Required	Description
`detailLevel`	string	No	`brief`, `detailed`, `technical` (default: detailed)
`includeCounterfactuals`	boolean	No	Include counterfactual analysis (default: false)
`format`	string	No	`prose`, `structured`, `executive` (default: structured)

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:

Parameter	Type	Required	Description
`category`	string	No	`all`, `core`, `advanced`, `workflow` (default: all)

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:

Parameter	Type	Required	Description
`format`	string	No	`svg`, `ascii`, or `tree` (default: ascii)
`highlightPath`	string	No	Path between two node IDs (format: `fromId-toId`)
`showConfidence`	boolean	No	Show confidence scores (default: true)

`simulate_devils_advocate`

Generate counterarguments and opposing viewpoints for a given thought.

Parameters:

Parameter	Type	Required	Description
`nodeId`	string	Yes	Target node ID or alias (`last`, `best`, `root`)
`depth`	number	No	Levels of counterarguments (1-5, default: 2)
`intensity`	string	No	`mild`, `moderate`, or `aggressive` (default: moderate)

`cross_disciplinary_synthesis`

Combine insights from multiple domains to generate novel perspectives.

Parameters:

Parameter	Type	Required	Description
`sourceDomains`	string[]	Yes	Domains to draw analogies from (e.g., `["biology", "economics", "art"]`)
`targetProblem`	string	Yes	Problem to apply cross-domain insights to
`maxAnalogies`	number	No	Max analogies to generate (1-10, default: 3)

`temporal_projection`

Project thoughts into future or past scenarios.

Parameters:

Parameter	Type	Required	Description
`nodeId`	string	Yes	Root node ID or alias
`years`	number	Yes	Years forward (positive) or backward (negative)
`scenario`	string	No	`optimistic`, `pessimistic`, `realistic`, `disruptive` (default: realistic)

`ethical_framework_evaluation`

Evaluate a thought or decision through multiple ethical frameworks.

Parameters:

Parameter	Type	Required	Description
`nodeId`	string	Yes	Node ID or alias
`frameworks`	string[]	No	Which frameworks: `deontological`, `consequentialist`, `virtue`, `rights_based` (default: all)

`emotional_intelligence_analysis`

Analyze emotional tone, stakeholder emotions, and social dynamics.

Parameters:

Parameter	Type	Required	Description
`text`	string	Yes	Text to analyze for emotional content
`context`	string	No	Context (e.g., `team meeting`, `customer feedback`, `crisis situation`)
`perspectiveTaking`	number	No	Level of perspective-taking 0-1 (default: 0.7)

`explain_decision`

Generate human-understandable explanation of a decision path.

Parameters:

Parameter	Type	Required	Description
`nodeId`	string	Yes	Decision/conclusion node ID or alias
`detailLevel`	string	No	`simple`, `detailed`, `technical` (default: detailed)
`includeCounterfactuals`	boolean	No	Show what-if scenarios (default: true)

`social_impact_analysis`

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

Parameters:

Parameter	Type	Required	Description
`nodeId`	string	Yes	Node ID or alias
`stakeholders`	string[]	No	Stakeholder groups (default: `["customers", "employees", "investors", "community"]`)

`optimize_prompt`

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

Parameters:

Parameter	Type	Required	Description
`originalPrompt`	string	Yes	User's raw, potentially vague prompt
`userContext`	object	No	`{ expertiseLevel, domainKnowledge[], preferences }`
`conversationHistory`	array	No	Previous messages for context (max 20)
`optimizationLevel`	string	No	`light`, `standard`, `aggressive` (default: standard)
`targetModel`	string	No	`claude`, `gpt4`, `gpt35`, `local`, `generic` (default: generic)
`autoRoute`	boolean	No	Auto-route to recommended strategy (default: false)

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

Feature	Description
Node Aliases	Use `"last"`, `"best"`, `"root"` instead of node IDs for all nodeId params
MCPResponse	Structured JSON responses with `status`, `summary`, `confidence`, `nextSuggested`
Session Persistence	Auto-save to `~/.deep-thinker/sessions/`, resume across restarts
Friendly Errors	Zod errors → human-readable hints with field-specific guidance
help Tool	3-category tool discovery with workflow examples
conclude Tool	Graph summary with primaryFinding, actionItems, graphHealth
strategy: auto	Automatic strategy selection based on content keywords + graph state

Comparison with sequential-thinking

Feature	sequential-thinking	deep-thinker
Thought structure	Linear chain	DAG (branch/merge/cross-edges)
Strategies	Sequential only	10 strategies (incl. auto-selection)
Schema Validation	None	Zod schemas for all strategies
Confidence	Basic thought number	Multi-factor scoring with trend analysis
Self-critique	None	Automatic with severity levels
Metacognition	None	Stuck detection, smart strategy triggers, auto-switching
Knowledge	None	External references, gap detection, consistency validation
Pruning	None	Dead-end, redundancy, path optimization
Graph queries	Linear review	Visualization, best path, branch analysis, statistics
Node references	By ID only	Aliases: last, best, root
Response format	Plain text	Structured MCPResponse with nextSuggested
Session persistence	None	Auto-save, save/load/resume
Error messages	Raw errors	Human-readable with hints
Tool discovery	None	help tool with categories & workflows
Conclusion	Manual review	conclude tool with actionItems
Strategy selection	Manual only	auto strategy based on content

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