Thinking Patterns

Thinking Patterns MCP Server

[](https://smithery.ai/server/@emmahyde/thinking-patterns) [](https://www.npmjs.com/package/@emmahyde/thinking-patterns)

TL;DR

[](https://www.mermaidchart.com/play#pako:eNp1VE1v2zAMStCTq0BYdiGNCPFbsEDZDelsGgZcbmqg9DkrMGw77KFlOnLi9GNYjcj3RPrvStoGV3ersix3RlqzpZuZ4QIHWq8Ew6b4b2UVlm3MylHk2k09DHHWRtubooidGTeyLRVDyGgM74ovtbuy7f0KNaPGxGsVb64vY1fCfFS0YZ6IDi5t6AOgaSoHJMiN7ZWqGuGpRW99ZTIGt-7lZF8WEk13pwCG8i4grfE0ImWOEpArvVr4ndoRyc59rV1HWiXsKZd4tqXzILKXAJyE0Ib9WB02bUXhKaQHuSlcbQ2SYxL9BMOPYWzbZk0HgD5c0klHyZjLRhdopvt-ADVAwHQA1w6aqoT3XY4e7Sk2HjOLk5mc6tgbStoZhSacsv1k01PwvOLQLv0ftYNGF2z06D59RLTVYpqK2DxHTKGJV9HMtF1oMKVPboGIXxIvi9HzWddT5BALHmkVax8EmcCeyYjnAWdAYyzM5H8SGZUniifFZGW9EU764Bp2YDJJaawGMiPPJOMKySP1kjswwAqHVN01jVKisN34k1na6q9A41rHsbqRfwhTlxNNDR6A7ExeLhmneL9dC2cU-h5ykG2WXWa3i616MPqPk65Dihzg48-b7jrZbsA1ukGFwoE6LkBFsqmkS4bTEnwVz0ScCFS9VZqc-mqIDeTbyanyuwTNfy26VNXhsRh3Le2SZPQe1aot0Ez5ShpnfAunNyHgJoU8UbLqcQ2WNlBRMS9anl9Qqf9FBSiKNZPm6K4AB5ft5fIAxz5fwFmjj6AaYgX3az-Qd2EQSk)

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](#quick-start) - Get up and running in 2 minutes
• [TOOLREFERENCE.md](./TOOLREFERENCE.md) - Complete tool specifications and parameters
• [EXAMPLES.md](./EXAMPLES.md) - Detailed usage examples and patterns
• [SUMMARY.md](./SUMMARY.md) - Executive summary and overview
• [SYSTEMINTENT.md](./SYSTEMINTENT.md) - System purpose and philosophy
• [TECHNICALARCHITECTURE.md](./TECHNICALARCHITECTURE.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

• sequentialthinking & problemdecomposition - 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

| Category | Tools | Best For | |----------|-------|----------| | Systematic | sequentialthinking, problemdecomposition, recursivethinking | Planning, breaking down complexity | | Mental Models | mentalmodel, decisionframework, domainmodeling | Strategic thinking, decision making | | Scientific | scientificmethod, criticalthinking, debuggingapproach | Analysis, troubleshooting, validation | | Collaborative | collaborativereasoning, structuredargumentation | Team thinking, debate, consensus | | Advanced | metacognitivemonitoring, visualreasoning, temporalthinking | Self-reflection, design, process modeling | | Probabilistic | stochastic_algorithm | Optimization, uncertainty, ML/AI |

🤝 Contributing

Contributions welcome! Please see our [Contributing Guide](CONTRIBUTING.md) for details.

📄 License

MIT License - see [LICENSE](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](./TOOL_REFERENCE.md) - Complete API documentation
• 💡 [Examples Guide](./EXAMPLES.md) - Usage examples and patterns
• 🐛 Report Issues
• 💬 Discussions

---

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

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: emmahyde
• Source: emmahyde/thinking-patterns
• License: MIT

Install and usage instructions live in the source repository linked above.