How do I use Think Strategies?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Think Strategies help me plan a marketing campaign using the Tree of Thoughts strategy" That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

Think Strategies

by aaronsb

Overview Schema Related Servers Score Discussions

JavaScript

Hybrid

Think Strategies MCP Server

Overview

An MCP server implementation that provides a tool for dynamic and reflective problem-solving through structured thinking processes. Choose from 10 different reasoning strategies:

🔄 Linear - Flexible thinking with revisions and branches
🔗 Chain of Thought - Sequential step-by-step reasoning
🎯 React - Reasoning combined with actions and observations
📋 ReWOO - Plan-execute pattern with parallel tool usage
📝 Scratchpad - Iterative calculations with state tracking
❓ Self-Ask - Decompose into sub-questions and answers
🔍 Self-Consistency - Multiple reasoning paths to consensus
🔭 Step-Back - Abstract principles before specific application
🌳 Tree of Thoughts - Explore and evaluate multiple branches
⚖️ Trilemma - Balance three competing objectives through satisficing

Documentation

Comprehensive documentation is available in the following files:

Executive Summary - High-level overview of Sequential Thinking
Practical Guide - Examples and best practices for using the tool (includes trilemma scenarios)
Technical Documentation - Detailed technical explanation of the architecture
Flow Engine Architecture - In-depth explanation of the flow engine's flexibility and strategy-specific flows
Strategy Comparison - Detailed comparison of all 10 thinking strategies including trilemma

Features

Break down complex problems into manageable steps
Revise and refine thoughts as understanding deepens
Branch into alternative paths of reasoning
Adjust the total number of thoughts dynamically
Support for unfixed step numbers through cyclic flows
Strategy-specific flow patterns for different reasoning approaches
Generate and verify solution hypotheses

Architecture

The think-strategies server uses a consolidated 3-tool architecture designed for optimal balance between simplicity and power:

Core Tools

1. `think-strategies` (Core Thinking)

Facilitates structured problem-solving with prominent strategy selection.

Parameters (7):

strategy (string): Primary choice - one of 10 reasoning strategies
thought (string): The current thinking step
thoughtNumber (integer): Current thought number (uses dual A1|S1 numbering)
totalThoughts (integer): Estimated total thoughts needed
nextThoughtNeeded (boolean): Whether another thought step is needed
plannedActions (array, optional): Plan tool calls for think→act→reflect workflow
actionResults (array, optional): Integrate results from executed tools
action (string, optional): Strategy-specific action (for ReAct, ReWOO)
observation (string, optional): Strategy-specific observation
finalAnswer (string, optional): Final result when thinking is complete

2. `think-tools` (Action-Based Utilities)

Consolidated utilities with action-based routing.

Parameters (6):

action (string): "connect-server" | "execute-actions" | "server-status" | "create-branch"
serverName (string, optional): MCP server name for connections
command (string, optional): Command to execute
args (array, optional): Command arguments
branchId (string, optional): Branch identifier for branching
branchFromThought (number, optional): Thought number to branch from
thought (string, optional): Context for branching

3. `think-session-manager` (Session Operations)

Manage thinking session persistence and continuity.

Parameters (3):

action (string): "list" | "get" | "resume"
sessionId (string, optional): Specific session ID
limit (number, optional): Number of sessions to return (default: 10)

Key Features

Strategy Selection Prominence: Clear choice among 10 reasoning strategies
Think→Act→Reflect Workflow: Seamless integration with any available tools
Dual Numbering System: Absolute (A1, A2...) and sequence-relative (S1, S2...) tracking
True Branching: Create alternative reasoning paths
Session Continuity: Persistent sessions with resume capability
MCP Integration: Connect to other MCP servers during thinking
No Tool Duplication: Clean separation of concerns across 3 focused tools

Resources

documentation: Complete tool documentation and usage examples
strategy-config: Configuration for all 10 thinking strategies and their stage flows

Usage

When to Use Think-Strategies

The think-strategies server is designed for:

Complex Problem-Solving: Break down multi-step challenges into manageable pieces
Strategic Analysis: Choose the optimal reasoning approach for your specific problem type
Iterative Refinement: Revise and improve your thinking as understanding deepens
Alternative Exploration: Branch into different solution paths and compare approaches
Tool Integration: Combine reasoning with real tool execution (think\u2192act\u2192reflect)
Session Continuity: Resume and build upon previous thinking sessions

Strategy Selection Guide

Linear/Chain of Thought: Step-by-step reasoning for straightforward problems
ReAct: When you need to gather information or execute actions during reasoning
ReWOO: For parallel tool usage and plan-execute workflows
Tree of Thoughts: When exploring multiple solution branches is valuable
Trilemma: For balancing three competing objectives through satisficing
Self-Ask: Break complex questions into simpler sub-questions
Step-Back: When you need to establish principles before diving into specifics

Installation

Prerequisites

Node.js (v14 or higher) and npm (v6 or higher) OR
Docker

Quick Start with npx (Easiest)

You can run the server directly using npx without cloning or installing:

# Run from npm registry (after publishing)
npx think-strategies

# Or run directly from GitHub
npx github:aaronsb/think-strategies

Setup with Node.js

Clone the repository:

git clone https://github.com/aaronsb/think-strategies.git
cd think-strategies

Install dependencies:

npm install

Make the server executable:

chmod +x index.js

Run the server:

node index.js

Setup with Docker

Using Pre-built Image (Recommended)

Pull and run the latest image from GitHub Container Registry:

docker run --rm -i ghcr.io/aaronsb/think-strategies:latest

Building Locally

Clone the repository:

git clone https://github.com/aaronsb/think-strategies.git
cd think-strategies

Build the Docker image:

./scripts/build-local.sh

Run the Docker container:

./scripts/run-local.sh

This will run the server with the correct permissions, ensuring that any files created are owned by the current user, not root.

Development

To contribute to the project:

Fork the repository on GitHub
Clone your fork locally
Add the upstream repository:

git remote add upstream https://github.com/aaronsb/think-strategies.git

Create a branch for your changes
Submit a pull request with your changes

Configuration

Using Claude Code CLI (Recommended)

Add the think-strategies MCP server using Claude Code's built-in command:

# Add from GitHub (latest version)
claude mcp add think-strategies "npx" "github:aaronsb/think-strategies" -- --storage-path "/home/$(whoami)/Documents/thinking"

# Add from local development path
claude mcp add think-strategies "node" "/path/to/think-strategies/index.js" -- --storage-path "/home/$(whoami)/Documents/thinking"

# Add with Docker
claude mcp add think-strategies "docker" "run" "--rm" "-i" "--user" "$(id -u):$(id -g)" "-v" "/home/$(whoami)/Documents/thinking:/app/data" "ghcr.io/aaronsb/think-strategies:latest"

# Optional: Use user scope to share thinking sessions across all projects
claude mcp add --scope user think-strategies "npx" "github:aaronsb/think-strategies" -- --storage-path "/home/$(whoami)/Documents/thinking"

Scope Options:

Local (default): Server available only in current project directory
User (recommended): Server available globally, allowing you to access all thinking sessions across projects and build a comprehensive knowledge base

Manual Configuration

Usage with Claude Desktop

Add this to your claude_desktop_config.json:

Using npx (Recommended)

{
  "mcpServers": {
    "think-strategies": {
      "autoApprove": ["think-strategies", "think-tools", "think-session-manager"],
      "disabled": false,
      "timeout": 60,
      "command": "npx",
      "args": [
        "github:aaronsb/think-strategies",
        "--storage-path",
        "/path/to/thinking/storage"
      ],
      "transportType": "stdio"
    }
  }
}

Usage with Cline

Add this to your cline_mcp_settings.json:

Using npx (Recommended)

{
  "mcpServers": {
    "think-strategies": {
      "autoApprove": ["think-strategies", "think-tools", "think-session-manager"],
      "disabled": false,
      "timeout": 60,
      "command": "npx",
      "args": [
        "github:aaronsb/think-strategies"
      ],
      "env": {},
      "transportType": "stdio"
    }
  }
}

Using Node.js

{
  "mcpServers": {
    "think-strategies": {
      "autoApprove": ["think-strategies", "think-tools", "think-session-manager"],
      "disabled": false,
      "timeout": 60,
      "command": "node",
      "args": [
        "/path/to/repo/think-strategies/index.js"
      ],
      "env": {},
      "transportType": "stdio"
    }
  }
}

Using Docker

{
  "mcpServers": {
    "think-strategies": {
      "autoApprove": ["think-strategies", "think-tools", "think-session-manager"],
      "disabled": false,
      "timeout": 60,
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "--user",
        "$(id -u):$(id -g)",
        "-v",
        "/tmp/sequentialthinking-plus-data:/app/data",
        "ghcr.io/aaronsb/think-strategies:latest"
      ],
      "env": {},
      "transportType": "stdio"
    }
  }
}

License

This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License.

Available Tools

3 tools

think-session-managerC

Manage thinking sessions: list with pagination/filtering, search by content, get detailed analysis, or resume previous sessions

ParametersJSON Schema

Name	Required	Default
`action`	Yes
`sessionId`	No
`limit`	No
`offset`	No
`query`	No
`strategy`	No
`includeTopics`	No
`sortBy`	No	timestamp
`completionStatus`	No
`minScore`	No

TDQS

C2.7/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions pagination/filtering for listing and content-based searching, but lacks details on permissions, rate limits, mutation effects (e.g., whether 'resume' modifies sessions), or response formats. For a tool with 10 parameters and multiple actions, this leaves significant behavioral gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that front-loads the core purpose and lists key actions. It avoids redundancy and wastes no words, though it could be slightly more structured (e.g., bullet points) given the complexity of actions and parameters.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (10 parameters, 4 actions, no annotations, no output schema), the description is incomplete. It lacks details on behavioral traits, parameter meanings, output expectations, and differentiation from siblings. The agent would struggle to use this tool effectively without additional context or trial-and-error.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only loosely maps to parameters: 'list with pagination/filtering' hints at 'limit', 'offset', and filtering parameters; 'search by content' hints at 'query'; 'get detailed analysis' and 'resume' hint at 'sessionId'. However, it omits many parameters (e.g., 'strategy', 'includeTopics', 'sortBy', 'completionStatus', 'minScore') and doesn't explain their semantics, failing to adequately compensate for the coverage gap.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose as managing thinking sessions with four specific actions: list, search, get detailed analysis, and resume. It uses specific verbs and identifies the resource as 'thinking sessions,' but doesn't explicitly differentiate from sibling tools like 'think-strategies' or 'think-tools' beyond the general domain.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus the sibling tools 'think-strategies' or 'think-tools.' It lists the available actions but doesn't explain when to choose one action over another or any prerequisites for usage. The agent must infer usage from the action parameter alone.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

think-strategiesB

Core thinking tool for structured problem-solving using 10 reasoning strategies. Choose your strategy (linear, chain_of_thought, react, rewoo, scratchpad, self_ask, self_consistency, step_back, tree_of_thoughts, trilemma) and engage in guided thinking with think→act→reflect workflows. Plan actions with 'plannedActions', integrate results with 'actionResults'. Use think-tools for utilities and think-session-manager for session persistence.

ParametersJSON Schema

Name	Required	Description	Default
`thought`	Yes
`nextThoughtNeeded`	No
`thoughtNumber`	No
`totalThoughts`	No
`strategy`	No
`sessionPurpose`	No
`qualityRating`	No
`action`	No
`observation`	No
`finalAnswer`	No
`plannedActions`	No
`actionResults`	No

TDQS

B3/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'think→act→reflect workflows' and integration with planned actions and results, but lacks critical behavioral details: it doesn't specify whether this tool performs read-only operations or mutations, what happens to session state, whether there are rate limits, authentication requirements, or what the output format looks like. For a complex tool with 12 parameters, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is reasonably concise with three sentences, but could be more front-loaded. The first sentence effectively introduces the core purpose, but the subsequent sentences mix usage guidance and parameter references without clear structural separation. Some phrases like 'engage in guided thinking' are somewhat vague and could be more precise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (12 parameters with nested objects, no output schema, no annotations), the description is inadequate. It doesn't explain the tool's behavioral characteristics, provides minimal parameter guidance, and offers no information about return values or error handling. For a sophisticated thinking tool with workflow capabilities, much more context is needed about how the tool actually operates and what agents should expect.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage and 12 parameters (many complex nested objects), the description provides minimal parameter guidance. It mentions 'strategy' parameter with 10 options and references 'plannedActions' and 'actionResults,' but doesn't explain the purpose or relationships of most parameters like 'thought,' 'qualityRating,' 'finalAnswer,' or the various numeric fields. The description fails to compensate for the complete lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose as 'Core thinking tool for structured problem-solving using 10 reasoning strategies' with specific verbs ('engage in guided thinking') and resources ('think→act→reflect workflows'). It distinguishes from siblings by mentioning 'think-tools for utilities and think-session-manager for session persistence,' though it doesn't fully explain how this tool differs functionally from those siblings beyond being the 'core' tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool ('structured problem-solving') and explicitly names alternatives ('think-tools for utilities and think-session-manager for session persistence'), giving good guidance on tool selection. However, it doesn't specify when NOT to use this tool or provide detailed exclusion criteria, keeping it from a perfect score.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

think-toolsC

Utilities for thinking workflows: connect to MCP servers, execute actions, check status, create branches

ParametersJSON Schema

Name	Required	Description	Default
`action`	Yes
`serverName`	No
`command`	No
`args`	No
`branchId`	No
`branchFromThought`	No
`thought`	No

TDQS

C2.4/5.0

Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions actions like 'connect to MCP servers' and 'execute actions' but doesn't clarify permissions needed, side effects, rate limits, or what 'check status' and 'create branches' entail in terms of behavior. This leaves significant gaps for a tool with multiple potential operations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded with a list of utilities, using a single sentence without unnecessary words. However, it could be more structured by explicitly linking actions to parameters or providing clearer categorization.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of 7 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It doesn't adequately explain how to use the tool, what each action does, or what to expect in return, making it insufficient for effective agent use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage and 7 parameters, the description does not add any meaning beyond the input schema. It lists actions but doesn't explain how parameters like serverName, command, args, branchId, branchFromThought, or thought relate to those actions, failing to compensate for the lack of schema documentation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description lists four utilities (connect to MCP servers, execute actions, check status, create branches) which gives a general idea of what the tool does, but it's vague about the specific verb+resource combinations and doesn't distinguish from sibling tools like think-session-manager or think-strategies. It states 'Utilities for thinking workflows' which is somewhat helpful but lacks specificity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides no guidance on when to use this tool versus its siblings (think-session-manager, think-strategies), nor does it specify contexts or exclusions for its different actions. It merely lists functions without indicating appropriate scenarios or alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.2/5.0

Disambiguation4/5

The three tools have distinct primary purposes: session management, core thinking strategies, and workflow utilities. However, there is some overlap between 'think-strategies' and 'think-tools' regarding action execution and integration, which could cause minor confusion about which tool to use for specific tasks like executing actions or handling results.

Naming Consistency5/5

All tool names follow a consistent 'think-' prefix pattern with descriptive suffixes (session-manager, strategies, tools). This creates a clear, predictable naming convention that helps agents identify the toolset as part of a coherent system.

Tool Count5/5

With 3 tools, this is well-scoped for a thinking strategies server. Each tool serves a distinct functional area (session management, reasoning strategies, utilities), and the count is appropriate for covering the domain without being overwhelming or insufficient.

Completeness4/5

The toolset covers core aspects of structured thinking: strategy selection, session persistence, and workflow utilities. A minor gap exists in direct manipulation of thinking artifacts (e.g., editing or deleting sessions), but the tools support the main think→act→reflect workflows adequately for most agent use cases.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

agentstack-mcp A
io.github.inity13
Deterministic reasoning stack for AI agents: simulate, decide & compute, plus cross-domain tools.
Autonomous Agents Agent Orchestration
241
Reasoning Commons
io.github.chenyuan35
AI Reasoning Cache & Consensus Layer with 11 MCP tools via Streamable HTTP.
AI & Machine Learning Knowledge & Memory Autonomous Agents
2
Hive Consult A
io.github.srotzin
Agent-to-agent reasoning-as-a-service: chain-of-thought, analysis, and decision support.
AI & Machine Learning Autonomous Agents
42
Mindlify
co.mindlify
Turn AI conversations into visual knowledge maps. Create, connect, search, and organize thoughts.
Knowledge & Memory Note Taking
1

Related MCP Servers

MCP Think Tank
Knowledge & Memory Autonomous Agents Agent Orchestration
flight505
A
license
B
quality
D
maintenance
Provides AI assistants with enhanced reasoning capabilities through structured thinking, persistent knowledge graph memory, and intelligent tool orchestration for complex problem-solving.
Updated a year ago (2025-07-14 11:03 UTC)
20
25
61
MIT
CRASH - Cascaded Reasoning
Autonomous Agents Code Analysis Developer Tools
nikkoxgonzales
A
license
A
quality
A
maintenance
Enables structured, iterative reasoning for complex problem-solving with features like confidence tracking, revision mechanisms, and branching support. Provides flexible validation and multiple output formats for systematic analysis and decision-making tasks.
Updated 9 months ago (2025-12-17 15:53 UTC)
1
22
72
MIT
Clear Thought 1.5
Developer Tools Autonomous Agents Code Analysis
waldzellai
A
license
Not graded
quality
F
maintenance
Provides 30+ unified reasoning operations including systematic thinking, mental models, debugging approaches, statistical analysis, interactive notebooks, and advanced problem-solving frameworks for enhanced decision-making and complex reasoning tasks.
Updated 10 months ago (2025-10-20 23:53 UTC)
188
53
MIT
Think MCP
Autonomous Agents Knowledge & Memory Developer Tools
GofMan5
A
license
A
quality
B
maintenance
Enables structured step-by-step reasoning with branching, revisions, and self-critique to help break down complex problems into manageable steps with confidence tracking and thought history search.
Updated a month ago (2026-07-23 15:17 UTC)
7
19
7
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/aaronsb/think-strategies'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Think Strategies MCP Server

Overview

Documentation

Features

Architecture

Core Tools

1. think-strategies (Core Thinking)

2. think-tools (Action-Based Utilities)

3. think-session-manager (Session Operations)

Key Features

Resources

Usage

When to Use Think-Strategies

Strategy Selection Guide

Installation

Prerequisites

Quick Start with npx (Easiest)

Setup with Node.js

Setup with Docker

Using Pre-built Image (Recommended)

Building Locally

Development

Configuration

Using Claude Code CLI (Recommended)

Manual Configuration

Usage with Claude Desktop

Using npx (Recommended)

Usage with Cline

Using npx (Recommended)

Using Node.js

Using Docker

License

Available Tools

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

1. `think-strategies` (Core Thinking)

2. `think-tools` (Action-Based Utilities)

3. `think-session-manager` (Session Operations)