Sequential Thinking MCP

Sequential Thinking MCP is the official reference MCP server that gives an AI model one tool for working through a problem as numbered thoughts it can revise or branch. It runs on your machine over stdio with npx or Docker, needs no API key, and is free. The server only records each step: the model does the thinking.

Quick facts (as of October 5, 2026)

What it does

The README describes it as "an MCP server implementation that provides a tool for dynamic and reflective problem-solving through a structured thinking process." It lists five things the tool lets a model do:

• Break down complex problems into manageable steps
• Revise and refine thoughts as understanding deepens
• Branch into alternative paths of reasoning
• Adjust the total number of thoughts dynamically
• Generate and verify solution hypotheses

In normal use you do not call the tool yourself (the README's one exception is a client that exposes raw tool calls). The README says to connect the server to an MCP client and ask the model to think through a problem step by step, and the client "can then decide to call the tool one or more times while it works." If MCP is new to you, start with how MCP servers work.

How it works under the hood

The source is short, and reading it answers the most common question about this server: what does it actually do with a thought?

1. The model calls the tool with the text of one thought, its number, an estimate of how many thoughts it will need, and whether another thought is needed.
2. If the thought number is higher than the estimate, the server raises the estimate to match.
3. The server adds that thought to a list held in memory. If the call includes both a branch point and a branch ID, it also files the thought under that branch ID.
4. Unless logging is turned off, the server prints the thought in a formatted box to stderr, labeled as a thought, a revision or a branch.
5. The server returns a small JSON status object. It does not return the thought text.

That is the whole loop. Nothing in the source calls a language model or an outside service, and the tool is annotated as read-only and closed-world (readOnlyHint: true, openWorldHint: false). The reasoning stays in the model's own tool calls. The server's job is to give the model a structured place to write each step, plus a long tool description that tells it how to behave: start with an estimate, question or revise earlier thoughts, mark branches, form a hypothesis, verify it, and only set nextThoughtNeeded to false "when truly done and a satisfactory answer is reached."

What the server sends back

The tool and its parameters

Two details from the source that the README leaves out. The number fields must be whole numbers of 1 or more, and the code also accepts numbers and true or false sent as strings. And needsMoreThoughts is accepted and stored, but nothing in the server code acts on it.

Is the tool called sequential_thinking or sequentialthinking?

Both names appear in official material. The README documents the tool as sequential_thinking. The code on the main branch, the npm build of version 2026.8.31 and the Docker Hub page all use sequentialthinking, with no underscore. If you write a tool allowlist, a permission rule or a prompt that names the tool, copy the name your client shows in its tool list.

Install and setup

Sequential Thinking is a local MCP server: your client launches it as a command and talks to it over stdio. There is no hosted endpoint in the README.

Claude Desktop

Add this to claude_desktop_config.json:

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

On Windows, the README sets "command": "cmd" and starts the args with "/c", "npx". The entry name is a label you choose: the README uses sequential-thinking, and the generated configs near the top of this page use sequential-thinking-mcp.

VS Code

The README offers one-click install buttons and two manual routes: run MCP: Open User Configuration from the Command Palette to edit your user mcp.json, or add a .vscode/mcp.json file to a workspace so the setup can be shared. VS Code uses a servers key:

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

Codex CLI

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

Claude Code

The server README has no Claude Code section. Claude Code's own docs give the pattern for any stdio server, claude mcp add [options] <name> -- <command> [args...], which makes the command:

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

By default this is saved at local scope, which loads only in the current project. Add --scope user to make it available in all your projects. claude mcp get sequential-thinking shows whether it connected. For more options, see our guide to Claude Code MCP servers.

Cursor

The server README has no Cursor section either. Cursor's docs say to create .cursor/mcp.json in a project or ~/.cursor/mcp.json in your home directory, with an mcpServers block:

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

Cursor's field table lists type as required for stdio servers, although its own Node.js example leaves it out, so it is included here. We also keep a list of other Cursor MCP servers.

Turning off thought logging

By default every thought is printed to the server's stderr stream. To stop that, set the environment variable DISABLE_THOUGHT_LOGGING to true. In a JSON config that means adding an env block:

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

In Claude Code, pass it with --env after the server name and before the --:

claude mcp add sequential-thinking --env DISABLE_THOUGHT_LOGGING=true -- npx -y @modelcontextprotocol/server-sequential-thinking

How to check it is working

The README gives a four-step check:

1. Restart or reload the client so it reconnects to the server.
2. Confirm the tool appears in the client's MCP tool list or inspector.
3. Ask for a non-trivial problem to be solved step by step.
4. Verify that the client calls the tool several times instead of giving a one-shot answer.

In the tool activity you should see repeated calls with thought, thoughtNumber, totalThoughts and nextThoughtNeeded. When the reasoning changes course you may also see isRevision, revisesThought, branchFromThought or branchId.

Example prompts from the README:

• "Plan a database migration from PostgreSQL 14 to 16, list risks, and revise the plan if downtime exceeds 5 minutes."
• "Debug why this deployment only fails in production and show your reasoning step by step."
• "Compare three architecture options for a file sync engine and branch if one assumption turns out to be wrong."

When it helps, and when it may not

The README says the tool is designed for:

• Breaking down complex problems into steps
• Planning and design with room for revision
• Analysis that might need course correction
• Problems where the full scope might not be clear initially
• Tasks that need to maintain context over multiple steps
• Situations where irrelevant information needs to be filtered out

What the README does not give is any measurement of how much the tool improves answers. Two things are worth weighing before you add it:

• Every thought is a separate tool call. A ten-step chain is ten round trips between the model and the server, each one adding to the conversation.
• Some models have a built-in reasoning feature. Anthropic's engineering article on its separate "think" tool (a different, simpler tool than this server) was updated on December 15, 2025 to say that extended thinking has improved enough that Anthropic recommends it "instead of a dedicated think tool in most cases." That guidance is not about Sequential Thinking MCP, but it is a fair reason to compare your results with and without the server.

A reasonable way to decide: run the same hard planning or debugging prompt with the server on and off in your own client, and keep it only if the step-by-step calls give you answers or visibility you would not get otherwise.

Who maintains it and how it is licensed

The server lives in modelcontextprotocol/servers. That repository's README says it houses "the small number of reference servers maintained by the MCP steering group" and closes with "Managed by Anthropic, but built together with the community."

The npm metadata changed in 2026. Releases up to 2025.12.18 list Anthropic, PBC as the author and MIT as the license. The two 2026 releases, 2026.7.4 and 2026.8.31, list the author as "Model Context Protocol a Series of LF Projects, LLC." and the license as "SEE LICENSE IN LICENSE".

On licensing, the repository README says the project is under the Apache License 2.0 for new contributions, with existing code under MIT, while the server's own README still says MIT. If the license matters for your use, read the LICENSE file in the repository.

Limitations and things to watch

• It records thoughts. It does not produce them. The quality of the reasoning depends on your model.
• Nothing is saved. Thoughts live in an in-memory list inside the server process. The source has no code that writes them to disk, so they are gone when the process stops.
• The model cannot read the list back. There is one tool, and its response holds counters and branch IDs, not earlier thought text.
• The history is never reset. The source has no reset step, so thoughtHistoryLength keeps counting for as long as the same server process runs.
• Thought text goes to stderr by default. If your client keeps MCP server logs, your thoughts may end up in them. Use DISABLE_THOUGHT_LOGGING if that matters.
• The prebuilt Docker image is older than the npm package. Docker Hub shows a single latest tag last pushed on May 2, 2025, and names the commit it was built from. The source at that commit does not contain DISABLE_THOUGHT_LOGGING, so that setting may not work in the prebuilt image. Building the image from the repository avoids the question.
• It is a reference implementation. The repository warns that its servers are "educational examples for developers building their own MCP servers, not as production-ready solutions."
• Two tool names. See the naming note above.

Sequential Thinking vs the Memory server

The same repository has a Memory reference server, and the two are easy to confuse. They do different jobs.

If what you want is for the assistant to remember facts between sessions, see the Memory MCP server instead.

Pros and cons

Pros

• Free, with no account and no API key in the documented setup.
• One command to install, with official instructions for Claude Desktop, VS Code and Codex CLI.
• Small and easy to audit: one tool, read-only, no outside calls in the source.
• Makes a model's steps visible as numbered tool calls, including revisions and branches.
• Kept in the official reference repository, with an npm release on August 31, 2026.

Cons

• Adds a tool call for every thought.
• No published evidence in the README of how much it improves results.
• No persistence and no way for the model to read earlier thoughts back from the server.
• The README and the code disagree on the tool name.
• The prebuilt Docker image dates from May 2025.
• Described by its own repository as a reference implementation, not a production-ready one.

Who it is for

A good fit if:

• You want a model to plan, debug or compare options in explicit numbered steps that you can watch in the tool log.
• You use a client or model without its own reasoning controls and want a structured alternative.
• You are learning MCP and want a small, readable server to study. It sits alongside the other reference servers such as the Filesystem MCP server.

Probably not needed if:

• Your model's built-in reasoning already handles the problems you give it.
• You need the assistant to remember things between sessions. That is a memory server's job.
• You want reasoning traces saved or exported. This server keeps nothing after it stops.

For other no-cost options, see our list of free and open-source MCP servers. If the planning work is code that depends on third-party libraries, the Context7 MCP server page covers a separate server that looks up library documentation.

What we could not verify

• Whether it improves answers for any given model. The README publishes no measurements, and we did not run any.
• The minimum Node.js version. The npm metadata has no engines field. The repository's Dockerfile uses Node 22 images.
• Whether the prebuilt Docker image supports DISABLE_THOUGHT_LOGGING. We compared the source at the commit Docker Hub names and did not pull or run the image.
• Which tool name each older npm version reports. We checked version 2026.8.31 only.
• Setup in Cursor, Claude Code and other clients not named in the README. The snippets above follow each client's general documentation. We did not check Windsurf or other clients.
• The exact license terms that apply to this package. The npm metadata says "SEE LICENSE IN LICENSE", the server README says MIT, and the repository LICENSE file describes a move from MIT to Apache 2.0.
• How the server behaves in practice. This page is based on reading the documentation and source code, not on running the server.

How this page was put together

We read the server's README, source files and Dockerfile in the modelcontextprotocol/servers repository, the npm registry entry and the published 2026.8.31 package, the Docker Hub listing, the Claude Code and Cursor MCP documentation and Anthropic's "think" tool article on October 5, 2026. Nothing here comes from running the server. Check the README before you rely on a detail, because reference servers change.

Sources

• Sequential Thinking MCP Server README (GitHub)
• Server source: index.ts and lib.ts
• modelcontextprotocol/servers repository README and LICENSE
• npm: @modelcontextprotocol/server-sequential-thinking
• Docker Hub: mcp/sequentialthinking
• Knowledge Graph Memory Server README (GitHub)
• Claude Code docs: Connect Claude Code to tools via MCP
• Cursor docs: Model Context Protocol (MCP)
• Anthropic Engineering: The "think" tool