Skip to main content
Glama
mcp-sequentialthinking-tools

mcp-sequentialthinking-tools

by spences10

mcp-sequentialthinking-tools

CI built with vite+ tested with vitest

A lightweight MCP server for recording sequential reasoning steps. It is a scratchpad with history, branching, revision metadata, and optional validation for model-authored tool plans.

It does not discover your other MCP tools and it does not choose tools for the model. If you pass available_tools and recommended_tools, the server validates that the recommended names exist and stores the step.

Why use it?

Use this when a task benefits from explicit, inspectable reasoning:

  • breaking a messy problem into steps;

  • revising or branching a plan;

  • keeping a small reasoning history by session;

  • validating tool-plan names against a supplied tool list;

  • clearing or inspecting reasoning history during a long agent run.

Do not use it for trivial requests. It adds overhead.

Related MCP server: Sequential-Thinking

Tools

sequentialthinking_tools

Records one thought.

Required parameters:

  • thought — current reasoning step

  • thought_number — current step number

  • total_thoughts — current estimate; automatically raised if lower than thought_number

  • next_thought_needed — whether another thought is needed

Optional parameters:

  • session_id — history bucket; defaults to default

  • is_revision, revises_thought

  • branch_from_thought, branch_id

  • needs_more_thoughts

  • available_tools — array of tool names or { name, description } objects

  • recommended_tools — model-authored recommendations to validate/store

  • remaining_steps — short list of upcoming steps

Example:

{
	"session_id": "svelte-debug",
	"thought": "First inspect the route files, then run the failing check.",
	"thought_number": 1,
	"total_thoughts": 3,
	"next_thought_needed": true,
	"available_tools": ["read", "bash"],
	"recommended_tools": [
		{
			"tool_name": "read",
			"confidence": 0.9,
			"rationale": "Need to inspect the relevant files before editing.",
			"priority": 1
		}
	]
}

If recommended_tools contains a name not present in available_tools, the call returns isError: true and does not store the thought.

Security posture

The server treats thought text, tool descriptions, rationales, and remaining-step text as untrusted input. Prompt-injection-like text is scanned and redacted before it is stored or returned in history. Calls with redactions include security_warnings showing which fields matched.

This is defensive filtering, not a guarantee that arbitrary adversarial text is safe. Do not put secrets in thoughts or tool descriptions.

get_thinking_history

Returns stored thoughts for a session.

Parameters:

  • session_id — defaults to default

  • branch_id — optional branch filter

  • limit — max records to return; default 50, max 500

clear_thinking_history

Clears one session or every session.

Parameters:

  • session_id — defaults to default

  • all_sessions — clear all history buckets

Prompt

sequential-thinking-guidance

A short prompt that tells the model how to use this server honestly: as a scratchpad and validator, not as an external reasoning engine.

Configuration

Claude Desktop / compatible MCP clients

{
	"mcpServers": {
		"mcp-sequentialthinking-tools": {
			"command": "npx",
			"args": ["-y", "mcp-sequentialthinking-tools"],
			"env": {
				"MAX_HISTORY_SIZE": "1000"
			}
		}
	}
}

MAX_HISTORY_SIZE is per session and defaults to 1000.

The server uses tmcp and includes a small stdio transport that accepts both standard Content-Length framed MCP messages and newline-delimited JSON used by older tmcp tooling.

Development

pnpm install
pnpm test
pnpm build
pnpm check

This project uses vite-plus for build, test, format, and lint orchestration.

Publishing

pnpm changeset
pnpm changeset version
pnpm release

License

MIT License — see LICENSE.

Acknowledgments

Available Tools

3 tools
clear_thinking_historyClear recorded sequential-thinking history for one session or all sessions.C

Clear recorded sequential-thinking history for one session or all sessions.

Inputs: session_id, all_sessions.

get_thinking_historyReturn recorded thoughts for a session. Use this to inspect or resume prior reasoning.C

Return recorded thoughts for a session. Use this to inspect or resume prior reasoning.

Inputs: limit, branch_id, session_id.

sequentialthinking_toolsRecord one step of sequential reasoning. Optionally include available_tools and recommended_tools; recommendations are validated, not generated, by this server.C

Record one step of sequential reasoning. Optionally include available_tools and recommended_tools; recommendations are validated, not generated, by this server.

Inputs: thought (required), thought_number (required), total_thoughts (required), next_thought_needed (required), +9 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3/5.0

    Scored across 3 tools

    Disambiguation5/5

    The three tools map cleanly to distinct actions on the same resource: write a thought, read the history, and clear it. There is no overlap or risk of misselection between recording, retrieving, and clearing.

    Naming Consistency3/5

    get_thinking_history and clear_thinking_history follow a consistent verb_noun pattern, but sequentialthinking_tools breaks it entirely, using a compound noun with no verb and no clear action cue. The mix is readable but not uniform.

    Tool Count4/5

    Three tools is lean but adequate for a reasoning-history server covering write, read, and clear. It is on the thin side, with no session-listing or search capability to round it out.

    Completeness4/5

    The record/get/clear trio covers the basic lifecycle of a thinking log with no dead ends. Minor gaps exist, such as listing sessions or fetching a single thought by id, which agents could work around.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      D
      maintenance
      A MCP server that implements sequential thinking protocols, provides structured problem-solving methods, decomposes complex problems into manageable steps, and supports iterative optimization and alternative reasoning paths.
      1
      2
      Apache 2.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      A sequential thinking tool based on the MCP protocol, used to break down complex problems into manageable steps and provide intelligent tool recommendations for each step.
      2
      Apache 2.0