# Sequential Thinking — MCP Server

> Give a model a scratchpad it can revise and branch mid-problem.

**Source:** https://mcpplaygroundonline.com/mcp-servers/sequential-thinking  
**Transport:** stdio  
**Requires auth:** No

---

## What it does

Most tools give a model access to something outside itself. This one gives it structure. The server exposes a single sequentialthinking tool that a model calls repeatedly, each call recording one numbered thought. Crucially, the model is not locked into its first plan: it can raise the total number of steps mid-way, mark a call as a revision of an earlier thought, or branch from a specific step to explore an alternative line and come back. The server itself does no reasoning — it stores the thought chain, formats it, and returns state on every call, which is what keeps the model honest about where it is in the problem. It is most useful for planning, design and multi-step debugging, where the shape of the problem is not clear at the start.

## Tools exposed

- sequentialthinking — record one numbered step of reasoning and get the chain state back
- thought / thoughtNumber / totalThoughts — the step itself and its place in the sequence
- nextThoughtNeeded — the model signals whether it wants to keep going
- isRevision / revisesThought — rewrite an earlier step after learning something
- branchFromThought / branchId — explore an alternative path without losing the original
- needsMoreThoughts — extend the plan past the original estimate mid-problem

## Example queries you can run

- "Think through how to migrate this service to a new database without downtime."
- "Work step by step through why these two test failures might share a root cause."
- "Plan a rollout for this feature, then revise the plan for a 10x traffic spike."
- "Compare three architectures for this problem, branching on each before deciding."

## Details

- **Recommended model:** openai/gpt-5.4 — The server earns its keep with capable non-reasoning models, which gain the most structure from it. Native reasoning models often duplicate what it provides.
- **Transport:** stdio
- **Authentication:** Not required — No credentials and no network access. The server only stores and formats the thought chain the model sends it.
- **Official source:** [Sequential Thinking — official reference implementation](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking)

## Connecting to Sequential Thinking

### Environment variables

- `DISABLE_THOUGHT_LOGGING` — Set to true to stop the server printing formatted thoughts to stderr. Useful when the log noise clutters your client.

### Client configuration

**npx (recommended)**

No install step — npx fetches the published package on first run.

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

**Docker**

Same server, pinned image, no Node toolchain on the host.

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

## Frequently asked questions

### What is the sequential thinking MCP server?

It is an official reference server from the Model Context Protocol project, published as @modelcontextprotocol/server-sequential-thinking. It gives a model an external scratchpad for step-by-step problem solving, with the ability to revise earlier steps and branch into alternatives.

### Does it make the model smarter?

It does not add reasoning capability — the server performs no inference at all. What it adds is structure and persistence: the chain is visible, revisable and survives across turns, which measurably helps models that do not have strong native planning.

### Is it redundant with reasoning models?

Largely, for a single hard question. Models with native extended thinking already decompose internally. The server still earns its place when you want the reasoning chain to be inspectable and revisable as an artefact rather than hidden inside the model.

### Does it need an API key or internet access?

Neither. It runs locally over stdio, holds the thought chain in memory for the session, and never makes a network call. That also means nothing persists once the process exits.

### How do I stop it flooding my logs?

Set DISABLE_THOUGHT_LOGGING to true in the server environment. By default it prints each formatted thought to stderr, which is useful while you are learning how a model uses it and noisy afterwards.

---

_Test this server across 40+ models on MCP Playground: https://mcpplaygroundonline.com/mcp-servers/sequential-thinking — free, no install._