Server profile

mcp-sequentialthinking-tools

mcp-sequentialthinking-tools records stepwise reasoning with session history, branches, and revision metadata. It validates model-authored tool plans against a supplied tool list rather than discovering or choosing tools itself.

Server facts

mcp-sequentialthinking-tools

Tech

Runtime / language
node
Transports
stdio
Remote available
No
Authentication
Not specified

Activity

GitHub stars
587
Last commit
Data as of

Tags

  • Branching
  • Plan Validation
  • Reasoning Scratchpad
  • Session History

Overview

mcp-sequentialthinking-tools is a scratchpad for recording structured reasoning steps during an agent workflow. Each recorded step includes the current thought, its number, an estimated total, and whether another step is expected. Optional session identifiers separate histories, while revision and branch metadata represent changes in direction without treating every step as a single linear plan. If the estimate falls below the current step number, the server raises it automatically. The README positions this for tasks that benefit from inspectable planning and revision, and explicitly discourages using it for trivial requests where the additional calls only add overhead.

Tool planning is deliberately limited to validation. A model can supply available tool names and its own recommendations; the server checks that recommended names exist in that supplied list. An unknown name causes an error and prevents the thought from being stored. The server does not discover other integrations or make recommendations itself. Separate tools retrieve a session's recorded steps, optionally filtering by branch, and clear one or all histories. Defensive scanning redacts prompt-injection-like text in thoughts and related fields, but the README warns this is not a safety guarantee and says not to include secrets. Client setup uses npx over stdio, with a configurable per-session history limit. A guidance prompt reinforces the distinction between a scratchpad and an external reasoning engine.

Install & configure

Requirements

  • npx
  • An MCP-compatible client
Documented launch / install command
npx -y mcp-sequentialthinking-tools

The history limit is per session and defaults to 1000. Its stdio transport accepts Content-Length framing and newline-delimited JSON used by older tmcp tooling.

Config file · macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Windows: %APPDATA%\Claude\claude_desktop_config.json

Use Settings → Developer → Edit Config when available. Do not assume a Linux configuration path; check the client documentation for your platform. Remote servers use the app’s connector flow when supported, not the local stdio file shown here. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Desktop configuration
{
  "mcpServers": {
    "mcp-sequentialthinking-tools": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-sequentialthinking-tools"
      ],
      "env": {
        "MAX_HISTORY_SIZE": "<maximum recorded steps per session; default 1000>"
      }
    }
  }
}

Read the Claude Desktop setup guide

Config file · Project: .cursor/mcp.json

User: ~/.cursor/mcp.json

The project path is relative to the workspace root. The tilde denotes your user home directory. Use Cursor’s MCP settings to confirm which configuration and scope your installed version is reading. Merge this example with existing settings; do not overwrite unrelated servers.

Cursor configuration
{
  "mcpServers": {
    "mcp-sequentialthinking-tools": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-sequentialthinking-tools"
      ],
      "env": {
        "MAX_HISTORY_SIZE": "<maximum recorded steps per session; default 1000>"
      }
    }
  }
}

Read the Cursor setup guide

Config file · Workspace: .vscode/mcp.json

For user scope, use the “MCP: Open User Configuration” command if available. Do not guess a user configuration path across operating systems, profiles, containers, or remote workspaces; check the client documentation. Merge this example with existing settings; do not overwrite unrelated servers.

VS Code configuration
{
  "servers": {
    "mcp-sequentialthinking-tools": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "mcp-sequentialthinking-tools"
      ],
      "env": {
        "MAX_HISTORY_SIZE": "<maximum recorded steps per session; default 1000>"
      }
    }
  }
}

Read the VS Code setup guide

Config file · macOS/Linux: ~/.codeium/windsurf/mcp_config.json

Windows: %USERPROFILE%\.codeium\windsurf\mcp_config.json

Open the MCP configuration through Windsurf’s settings when possible to confirm the active file. Paths can differ in managed or future releases; check the client documentation if this location is not present. Merge this example with existing settings; do not overwrite unrelated servers.

Windsurf configuration
{
  "mcpServers": {
    "mcp-sequentialthinking-tools": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-sequentialthinking-tools"
      ],
      "env": {
        "MAX_HISTORY_SIZE": "<maximum recorded steps per session; default 1000>"
      }
    }
  }
}

Read the Windsurf setup guide

Config file · Project scope: .mcp.json at the repository root

The project file uses mcpServers. For user scope, use claude mcp add --scope user rather than assuming .mcp.json in your home directory is the user configuration. Check the client documentation for managed settings and storage details. Merge this example with existing settings; do not overwrite unrelated servers.

Claude Code configuration
{
  "mcpServers": {
    "mcp-sequentialthinking-tools": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "mcp-sequentialthinking-tools"
      ],
      "env": {
        "MAX_HISTORY_SIZE": "<maximum recorded steps per session; default 1000>"
      }
    }
  }
}

Read the Claude Code setup guide

Examples are translated from the published configuration. Supply your own credentials and verify requirements in the upstream README. Remote connectors are shown only where a supported configuration format is known.

Tools

Source: repository tool metadata. Tool descriptions are a documented snapshot, not a live capability check.

ToolWhat it does
sequentialthinking_toolsRecord one reasoning step and optionally validate model-proposed tools against a supplied list.
get_thinking_historyRetrieve recorded session steps, optionally restricted by branch and record limit.
clear_thinking_historyDelete one session history or clear all session histories.

Names, permissions, and defaults can change. Check the current upstream documentation before granting access.

Use cases

  • Record explicit planning steps for a complex agent task
  • Keep separate session histories with branches and revisions
  • Validate proposed tool names against an explicitly supplied list
  • Inspect or clear history during a long agent workflow

Strengths

  • Supports session separation, branching, and revision metadata
  • Rejects unknown recommended tool names before storing a step
  • Includes history retrieval, clearing, and defensive text filtering

Limitations

  • Does not discover available tools or select tools for the model
  • Adds unnecessary overhead for trivial requests
  • Text filtering is not a guarantee against adversarial input

Frequently asked questions

No. It only validates and stores recommendations authored by the model against an explicitly supplied available-tool list.

An unknown recommended name prevents storage of the thought and produces an isError: true result.

Yes. session_id selects a history bucket, with default used when no session is provided.

No. The README says filtering is defensive rather than guaranteed and instructs users not to include secrets.

Independent listing, not an affiliation or security review. Grant the least access needed and verify the upstream instructions before running code.

Related MCP servers