Advanced Reasoning MCP

🚀 Advanced Reasoning MCP Server

An elegant, self - contained MCP server that leverages sequential thinking patterns with advanced cognitive capabilities, including meta - reasoning, hypothesis testing, integrated memory libraries, and structured data storage.

✨ Features

• Meta - Cognitive Assessment: Track confidence and evaluate reasoning quality.
• Hypothesis Testing: Systematically formulate, test, and validate hypotheses.
• Integrated Memory Libraries: Manage named graph - based memory libraries for different contexts.
• SystemJSON Storage: Store workflows, instructions, and domain - specific knowledge in a structured way.
• Enhanced Visualization: Display rich console output with confidence bars and quality indicators.

🚀 Quick Start

📦 Installation

cd /advanced-reasoning-mcp
npm install
npm run build

💻 Usage

MCP Client Integration

Add the following to your MCP client configuration:

{
  "mcpServers": {
    "advanced-reasoning": {
      "command": "node",
      "args": ["/path-to/advanced-reasoning-mcp/build/index.js"]
    }
  }
}

🔧 Technical Details

Core Reasoning

advanced_reasoning

Enhanced reasoning with cognitive features:

• All sequential thinking capabilities (branching, revisions, dynamic thought counts).
• Confidence tracking (0.0 - 1.0).
• Reasoning quality assessment (low/medium/high).
• Meta - cognitive reflection.
• Hypothesis formulation and testing.
• Evidence tracking and validation.
• Memory integration with session context.

query_reasoning_memory

Search integrated memory:

• Find related insights and hypotheses.
• Discover connections between ideas.
• Build on previous reasoning sessions.
• Context - aware memory retrieval.

Memory Library Management

create_memory_library

Create named memory libraries for organized knowledge:

• Separate libraries for different projects/domains.
• Clean architectural separation.
• Library name validation.

list_memory_libraries

List all available memory libraries:

• Shows library metadata (name, size, last modified).
• Organized, searchable library information.

switch_memory_library

Switch between different memory libraries:

• Maintains session state during switches.
• Context - aware library management.

get_current_library_info

Get information about currently active library:

• Current library name and statistics.
• Node count and session information.

SystemJSON Structured Storage

create_system_json

Create structured data storage for workflows and instructions:

• Domain categorization.
• Searchable content with tags.
• JSON - serializable data storage.
• Atomic write operations with validation.

get_system_json

Retrieve structured data by name:

• Complete data retrieval with metadata.
• Timestamp and modification tracking.

search_system_json

Search through structured data:

• Relevance scoring and ranking.
• Multi - field search capability.

list_system_json

List all available structured data files:

• Organized by domain and description.
• Complete metadata overview.

💻 Usage Examples

Basic Advanced Reasoning

// Create a new memory library for this project
const library = await callTool("create_memory_library", {
  library_name: "database_optimization"
});

// Advanced reasoning with meta-cognition (no session creation needed)
const result = await callTool("advanced_reasoning", {
  thought: "I need to analyze the query execution plan first",
  thoughtNumber: 1,
  totalThoughts: 5,
  nextThoughtNeeded: true,
  confidence: 0.8,
  reasoning_quality: "high",
  meta_thought: "This is a logical first step, high confidence approach",
  goal: "Optimize database query performance"
});

Advanced Usage - Hypothesis Testing

const result = await callTool("advanced_reasoning", {
  thought: "The bottleneck appears to be in the JOIN operations",
  thoughtNumber: 2,
  totalThoughts: 5,
  nextThoughtNeeded: true,
  confidence: 0.6,
  reasoning_quality: "medium",
  meta_thought: "Need to verify this with actual data",
  hypothesis: "JOIN operations are causing 80% of query time",
  test_plan: "Run EXPLAIN ANALYZE and check execution times"
});

Advanced Usage - Memory Integration

// Query related memories (no session_id needed)
const memories = await callTool("query_reasoning_memory", {
  query: "database optimization techniques"
});

Advanced Usage - SystemJSON Usage

// Store a workflow for reuse
const workflow = await callTool("create_system_json", {
  name: "api_testing_workflow",
  domain: "software_development",
  description: "Complete API testing methodology",
  data: {
    phases: ["setup", "unit_tests", "integration_tests", "performance_tests"],
    tools: ["jest", "supertest", "newman"],
    checklist: ["auth validation", "error handling", "rate limiting"]
  },
  tags: ["testing", "api", "workflow"]
});

// Retrieve the workflow later
const storedWorkflow = await callTool("get_system_json", {
  name: "api_testing_workflow"
});

🏗️ Architecture

Built on proven sequential thinking with dual storage systems:

┌─────────────────────────────────────────────────────────────┐
│                    MCP Interface                            │
├─────────────────────────────────────────────────────────────┤
│                Advanced Reasoning Server                    │
│                                                             │
│  ┌──────────────────┐              ┌──────────────────┐     │
│  │   CognitiveMemory │              │    SystemJSON    │     │
│  │   (Graph-Based)   │              │ (Document-Based) │     │
│  │                  │              │                  │     │
│  │ • Named Libraries │              │ • Domain-Indexed │     │
│  │ • Session Context │              │ • Searchable     │     │
│  │ • Node Relations  │              │ • Tagged Content │     │
│  │ • Hypothesis      │              │ • Workflows      │     │
│  │   Tracking        │              │ • Instructions   │     │
│  └──────────────────┘              └──────────────────┘     │
│           │                                  │               │
│  ┌──────────────────┐              ┌──────────────────┐     │
│  │  Meta-Cognitive  │              │   Enhanced       │     │
│  │   Assessment     │              │  Sequential      │     │
│  │                  │              │   Thinking       │     │
│  │ • Confidence     │              │                  │     │
│  │ • Quality Rating │              │ • Branching      │     │
│  │ • Evidence       │              │ • Revisions      │     │
│  │ • Hypothesis     │              │ • Dynamic Counts │     │
│  │   Testing        │              │ • Meta-Thoughts  │     │
│  └──────────────────┘              └──────────────────┘     │
└─────────────────────────────────────────────────────────────┘

🎯 Advanced Features

Meta - Cognitive Assessment

• Confidence Tracking: Self - assess reasoning certainty (0.0 - 1.0).
• Quality Evaluation: Indicate reasoning quality as low/medium/high.
• Meta - Thoughts: Reflect on the reasoning process.
• Evidence Integration: Systematically collect and validate evidence.

Hypothesis Testing Framework

• Hypothesis Formulation: Clearly state working theories.
• Test Planning: Define validation/refutation strategies.
• Evidence Tracking: Collect supporting/contradicting evidence.
• Result Integration: Incorporate test outcomes into reasoning.

Dual Storage Architecture

CognitiveMemory (Graph - Based)

• Named Libraries: Separate contexts for different projects.
• Graph Storage: Store connected thoughts, hypotheses, and evidence.
• Session Management: Maintain persistent reasoning contexts.
• Memory Queries: Find relevant insights across sessions.
• Storage: memory_data/{library_name}.json

SystemJSON (Document - Based)

• Structured Storage: Store JSON - serializable workflows and instructions.
• Domain Organization: Categorize by domain/purpose.
• Search & Discovery: Perform full - text search with relevance scoring.
• Tag System: Organize content flexibly.
• Storage: memory_data/system_json/{name}.json

Enhanced Visualization

• Confidence Bars: Visually represent reasoning certainty.
• Quality Indicators: Use color - coded indicators for reasoning assessment.
• Rich Formatting: Provide a clear structure for complex reasoning.
• Meta - Information: Display confidence, quality, and connections.

🔄 Compatibility

Fully compatible with sequential thinking patterns:

• Preserve all branching and revision capabilities.
• Support dynamic thought count adjustment.
• Use a familiar parameter structure with optional enhancements.
• Be backward compatible with existing sequential thinking workflows.

📊 Benefits Over Sequential Thinking

• Self - Awareness: Track confidence and reasoning quality.
• Systematic Validation: Use an explicit hypothesis testing framework.
• Organized Memory: Manage named libraries for different contexts.
• Structured Storage: Store workflows and instructions as searchable data.
• Enhanced Clarity: Visualize the reasoning process richly.
• Progress Tracking: Monitor progress towards defined goals.
• Evidence - Based: Systematically collect and evaluate evidence.

🗂️ File Structure

memory_data/
├── cognitive_memory.json      # Default reasoning library
├── {library_name}.json        # Named reasoning libraries
└── system_json/              # Structured data storage
    ├── {workflow_name}.json  # Workflow definitions
    ├── {instruction_set}.json # Instruction sets
    └── {domain_data}.json    # Domain-specific data

📚 Use Cases

Memory Libraries

• Project - specific reasoning: Use separate libraries for each project.
• Domain expertise: Maintain different libraries for different knowledge domains.
• Context switching: Cleanly separate reasoning contexts.

SystemJSON Storage

• Workflow documentation: Store reusable process definitions.
• Instruction sets: Save step - by - step procedures and guidelines.
• Domain knowledge: Organize structured information for specific fields.
• Configuration data: Store settings and parameters for different scenarios.

This server transforms sequential thinking into a sophisticated dual - storage cognitive reasoning system, offering both graph - based memory for reasoning sessions and structured document storage for workflows and instructions, while retaining the elegant simplicity that made the original sequential thinking pattern so effective.

Made by angrysky56 (Ty Hall) and Claude

📄 License

MIT