MCP Langbase Reasoning

🚀 mcp-langbase-reasoning

A Model Context Protocol (MCP) server offering structured reasoning capabilities powered by Langbase Pipes. Written in Rust with SQLite persistence.

✨ Features

• 12 Reasoning Modes: Linear, tree, divergent, reflection, backtracking, auto-selection, Graph-of-Thoughts, decision framework, evidence assessment, timeline, MCTS, and counterfactual.
• Reasoning Time Machine: Timeline-based exploration, MCTS-guided search, and counterfactual "what if" analysis.
• 5 Workflow Presets: Code review, debugging, architecture decisions, strategic decisions, and evidence-based conclusions.
• Cognitive Analysis: Bias detection and logical fallacy identification.
• Autonomous Self-Improvement: A 4-phase optimization loop with safety controls (Monitor → Analyzer → Executor → Learner).
• Session Persistence: SQLite storage for sessions, thoughts, branches, checkpoints, and timelines.
• Production Ready: Over 2000 tests, async I/O, retry logic, and structured error handling.

🚀 Quick Start

Prerequisites

• Rust 1.70+
• A Langbase account with an API key

Installation

git clone https://github.com/quanticsoul4772/mcp-langbase-reasoning.git
cd mcp-langbase-reasoning

# Configure environment
cp .env.example .env
# Edit .env: set LANGBASE_API_KEY=your_key

# Build
cargo build --release

Configure MCP Client

Add to Claude Desktop configuration (claude_desktop_config.json):

{
  "mcpServers": {
    "langbase-reasoning": {
      "command": "/path/to/mcp-langbase-reasoning",
      "env": {
        "LANGBASE_API_KEY": "your_api_key"
      }
    }
  }
}

💻 Usage Examples

Core Reasoning

Tree Navigation

Checkpoints

Graph-of-Thoughts

Decision & Evidence

Time Machine

Cognitive Analysis

Workflow Presets

Built-in Presets: code-review, debug-analysis, architecture-decision, strategic-decision, evidence-based-conclusion

📚 Documentation

Configuration

Required

Optional

Self-Improvement System

The server includes an autonomous self-improvement loop that monitors system health, diagnoses issues, executes safe optimizations, and learns from outcomes. See the Architecture diagram for the system overview.

Safety Features

• Always Enabled: Self-improvement runs continuously
• Circuit Breaker: Stops after consecutive failures (default: 5)
• Action Allowlist: Only bounded, pre-approved parameter changes allowed
• Rate Limiting: Maximum actions per hour (default: 10)
• Automatic Rollback: Reverts changes that cause regression
• Cooldown Periods: Minimum time between actions (default: 60s)
• AI Validation: Bias and fallacy detection on decisions

Configuration

Allowed Actions

The system can only adjust pre-defined safe parameters:

CLI Commands

# View system status
cargo run -- self-improve status

# View action history
cargo run -- self-improve history

# Enable/disable the system
cargo run -- self-improve enable
cargo run -- self-improve disable

# Pause temporarily
cargo run -- self-improve pause --duration 1h

# View current configuration
cargo run -- self-improve config

# Force a health check
cargo run -- self-improve check

# Rollback last action
cargo run -- self-improve rollback

Example Output

$ cargo run -- self-improve status

Self-Improvement System Status
==============================
Enabled:           true
Circuit State:     closed
Consecutive Fails: 0
In Cooldown:       false
Actions This Hour: 3/10
Total Cycles:      47
Total Successes:   42
Total Rollbacks:   2
Last Cycle:        2025-12-26T10:30:00Z

🔧 Technical Details

Architecture

┌─────────────┐     stdio      ┌──────────────────┐     HTTPS     ┌─────────────────┐
│ MCP Client  │◄──────────────►│ mcp-langbase-    │◄─────────────►│ Langbase Pipes  │
│ (Claude)    │   JSON-RPC     │   reasoning      │               │ (8 pipes)       │
└─────────────┘                └────────┬─────────┘               └─────────────────┘
                                        │                                  ▲
                                        │                                  │
                                        ▼                                  │
                               ┌──────────────────┐                        │
                               │     SQLite       │                        │
                               │  sessions,       │                        │
                               │  thoughts,       │                        │
                               │  graphs,         │                        │
                               │  metrics         │                        │
                               └────────┬─────────┘                        │
                                        │                                  │
                    ┌───────────────────┴───────────────────┐              │
                    │         Self-Improvement Loop         │              │
                    │  ┌─────────┐ ┌─────────┐ ┌─────────┐  │   diagnosis  │
                    │  │ Monitor │→│ Analyze │→│ Execute │──┼──────────────┘
                    │  └────┬────┘ └─────────┘ └────┬────┘  │
                    │       │      ┌─────────┐      │       │
                    │       └──────│  Learn  │◄─────┘       │
                    │              └─────────┘              │
                    └───────────────────────────────────────┘

Development

cargo build              # Debug build
cargo build --release    # Release build
cargo test               # Run all 2000+ tests
cargo clippy -- -D warnings  # Lint (0 warnings)
cargo llvm-cov           # Generate coverage report

Project Structure

src/
├── main.rs           # Entry point
├── config/           # Environment configuration
├── error/            # Structured error types
├── langbase/         # Langbase API client
├── modes/            # 12 reasoning implementations
│   ├── timeline.rs   # Timeline management
│   ├── mcts.rs       # MCTS exploration
│   └── counterfactual.rs  # "What if" analysis
├── presets/          # Workflow preset system
├── self_improvement/ # Autonomous optimization
├── server/           # MCP protocol handling
└── storage/          # SQLite persistence

docs/
├── API_REFERENCE.md  # Complete tool documentation
├── ARCHITECTURE.md   # Technical design
├── LANGBASE_API.md   # Pipe integration
└── REASONING_TIME_MACHINE.md  # Time Machine design

📄 License

MIT