Filesystem MCP Server: Install, Tools and Safety

The Sequential Thinking MCP server gives an AI model a single tool for working through a problem one numbered step at a time, with room to revise earlier steps or branch into alternatives. It is a reference server from the official MCP repo, run with npx -y @modelcontextprotocol/server-sequential-thinking. It does not search or act. We checked the README and npm on 31 October 2026.

Quick facts

What it is, in plain words

Most MCP servers connect a model to something outside it: a database, a browser, a ticket tracker. This one connects the model to a notebook. The tool takes a "thought" the model has written and records it, along with where it sits in the sequence and whether another thought is needed.

The server does no reasoning of its own. The README describes it as a tool for "dynamic and reflective problem-solving through a structured thinking process". The model supplies each thought. The server holds the structure: the number, the total estimate, revisions and branches.

That is why the page is short on features and long on judgment. Whether it helps depends on your model and your task, and the README does not claim otherwise.

The tool and its inputs

There is one tool, sequential_thinking.

The features the README lists follow from those fields:

• Break a complex problem 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.

A detail worth noticing: totalThoughts is an estimate that can change. The model might start at five thoughts and raise it to eight when the problem turns out harder. That mirrors how people plan.

What a session looks like

The README says you do not call the tool by hand unless your client exposes raw tool calls. You connect the server to an MCP-aware host, ask the model to think through a problem step by step, and the host may call the tool several times.

The README's example prompts:

• "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."

A call sequence would show repeated sequential_thinking calls with rising thoughtNumber values. When the model changes its mind you would see isRevision with revisesThought, or a branchId. The README's check for whether it works: confirm the tool shows in your host's tool list, ask a non-trivial question, and see that the host calls it more than once rather than answering in one shot.

Install it in each agent

The README has vendor lines for Claude Desktop (npx and Docker) and VS Code. Lines for other agents are our adaptation.

The standard entry:

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

On Windows the README says to launch through cmd /c. The Docker form runs docker run --rm -i mcp/sequentialthinking.

Claude Code

Our adaptation of claude mcp add:

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

Codex

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

[mcp_servers.sequential-thinking]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-sequential-thinking"]

Both are our adaptation from the Codex docs.

Cursor

Use the standard entry in .cursor/mcp.json or ~/.cursor/mcp.json. Our adaptation.

Gemini CLI and Antigravity

Gemini CLI takes the standard entry in settings.json. It is now for Code Assist enterprise customers, and individuals moved to Antigravity CLI on 18 June 2026. For Antigravity, put the same entry in ~/.gemini/config/mcp_config.json or <workspace>/.agents/mcp_config.json. Both are our adaptation.

VS Code

The README gives the VS Code form with a servers key, in a user mcp.json (Command Palette, "MCP: Open User Configuration") or .vscode/mcp.json:

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

OpenCode

Our adaptation:

{
  "mcp": {
    "sequential-thinking": {
      "type": "local",
      "command": ["npx", "-y", "@modelcontextprotocol/server-sequential-thinking"]
    }
  }
}

For how each agent names these fields, see MCP clients.

Does it make a model better?

Here the README is quiet, and so should we be. It lists what the tool is designed for: breaking down problems, planning with room for revision, analysis that might need correction, problems whose scope is unclear at first, and tasks that need to keep context over many steps. It does not publish a benchmark or a before-and-after.

What we can say from the design:

• It externalizes steps. Writing a numbered thought and then a next one can encourage a model to slow down and check itself. That is the idea.
• It adds calls. Each thought is a tool call, and each call costs tokens and time. A ten-step session is ten round trips.
• It overlaps with built-in reasoning. Many current models have an internal thinking or reasoning mode. When a model already reasons before it answers, this tool adds a visible log on top, and may add little else. The README cites no benchmark of its effect on a reasoning model, and we ran none.
• It helps most when you want the trail. A visible, numbered thought sequence is easy to read and to review. For some people that audit trail is the product.

If you cannot say what you would learn from the extra calls, skip the server and ask the model to plan in the chat.

Logging and privacy

The README says to set DISABLE_THOUGHT_LOGGING to true to turn off logging of thought information. By default, then, thoughts are logged. The README does not say where, but the source prints them to standard error, so a client may show them in its server log.

Consider what goes into a thought. A model working on a task may write internal details, such as file names, credentials it saw or private reasoning, into a thought. If logs go to a shared location, that leaks. Set the variable in environments where that matters:

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

Security and permissions

This is among the safest servers you can install, because it has no reach beyond its own memory.

• No network, no files. The tool takes text and returns a record of it. Nothing in the README suggests it reads files or calls out.
• No credentials. There is no sign-in.
• No external action. It cannot change anything outside the session.

What remains:

1. It still runs code on your machine. An npx server is a package from npm. Pin a version if you share a config, and prefer the Docker image if you want isolation.
2. Thought content is model-written. If the model was steered by injected text elsewhere, the thoughts may reflect it. The tool does not filter them.
3. Logging. See above.
4. Context. Long sessions add every thought to the conversation.

A baseline: leave approval on, pin the version, and disable logging if your tasks involve private data.

Limits and known issues

• Node 24 requirement. Older Node versions fail to start through npx. Use Docker if you cannot upgrade.
• Connection-scoped memory. The README says the thought history lasts as long as the client's connection. A new connection starts empty, so it is not a long-term memory. For that, see Memory MCP.
• No guarantee the model uses it well. A model can call it once and answer anyway, or call it many times for a simple question.
• Two protocol eras. The README says the server handles both 2026-07-28 clients and 2025-era clients over stdio, so older hosts work.
• No measured benefit. See the section above.
• Open issues. The servers repository showed 34 open issues when we checked, across all reference servers. We did not read them.

A worked example of the shape

The README does not include a transcript, so this is an illustration of the field values, not a captured session. Say a model plans a database migration. Thought 1 states the goal and sets totalThoughts to 5. Thought 2 lists the risks. Thought 3 finds that downtime may exceed the limit, so thought 4 is sent with isRevision true and revisesThought 2, correcting the risk list. Thought 5 sets nextThoughtNeeded to false and gives the plan.

If the model wants to compare two approaches, it can send thought 3 twice with different branchId values, such as "rolling" and "cutover", both with branchFromThought set to 2. Nothing in the server decides which branch wins. The model does, and the record shows both.

That is the whole mechanism. It is a structured scratchpad, and it is useful only to the degree that you read the pad or the model reads it back.

Prompts that invite the tool

Models do not always call an optional tool. A prompt that asks for stepwise work tends to trigger it: "Think through this in numbered steps, revising earlier steps if you find a mistake, and branch if two options look equal." Avoid asking for it on trivial questions, where it only adds round trips.

Alternatives

A prompt that says "write a numbered plan, then revise it after each step" costs no installation and gives a similar trail. The MCP servers hub lists more.

Which agents it suits

• Chat apps with no thinking mode gain the most.
• Coding agents already plan, and some have plan modes, so the gain is smaller.
• Reviewable workflows suit it: a numbered thought log is easy to attach to a ticket.
• Cost-sensitive setups should skip it, because each thought is a call.

Our take

We did not run this server against any benchmark for this page. This is from the README and npm.

Sequential Thinking is the smallest server we have covered. One tool, no side effects, no credentials. That makes it safe to try. It does not make it useful by default.

The honest case for it is the trail. If you want to see a model's steps as numbered, reviewable thoughts, with revisions and branches marked, it gives you that. The honest case against it is that many models already reason well without help, and each thought adds a round trip.

Try it on one task you care about, such as a migration plan, and compare the answer with and without it. If you cannot see a difference, remove it. A tool that costs tokens on every call has to earn its place.

A short setup checklist

1. Check node --version prints 24 or later, or use Docker.
2. Add the server with the line for your agent.
3. Restart and confirm sequential_thinking is listed.
4. Ask a multi-step question and watch for repeated calls.
5. Set DISABLE_THOUGHT_LOGGING if the task is private.
6. Compare one task with and without it.
7. Remove it if the difference is not clear.

Frequently asked questions

What does the Sequential Thinking MCP server do?

It gives a model one tool for numbered, revisable steps, with branching.

Does it make a model smarter?

The README makes no benchmark claim. Measure on your own tasks.

How do I install it?

Run npx -y @modelcontextprotocol/server-sequential-thinking as a stdio server, or use the mcp/sequentialthinking Docker image.

Can I turn off thought logging?

Yes, with DISABLE_THOUGHT_LOGGING set to true.

Do I need it if my model has an extended thinking mode?

Often not. The server adds a visible, structured log on top.