モデル・コンテキスト・プロトコル（MCP）サーバーは、定義された段階を通して構造化された段階的な思考を促進します。このツールは、複雑な問題を段階的な思考に分解し、思考プロセスの進行を追跡し、要約を生成するのに役立ちます。
構造化思考フレームワーク：標準的な認知段階（問題の定義、調査、分析、統合、結論）を通じて思考を整理します
思考追跡: メタデータを使用して連続的な思考を記録し、管理します
関連思考分析：類似した思考間のつながりを特定する
進捗状況のモニタリング：全体的な思考の順序におけるあなたの位置を追跡します
要約生成: 思考プロセス全体の簡潔な概要を作成します
永続ストレージ: スレッドセーフで思考セッションを自動的に保存します
データのインポート/エクスポート: 思考セッションの共有と再利用
拡張可能なアーキテクチャ: 機能を簡単にカスタマイズおよび拡張できます
堅牢なエラー処理: エッジケースや破損したデータの適切な処理
型安全性: 包括的な型注釈と検証
Related MCP server: Sequential Thinking MCP Server
Python 3.10以上
UV パッケージ マネージャー (インストール ガイド)
Pydantic : データの検証とシリアル化
Portalocker : スレッドセーフなファイルアクセス
FastMCP : モデルコンテキストプロトコル統合用
リッチ: 強化されたコンソール出力用
PyYAML : 構成管理用
mcp-sequential-thinking/
├── mcp_sequential_thinking/
│ ├── server.py # Main server implementation and MCP tools
│ ├── models.py # Data models with Pydantic validation
│ ├── storage.py # Thread-safe persistence layer
│ ├── storage_utils.py # Shared utilities for storage operations
│ ├── analysis.py # Thought analysis and pattern detection
│ ├── testing.py # Test utilities and helper functions
│ ├── utils.py # Common utilities and helper functions
│ ├── logging_conf.py # Centralized logging configuration
│ └── __init__.py # Package initialization
├── tests/
│ ├── test_analysis.py # Tests for analysis functionality
│ ├── test_models.py # Tests for data models
│ ├── test_storage.py # Tests for persistence layer
│ └── __init__.py
├── run_server.py # Server entry point script
├── debug_mcp_connection.py # Utility for debugging connections
├── README.md # Main documentation
├── CHANGELOG.md # Version history and changes
├── example.md # Customization examples
├── LICENSE # MIT License
└── pyproject.toml # Project configuration and dependenciesプロジェクトの設定
# Create and activate virtual environment
uv venv
.venv\Scripts\activate # Windows
source .venv/bin/activate # Unix
# Install package and dependencies
uv pip install -e .
# For development with testing tools
uv pip install -e ".[dev]"
# For all optional dependencies
uv pip install -e ".[all]"サーバーを実行する
# Run directly
uv run -m mcp_sequential_thinking.server
# Or use the installed script
mcp-sequential-thinkingテストを実行する
# Run all tests
pytest
# Run with coverage report
pytest --cov=mcp_sequential_thinkingClaude Desktop 構成 (Windows の場合は%APPDATA%\Claude\claude_desktop_config.json ) に追加します。
{
"mcpServers": {
"sequential-thinking": {
"command": "uv",
"args": [
"--directory",
"C:\\path\\to\\your\\mcp-sequential-thinking\\run_server.py",
"run",
"server.py"
]
}
}
}あるいは、 pip install -e .を使用してパッケージをインストールした場合は、次を使用できます。
{
"mcpServers": {
"sequential-thinking": {
"command": "mcp-sequential-thinking"
}
}
}サーバーは思考履歴を保持し、構造化されたワークフローを通じて処理します。各思考はPydanticモデルを用いて検証され、思考段階に分類され、関連するメタデータとともにスレッドセーフなストレージシステムに保存されます。サーバーはデータの永続化とバックアップ作成を自動的に処理し、思考間の関係性を分析するためのツールを提供します。
Sequential Thinking サーバーは、次の 3 つの主要なツールを公開します。
process_thought連続的な思考プロセスにおける新しい考えを記録し、分析します。
パラメータ:
thought (文字列): 思考の内容
thought_number （整数）：シーケンス内の位置（例：最初の思考は1）
total_thoughts (整数): シーケンス内の予想される合計思考数
next_thought_needed (boolean): この思考の後にさらに思考が必要かどうか
stage (文字列): 思考段階 - 次のいずれかになります:
「問題の定義」
"研究"
"分析"
"合成"
"結論"
tags （文字列のリスト、オプション）：あなたの考えのキーワードまたはカテゴリ
axioms_used （文字列のリスト、オプション）：思考に適用された原則または公理
assumptions_challenged (文字列のリスト、オプション): 仮定、あなたの考え、質問、または課題
例：
# First thought in a 5-thought sequence
process_thought(
thought="The problem of climate change requires analysis of multiple factors including emissions, policy, and technology adoption.",
thought_number=1,
total_thoughts=5,
next_thought_needed=True,
stage="Problem Definition",
tags=["climate", "global policy", "systems thinking"],
axioms_used=["Complex problems require multifaceted solutions"],
assumptions_challenged=["Technology alone can solve climate change"]
)generate_summary思考プロセス全体の要約を生成します。
出力例:
{
"summary": {
"totalThoughts": 5,
"stages": {
"Problem Definition": 1,
"Research": 1,
"Analysis": 1,
"Synthesis": 1,
"Conclusion": 1
},
"timeline": [
{"number": 1, "stage": "Problem Definition"},
{"number": 2, "stage": "Research"},
{"number": 3, "stage": "Analysis"},
{"number": 4, "stage": "Synthesis"},
{"number": 5, "stage": "Conclusion"}
]
}
}clear_history記録された思考をすべて消去して思考プロセスをリセットします。
意思決定：重要な決定を系統的に行う
問題解決：複雑な問題を管理可能なコンポーネントに分割する
研究計画：明確な段階を設けて研究アプローチを構築する
執筆の構成：執筆前にアイデアを段階的に展開する
プロジェクト分析: 定義された分析段階を通じてプロジェクトを評価する
MCPを適切に設定すれば、 process_thoughtツールを使って思考を順番に整理し始めることができます。作業を進めるにつれて、 generate_summaryで概要を把握し、必要に応じてclear_historyで履歴をリセットできます。
Sequential Thinkingサーバーのカスタマイズと拡張方法の詳細な例については、 example.mdをご覧ください。以下のコードサンプルが含まれています。
思考段階の修正
Pydanticによる思考データ構造の強化
データベースによる永続性の追加
NLPによる強化分析の実装
カスタムプロンプトの作成
高度な設定の設定
Web UI統合の構築
視覚化ツールの実装
外部サービスへの接続
協力的な環境の構築
テストコードの分離
再利用可能なユーティリティの構築
MITライセンス
Clear the thought history.
Returns:
dict: Status message
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must disclose all behavioral traits. It only states the action and return type, omitting details like destructiveness, scope, or confirmation requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise at two sentences, front-loading the key action. While it lacks depth, it contains no superfluous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the tool's simplicity, the description is incomplete. It does not mention that clearing history is irreversible or provide any behavioral context, especially given the lack of annotations and output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the baseline is 4. The description does not need to add parameter information since none exist.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Clear the thought history,' which matches the tool name 'clear_history.' The verb 'clear' and resource 'thought history' are clear and distinct from sibling tools like export_session or process_thought.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, side effects, or context for clearing history.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Export the current thinking session to a file.
Args:
file_path: Path to save the exported session
Returns:
dict: Status message
| Name | Required | Description | Default |
|---|---|---|---|
| file_path | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries full burden. It does not disclose side effects, file overwrite behavior, or access permissions; merely states the action and returns 'Status message' without detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences plus structured Args/Returns sections, clear and front-loaded; no unnecessary text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Adequate for a simple tool with one parameter and no output schema, but lacks information on file format, overwrite behavior, or status message contents.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description adds 'Path to save the exported session' for file_path, clarifying its purpose beyond the schema's type definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Export') and resource ('current thinking session') with destination ('to a file'), clearly distinguishing from siblings like import_session or generate_summary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives; lacks context on prerequisites or situations like saving vs sharing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Generate a summary of the entire thinking process.
Returns:
dict: Summary of the thinking process
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, and the description does not disclose behavioral traits (e.g., whether it is a read-only operation, requires state, or has side effects). It only states it returns a dict, which is insufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise with two short sentences, no unnecessary words, and the key information is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no output schema and sibling tools, the description lacks details about what the summary contains, how it is generated, or any dependencies. It feels incomplete for a tool that produces a significant output.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so schema coverage is trivially 100%. The description adds meaning by specifying the output is a summary of the thinking process, which is helpful beyond an empty schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Generate') and the resource ('summary of the entire thinking process'). It is a specific verb+resource combination that distinguishes it from sibling tools like 'clear_history', 'export_session', etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. There is no mention of prerequisites, context, or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Import a thinking session from a file.
Args:
file_path: Path to the file to import
Returns:
dict: Status message
| Name | Required | Description | Default |
|---|---|---|---|
| file_path | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must cover behavioral traits. It only states 'Import a thinking session from a file' without mentioning side effects (e.g., overwriting current session), file requirements, or error behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is brief (three lines) and uses a standard Args/Returns structure. However, it is too terse to be fully effective, lacking essential details.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the absence of an output schema, the description only vaguely states 'dict: Status message'. It does not explain what the status indicates or what happens to the existing session, leaving the agent uninformed.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, so the description must compensate. It merely repeats 'Path to the file to import', adding no detail about file format, size limits, or path constraints.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (import) and the object (thinking session from a file). It is distinguishable from sibling tools like export_session, but lacks specifics on file format or source.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives, no context on prerequisites or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Add a sequential thought with its metadata.
Args:
thought: The content of the thought
thought_number: The sequence number of this thought
total_thoughts: The total expected thoughts in the sequence
next_thought_needed: Whether more thoughts are needed after this one
stage: The thinking stage (Problem Definition, Research, Analysis, Synthesis, Conclusion)
tags: Optional keywords or categories for the thought
axioms_used: Optional list of principles or axioms used in this thought
assumptions_challenged: Optional list of assumptions challenged by this thought
is_revision: Whether this thought revises an earlier thought
revises_thought_number: The number of the earlier thought being revised (required if is_revision is true)
branch_from_thought: The thought number this thought branches from, to explore an alternative path
branch_id: Identifier for the branch (letters, digits, '-', '_'; max 64 chars; requires branch_from_thought)
ctx: Optional MCP context object
Returns:
dict: Analysis of the processed thought
| Name | Required | Description | Default |
|---|---|---|---|
| ctx | No | ||
| tags | No | ||
| stage | Yes | ||
| thought | Yes | ||
| branch_id | No | ||
| axioms_used | No | ||
| is_revision | No | ||
| thought_number | Yes | ||
| total_thoughts | Yes | ||
| branch_from_thought | No | ||
| next_thought_needed | Yes | ||
| assumptions_challenged | No | ||
| revises_thought_number | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description must disclose all behavioral traits. It details what the tool does but omits side effects, permission requirements, error handling, or the state modifications (e.g., appending to a thought list). The return value is only vaguely described as 'dict: Analysis of the processed thought.'
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is front-loaded with a one-line summary, then structured as a docstring with Args and Returns. It is reasonably concise, though the parameter list is lengthy. Every sentence adds value, but could be more compact.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (13 parameters, no output schema, no annotations), the description explains each parameter but lacks guidance on the overall workflow (e.g., sequential numbering, when to set 'next_thought_needed'). The stage values are enumerated, but the return value and error conditions are unspecified.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has no property descriptions (0% coverage), so the description must compensate. The Args list provides brief explanations for each parameter, but these mostly restate the parameter names (e.g., 'thought: The content of the thought') without adding deeper semantics, constraints, or examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Add a sequential thought with its metadata,' which clearly states the action and resource. This distinguishes it from sibling tools (clear_history, export_session, generate_summary, import_session) which serve different purposes.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description does not explicitly state when to use this tool versus alternatives. The usage is implied by the tool name and sibling context, but no exclusion criteria or when-not scenarios are provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v1.0.1clear_historyexport_sessiongenerate_summaryimport_sessionprocess_thoughtScored across 5 tools
Each tool has a distinct purpose: clearing history, exporting/importing sessions, generating summaries, and processing thoughts. No functional overlap.
All tool names follow a consistent verb_noun pattern in snake_case (e.g., clear_history, export_session). The naming is predictable and clear.
Five tools is appropriate for a focused sequential thinking server, covering core operations without unnecessary bloat.
The tool surface covers the full lifecycle: adding thoughts (with revision and branching), clearing, exporting/importing, and generating summaries. Minor gap: lack of a dedicated edit/delete tool, but revisions handle edits.
Official DevSpeak MCP server — translate technical text into formal specs from any AI IDE or agent
An MCP server for deep research or task groups
Official MCP server for Agentwork — delegate tasks to AI agents with human-in-the-loop
MCP server for generating rough-draft project plans from natural-language prompts.
