criticalthinking-mcp

Justar96/criticalthinking-mcp

3.2

If you are the rightful owner of criticalthinking-mcp and would like to certify it and/or have it hosted online, please leave a comment on the right or send an email to henry@mcphub.com.

The Critical Thinking MCP Server is an independent server that enhances development workflows with critical thinking tools, operating standalone without the need for other servers.

Tools

  1. clarify

    Breaks down ambiguous requirements into clearer, actionable statements.

  2. assumption_audit

    Identifies hidden assumptions in plans, code, or approaches.

  3. perspective_flip

    Suggests alternative approaches and highlights potential blind spots.

  4. batch

    Performs comprehensive critical thinking analysis on Sequential-Thinking output in a single call.

Critical Thinking MCP Server

An independent MCP server that enhances development workflows with critical thinking tools. Works completely standalone - no other servers required!

Key Point: Critical Thinking MCP provides immediate value with three standalone tools. You don't need Sequential-Thinking or any other MCP server to use it.

Repository Note: This repository contains the Critical Thinking MCP Server. The sequentialthinking/ directory is a separate Anthropic project that should be moved to its own repository. See for details.

📚 Documentation

For comprehensive documentation, see the folder:

  • - Start here!
  • - Complete project overview
  • - Testing documentation and results

Features

🚀 Standalone Tools (No Dependencies Required)

  • Clarify: Break down vague requirements into actionable items
  • Assumption Audit: Surface hidden assumptions that might cause problems
  • Perspective Flip: Suggest alternative approaches and highlight blind spots

🔗 Integration Tool (Optional)

  • Batch: Comprehensive analysis of Sequential-Thinking output in one call (only tool that requires Sequential-Thinking)

Tools

clarify

Breaks down ambiguous requirements into clearer, actionable statements.

Inputs:

  • statement (string): The requirement or goal that needs clarification
  • context (string, optional): Additional context about the project or domain

Outputs:

  • interpretation: Clear understanding of the request
  • missing_details: Information that's needed but not provided
  • implicit_requirements: Hidden requirements that are often overlooked
  • clarifying_questions: Questions to ask for more information

Example:

{
  "statement": "Add caching to improve performance",
  "context": "E-commerce API with high traffic"
}

assumption_audit

Identifies hidden assumptions in plans, code, or approaches.

Inputs:

  • context (string): Description of the plan, code, or approach to audit

Outputs:

  • assumptions: List of assumptions with impact analysis and validation methods
  • consider_checking: Top assumptions worth validating first

Example:

{
  "context": "Building a microservices architecture with REST APIs"
}

perspective_flip

Suggests alternative approaches and highlights potential blind spots.

Inputs:

  • approach (string): Current approach or solution being considered
  • goal (string): What you're trying to achieve

Outputs:

  • alternatives: Different approaches with their use cases and tradeoffs
  • overlooked_angle: Something the current approach might miss
  • questions_to_consider: Thought-provoking questions about the approach

Example:

{
  "approach": "Using a SQL database for user data",
  "goal": "Store and query user profiles efficiently"
}

batch

Performs comprehensive critical thinking analysis on Sequential-Thinking output in a single call.

Inputs:

  • thoughtTrace (array): Array of thought objects from Sequential-Thinking output
  • depth (number, optional): Analysis depth parameter (0-1, default 0.5)

Outputs:

  • clarify: Object with goal and unknowns extracted from the thinking process
  • assumptions: Array of assumptions with text and criticality scores
  • counter_view: Alternative perspective that challenges the current thinking

Example:

{
  "thoughtTrace": [
    {
      "thought": "I need to implement user authentication using JWT tokens",
      "thoughtNumber": 1,
      "totalThoughts": 3,
      "nextThoughtNeeded": true
    },
    {
      "thought": "Assuming HTTPS is available, JWT should be secure in localStorage",
      "thoughtNumber": 2,
      "totalThoughts": 3,
      "nextThoughtNeeded": true
    },
    {
      "thought": "This approach should work well for our needs",
      "thoughtNumber": 3,
      "totalThoughts": 3,
      "nextThoughtNeeded": false
    }
  ],
  "depth": 0.7
}

Pipeline Usage: The batch tool is designed for host-level pipeline patterns where Sequential-Thinking output is piped directly into Critical-Thinking for comprehensive analysis with minimal latency.

Installation & Usage

Quick Start (Standalone)

# Use immediately with npx (no installation needed)
npx @justarr/server-critical-thinking list-tools

# Or install globally
npm install -g @justarr/server-critical-thinking

With Claude Desktop

Add this to your claude_desktop_config.json:

NPX (Recommended)
{
  "mcpServers": {
    "server-critical-thinking": {
      "command": "npx",
      "args": [
        "-y",
        "@justarr/server-critical-thinking"
      ]
    }
  }
}
Docker
{
  "mcpServers": {
    "server-critical-thinking": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "justarr/server-critical-thinking"
      ]
    }
  }
}

With VS Code

Add to your VS Code settings JSON or .vscode/mcp.json:

{
  "mcp": {
    "servers": {
      "server-critical-thinking": {
        "command": "npx",
        "args": [
          "-y",
          "@justarr/server-critical-thinking"
        ]
      }
    }
  }
}

Standalone Usage Examples

// You only need Server-Critical-Thinking - no other servers required!

// Clarify vague requirements
const result = await mcp.callTool('clarify', {
  statement: "Build a fast API",
  context: "E-commerce platform"
});

// Audit assumptions in your approach
const assumptions = await mcp.callTool('assumption_audit', {
  context: "Using microservices for a startup MVP"
});

// Explore alternative approaches
const alternatives = await mcp.callTool('perspective_flip', {
  approach: "NoSQL for everything",
  goal: "Handle complex data relationships"
});

Environment Variables

  • DISABLE_CRITICAL_THINKING_LOGGING: Set to "true" to disable console logging

Development

Building

npm install
npm run build

Running locally

npm run dev

Docker

docker build -t justarr/server-critical-thinking .

Why Use Server-Critical-Thinking?

🎯 Immediate Value

  • No Dependencies: Works standalone without Sequential-Thinking or any other server
  • Three Powerful Tools: Clarify, Assumption Audit, and Perspective Flip work independently
  • Quick Setup: Install and start using in minutes
  • Focused Analysis: Each tool solves specific development problems

🧠 Design Philosophy

This server is designed to enhance rather than override development agent behavior:

  • Neutral Language: Outputs use suggestive rather than directive language
  • Complementary: Provides additional context without contradicting existing instructions
  • Development-Focused: Tailored specifically for coding and technical scenarios
  • Non-Prescriptive: Offers insights and questions rather than commands
  • Standalone First: Designed to work independently, with optional integration capabilities

Example Integration

When a development agent receives a vague requirement like "make it faster", the clarify tool can help by:

  1. Interpreting what "faster" might mean in context
  2. Identifying missing details (what specifically is slow?)
  3. Surfacing implicit requirements (monitoring, backwards compatibility)
  4. Generating clarifying questions for stakeholders

The agent can then naturally incorporate these insights into its response without conflicting with its core instructions.

Multi-Server Integration with Sequential-Thinking

The Critical-Thinking MCP server is designed to work seamlessly with the Sequential-Thinking MCP server to create powerful thinking pipelines. This integration combines structured problem-solving with critical analysis for comprehensive insights.

Pipeline Architecture

Sequential-Thinking → Critical-Thinking → Enhanced Results
    (Step-by-step)      (Analysis)         (Comprehensive)

The tool is specifically designed to process Sequential-Thinking output efficiently:

  1. Sequential-Thinking generates a structured thought trace
  2. Critical-Thinking analyzes the complete thinking process
  3. Host application combines both outputs for comprehensive results

Quick Start

1. Configure Both Servers

Claude Desktop ():

{
  "mcpServers": {
    "sequential-thinking": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
    },
    "critical-thinking": {
      "command": "npx",
      "args": ["-y", "@justarr/mcp-server-critical-thinking"]
    }
  }
}

VS Code ():

{
  "mcp": {
    "servers": {
      "sequential-thinking": {
        "command": "npx",
        "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
      },
      "critical-thinking": {
        "command": "npx",
        "args": ["-y", "@justarr/mcp-server-critical-thinking"]
      }
    }
  }
}
2. Run the Integration Example
# Navigate to examples directory
cd examples

# Run with a specific problem
node integration-example.js "Design a scalable microservices architecture"

# Interactive mode
node integration-example.js --interactive

# Default examples
node integration-example.js

Integration Benefits

  • 🧠 Enhanced Problem Solving: Combines structured thinking with critical analysis
  • ⚡ Efficient Pipeline: Single workflow handles both thinking and analysis phases
  • 🔍 Comprehensive Insights: Identifies assumptions, alternatives, and blind spots
  • 🎯 Actionable Results: Provides both the thinking process and critical evaluation

Example Output

Input: "Implement user authentication with JWT tokens"

Sequential-Thinking Output:

[
  {
    "thought": "I need to implement user authentication using JWT tokens",
    "thoughtNumber": 1,
    "totalThoughts": 3,
    "nextThoughtNeeded": true
  },
  {
    "thought": "Assuming HTTPS is available, JWT should be secure in localStorage",
    "thoughtNumber": 2,
    "totalThoughts": 3,
    "nextThoughtNeeded": true
  }
]

Critical-Thinking Analysis:

{
  "clarify": {
    "goal": "Implement secure user authentication system",
    "unknowns": ["Token expiration strategy", "Refresh token handling"]
  },
  "assumptions": [
    {
      "text": "HTTPS is available in production",
      "criticality": 0.9
    },
    {
      "text": "localStorage is acceptable for token storage",
      "criticality": 0.7
    }
  ],
  "counter_view": "Consider httpOnly cookies instead of localStorage for better XSS protection"
}

Advanced Usage

See the directory for:

  • with full pipeline implementation
  • for different environments
  • with usage patterns and best practices

Use Cases

  • Software Architecture Planning: Structure the design process, then critically evaluate assumptions
  • Technical Problem Solving: Break down complex issues, then identify potential blind spots
  • Code Review and Refactoring: Plan changes systematically, then analyze risks and alternatives
  • Requirements Analysis: Clarify vague requirements, then audit assumptions and suggest alternatives

License

MIT License - see LICENSE file for details.

Contributing

Contributions welcome! Please see CONTRIBUTING.md for guidelines.