Deep Thinker

Servidor MCP de pensamento cognitivo avançado com grafo de pensamento baseado em DAG, múltiplas estratégias de raciocínio, metacognição e autoavaliação.

GitHub

Experimente este MCPPatrocinado

Documentação

deep-thinker

Servidor MCP de pensamento cognitivo avançado com grafo de pensamento baseado em DAG, 10 estratégias de raciocínio (incluindo seleção automática), 17 ferramentas, aliases de nós, persistência de sessão, respostas estruturadas e tratamento inteligente de erros.

Uma evolução significativa além do MCP de pensamento sequencial, fornecendo raciocínio profundo estruturado com gerenciamento de pensamento baseado em grafo, validação de esquema e seleção inteligente de estratégia.

Início Rápido

npx deep-thinker

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

Exemplos

Exemplo	Estratégia	Caso de Uso
Decisão de Arquitetura	Dialética + Paralela	Monólito vs microsserviços
Incidente de Depuração	Abdutiva	Erros 500 em produção
Priorização de Funcionalidades	Paralela + Dialética	Planejamento do roadmap do Q3
Hipótese Científica	Analógica + Abdutiva	Entrega de LNP para CRISPR
Superando Becos Sem Saída	Troca metacognitiva	Análise de custo de serverless

Recursos

Grafo de Pensamento Baseado em DAG — Os pensamentos formam um grafo acíclico direcionado com ramificações, fusões e arestas cruzadas (não apenas uma cadeia linear)
10 Estratégias de Raciocínio — Sequencial, Dialética (tese→antítese→síntese), Paralela, Analógica, Abdutiva, Primeiros Princípios (deconstruir até fundamentos), Contrafactual (e se com efeitos em cascata), Pensamento Sistêmico (ciclos de feedback e pontos de alavancagem), MCTS (otimização de Monte Carlo), Auto (seleção automática inteligente baseada no conteúdo e estado do grafo)
Aliases de Nós — Use "last", "best", "root" em vez de IDs de nós criptográficos para qualquer parâmetro nodeId
Respostas Estruturadas — Todas as respostas das ferramentas retornam JSON MCPResponse consistente com ação status, summary, confidence, nextSuggested
Persistência de Sessão — Salva automaticamente o grafo de pensamento em ~/.deep-thinker/sessions/; retome após reinicializações do MCP com reset({ resume: "name" })
Mensagens de Erro Amigáveis — Erros de validação Zod traduzidos para dicas legíveis por humanos (ex.: "confidence 0 ile 1 arasında...")
Pontuação de Confiança — Avaliação de confiança multifatorial com análise de suporte/contradição, penalidades de profundidade e aumentos de integração de conhecimento
Autocrítica — Geração automática de críticas com níveis de gravidade e ajustes de confiança
Mecanismo Metacognitivo — Detecta estados travados, estagnação, confiança em declínio; sugere trocas de estratégia e ações corretivas
Integração de Conhecimento — Anexe conhecimento externo aos pensamentos, detecte lacunas, valide consistência entre fontes
Poda de Pensamentos — Detecção de becos sem saída, remoção de redundâncias, eliminação de ramos profundos improdutivos, otimização de caminhos
Ferramenta help — Descubra todas as 17 ferramentas agrupadas por categoria (núcleo/avançado/fluxo de trabalho) com exemplos de início rápido
Ferramenta conclude — Resumo abrangente do grafo com primaryFinding, actionItems, graphHealth e nextSuggested
Aprimoramentos de Raciocínio de Alto QI — 8 ferramentas avançadas: visualização, advogado do diabo, síntese interdisciplinar, projeção temporal, avaliação ética, análise de inteligência emocional, explicação de decisão, análise de impacto social
Inteligência Emocional — Analise tom emocional, empatia, eficácia de persuasão, emoções das partes interessadas
Estruturas Éticas — Avalie através de perspectivas deontológicas, consequencialistas, ética da virtude e baseadas em direitos
Síntese Entre Domínios — Combine insights de biologia, economia, física, psicologia, ciência da computação, arte
Raciocínio Temporal — Projete pensamentos em cenários futuros/passados com cenários otimistas, pessimistas, realistas e disruptivos
Modelagem de Impacto Social — Analise emoções das partes interessadas, coesão de grupo, eficácia de persuasão, alinhamento ético
Quantificação de Incerteza — Intervalos de confiança, distribuições de probabilidade, análise de sensibilidade para decisões robustas
Suporte a Múltiplos Idiomas — Pensamentos em inglês, turco, alemão, francês, espanhol, japonês, chinês, russo
Camadas Meta-Cognitivas — Raciocínio recursivo em 5 níveis de metacognição
PromptOptimizer (Nó Zero) — Ponto de entrada que transforma prompts vagos em Super Prompts otimizados com roteamento automático de estratégia

Instalação

Global

npm install -g deep-thinker

npx (sem instalação)

npx deep-thinker

Configuração do MCP

Claude Desktop

Adicione ao seu claude_desktop_config.json:

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

Ou se instalado globalmente:

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

Outros Clientes MCP

O servidor se comunica via stdio. Aponte seu cliente MCP para o comando deep-thinker ou node path/to/dist/index.js.

Formato de Resposta

Todas as respostas das ferramentas seguem a estrutura MCPResponse:

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

O campo nextSuggested sempre recomenda o próximo passo lógico, facilitando o encadeamento de chamadas de ferramentas sem adivinhação.

Aliases de Nós

Em vez de procurar IDs de nós criptográficos, use aliases para qualquer parâmetro nodeId, parentId ou targetId:

Alias	Resolve Para
`"last"`	Nó adicionado mais recentemente (ordem de inserção)
`"best"`	Nó com maior pontuação de confiança
`"root"`	Primeiro nó sem arestas de entrada

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

Persistência de Sessão

Os grafos de pensamento são salvos automaticamente após cada chamada de think. As sessões são armazenadas em ~/.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" })

Ferramentas

Ferramentas Núcleo

`think`

Adicione um pensamento ao grafo cognitivo usando uma estratégia de raciocínio.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`content`	string	Sim	O conteúdo do pensamento
`type`	string	Não	Tipo de pensamento: `hypothesis`, `analysis`, `evidence`, `conclusion`, `question`, `assumption`, `insight`, `critique`, `synthesis`, `observation`
`strategy`	string	Não	Estratégia: `sequential`, `dialectic`, `parallel`, `analogical`, `abductive`, `first_principles`, `counterfactual`, `systems_thinking`, `mcts`, `auto`
`confidence`	number	Não	Confiança inicial 0-1 (padrão: 0.5)
`parentId`	string	Não	ID do nó pai ou alias (padrão: última folha)
`branch`	string	Não	Nome do ramo para exploração paralela
`tags`	string[]	Não	Tags para categorização
`edgeTo`	object	Não	Aresta explícita: `{ targetId, type }`
`dialectic`	object	Não	Modo dialético: `{ thesis, antithesis?, synthesis? }`
`parallel`	array	Não	Modo paralelo: `[{ content, type, confidence }]`
`analogical`	object	Não	Modo analógico: `{ sourceDomain, mapping, projectedConclusion }`
`abductive`	object	Não	Modo abdutivo: `{ observation, explanations[], bestExplanation? }`
`firstPrinciples`	object	Não	Modo primeiros princípios: `{ problem, assumptions?, depth?, domain? }`
`counterfactual`	object	Não	Modo contrafactual: `{ currentState?, variablesToChange, rippleDepth? }`
`systemsThinking`	object	Não	Modo pensamento sistêmico: `{ systemDescription?, components, focusArea? }`
`mcts`	object	Não	Modo MCTS: `{ problem?, possibleActions, numSimulations? }`
`knowledge`	object	Não	Anexar conhecimento: `{ source, content, relevance }`

Detalhes da estratégia:

Estratégia	Descrição	Melhor Para
Sequencial	Cadeia linear: cada pensamento deriva do anterior	Raciocínio passo a passo
Dialética	Padrão Tese → Antítese → Síntese para resolver contradições	Resolver conflitos
Paralela	Explore múltiplas ramificações independentes simultaneamente	Brainstorming de opções
Analógica	Mapeie padrões de um domínio conhecido para o problema atual	Insights entre domínios
Abdutiva	Gere hipóteses e infira a melhor explicação	Análise de causa raiz
Primeiros Princípios	Deconstrua até verdades fundamentais, desafie suposições	Quebrar convenções
Contrafactual	Cenários "e se" com efeitos em cascata de múltiplos estágios	Análise de risco/impacto
Pensamento Sistêmico	Ciclos de feedback, pontos de alavancagem, propriedades emergentes	Sistemas complexos
MCTS	Busca em Árvore de Monte Carlo para seleção ótima de decisão	Problemas de otimização
Auto	Seleciona automaticamente a estratégia com base em sinais de conteúdo e contexto do grafo	Raciocínio sem intervenção

Como funciona a estratégia auto:

A estratégia auto analisa seu conteúdo em busca de palavras-chave e o estado atual do grafo:

Conteúdo com "why"/"neden"/"how"/"nasıl" → abductive
Conteúdo com "if"/"eğer"/"what if"/"varsayalım" → counterfactual
Conteúdo com "vs"/"veya"/"compare"/"karşılaştır" → dialectic
Conteúdo com "system"/"sistem"/"loop"/"döngü" → systems_thinking
Conteúdo com "fundamental"/"temel"/"assumption"/"varsayım" → first_principles
Confiança média baixa + muitos nós → parallel (superar impasse)
Primeiro pensamento → sequential
Após 4+ pensamentos sequenciais → dialectic (introduzir visão oposta)
Padrão → sequential

Tipos de aresta: derives_from, contradicts, supports, refines, challenges, synthesizes, parallels, abstracts, instantiates

`evaluate`

Avalie o processo de pensamento com pontuação de confiança, crítica e análise de saúde do grafo.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`nodeId`	string	Não	Nó específico para avaliar (aceita aliases: `last`, `best`, `root`)
`critique`	boolean	Não	Gerar autocrítica (padrão: true)
`findGaps`	boolean	Não	Encontrar lacunas de conhecimento (padrão: false)
`validateKnowledge`	boolean	Não	Validar consistência do conhecimento (padrão: false)

`metacog`

Operações metacognitivas — monitore e controle o processo de pensamento.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`action`	string	Sim	`report` = estado completo, `switch` = mudar estratégia, `auto_update` = deixar o sistema analisar
`strategy`	string	Não	Nova estratégia (para ação `switch`)
`reason`	string	Não	Motivo da troca (para ação `switch`)

O mecanismo metacognitivo automaticamente:

Detecta estagnação (confiança não melhorando)
Detecta tendências de confiança em declínio
Detecta contradições excessivas
Sugere trocas de estratégia, poda, retrocesso ou conclusão

`graph`

Consulte e visualize o grafo de pensamento.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`action`	string	Sim	`visualize`, `stats`, `path`, `node`, `branches`, `best_path`, `leaves`
`nodeId`	string	Não	ID do nó ou alias (para ações `path`, `node`)
`targetId`	string	Não	ID de destino ou alias (para ação `path`)

`prune`

Pode e otimize o grafo de pensamento.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`action`	string	Sim	`analyze` (somente relatório), `prune` (executar), `optimize_path`, `prune_node`
`nodeId`	string	Não	Nó para podar — aceita aliases (para `prune_node`)
`reason`	string	Não	Motivo (para `prune_node`)

`reset`

Redefina o grafo de pensamento e inicie uma nova sessão, salve ou retome uma sessão salva.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`problem`	string	Não	Nova declaração do problema
`save`	boolean	Não	Salvar a sessão atual antes de redefinir (padrão: false)
`saveName`	string	Não	Nome para a sessão salva (recomendado se save: true)
`resume`	string	Não	Retomar uma sessão salva anteriormente pelo nome
`listSessions`	boolean	Não	Listar todas as sessões salvas

`conclude`

Analise todo o grafo de pensamento e produza um resumo-conclusão abrangente com itens de ação e relatório de saúde do grafo.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`detailLevel`	string	Não	`brief`, `detailed`, `technical` (padrão: detailed)
`includeCounterfactuals`	boolean	Não	Incluir análise contrafactual (padrão: false)
`format`	string	Não	`prose`, `structured`, `executive` (padrão: structured)

A resposta inclui:

primaryFinding — Conclusão principal com confiança
supportingEvidence — Nós adicionais de alta confiança
strategiesUsed — Quais estratégias contribuíram
keyInsights — Nós do tipo insight do melhor caminho
actionItems — Ações priorizadas derivadas das conclusões
graphHealth — Contagem de nós, becos sem saída, confiança média, recomendação
nextSuggested — Próximo passo lógico (podar se não saudável, salvar se concluído)

`help`

Descubra as ferramentas do deep-thinker e aprenda fluxos de trabalho de uso.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`category`	string	Não	`all`, `core`, `advanced`, `workflow` (padrão: all)

Categorias:

core — 7 ferramentas de uso diário (think, evaluate, metacog, graph, prune, reset, conclude)
advanced — 8 ferramentas de análise profunda (visualization, devil's advocate, cross-disciplinary, temporal, ethical, emotional, explanation, social impact, prompt optimizer)
workflow — 3 fluxos de trabalho recomendados:
- 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

Ferramentas Aprimoradas (Raciocínio de Alto QI)

`visualize_thought_graph`

Gere uma representação visual do grafo de pensamento como SVG ou ASCII.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`format`	string	Não	`svg`, `ascii`, ou `tree` (padrão: ascii)
`highlightPath`	string	Não	Caminho entre dois IDs de nós (formato: `fromId-toId`)
`showConfidence`	boolean	Não	Mostrar pontuações de confiança (padrão: true)

`simulate_devils_advocate`

Gere contra-argumentos e pontos de vista opostos para um determinado pensamento.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`nodeId`	string	Sim	ID do nó alvo ou alias (`last`, `best`, `root`)
`depth`	number	Não	Níveis de contra-argumentos (1-5, padrão: 2)
`intensity`	string	Não	`mild`, `moderate`, ou `aggressive` (padrão: moderate)

`cross_disciplinary_synthesis`

Combine insights de múltiplos domínios para gerar perspectivas inovadoras.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`sourceDomains`	string[]	Sim	Domínios para extrair analogias (ex.: `["biology", "economics", "art"]`)
`targetProblem`	string	Sim	Problema ao qual aplicar insights entre domínios
`maxAnalogies`	number	Não	Máximo de analogias a gerar (1-10, padrão: 3)

`temporal_projection`

Projete pensamentos em cenários futuros ou passados.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`nodeId`	string	Sim	ID do nó raiz ou alias
`years`	number	Sim	Anos para frente (positivo) ou para trás (negativo)
`scenario`	string	Não	`optimistic`, `pessimistic`, `realistic`, `disruptive` (padrão: realistic)

`ethical_framework_evaluation`

Avalie um pensamento ou decisão por meio de múltiplos frameworks éticos.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`nodeId`	string	Sim	ID do nó ou alias
`frameworks`	string[]	Não	Quais frameworks: `deontological`, `consequentialist`, `virtue`, `rights_based` (padrão: all)

`emotional_intelligence_analysis`

Analise o tom emocional, as emoções das partes interessadas e as dinâmicas sociais.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`text`	string	Sim	Texto a ser analisado quanto ao conteúdo emocional
`context`	string	Não	Contexto (ex.: `team meeting`, `customer feedback`, `crisis situation`)
`perspectiveTaking`	number	Não	Nível de tomada de perspectiva 0-1 (padrão: 0.7)

`explain_decision`

Gere uma explicação compreensível para humanos de um caminho de decisão.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`nodeId`	string	Sim	ID do nó de decisão/conclusão ou alias
`detailLevel`	string	Não	`simple`, `detailed`, `technical` (padrão: detailed)
`includeCounterfactuals`	boolean	Não	Mostrar cenários hipotéticos (padrão: true)

`social_impact_analysis`

Analise o impacto social, as emoções das partes interessadas, a coesão do grupo e a eficácia da persuasão.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`nodeId`	string	Sim	ID do nó ou alias
`stakeholders`	string[]	Não	Grupos de partes interessadas (padrão: `["customers", "employees", "investors", "community"]`)

`optimize_prompt`

PromptOptimizer (Node Zero) — transforme prompts vagos em Super Prompts otimizados com roteamento de estratégia.

Parâmetros:

Parâmetro	Tipo	Obrigatório	Descrição
`originalPrompt`	string	Sim	Prompt bruto do usuário, potencialmente vago
`userContext`	object	Não	`{ expertiseLevel, domainKnowledge[], preferences }`
`conversationHistory`	array	Não	Mensagens anteriores para contexto (máx. 20)
`optimizationLevel`	string	Não	`light`, `standard`, `aggressive` (padrão: standard)
`targetModel`	string	Não	`claude`, `gpt4`, `gpt35`, `local`, `generic` (padrão: generic)
`autoRoute`	boolean	Não	Roteamento automático para a estratégia recomendada (padrão: false)

Exemplos de Uso

Seleção Automática de Estratégia (Novo!)

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)

Raciocínio Sequencial

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

Raciocínio Dialético

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

Usando Aliases de Nós

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

Salvar e Retomar Sessão

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

Raciocínio por Primeiros Princípios

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

Análise Contrafactual (E Se)

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

Pensamento Sistêmico

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 (Busca em Árvore Monte Carlo)

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

Análise de Conclusão

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

Orientação Metacognitiva

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

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

Poda

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

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

Obtendo Ajuda

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

Mensagens de Erro Amigáveis

Quando a validação falha, você recebe erros legíveis por humanos em vez da saída bruta do Zod:

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

Arquitetura

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

Novidades na v3.0.0

Recurso	Descrição
Node Aliases	Use `"last"`, `"best"`, `"root"` em vez de IDs de nós para todos os parâmetros nodeId
MCPResponse	Respostas JSON estruturadas com `status`, `summary`, `confidence`, `nextSuggested`
Session Persistence	Salvamento automático em `~/.deep-thinker/sessions/`, retomada entre reinicializações
Friendly Errors	Erros do Zod → dicas legíveis por humanos com orientação específica por campo
help Tool	Descoberta de ferramentas em 3 categorias com exemplos de fluxos de trabalho
conclude Tool	Resumo do grafo com primaryFinding, actionItems, graphHealth
strategy: auto	Seleção automática de estratégia com base em palavras-chave do conteúdo + estado do grafo

Comparação com sequential-thinking

Recurso	sequential-thinking	deep-thinker
Estrutura de pensamento	Cadeia linear	DAG (branch/merge/cross-edges)
Estratégias	Somente sequencial	10 estratégias (incl. seleção automática)
Validação de esquema	Nenhuma	Esquemas Zod para todas as estratégias
Confiança	Número básico de pensamento	Pontuação multifatorial com análise de tendência
Autocrítica	Nenhuma	Automática com níveis de gravidade
Metacognição	Nenhuma	Detecção de travamento, gatilhos inteligentes de estratégia, troca automática
Conhecimento	Nenhum	Referências externas, detecção de lacunas, validação de consistência
Poda	Nenhuma	Beco sem saída, redundância, otimização de caminho
Consultas de grafo	Revisão linear	Visualização, melhor caminho, análise de ramificações, estatísticas
Referências de nós	Somente por ID	Aliases: last, best, root
Formato de resposta	Texto simples	MCPResponse estruturado com nextSuggested
Persistência de sessão	Nenhuma	Salvamento automático, salvar/carregar/retomar
Mensagens de erro	Erros brutos	Legíveis por humanos com dicas
Descoberta de ferramentas	Nenhuma	Ferramenta help com categorias e fluxos de trabalho
Conclusão	Revisão manual	Ferramenta conclude com actionItems
Seleção de estratégia	Somente manual	estratégia auto baseada no conteúdo

Desenvolvimento

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

Testes

npm run build
npm test

131 testes cobrindo todos os módulos: Node, Graph, 10 Strategies (incluindo auto), Scorer, Metacog, Knowledge, Pruner, Integration, Edge Cases, Schema Validation.

Documentação

Architecture Deep Dive — como o DAG, a pontuação, o metacog e a poda funcionam internamente
Strategy Selection Guide — quando usar cada estratégia e como combiná-las

Contribuição

Consulte CONTRIBUTING.md para obter as diretrizes. PRs são bem-vindos — especialmente novas estratégias de raciocínio e ideias de ferramentas MCP.

Licença

MIT