# Sequential Thinking MCP: Step-by-Step Reasoning

URL: https://research-memex.org/docs/toolkit/sequential-thinking-mcp
Description: A deep dive into using the Sequential Thinking MCP to add step-by-step reasoning capabilities to any AI model for complex research tasks.



*Visible reasoning is the only reasoning you can trust and correct.*

<ToolMeta slug="sequential-thinking-mcp" runtime="Node.js via npx" />

Maintained by [Model Context Protocol](https://modelcontextprotocol.io/); the official monorepo entry is [modelcontextprotocol/servers/src/sequentialthinking](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking), distributed as [`@modelcontextprotocol/server-sequential-thinking`](https://www.npmjs.com/package/@modelcontextprotocol/server-sequential-thinking).

Why it's here: This canonical step-by-step reasoning MCP pairs with [Lotus Wisdom](/docs/toolkit/lotus-wisdom-mcp) and is bundled in the [Interpretive Orchestration Plugin](/docs/toolkit/interpretive-orchestration-plugin), where it powers `/qual-think-through`.

## Why it matters [#why-it-matters]

The Sequential Thinking MCP adds a structured, revisable reasoning tool to any AI model, including models without built-in thinking modes. Use it when you want the model to break down a problem, revise earlier steps, or branch into alternatives. The tool makes the reasoning process inspectable.

## The tool [#the-tool]

The server exposes one tool, `sequential_thinking`. Each call carries a single step and declares whether another is needed.

<KeyTable>
  | Field                             | What it carries                                                         |
  | --------------------------------- | ----------------------------------------------------------------------- |
  | `thought`                         | The current thinking step                                               |
  | `thoughtNumber` / `totalThoughts` | Position in the chain, and the running estimate of how long it will run |
  | `nextThoughtNeeded`               | Whether the chain continues                                             |
  | `isRevision` / `revisesThought`   | Marks a step that reconsiders an earlier one                            |
  | `branchFromThought` / `branchId`  | Forks an alternative line of reasoning                                  |
  | `needsMoreThoughts`               | Extends the estimate mid-chain                                          |
</KeyTable>

You do not call the tool by hand. You connect the server to a host and ask the model to work a problem through; the host decides to invoke it, repeatedly, as it goes. The estimate is the interesting part: `totalThoughts` is a guess the model is allowed to revise, so watching it climb, or watching a `revisesThought` appear, is how you tell the reasoning is genuinely changing course rather than performing a fixed script.

Set `DISABLE_THOUGHT_LOGGING=true` in the server's environment if you would rather the steps not be written to the host's log.

## When to use Sequential Thinking [#when-to-use-sequential-thinking]

* Complex theoretical analysis: breaking down multi-layered arguments
* Methodology development: step-by-step research design
* Literature synthesis: systematic comparison of multiple frameworks
* Problem-solving: when you need to see the AI's "work"

## How to access in Cherry Studio [#how-to-access-in-cherry-studio]

1. Start a conversation with any model
2. Click the Tools icon at the bottom of the input box. Hover to reveal the MCP label, then click to open the MCP panel.
3. Select "Sequential Thinking"
4. Describe your complex task in detail
5. Watch the AI think through each step

## Models we've tested [#models-weve-tested]

<Aside label="NOT A LEADERBOARD">
  These notes come from practical use, not a universal leaderboard. Try different models against your own research tasks.
</Aside>

* Kimi K2.7 / K2.6: Works well for critical challenge, coding-adjacent review, and exploratory reasoning chains.
* GLM-5.2: Strong for coding-adjacent and systematic long-context reasoning, especially when paired with explicit step constraints.
* Regular non-reasoning models: Can gain a visible scratchpad and revision loop from the MCP tool.
* Frontier reasoning models: May still benefit when you want tool-visible reasoning steps rather than an opaque internal trace.

## Example use cases [#example-use-cases]

```
Sequential Thinking MCP Prompt:
"Analyze the theoretical tensions between agency theory and
stewardship theory in corporate governance literature.
I need a step-by-step comparison covering:
1. Core assumptions about human behavior
2. Implications for board structure
3. Empirical evidence quality
4. Integration possibilities"
```

Result: The AI works through each step methodically, showing its reasoning and building toward a comprehensive analysis.

## Tips for effective Sequential Thinking [#tips-for-effective-sequential-thinking]

* Be specific: Clearly outline the steps you want
* Set context: Provide relevant background information
* Use iteratively: Build on previous reasoning steps
* Use model-appropriate controls: Prefer each provider's current reasoning or thinking settings; change temperature only when that model supports it.
* Document insights: Save reasoning chains for later reference

## Host support [#host-support]

A stdio MCP server distributed via npm: install once, run from any MCP client.

<HostSupport
  rows="[
{ host: 'Claude Code (CLI / Desktop)', status: 'full', note: 'claude mcp add sequential-thinking -- npx -y @modelcontextprotocol/server-sequential-thinking' },
{ host: 'Codex CLI', status: 'full', note: 'codex mcp add sequential-thinking npx -y @modelcontextprotocol/server-sequential-thinking' },
{ host: 'Claude Desktop (chat)', status: 'full', note: 'claude_desktop_config.json' },
{ host: 'Cursor / VS Code / Windsurf', status: 'full', note: 'VS Code keys the config on `servers`, not `mcpServers`' },
{ host: 'Cherry Studio, Witsy, other MCP clients', status: 'full', note: 'Standard stdio MCP config' },
]"
/>

The config shapes are in Install below.

## Install [#install]

One npm package, fetched on demand. Add it to your host's MCP config:

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

That shape covers Claude Desktop (`claude_desktop_config.json`), Cherry Studio, and most MCP clients. On Windows, launch `npx` through the shell: set `"command": "cmd"` and put `"/c"` at the front of the args.

VS Code keys the same server on `servers` rather than `mcpServers`, in either your user `mcp.json` (Command Palette, then `MCP: Open User Configuration`) or a workspace `.vscode/mcp.json`.

Codex CLI registers it in one line:

```bash
codex mcp add sequential-thinking npx -y @modelcontextprotocol/server-sequential-thinking
```

An official Docker image is published too, if you would rather not run `npx`:

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

Resources:

* GitHub: [modelcontextprotocol/servers/src/sequentialthinking](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking) (official MCP servers monorepo)
* npm: [`@modelcontextprotocol/server-sequential-thinking`](https://www.npmjs.com/package/@modelcontextprotocol/server-sequential-thinking)
* Smithery: [listing for one-click install into supported clients](https://smithery.ai/server/@modelcontextprotocol/server-sequential-thinking)
* Official docs: [Model Context Protocol](https://modelcontextprotocol.io/)

See also: [Lotus Wisdom MCP](/docs/toolkit/lotus-wisdom-mcp) for contemplative problem-solving.