Deliberate Reasoning Engine (DRE)

A Model Context Protocol (MCP) server that transforms linear AI reasoning into structured, auditable thought graphs. DRE enables Language Models to externalize their reasoning process as a directed acyclic graph (DAG) with semantic thought types, dependencies, and validation.

🌟 Features

• 🧠 Semantic Thought Types: Categorize thoughts as Objectives, Hypotheses, Assumptions, Questions, Evidence, Actions, Synthesis, and Critiques

• 🔗 Graph-Based Dependencies: Build a DAG of thoughts with explicit relationships and dependencies

• 🚨 Assumption Tracking: Monitor and invalidate assumptions with automatic cascade to dependent thoughts

• 📊 Hypothesis Scoring: Track supporting and contradicting evidence (coming soon)

• 💾 Session Persistence: Save and load reasoning sessions (coming soon)

• ✅ Graph Validation: Detect cycles, contradictions, and orphaned thoughts

• 🎯 Focused Reasoning: Keep LLMs on track with structured problem decomposition

📦 Installation

As an MCP Server

npm install -g deliberate-reasoning-engine

For Development

git clone https://github.com/haasonsaas/deliberate-reasoning-engine.git
cd deliberate-reasoning-engine
npm install
npm run build

🚀 Quick Start

Configure with Claude Desktop

Add to your Claude Desktop configuration (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "dre": {
      "command": "npx",
      "args": ["deliberate-reasoning-engine"]
    }
  }
}

Or use the local development version:

{
  "mcpServers": {
    "dre": {
      "command": "node",
      "args": ["/absolute/path/to/dre/dist/index.js"]
    }
  }
}

Restart Claude Desktop, and you'll see the DRE tools available in the 🔧 menu.

🛠️ Available Tools

log_thought

Log a structured thought with semantic type and dependencies.

Parameters:

• thought (string, required): The content of the thought

• thought_type (enum, required): One of:

  • objective: The overall goal of the reasoning task

  • hypothesis: A proposed explanation or solution

  • assumption: A belief taken as true for this reasoning line

  • question: A point of uncertainty to resolve

  • sub_problem: Decomposition of a larger problem

  • evidence: Data from tools or prior knowledge

  • action: A plan to use a tool

  • synthesis: A conclusion from previous thoughts

  • critique: Self-correction or flaw identification

• dependencies (string[], optional): IDs of thoughts this depends on

• confidence (number 0-1, optional): Confidence level

• action_request (object, optional): Tool and parameters to execute

get_thought_graph

Retrieve the current reasoning graph.

Parameters:

• format (enum, optional): "full" or "summary" (default: "summary")

invalidate_assumption

Mark an assumption as invalid, cascading to all dependent thoughts.

Parameters:

• thought_id (string, required): ID of the assumption to invalidate

• reason (string, required): Explanation for invalidation

📖 Example Usage

Here's how an LLM might use DRE to analyze a complex decision:

// 1. Set the objective
const objective = await use_mcp_tool("dre", "log_thought", {
  thought: "Should we acquire Company X?",
  thought_type: "objective"
});

// 2. Form hypotheses
const hyp1 = await use_mcp_tool("dre", "log_thought", {
  thought: "Acquiring Company X will increase our market share by 20%",
  thought_type: "hypothesis",
  dependencies: [objective.thought_id],
  confidence: 0.7
});

// 3. Identify assumptions
const assumption = await use_mcp_tool("dre", "log_thought", {
  thought: "Company X's technology is compatible with our stack",
  thought_type: "assumption",
  dependencies: [hyp1.thought_id],
  confidence: 0.8
});

// 4. Break down into sub-problems
const subproblem = await use_mcp_tool("dre", "log_thought", {
  thought: "Verify technical compatibility through due diligence",
  thought_type: "sub_problem",
  dependencies: [assumption.thought_id]
});

// 5. If assumption proves false, invalidate it
await use_mcp_tool("dre", "invalidate_assumption", {
  thought_id: assumption.thought_id,
  reason: "Technical audit revealed major incompatibilities"
});
// This automatically marks the sub-problem and any dependent thoughts as stale

🏗️ Architecture

DRE models reasoning as a directed acyclic graph where:

• Nodes are thoughts with semantic types

• Edges represent dependencies between thoughts

• Status tracking (active/stale) enables dynamic reasoning updates

• Cascade invalidation ensures reasoning consistency

🤝 Use Cases

• Strategic Decision Making: Break down complex business decisions

• Research Planning: Structure research questions and hypotheses

• Problem Solving: Decompose problems into manageable sub-problems

• Risk Analysis: Track assumptions and their implications

• Debugging: Systematic root cause analysis

• Learning: Structured exploration of new topics

🔧 Development

# Install dependencies
npm install

# Build TypeScript
npm run build

# Run in development mode
npm run dev

# Run tests
npm test

📝 Contributing

We welcome contributions! Please see CONTRIBUTING.md for guidelines.

🐛 Troubleshooting

Common Issues

1. "Server not found" in Claude Desktop

   • Ensure the path in your config is absolute

   • Restart Claude Desktop after config changes

2. "Cannot find module" errors

   • Run npm install and npm run build

   • Check that you're using Node.js 18+

📄 License

MIT - see LICENSE for details.

🙏 Acknowledgments

• Built on the Model Context Protocol

• Inspired by structured reasoning systems and cognitive architectures

• Thanks to Anthropic for Claude and the MCP specification

🚦 Roadmap

• Hypothesis scoring based on evidence

• Session persistence and resumption

• Graph visualization export

• Conflict detection between branches

• Integration with external reasoning tools

• Multi-agent reasoning support

📊 Stats