MCP 服务器

Deliberate Reasoning Engine

An MCP server that structures AI reasoning as directed acyclic graphs of semantic thoughts, enabling explicit dependencies, assumption tracking, and cascade invalidation for transparent decision-making.

README

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

"Server not found" in Claude Desktop
- Ensure the path in your config is absolute
- Restart Claude Desktop after config changes
"Cannot find module" errors
- Run npm install and npm run build
- Check that you're using Node.js 18+