The Sequential Thinking MCP Server enables advanced meta-cognition and dynamic problem-solving through structured thought logging and workflow orchestration:
Dynamic Problem-Solving: Logs AI's internal thoughts and reasoning to guide through complex tasks
Agentic Workflow Orchestration: Breaks tasks into precise, manageable, and traceable steps
Iterative Refinement: Self-corrects and adapts based on step outcomes or new information
Proactive Planning: Manages future tasks using left_to_be_done fields
Tool Recommendations: Suggests specific tools for executing planned actions
Automatic Smart Thinking: Minimizes user input by proactively determining next steps
Thread Management: Organizes thoughts into structured problem-solving threads
Thought Tracking: Uses thought_index to chronologically track and revise reasoning
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@sequential-thinking-mcp think through how to optimize our database queries for the user analytics dashboard"
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.
This repository provides an MCP (Model Context Protocol) server that enables an AI agent to perform advanced meta-cognition and dynamic, reflective problem-solving.
This version of Sequential Thinking is quite different than the original one, as it only forces the agent to virtually log its thoughts and plans, without actually doing anything, except prompting itself. I found it to be sufficient enough for any kind of LLMs.
Related MCP server: Root Signals MCP Server
Advanced Meta-Cognition: Provides a think tool for dynamic and reflective problem-solving through thought logging.
Agentic Workflow Orchestration: Guides AI agents through complex tasks by breaking them into precise, manageable, and traceable steps.
Iterative Refinement: Assesses the success of each step and self-corrects if necessary, adapting to new information or errors.
Proactive Planning: Utilizes left_to_be_done for explicit future state management and task estimation.
Tool Recommendation: Suggests specific tools via tool_recommendation to execute planned actions or gather necessary information.
Python 3.10+
uv (for local development)
Choose one of the following installation methods.
This method is best for using the package as a library or running the server without modifying the code.
Install the package from PyPI:
pip install sequential-thinking-mcpRun the MCP server (default: stdio):
python -m sequential_thinkingThis method is for contributors who want to modify the source code.
Using uv:
Clone the repository:
git clone https://github.com/philogicae/sequential-thinking-mcp.git
cd sequential-thinking-mcpInstall dependencies using uv:
uv sync --lockedRun the MCP server (default: stdio):
uv run -m sequential_thinkingClone the repository (if you haven't already):
git clone https://github.com/philogicae/sequential-thinking-mcp.git
cd sequential-thinking-mcpBuild and run the container using Docker Compose (default port: 8000):
docker compose up --build -dAccess container logs:
docker logs sequential-thinking-mcp -ffrom sequential_thinking import mcp
mcp.run(transport="sse")Usable with any MCP-compatible client. Available tools:
think: Log a thought, plan next steps, and recommend tools.
Configuration:
{
"mcpServers": {
...
# with stdio (only requires uv)
"sequential-thinking-mcp": {
"command": "uvx",
"args": [ "sequential-thinking-mcp" ]
},
# with docker (only requires docker)
"sequential-thinking-mcp": {
"command": "docker",
"args": [ "run", "-i", "-p", "8000:8000", "philogicae/sequential-thinking-mcp:latest", "sequential-thinking-mcp" ]
},
# with sse transport (requires installation)
"sequential-thinking-mcp": {
"serverUrl": "http://127.0.0.1:8000/sse"
},
# with streamable-http transport (requires installation)
"sequential-thinking-mcp": {
"serverUrl": "http://127.0.0.1:8000/mcp" # not yet supported by every client
},
...
}
}See CHANGELOG.md for a history of changes to this project.
Contributions are welcome! Please open an issue or submit a pull request.
This project is licensed under the MIT License - see the LICENSE file for details.
Logs a thought step for agentic problem-solving, tracking reasoning, tools, and future plans. Start a new thread for each user message.
Workflow Orchestration: Breaks complex tasks into manageable steps.
Iterative Refinement: Self-corrects based on new info or errors.
Tool Recommendation: Suggests specific tools for the next action.
Forward Planning: Tracks remaining tasks via left_to_be_done.
Args: thread_purpose: Short objective/topic for the thread. thought: Current reasoning or action description. thought_index: Monotonically increasing step number (1, 2, 3...). tool_recommendation: Tool to call next, or 'None'. left_to_be_done: Remaining steps/sub-goals, or 'None'. Returns: Confirmation of log.
User: "I keep hearing about central banks, but I don't understand what they are and how they work."
think( thread_purpose="Explain Central Banks", thought="The user needs a comprehensive explanation of central banks. I need to identify their core definition, key roles (monetary policy, financial stability, currency issuance), and operational mechanisms (interest rates, reserves). I should search for a structured overview to ensure I don't miss major aspects like the Federal Reserve or ECB as examples.", thought_index=1, tool_recommendation="search_web", left_to_be_done="1. Search for 'how central banks work' and key functions. 2. Synthesize findings into a clear explanation. 3. Create a visual graph of the banking system structure if possible. 4. Present final answer." )
call search_web(query="how central banks work and their main functions")
think( thread_purpose="Explain Central Banks", thought="Search results clarify that central banks manage currency stability, control inflation via interest rates, and act as lenders of last resort. I have enough textual information. Now, to make this easier to understand, I should create a graph representing the flow of money and influence between the central bank, commercial banks, and the economy.", thought_index=2, tool_recommendation="create_graph", left_to_be_done="Create a graph showing Central Bank -> Commercial Banks -> Public/Economy relations." )
call create_graph(data=...)
Final Response: "Here is an explanation of central banks..." (Task complete, no further think call needed).
| Name | Required | Description | Default |
|---|---|---|---|
| thread_purpose | Yes | ||
| thought | Yes | ||
| thought_index | Yes | ||
| tool_recommendation | No | None | |
| left_to_be_done | No | None |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It explains the tool's behavior: it logs reasoning steps, tracks `left_to_be_done`, and returns a confirmation. It does not mention side effects, but given its logging nature, none are expected. The description fully discloses what the tool does without contradicting any annotations (none present).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is somewhat long but well-structured, with a clear opening sentence, bullet-point capabilities, an Args list, and a detailed example. Every section adds value, and the core purpose is front-loaded. While the example is extensive, it aids understanding for an orchestration tool. Minor redundancy could be trimmed, but overall it is efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no siblings, no annotations, and an output schema present, the description covers all necessary aspects: purpose, parameters, usage example, and return value ('Confirmation of log'). It explains the workflow context and includes common patterns. The tool is fully contextualized for an AI agent to use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
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. The 'Args' section provides clear meanings for all five parameters: `thread_purpose` as short objective, `thought` as current reasoning, `thought_index` as step number, `tool_recommendation` as next tool, and `left_to_be_done` as remaining steps. This adds significant value beyond the raw schema, though examples could be more concisely integrated.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Logs a thought step for agentic problem-solving, tracking reasoning, tools, and future plans.' It uses a specific verb ('Logs') and resource ('thought step'), and distinguishes itself from any potential siblings by detailing its unique role in workflow orchestration. No tautology or misleading information.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'Start a new thread for each user message.' It outlines capabilities (Workflow Orchestration, Iterative Refinement, etc.) that imply when the tool should be used. Although it does not specify when not to use it, the example clearly demonstrates a typical workflow. With no sibling tools, the guidance is adequate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.3.0think7 fields changedInput schema / properties / left_to_be_done / titleRemoved value: -"Left To Be Done"Input schema / properties / thought / titleRemoved value: -"Thought"Input schema / properties / thought_index / titleRemoved value: -"Thought Index"Input schema / properties / thread_purpose / titleRemoved value: -"Thread Purpose"Input schema / properties / tool_recommendation / titleRemoved value: -"Tool Recommendation"Output schema / properties / result / titleRemoved value: -"Result"Output schema / titleRemoved value: -"_WrappedResult"v1.0.0thinkOnly one tool exists, so there is no possibility of confusion with other tools. The tool's purpose is clearly unique.
With a single tool named 'think', there is no inconsistency. The name is a clear verb describing the action.
One tool is perfect for this server's focused purpose—tracking reasoning steps. It fits seamlessly into larger agent workflows without unnecessary complexity.
The tool fully covers the intended functionality: logging thought steps. No additional operations are needed for the given domain.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Hugging Face Hub MCP — models, datasets, spaces
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/philogicae/sequential-thinking-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
