---
title: "Sequential Thinking MCP Server: Step-by-Step Reasoning"
url: "https://mcpshelf.co/servers/sequential-thinking"
description: "The reference Sequential Thinking server gives a model a scratchpad for numbered, revisable thoughts and branches. What it does, the npx config, our test."
updated: "2026-10-27"
site: "MCP Shelf"
---

# Sequential Thinking

> A numbered scratchpad the model fills in, revises and branches while it works.

## At a glance

Sequential Thinking is one of the reference servers kept by the Model Context Protocol project. It has a single tool, and that tool does no outside work at all: the model writes one thought per call, says how many it expects to need, and can go back to revise an earlier thought or fork off a branch to try another idea.

What you get is structure. The model commits to a plan in visible steps, which tends to help on long debugging sessions, migrations and design choices where the first idea is often wrong. On short questions it only adds calls, so leave it to the model to decide when to use it.

|  |  |
| --- | --- |
| Made by | The Model Context Protocol project (reference server) |
| GitHub | https://github.com/modelcontextprotocol/servers |
| npm package | [@modelcontextprotocol/server-sequential-thinking](https://www.npmjs.com/package/@modelcontextprotocol/server-sequential-thinking) 2.0.0 (19 Oct 2026) |
| GitHub stars | 91.6K |
| Downloads | 169.3K a week |
| Last commit | 25 Oct 2026 |
| Tools | 1 |
| Runs on | Your computer |
| Install check | Started in our test |
| Category | [Agent helpers and desktop control](https://mcpshelf.co/categories/agents-and-automation) |

**Our check:** We ran this exact config on 27 Oct 2026: it started and answered with 1 tools. The shared database pointed at @modelcontextprotocol/server-everything, a test server from the same repository. The Sequential Thinking package is @modelcontextprotocol/server-sequential-thinking, and its npm entry links back to modelcontextprotocol/servers.

## Tools

We listed 1 tools on 27 Oct 2026. 0 only read; the rest can change things or run commands.

| Tool | Kind | What it is for |
| --- | --- | --- |
| `sequentialthinking` | changes | Records one numbered thought, with the expected total, and lets the model revise an earlier thought or branch off to try another line of reasoning. |

### How clearly it describes its tools

1 of 1 tools have a description and 1 of 1 say whether they change things. The tool list takes at least ~800 tokens of context. Every tool says whether it only reads or can change things, so a client can ask before the risky ones.

## Set it up

### Claude Desktop

Where: claude_desktop_config.json (Settings → Developer → Edit Config)

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

### Claude Code

Where: Your terminal, in the project folder

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

### Cursor

Where: ~/.cursor/mcp.json, or .cursor/mcp.json in a project

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

### VS Code

Where: .vscode/mcp.json in your project

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

### Windsurf

Where: ~/.codeium/windsurf/mcp_config.json

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

### ChatGPT

Where: Not supported

ChatGPT only connects to remote servers by URL. This one runs on your computer, so use Claude, Cursor or VS Code.

Set "DISABLE_THOUGHT_LOGGING": "true" in env if you do not want each thought printed to the server log.

## Settings

| Setting | Kind | Required | What it does |
| --- | --- | --- | --- |
| `DISABLE_THOUGHT_LOGGING` | env | no | Stops the server printing each thought to its log (stderr). Handy when your client shows server logs and you only want the answer. Example: `true` |
| `mcp/sequentialthinking` | config | no | The Docker image of the same server, for people who would rather not run npx. Start it with docker run --rm -i mcp/sequentialthinking. |

## What it can touch

**It can read**

- Nothing outside the conversation: it only keeps the thoughts the model sends it

**It can change**

- Nothing on your machine or online. The thought history lives in memory and ends when the client disconnects

**Safer setup:** There is little to lock down. If you want fewer tool calls, say in your prompt when step-by-step thinking is worth it.

## Before you start

- Node.js 24 or newer (the package asks for it)
- Nothing else: no account, key or network access

## Good for

- Planning work with many steps, such as a migration or a refactor
- Debugging where the cause is not obvious and the plan will change
- Seeing how a model reached an answer, one thought at a time

## If it does not work

**npx warns about the Node.js version or the server will not start**
Version 2 of the package asks for Node.js 24 or newer. Update Node, or run the Docker image instead.

**On Windows the client says it cannot find npx**
Use "command": "cmd" with "args": ["/c", "npx", "-y", "@modelcontextprotocol/server-sequential-thinking"].

**The tool is listed but the model never calls it**
Ask for it: phrases like "think this through step by step" or "plan it, then revise the plan if an assumption fails" usually trigger it.

## Similar servers

| Server | Tools | Runs on | Stars |
| --- | --- | --- | --- |
| [Windows-MCP](https://mcpshelf.co/servers/windows-mcp) | 21 | Your computer | 10.4K |
| [Mobile MCP](https://mcpshelf.co/servers/mobile-mcp) | 34 | Your computer | 10K |
| [Container Use](https://mcpshelf.co/servers/container-use) | 15 | Your computer | 4.1K |

## Questions

### Does Sequential Thinking make the model smarter?

Not by itself. It gives the model a place to lay out steps and correct them, which helps on long, messy problems. The thinking is still the model's own.

### Is it worth it with models that already reason internally?

Less than it used to be. Its main value now is that the steps are visible to you and can branch, which makes long plans easier to follow and check.

### Does it send my data anywhere?

No. It makes no network calls and stores nothing on disk; the thoughts exist only while the client is connected.

### Who maintains it?

It is one of the reference servers in the modelcontextprotocol/servers repository, kept by the Model Context Protocol project, and it is MIT licensed.

Full docs on GitHub: https://github.com/modelcontextprotocol/servers

---

From [MCP Shelf](https://mcpshelf.co/): A short shelf of MCP servers that are worth installing. Index for agents: https://mcpshelf.co/llms.txt

