mcp-sequentialthinking-tools
It is a lightweight MCP server for recording, managing, and validating sequential reasoning steps.
Record one thought at a time with session history (
sequentialthinking_tools)Store thought metadata: revisions, branches, next steps, tool recommendations, remaining steps, and more
Validate model-authored recommended tools against an available tool list; invalid recommendations return an error and are not stored
Retrieve stored thinking history by session or branch, with a limit (
get_thinking_history)Clear one session or all sessions (
clear_thinking_history)Provide a guidance prompt for scratchpad/validator use (
sequential-thinking-guidance)Redact prompt-injection-like text and return security warnings
Support per-session
MAX_HISTORY_SIZEand dual stdio transports
The server provides examples of how it can be used to gather information about Svelte 5's universal reactivity as part of its problem-solving approach
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@mcp-sequentialthinking-tools help me plan how to research and implement a new authentication system"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
mcp-sequentialthinking-tools
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 stepthought_number— current step numbertotal_thoughts— current estimate; automatically raised if lower thanthought_numbernext_thought_needed— whether another thought is needed
Optional parameters:
session_id— history bucket; defaults todefaultis_revision,revises_thoughtbranch_from_thought,branch_idneeds_more_thoughtsavailable_tools— array of tool names or{ name, description }objectsrecommended_tools— model-authored recommendations to validate/storeremaining_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 todefaultbranch_id— optional branch filterlimit— max records to return; default50, max500
clear_thinking_history
Clears one session or every session.
Parameters:
session_id— defaults todefaultall_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 checkThis project uses vite-plus for build, test, format, and lint
orchestration.
Publishing
pnpm changeset
pnpm changeset version
pnpm releaseLicense
MIT License — see LICENSE.
Acknowledgments
Built on the Model Context Protocol
Adapted from the MCP Sequential Thinking Server
Available Tools
3 toolsclear_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
Scored across 3 tools
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.
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.
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.
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
Related MCP Connectors
MCP server for progressive tool usage at any scale (see https://klavis.ai)
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
MCP server for generating rough-draft project plans from natural-language prompts.
Hybrid human + AI expertise for faster, trusted answers and decisions via MCP Server.
Related MCP Servers
- AlicenseAqualityBmaintenanceThis server facilitates structured problem-solving by breaking down complex issues into sequential steps, supporting revisions, and enabling multiple solution paths through full MCP integration.595 PyPI960MIT
- AlicenseAqualityDmaintenanceA 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.12Apache 2.0
- AlicenseNot gradedqualityDmaintenanceA 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.2Apache 2.0
- AlicenseAqualityDmaintenanceA structured problem-solving MCP server that breaks down complex tasks into sequential steps, supports iterative refinement and branching, and helps maintain context and explore alternative reasoning paths.113 npm41MIT