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.
- 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
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.
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
- 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.
Recommended: Smithery (for Cursor users)
npx -y @smithery/cli install @emmahyde/thinking-patterns --client cursorNPM
npm install @emmahyde/thinking-patternsNPX (no installation)
npx -y @emmahyde/thinking-patternsAdd to your MCP client configuration:
{
"mcpServers": {
"thinking-patterns": {
"command": "npx",
"args": ["-y", "@emmahyde/thinking-patterns"]
}
}
}# Example: Use sequential thinking for planning
{
"tool": "sequential_thinking",
"arguments": {
"thought": "Plan a product launch strategy",
"thoughtNumber": 1,
"totalThoughts": 5
}
}- 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_model - Apply proven frameworks (First Principles, Inversion, etc.)
- decision_framework - Multi-criteria decision analysis
- domain_modeling - Create conceptual models of problem domains
- scientific_method - Formal hypothesis testing and experimentation
- critical_thinking - Systematic evaluation of arguments and assumptions
- debugging_approach - Systematic troubleshooting methodologies
- collaborative_reasoning - Multi-perspective problem solving with personas
- structured_argumentation - Dialectical reasoning and argument analysis
- metacognitive_monitoring - Self-assessment of reasoning quality
- visual_reasoning - Diagram-based thinking and spatial reasoning
- temporal_thinking - Time-based system analysis with state transitions
- 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)
- 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
- Node.js 18+ (for local installation)
- MCP-compatible client (Claude, Cursor, etc.)
- Optional: Docker for containerized deployment
Automatically configures MCP client:
npx -y @smithery/cli install @emmahyde/thinking-patterns --client cursorFor local development:
npm install @emmahyde/thinking-patternsRun without installing:
npx -y @emmahyde/thinking-patterns# Build image
docker build -t thinking-patterns .
# Run container
docker run -it thinking-patternsgit clone https://github.com/emmahyde/thinking-patterns
cd thinking-patterns
npm install
npm run build
npm start- Debug production issues systematically
- Decompose complex features into user stories
- Review code with multiple perspectives
- Plan architecture changes step-by-step
- Make data-driven decisions with frameworks
- Apply mental models to strategic planning
- Model business processes over time
- Optimize resource allocation
- Test hypotheses with scientific method
- Evaluate arguments critically
- Model new domains systematically
- Analyze temporal patterns
- Use visual reasoning for design challenges
- Apply recursive thinking to complex patterns
- Optimize solutions with probabilistic algorithms
- Generate innovative solutions with mental models
{
"mcpServers": {
"thinking-patterns": {
"command": "npx",
"args": ["-y", "@emmahyde/thinking-patterns"]
}
}
}{
"mcpServers": {
"thinking-patterns": {
"command": "node",
"args": ["/path/to/thinking-patterns/dist/index.js"]
}
}
}| Category | Tools | Best For |
|---|---|---|
| Systematic | sequential_thinking, problem_decomposition, recursive_thinking | Planning, breaking down complexity |
| Mental Models | mental_model, decision_framework, domain_modeling | Strategic thinking, decision making |
| Scientific | scientific_method, critical_thinking, debugging_approach | Analysis, troubleshooting, validation |
| Collaborative | collaborative_reasoning, structured_argumentation | Team thinking, debate, consensus |
| Advanced | metacognitive_monitoring, visual_reasoning, temporal_thinking | Self-reflection, design, process modeling |
| Probabilistic | stochastic_algorithm | Optimization, uncertainty, ML/AI |
Contributions welcome! Please see our Contributing Guide for details.
MIT License - see LICENSE for details.
- 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
- 📖 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.