Sequential Thinking MCP: Step-by-Step Reasoning

Keep an explicit problem-solving record you can inspect and revise.

Maintained by Model Context Protocol (opens in a new tab); the official monorepo entry is modelcontextprotocol/servers/src/sequentialthinking (opens in a new tab), distributed as @modelcontextprotocol/server-sequential-thinking (opens in a new tab).

Current source version: 2.1.1 (opens in a new tab)

Version 2.1.1 was published to npm on November 4, 2026. It requires Node.js 24 or newer. This also applies when another plugin launches the unversioned package for you; an older plugin's own runtime minimum may no longer be sufficient.

Why it's here: This canonical step-by-step reasoning MCP is an optional companion to Lotus Wisdom. Interpretive Orchestration no longer bundles it; /qual-think-through now asks the model to write its steps in the conversation.

Why it matters

The canonical server keeps its record in process memory. If you need to retrieve steps after the process exits, consider Durable Thinking, a separate server with persistent Cloudflare storage. It requires its own deployment and data-handling decisions.

The Sequential Thinking MCP provides a structured, revisable record for models that can call it through their host. Use it to state assumptions, compare alternatives, and revise an explanation. These are model-authored tool outputs, not access to the model's hidden internal reasoning. Inspect their evidence and conclusions rather than treating a visible sequence as proof of how the model reached its answer.

In October 2026, the author reported using this tool less and Lotus Wisdom more, after encountering friction in some model/host combinations. That experience does not establish a universal block or its technical cause.

The tool

The server exposes one tool, sequentialthinking (without an underscore). Each call carries a single step and declares whether another is needed.

You do not call the tool by hand. Connect the server to a host and ask the model to work through a problem using it. The model can revise totalThoughts or use revisesThought to mark a changed step. Those fields make the written record easier to inspect; they do not prove that the model's internal reasoning changed.

In the current source, nextThoughtNeeded remains required. The schema accepts booleans and the strings "true" and "false". The server reports its version from package metadata.

The tool remains stateful: each accepted call appends to its history in memory, including repeated calls. It is not idempotent. It has a display title and returns structured output alongside its JSON text. Version 2 supports both MCP 2026-07-28 discovery and legacy 2025 initialization over stdio. History and branches last for the client's connection, not across restarts. Version 2.1.1 defaults MAX_THOUGHT_HISTORY to 1,000; it evicts the oldest records and branch entries beyond that limit. Configure a positive integer in the server environment when a different bounded history is needed.

Version 2 also changes client-facing errors and schemas: messages larger than 10 MiB close the stdio connection, unknown tool names return JSON-RPC -32602, and tool schemas declare JSON Schema 2020-12. Check the upstream changelog (opens in a new tab) before upgrading a custom client. The executing source still names the tool sequentialthinking, even where README prose uses an underscore.

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

• 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

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

• 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

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

• 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

The tested-model examples above are historical experience, not a current access guarantee. Check each provider's lifecycle notices; Moonshot restricts K2-series access for new direct-API accounts and expects deprecation in late December 2026 (opens in a new tab).

Host support

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

The config shapes are in Install below.

Install

Install Node.js 24 or newer with npm and make npx available on the host's PATH. Check node --version in that environment; a GUI host may not inherit your terminal's path. The package is fetched on demand. Add it to your host's MCP config:

{
  "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:

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

The Docker Hub mcp/sequentialthinking:latest tag still pointed to a May 2025 image when checked October 19, 2026. It is not evidence of the current npm 2.1.1 release. Use the npm route above for the reviewed version; do not infer a container release from a current source Dockerfile. Check the image tags (opens in a new tab) before choosing a container route.

Resources:

• GitHub: modelcontextprotocol/servers/src/sequentialthinking (opens in a new tab) (official MCP servers monorepo)
• npm: @modelcontextprotocol/server-sequential-thinking (opens in a new tab)
• Official docs: Model Context Protocol (opens in a new tab)

See also: Lotus Wisdom MCP for contemplative problem-solving.