Structured Thinking

🚀 Structured Thinking MCP Server

This is a Model Context Protocol (MCP) server implemented in TypeScript, based on the Python server of Sequential Thinking by Arben Ademi. The project aims to allow Large Language Models (LLMs) to programmatically build mind maps to explore an idea space and enforce "metacognitive" self-reflection.

🚀 Quick Start

Set up the tool configuration in Claude Desktop, Cursor, or other MCP clients as follows:

{
  "structured-thinking": {
    "command": "npx",
    "args": ["-y", "structured-thinking"]
  }
}

✨ Features

Thought Quality Score

When an LLM captures a thought, it assigns a quality score between 0 and 1 to the thought. This score, combined with the thought's stage, is used to provide "metacognitive" feedback to the LLM, guiding it on how to "steer" its thinking process.

Thought Stages

Each thought is labeled with a stage (e.g., problem definition, analysis, ideation) to help manage the lifecycle of the LLM's thinking process. In the current implementation, these stages play a very important role. In fact, if the LLM spends too much time in a given stage or generates low-quality thoughts in the current stage, the server will provide feedback, prompting the LLM to shift its thinking to other stages or at least consider strategies that are less typical of the current stage (e.g., in the deductive mode, the LLM will be encouraged to consider more creative thoughts).

Thought Branching

The LLM can "spawn" "branches" from a particular thought to explore different lines of reasoning in parallel. Each branch is tracked separately, allowing you to manage scenarios where multiple solutions or ideas coexist.

Memory Management

The server maintains a "short-term" memory buffer containing the LLM's last ten thoughts and "long-term" memory that can be retrieved based on its labels to summarize the entire topic history.

🔧 Technical Details

Mechanical Application of Metacognitive Monitoring

Currently, the quality metrics and metacognitive feedback are mechanically derived from a single self-reported quality score through a simple stage-based multiplier.

As part of future work, I plan to add more sophisticated metacognitive feedback, including semantic analysis of thought content, thought validation processes, and more intelligent monitoring of reasoning errors.

Lack of User Interface

Currently, the server stores all thoughts in memory and does not persist them to a file or database. There is also no user interface for reviewing the thought space or visualizing the mind map.

As part of future work, I plan to integrate a simple visualization client so that users can watch how the thought graph evolves.

📚 Documentation

MCP Tools

The server exposes the following MCP tools:

capture_thought

Create a thought in the thought history and record metadata about the thought type, quality, content, and its relationship to other thoughts.

Parameters:

• thought: The content of the thought
• thought_number: The current sequential number
• total_thoughts: The estimated total number of thoughts
• next_thought_needed: Whether another thought is needed
• stage: The current thinking stage (e.g., "problem definition", "analysis")
• branch: The branch ID
• parent_id: The parent ID
• context: Context information

revise_thought

Revise or update an existing thought.

Parameters:

• thought_id: The thought ID
• new_thought: The new thought content
• stage: The new stage (optional)
• branch: The branch ID (optional)

merge_thoughts

Merge two or more thoughts.

Parameters:

• source_ids: A list of source thought IDs
• target_id: The target thought ID
• context: Context information (optional)

delete_thought

Delete a specific thought and all its related data.

Parameters:

• thought_id: The thought ID
• recursive: Whether to recursively delete branches (optional, default is false)

💻 Usage Examples

Basic Usage

// Capture a new thought
capture_thought({
  thought: "We need to add user authentication functionality",
  stage: "Problem Definition",
  branch: "auth-feature"
});

// Revise an existing thought
revise_thought({
  thought_id: "12345",
  new_thought: "We need to implement user authentication functionality in the next sprint"
});

// Merge thoughts
merge_thoughts({
  source_ids: ["67890", "54321"],
  target_id: "43210"
});

// Delete an old thought
delete_thought({
  thought_id: "12345",
  recursive: true
});

📄 Summary

This TypeScript MCP server provides a structured environment for LLMs to support complex thinking and problem-solving processes. By capturing, revising, merging, and deleting thoughts, users can effectively manage the thinking process and make adjustments when needed. Despite the current limitations, future work will focus on enhancing its functionality and expanding its capabilities.