Enhance README and server functionality for Sequential Thinking MCP Server

- Updated project description and features in README.md
- Added new features: thought categorization, dynamic adaptation, and summary generation
- Introduced ThoughtStage enum for structured thought processing in server.py
- Enhanced ThoughtData class with scoring and tagging capabilities
- Implemented generate_summary method to summarize the thinking process

Author: arben-adm

README.md

@@ -1,13 +1,16 @@
-# Sequential Thinking MCP Server
+# Enhanced Sequential Thinking MCP Server
 
-A Model Context Protocol (MCP) server that helps break down complex problems into clear, sequential steps. This tool enhances structured problem-solving by managing thought sequences, allowing revisions, and supporting multiple solution paths.
+This project implements an advanced Sequential Thinking server using the Model Context Protocol (MCP). It provides a structured and flexible approach to problem-solving and decision-making through a series of thought steps, incorporating stages, scoring, and tagging.
 
 <a href="https://glama.ai/mcp/servers/m83dfy8feg"><img width="380" height="200" src="https://glama.ai/mcp/servers/m83dfy8feg/badge" alt="Sequential Thinking Server MCP server" /></a>
 
 ## Features
 
-- 🧠 **Sequential Problem Solving**: Break down complex problems step-by-step
-- 📊 **Progress Tracking**: Monitor thought sequences and branches
+- 🧠 **Structured Problem Solving**: Break down complex problems into defined stages
+- 📊 **Progress Tracking**: Monitor thought sequences, branches, and revisions
+- 🏷️ **Thought Categorization**: Tag and score thoughts for better organization
+- 📈 **Dynamic Adaptation**: Adjust the thinking process as new insights emerge
+- 📝 **Summary Generation**: Get an overview of the entire thinking process
 
 ## Prerequisites
 
@@ -38,6 +41,12 @@ mcp-sequential-thinking/
    uv pip install -e .
    ```
 
+2. **Run the Server**
+   ```bash
+   cd mcp_sequential_thinking
+   uv run server.py
+   ```
+
 ## Claude Desktop Integration
 
 Add to your Claude Desktop configuration (`%APPDATA%\Claude\claude_desktop_config.json` on Windows):
@@ -58,13 +67,31 @@ Add to your Claude Desktop configuration (`%APPDATA%\Claude\claude_desktop_confi
 }
 ```
 
-## Development
+## API
 
-Test the server manually:
-```bash
-cd mcp_sequential_thinking
-uv run server.py
-```
+The server exposes two main tools:
+
+### 1. `sequential_thinking`
+
+This tool processes individual thoughts in the sequential thinking process.
+
+Parameters:
+- `thought` (str): The content of the current thought
+- `thought_number` (int): The sequence number of the current thought
+- `total_thoughts` (int): The total number of thoughts expected
+- `next_thought_needed` (bool): Whether another thought is needed
+- `stage` (str): The current stage of thinking (Problem Definition, Analysis, Ideation, Evaluation, Conclusion)
+- `is_revision` (bool, optional): Whether this revises previous thinking
+- `revises_thought` (int, optional): Which thought is being reconsidered
+- `branch_from_thought` (int, optional): Branching point thought number
+- `branch_id` (str, optional): Branch identifier
+- `needs_more_thoughts` (bool, optional): If more thoughts are needed
+- `score` (float, optional): Score for the thought (0.0 to 1.0)
+- `tags` (List[str], optional): List of tags for categorizing the thought
+
+### 2. `get_thinking_summary`
+
+This tool generates a summary of the entire thinking process.
 
 ## Troubleshooting
 
@@ -75,19 +102,6 @@ Common issues:
   - Check Claude Desktop logs: `%APPDATA%\Claude\logs`
   - Test manual server start
 
-## Parameters
-
-| Parameter | Description | Required |
-|-----------|-------------|----------|
-| `thought` | Current thinking step | Yes |
-| `thought_number` | Step sequence number | Yes |
-| `total_thoughts` | Estimated steps needed | Yes |
-| `next_thought_needed` | Indicates if more steps required | Yes |
-| `is_revision` | Marks thought revision | No |
-| `revises_thought` | Identifies thought being revised | No |
-| `branch_from_thought` | Starting point for new branch | No |
-| `branch_id` | Unique branch identifier | No |
-
 ## License
 
 MIT License

mcp_sequential_thinking/server.py

@@ -1,24 +1,35 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from typing import Dict, List, Optional, Any
 import json
+from enum import Enum
 from mcp.server.fastmcp import FastMCP
 from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
 
 console = Console(stderr=True)
 
+class ThoughtStage(Enum):
+    PROBLEM_DEFINITION = "Problem Definition"
+    ANALYSIS = "Analysis"
+    IDEATION = "Ideation"
+    EVALUATION = "Evaluation"
+    CONCLUSION = "Conclusion"
+
 @dataclass
 class ThoughtData:
     thought: str
     thought_number: int
     total_thoughts: int
     next_thought_needed: bool
+    stage: ThoughtStage
     is_revision: Optional[bool] = None
     revises_thought: Optional[int] = None
     branch_from_thought: Optional[int] = None
     branch_id: Optional[str] = None
     needs_more_thoughts: Optional[bool] = None
+    score: Optional[float] = None
+    tags: List[str] = field(default_factory=list)
 
 class SequentialThinkingServer:
     def __init__(self):
@@ -31,7 +42,8 @@ def _validate_thought_data(self, input_data: dict) -> ThoughtData:
             "thought": str,
             "thoughtNumber": int,
             "totalThoughts": int,
-            "nextThoughtNeeded": bool
+            "nextThoughtNeeded": bool,
+            "stage": str
         }
 
         for field, field_type in required_fields.items():
@@ -40,16 +52,24 @@ def _validate_thought_data(self, input_data: dict) -> ThoughtData:
             if not isinstance(input_data[field], field_type):
                 raise ValueError(f"Invalid type for {field}: expected {field_type}")
 
+        try:
+            stage = ThoughtStage(input_data["stage"])
+        except ValueError:
+            raise ValueError(f"Invalid stage: {input_data['stage']}")
+        
         return ThoughtData(
             thought=input_data["thought"],
             thought_number=input_data["thoughtNumber"],
             total_thoughts=input_data["totalThoughts"],
             next_thought_needed=input_data["nextThoughtNeeded"],
+            stage=stage,
             is_revision=input_data.get("isRevision"),
             revises_thought=input_data.get("revisesThought"),
             branch_from_thought=input_data.get("branchFromThought"),
             branch_id=input_data.get("branchId"),
-            needs_more_thoughts=input_data.get("needsMoreThoughts")
+            needs_more_thoughts=input_data.get("needsMoreThoughts"),
+            score=input_data.get("score"),
+            tags=input_data.get("tags", [])
         )
 
     def _format_thought(self, thought_data: ThoughtData) -> Panel:
@@ -67,11 +87,12 @@ def _format_thought(self, thought_data: ThoughtData) -> Panel:
             context = ""
             style = "blue"
 
-        header = Text(f"{prefix} {thought_data.thought_number}/{thought_data.total_thoughts}{context}", style=style)
+        header = Text(f"{prefix} {thought_data.thought_number}/{thought_data.total_thoughts} - {thought_data.stage.value}{context}", style=style)
         content = Text(thought_data.thought)
+        footer = Text(f"Score: {thought_data.score:.2f} | Tags: {', '.join(thought_data.tags)}" if thought_data.score is not None else f"Tags: {', '.join(thought_data.tags)}")
 
         return Panel.fit(
-            content,
+            Group(content, footer),
             title=header,
             border_style=style,
             padding=(1, 2)
@@ -105,8 +126,11 @@ def process_thought(self, input_data: Any) -> dict:
                         "thoughtNumber": thought_data.thought_number,
                         "totalThoughts": thought_data.total_thoughts,
                         "nextThoughtNeeded": thought_data.next_thought_needed,
+                        "stage": thought_data.stage.value,
                         "branches": list(self.branches.keys()),
-                        "thoughtHistoryLength": len(self.thought_history)
+                        "thoughtHistoryLength": len(self.thought_history),
+                        "score": thought_data.score,
+                        "tags": thought_data.tags
                     }, indent=2)
                 }]
             }
@@ -123,6 +147,17 @@ def process_thought(self, input_data: Any) -> dict:
                 "isError": True
             }
 
+    def generate_summary(self) -> str:
+        """Generate a summary of the thinking process."""
+        summary = []
+        for stage in ThoughtStage:
+            stage_thoughts = [t for t in self.thought_history if t.stage == stage]
+            if stage_thoughts:
+                summary.append(f"{stage.value}:")
+                for thought in stage_thoughts:
+                    summary.append(f"  - Thought {thought.thought_number}: {thought.thought[:50]}...")
+        return "\n".join(summary)
+
 def create_server() -> FastMCP:
     """Create and configure the MCP server."""
     mcp = FastMCP("sequential-thinking")
@@ -134,43 +169,58 @@ async def sequential_thinking(
         thought_number: int,
         total_thoughts: int,
         next_thought_needed: bool,
+        stage: str,
         is_revision: Optional[bool] = None,
         revises_thought: Optional[int] = None,
         branch_from_thought: Optional[int] = None,
         branch_id: Optional[str] = None,
-        needs_more_thoughts: Optional[bool] = None
+        needs_more_thoughts: Optional[bool] = None,
+        score: Optional[float] = None,
+        tags: Optional[List[str]] = None
     ) -> str:
-        """A detailed tool for dynamic and reflective problem-solving through thoughts.
+        """An advanced tool for dynamic and reflective problem-solving through structured thoughts.
         
         This tool helps analyze problems through a flexible thinking process that can adapt and evolve.
-        Each thought can build on, question, or revise previous insights as understanding deepens.
+        Each thought is categorized into specific stages, can be scored, tagged, and can build on, 
+        question, or revise previous insights as understanding deepens.
         
         Args:
             thought: Your current thinking step
             thought_number: Current thought number in sequence
             total_thoughts: Current estimate of thoughts needed
             next_thought_needed: Whether another thought step is needed
+            stage: The current stage of thinking (Problem Definition, Analysis, Ideation, Evaluation, Conclusion)
             is_revision: Whether this revises previous thinking
             revises_thought: Which thought is being reconsidered
             branch_from_thought: Branching point thought number
             branch_id: Branch identifier
             needs_more_thoughts: If more thoughts are needed
+            score: Optional score for the thought (0.0 to 1.0)
+            tags: Optional list of tags for categorizing the thought
         """
         input_data = {
             "thought": thought,
             "thoughtNumber": thought_number,
             "totalThoughts": total_thoughts,
             "nextThoughtNeeded": next_thought_needed,
+            "stage": stage,
             "isRevision": is_revision,
             "revisesThought": revises_thought,
             "branchFromThought": branch_from_thought,
             "branchId": branch_id,
-            "needsMoreThoughts": needs_more_thoughts
+            "needsMoreThoughts": needs_more_thoughts,
+            "score": score,
+            "tags": tags or []
         }
 
         result = thinking_server.process_thought(input_data)
         return result["content"][0]["text"]
 
+    @mcp.tool()
+    async def get_thinking_summary() -> str:
+        """Generate a summary of the entire thinking process."""
+        return thinking_server.generate_summary()
+
     return mcp
 
 def main():
@@ -180,4 +230,4 @@ def main():
 
 if __name__ == "__main__":
     server = create_server()
-    server.run()
+    server.run()