# Sequential Thinking [Verified] [Health: Active]

**Category:** 🧠 Knowledge & Memory  
**Repository:** https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking  
**GitHub Stars:** 91814  
**npm Downloads (last month):** 653528  
**Views:** 12  
**Installs:** 3  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/sequential-thinking

## Description
Dynamic and reflective problem-solving through thought sequences.

## Tools
Capabilities this server exposes over MCP:

- **thought**
- **nextThoughtNeeded**
- **thoughtNumber**
- **totalThoughts**
- **isRevision**
- **revisesThought**
- **branchFromThought**
- **branchId**
- **needsMoreThoughts**

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "sequential-thinking": {
    "command": "npx",
    "args": ["-y","@modelcontextprotocol/server-sequential-thinking"]
  }
}
```

## Documentation

## What Sequential Thinking does

Sequential Thinking adds a structured reasoning workflow to an MCP host. It does not connect to a database, SaaS API, or external knowledge source; instead, it receives thinking steps from the host and maintains their sequence during the connection. The workflow is useful when a task benefits from decomposition, explicit course correction, or comparison of multiple possible approaches.

Typical applications include planning a database migration, investigating a deployment failure, comparing architecture options, and working through problems whose full scope is unclear at the start. The host can ask the model to use the tool rather than requiring a developer to issue raw tool calls manually.

## How it works

The server exposes a `sequential_thinking` tool. Each call carries the current thought, its number, an estimate of the total number of thoughts, and a flag indicating whether another step is needed. The host may call the tool repeatedly as the model progresses.

A later call can revise an earlier thought by identifying the thought being reconsidered. Reasoning can also split from a selected point into a named branch, allowing alternative paths to be explored. The estimated total can change as the task becomes clearer, and `needsMoreThoughts` can indicate that additional work is required.

Thought history lasts only as long as the client connection, and the server supports both the 2026-07-28 discovery flow and the 2025-era initialization flow over stdio. When connected correctly, an MCP tool list or inspector should show repeated calls with fields such as `thought`, `thoughtNumber`, `totalThoughts`, and `nextThoughtNeeded`.

## Setup and configuration

Node.js 24 or later is required when running through `npx` or from source. The package is published as `@modelcontextprotocol/server-sequential-thinking`.

For an MCP host that supports stdio, run it with:

```json
{
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
}
```

On Windows, launch the same command through `cmd /c`. A Docker option is also available:

```json
{
  "command": "docker",
  "args": ["run", "--rm", "-i", "mcp/sequentialthinking"]
}
```

Claude Desktop uses an `mcpServers` entry, while VS Code uses a `servers` entry in its user configuration or workspace `.vscode/mcp.json`. Codex CLI can register the package with `codex mcp add sequential-thinking npx -y @modelcontextprotocol/server-sequential-thinking`.

Set `DISABLE_THOUGHT_LOGGING` to `true` to disable logging of thought information. After installation, restart or reload the host, confirm that the tool is listed, and ask it to solve a non-trivial problem step by step.

## Tools and capabilities

The server provides one MCP tool, `sequential_thinking`, with these controls:

- `thought`: the current reasoning step.
- `thoughtNumber` and `totalThoughts`: position and estimated scope of the sequence.
- `nextThoughtNeeded`: whether the sequence should continue.
- `isRevision` and `revisesThought`: correction of an earlier step.
- `branchFromThought` and `branchId`: exploration of an alternative reasoning path.
- `needsMoreThoughts`: indication that further analysis is needed.

These controls support stepwise decomposition, plan refinement, hypothesis generation and checking, filtering of irrelevant information, and analysis that requires maintaining context across several calls.

## Limitations and notes

The tool is intended to be used through an MCP-aware host. Direct manual calls are generally unnecessary unless the client exposes raw MCP tool invocation. It provides a process for organizing reasoning; it does not supply domain data or independently validate the conclusions produced by the model. Its retained thought history ends when the client connection ends.

The included configurations use stdio transport. Docker requires an available `mcp/sequentialthinking` image, while the `npx` path requires Node.js 24 or later. The project is licensed under the MIT License.

_Full upstream README: https://allmcps.com/mcp/sequential-thinking/readme_