Thinking Patterns MCP Server

A comprehensive Model Context Protocol (MCP) server that combines systematic thinking, mental models, debugging approaches, and stochastic algorithms for enhanced problem-solving capabilities. This server merges the functionality of Clear Thought and Stochastic Thinking servers into a unified cognitive toolkit.

Features

$3

1. sequential_thinking - Dynamic multi-step thinking with revision support
2. mental_model - Structured mental models for problem-solving
3. debugging_approach - Systematic debugging methodologies
4. stochastic_algorithm - Probabilistic algorithms for decision-making under uncertainty
5. collaborative_reasoning - Multi-perspective collaborative problem solving
6. decision_framework - Structured decision analysis and rational choice
7. metacognitive_monitoring - Self-assessment of knowledge and reasoning quality
8. scientific_method - Formal hypothesis testing and experimentation
9. structured_argumentation - Dialectical reasoning and argument analysis
10. visual_reasoning - Diagram-based thinking and problem solving

$3

Markov Decision Processes: Sequential decision-making with clear state transitions and defined rewards.

Monte Carlo Tree Search: Game playing, strategic planning, large decision spaces where simulation is possible.

Multi-Armed Bandit: A/B testing, resource allocation, online advertising, quick adaptation needs.

Bayesian Optimization: Hyperparameter tuning, expensive function optimization, continuous parameter spaces.

Hidden Markov Models: Time series analysis, pattern recognition, state inference, sequential data modeling.

Installation

$3

To install Thinking Patterns MCP Server for Claude Desktop automatically via Smithery:

``bash
npx -y @smithery/cli install @emmahyde/thought-patterns --client claude
`

$3


`bash
npm install @emmahyde/thought-patterns
`

Or run with npx:

`bash
npx @emmahyde/thinking-patterns
`

$3

Build the Docker image:

`bash
docker build -t emmahyde/thinking-patterns .
`

Run the container:

`bash
docker run -it emmahyde/thinking-patterns
`

$3

1. Clone the repository
2. Install dependencies: npm install
3. Build the project: npm run build
4. Start the server: npm start

Usage Examples

$3


`typescript
const response = await mcp.callTool("mental_model", {
modelName: "first_principles",
problem: "How to implement a new feature?",
steps: [
"Break down the problem",
"Analyze components",
"Build solution"
]
});
`

$3

`typescript
const response = await mcp.callTool("sequential_thinking", {
thought: "Initial analysis of the problem",
thoughtNumber: 1,
totalThoughts: 3,
nextThoughtNeeded: true
});
`

$3

`typescript
// Markov Decision Process
const response = await mcp.callTool("stochastic_algorithm", {
algorithm: "mdp",
problem: "Optimize robot navigation policy",
parameters: {
states: 100,
actions: ["up", "down", "left", "right"],
gamma: 0.9,
learningRate: 0.1
}
});

// Monte Carlo Tree Search
const response = await mcp.callTool("stochastic_algorithm", {
algorithm: "mcts",
problem: "Find optimal game moves",
parameters: {
simulations: 1000,
explorationConstant: 1.4,
maxDepth: 10
}
});
`

$3


`typescript
const response = await mcp.callTool("debugging_approach", {
approachName: "binary_search",
issue: "Performance degradation in the system",
steps: [
"Identify performance metrics",
"Locate bottleneck",
"Implement solution"
]
});
`

$3

`typescript
const response = await mcp.callTool("collaborative_reasoning", {
topic: "System architecture decision",
personas: [
{
id: "architect",
name: "Senior Architect",
expertise: ["distributed systems", "scalability"],
background: "10+ years in system design",
perspective: "Long-term maintainability focus",
biases: ["over-engineering"],
communication: { style: "analytical", tone: "measured" }
}
],
contributions: [],
stage: "problem-definition",
activePersonaId: "architect",
sessionId: "session-1",
iteration: 1,
nextContributionNeeded: true
});
`

$3

`typescript
const response = await mcp.callTool("decision_framework", {
decisionContext: "Selecting a cloud provider",
options: ["AWS", "GCP", "Azure"],
criteria: ["cost", "scalability", "support"],
weights: { cost: 0.5, scalability: 0.3, support: 0.2 },
rationale: "Prioritize cost and scalability for a startup."
});
`

$3

`typescript
const response = await mcp.callTool("metacognitive_monitoring", {
task: "Code review for critical bug fix",
confidenceLevel: 0.7,
knowledgeGaps: ["edge case handling"],
reflection: "Need to double-check concurrency issues."
});
`

$3

`typescript
const response = await mcp.callTool("scientific_method", {
hypothesis: "Increasing cache size will improve response time",
experiment: {
control: { cacheSize: 128 },
variant: { cacheSize: 512 },
metric: "averageResponseTime"
},
results: null,
nextStep: "Run A/B test and collect data"
});
`

$3

`typescript
const response = await mcp.callTool("structured_argumentation", {
claim: "Microservices are better than monoliths for scaling",
argumentsFor: ["Independent deployment", "Fault isolation"],
argumentsAgainst: ["Increased complexity", "Operational overhead"],
conclusion: null
});
`

$3

`typescript
const response = await mcp.callTool("visual_reasoning", {
problem: "Optimize network topology",
diagramType: "graph",
nodes: ["A", "B", "C", "D"],
edges: [
{ from: "A", to: "B" },
{ from: "B", to: "C" },
{ from: "C", to: "D" },
{ from: "A", to: "D" }
],
transformation: "minimize total edge length"
});
``

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT License - see LICENSE for details.

Acknowledgments

- Based on the clear-thought server, which is based on the Model Context Protocol (MCP) by Anthropic
- Combines functionality from Clear Thought and Stochastic Thinking MCP servers
- Mental Models framework inspired by James Clear's comprehensive guide to mental models
- Stochastic algorithms based on classic works in reinforcement learning and decision theory