What is Thinking Patterns

Thinking-patterns is a comprehensive Model Context Protocol (MCP) server that integrates systematic thinking, mental models, debugging approaches, and stochastic algorithms to enhance problem-solving capabilities.

Use cases

Use cases include software debugging, decision-making in uncertain environments, collaborative problem-solving in teams, structured argumentation in debates, and visual reasoning for complex data interpretation.

How to use

Users can leverage the various tools provided by the thinking-patterns MCP server, such as sequential thinking, mental models, and stochastic algorithms, to approach complex problems systematically and collaboratively.

Key features

Key features include dynamic multi-step thinking, structured mental models, systematic debugging methodologies, probabilistic decision-making algorithms, collaborative reasoning, structured decision analysis, metacognitive monitoring, formal hypothesis testing, dialectical reasoning, and visual reasoning.

Where to use

Thinking-patterns can be applied in various fields such as software development, data analysis, strategic planning, education, and any domain requiring enhanced problem-solving and decision-making capabilities.

Thinking Patterns MCP Server

TL;DR

A comprehensive MCP server that provides AI systems with structured thinking frameworks that follow existing problem-solving paradigms. Transform abstract cognitive patterns into concrete, invocable tools. Enforces adherence to the paradigms through schema validation.

📚 Documentation

• Quick Start - Get up and running in 2 minutes
• TOOL_REFERENCE.md - Complete tool specifications and parameters
• EXAMPLES.md - Detailed usage examples and patterns
• SUMMARY.md - Executive summary and overview
• SYSTEM_INTENT.md - System purpose and philosophy
• TECHNICAL_ARCHITECTURE.md - Technical implementation details

Problem

LLMs struggle to maintain consistent reasoning patterns throughout extended conversations due to context window limitations and degrading adherence to initial instructions. Traditional approaches like “keep X in mind” or role-based prompting fail when:

• Critical context passes out of the attention window
• Models acknowledge constraints but don’t consistently apply them
• Reasoning structures decay over multi-turn interactions

thinking-patterns enforces structural consistency through interactive schema validation rather than passive instruction-following.

Solution

thinking-patterns works by implicitly encouraging good engineering behaviors and approaches:

• Schema validation ensures reasoning patterns persist beyond context window limits
• Structural requirements live in tool definitions rather than repeated prompt text, reducing token overhead
• Tool interaction success/failure provides objective metrics for reasoning quality
  • Indicates to the model that they are not following the pattern appropriately without additional user interaction
• Reusable thinking structures across different problem domains

Reasoning Improvements

• Attention Drift Prevention: Without structural anchors, models experience “goal drift” as new contextual information competes with original objectives. Schema validation creates persistent attention anchors.
• State Crystallization: Explicit articulation of reasoning state (forced by tool parameters) appears to strengthen internal representation compared to implicit state maintenance. Models demonstrate measurably better state consistency when reasoning is externalized.
• Error-Driven Learning: Schema validation errors create immediate, interactive corrective feedback loops within a single response, unlike instruction-based approaches where non-compliance often goes undetected until task completion.
• Cognitive Load Distribution: Externalizing structural requirements to schemas allows models to allocate more processing capacity to problem-solving rather than format compliance, similar to how humans benefit from external memory aids.
• Iterative Reinforcement: Repeated successful tool interactions strengthen adherence patterns through practice, creating compound consistency benefits over conversation length.

🚀 Quick Start

1. Install (Choose One)

Recommended: Smithery (for Cursor users)

npx -y @smithery/cli install @emmahyde/thinking-patterns --client cursor

NPM

npm install @emmahyde/thinking-patterns

NPX (no installation)

npx -y @emmahyde/thinking-patterns

2. Configure MCP Client

Add to your MCP client configuration:

{
  "mcpServers": {
    "thinking-patterns": {
      "command": "npx",
      "args": [
        "-y",
        "@emmahyde/thinking-patterns"
      ]
    }
  }
}

3. Try Your First Tool

# Example: Use sequential thinking for planning
{
  "tool": "sequential_thinking",
  "arguments": {
    "thought": "Plan a product launch strategy",
    "thoughtNumber": 1,
    "totalThoughts": 5
  }
}

🧠 Available Thinking Tools

Core Systematic Thinking

• sequential_thinking - Multi-step reasoning with revision support
• problem_decomposition - Break complex problems into manageable parts
• recursive_thinking - Apply recursive strategies to self-similar problems

Mental Models & Frameworks

• mental_model - Apply proven frameworks (First Principles, Inversion, etc.)
• decision_framework - Multi-criteria decision analysis
• domain_modeling - Create conceptual models of problem domains

Scientific & Critical Analysis

• scientific_method - Formal hypothesis testing and experimentation
• critical_thinking - Systematic evaluation of arguments and assumptions
• debugging_approach - Systematic troubleshooting methodologies

Collaborative & Dialectical

• collaborative_reasoning - Multi-perspective problem solving with personas
• structured_argumentation - Dialectical reasoning and argument analysis

Advanced Cognitive Patterns

• metacognitive_monitoring - Self-assessment of reasoning quality
• visual_reasoning - Diagram-based thinking and spatial reasoning
• temporal_thinking - Time-based system analysis with state transitions

Probabilistic & Optimization

• stochastic_algorithm - Decision-making under uncertainty [BETA]
  • Markov Decision Processes (MDPs)
  • Monte Carlo Tree Search (MCTS)
  • Multi-Armed Bandit algorithms
  • Bayesian Optimization
  • Hidden Markov Models (HMMs)

💡 Recommended Starting Points

• sequential_thinking & problem_decomposition - Perfect for planning and breaking down complex tasks
• debugging_approach - Send error messages directly for systematic troubleshooting
• collaborative_reasoning - Simulate team discussions to uncover blind spots

📋 Prerequisites

• Node.js 18+ (for local installation)
• MCP-compatible client (Claude, Cursor, etc.)
• Optional: Docker for containerized deployment

🔧 Installation Options

Option 1: Smithery (Recommended for Cursor)

Automatically configures MCP client:

npx -y @smithery/cli install @emmahyde/thinking-patterns --client cursor

Option 2: NPM Package

For local development:

npm install @emmahyde/thinking-patterns

Option 3: NPX (Zero Installation)

Run without installing:

npx -y @emmahyde/thinking-patterns

Option 4: Docker

# Build image
docker build -t thinking-patterns .

# Run container
docker run -it thinking-patterns

Option 5: Development Setup

git clone https://github.com/emmahyde/thinking-patterns
cd thinking-patterns
npm install
npm run build
npm start

🎯 Use Cases

Software Development

• Debug production issues systematically
• Decompose complex features into user stories
• Review code with multiple perspectives
• Plan architecture changes step-by-step

Business Strategy

• Make data-driven decisions with frameworks
• Apply mental models to strategic planning
• Model business processes over time
• Optimize resource allocation

Research & Analysis

• Test hypotheses with scientific method
• Evaluate arguments critically
• Model new domains systematically
• Analyze temporal patterns

Creative Problem Solving

• Use visual reasoning for design challenges
• Apply recursive thinking to complex patterns
• Optimize solutions with probabilistic algorithms
• Generate innovative solutions with mental models

🔗 Integration Examples

npx

{
  "mcpServers": {
    "thinking-patterns": {
      "command": "npx",
      "args": [
        "-y",
        "@emmahyde/thinking-patterns"
      ]
    }
  }
}

Local Development

{
  "mcpServers": {
    "thinking-patterns": {
      "command": "node",
      "args": [
        "/path/to/thinking-patterns/dist/index.js"
      ]
    }
  }
}

📊 Tool Categories

🤝 Contributing

Contributions welcome! Please see our Contributing Guide for details.

📄 License

MIT License - see LICENSE for details.

🙏 Acknowledgments

• Built on the Model Context Protocol (MCP) by Anthropic
• Mental Models framework inspired by cognitive science research
• Stochastic algorithms based on reinforcement learning and decision theory

📞 Support

• 📖 Tool Reference - Complete API documentation
• 💡 Examples Guide - Usage examples and patterns
• 🐛 Report Issues
• 💬 Discussions

Give an AI thinking patterns, and it can solve any problem systematically.