mcp-server-mas-sequential-thinking 0.2.1__py3-none-any.whl → 0.2.3__py3-none-any.whl

main.py

@@ -308,7 +308,7 @@ def get_model_config() -> tuple[Type[Model], str, str]:
         ModelClass = DeepSeek
         # Use environment variables for DeepSeek model IDs if set, otherwise use defaults
         team_model_id = os.environ.get("DEEPSEEK_TEAM_MODEL_ID", "deepseek-chat")
-        agent_model_id = os.environ.get("DEEPSEEK_AGENT_MODEL_ID", "deepseek-reasoner")
+        agent_model_id = os.environ.get("DEEPSEEK_AGENT_MODEL_ID", "deepseek-chat")
         logger.info(f"Using DeepSeek: Team Model='{team_model_id}', Agent Model='{agent_model_id}'")
     elif provider == "groq":
         ModelClass = Groq
@@ -465,6 +465,7 @@ def create_sequential_thinking_team() -> Team:
             " 5. Formulate a response presenting the synthesized information or conclusions.",
             " 6. Return your response to the Team Coordinator.",
             "Focus on creating clarity and coherence for the delegated synthesis task.",
+            "**For the final synthesis task provided by the Coordinator:** Aim for a concise and high-level integration. Focus on the core synthesized understanding and key takeaways, rather than detailing the step-by-step process or extensive analysis of each component.",
         ],
         model=agent_model_instance, # Use the designated agent model
         add_datetime_to_instructions=True,
@@ -573,18 +574,20 @@ mcp = FastMCP()
 
 # --- MCP Handlers ---
 
-@mcp.prompt("sequential-thinking-starter")
-def sequential_thinking_starter(problem: str, context: str = ""):
+@mcp.prompt("sequential-thinking")
+def sequential_thinking_prompt(problem: str, context: str = ""):
     """
     Starter prompt for sequential thinking that ENCOURAGES non-linear exploration
-    using coordinate mode.
+    using coordinate mode. Returns separate user and assistant messages.
     """
     min_thoughts = 5 # Set a reasonable minimum number of initial thoughts
 
-    prompt_text = f"""Initiate a comprehensive sequential thinking process for the following problem:
+    user_prompt_text = f"""Initiate a comprehensive sequential thinking process for the following problem:
 
 Problem: {problem}
-{f'Context: {context}' if context else ''}
+{f'Context: {context}' if context else ''}"""
+
+    assistant_guidelines = f"""Okay, let's start the sequential thinking process. Here are the guidelines and the process we'll follow using the 'coordinate' mode team:
 
 **Sequential Thinking Goals & Guidelines (Coordinate Mode):**
 
@@ -600,17 +603,22 @@ Problem: {problem}
 
 **Process:**
 
-*   The `sequentialthinking` tool will track your progress. The Agno team operates in 'coordinate' mode. The Coordinator agent receives your thought, delegates sub-tasks to specialists (like Analyzer, Critic), and synthesizes their results, potentially including recommendations for revision or branching.
+*   The `sequentialthinking` tool will track your progress. The Agno team operates in 'coordinate' mode. The Coordinator agent receives your thought, delegates sub-tasks to specialists (like Analyzer, Critic), and synthesizes their outputs, potentially including recommendations for revision or branching.
 *   Focus on insightful analysis, constructive critique (leading to potential revisions), and creative exploration (leading to potential branching).
-*   Actively reflect on the process. Linear thinking might be insufficient for complex problems. Proceed with the first thought."""
+*   Actively reflect on the process. Linear thinking might be insufficient for complex problems.
 
-    return {
-        "description": "Mandatory non-linear sequential thinking starter prompt (coordinate mode)",
-        "messages": [{"role": "user", "content": {"type": "text", "text": prompt_text}}]
-    }
+Proceed with the first thought based on these guidelines."""
+
+    return [
+        {
+            "description": "Starter prompt for non-linear sequential thinking (coordinate mode), providing problem and guidelines separately.",
+            "messages": [
+                {"role": "user", "content": {"type": "text", "text": user_prompt_text}},
+                {"role": "assistant", "content": {"type": "text", "text": assistant_guidelines}}
+            ]
+        }
+    ]
 
-# Removed process_agent_tasks function as it's not needed for coordinate mode.
-# The Team's coordinator handles delegation internally.
 
 @mcp.tool()
 async def sequentialthinking(thought: str, thoughtNumber: int, totalThoughts: int, nextThoughtNeeded: bool,
@@ -618,26 +626,60 @@ async def sequentialthinking(thought: str, thoughtNumber: int, totalThoughts: in
                       branchFromThought: Optional[int] = None, branchId: Optional[str] = None,
                       needsMoreThoughts: bool = False) -> str:
     """
-    Processes one step in a sequential thinking chain using the Agno team in coordinate mode.
-
-    The Coordinator agent within the team receives the thought, breaks it down,
-    delegates to specialists (Planner, Researcher, Analyzer, Critic, Synthesizer),
-    and synthesizes their outputs into a final response. The Coordinator's response
-    may include suggestions for revision or branching.
+    A detailed tool for dynamic and reflective problem-solving through 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.
+    It uses an Agno multi-agent team (in coordinate mode) to process each thought, where a
+    Coordinator delegates sub-tasks to specialists (Planner, Researcher, Analyzer, Critic, Synthesizer)
+    and synthesizes their outputs.
+
+    When to use this tool:
+    - Breaking down complex problems into manageable steps.
+    - Planning and design processes requiring iterative refinement and revision.
+    - Complex analysis where the approach might need course correction based on findings.
+    - Problems where the full scope or optimal path is not clear initially.
+    - Situations requiring a multi-step solution with context maintained across steps.
+    - Tasks where focusing on relevant information and filtering out noise is crucial.
+    - Developing and verifying solution hypotheses through a chain of reasoning.
+
+    Key features & usage guidelines:
+    - The process is driven by the caller (e.g., an LLM) making sequential calls to this tool.
+    - Start with an initial estimate for `totalThoughts`, but adjust it dynamically via subsequent calls if needed.
+    - Use `isRevision=True` and `revisesThought` to explicitly revisit and correct previous steps.
+    - Use `branchFromThought` and `branchId` to explore alternative paths or perspectives.
+    - If the estimated `totalThoughts` is reached but more steps are needed, set `needsMoreThoughts=True` on the *last* thought within the current estimate to signal the need for extension.
+    - Express uncertainty and explore alternatives within the `thought` content.
+    - Generate solution hypotheses within the `thought` content when appropriate.
+    - Verify hypotheses in subsequent `thought` steps based on the reasoning chain.
+    - The caller should repeat the process, calling this tool for each step, until a satisfactory solution is reached.
+    - Set `nextThoughtNeeded=False` only when the caller determines the process is complete and a final answer is ready.
 
     Parameters:
-        thought (str): The current thinking step.
-        thoughtNumber (int): Current sequence number (≥1)
-        totalThoughts (int): Estimated total thoughts needed (≥5 suggested)
-        nextThoughtNeeded (bool): Whether another thought step is needed
-        isRevision (bool, optional): Whether this revises previous thinking
-        revisesThought (int, optional): Which thought is being reconsidered
-        branchFromThought (int, optional): If branching, which thought number is the branch point
-        branchId (str, optional): Branch identifier
-        needsMoreThoughts (bool, optional): If more thoughts are needed beyond current estimate
+        thought (str): The content of the current thinking step. This can be an analytical step,
+                       a plan, a question, a critique, a revision, a hypothesis, or verification.
+                       Make it specific enough to imply the desired action.
+        thoughtNumber (int): The sequence number of this thought (>=1). Can exceed initial `totalThoughts`
+                             if the process is extended.
+        totalThoughts (int): The current *estimate* of the total thoughts required for the process.
+                             This can be adjusted by the caller in subsequent calls. Minimum 5 suggested.
+        nextThoughtNeeded (bool): Indicates if the caller intends to make another call to this tool
+                                  after the current one. Set to False only when the entire process is deemed complete.
+        isRevision (bool, optional): True if this thought revises or corrects a previous thought. Defaults to False.
+        revisesThought (int, optional): The `thoughtNumber` of the thought being revised, required if `isRevision` is True.
+                                        Must be less than the current `thoughtNumber`.
+        branchFromThought (int, optional): The `thoughtNumber` from which this thought branches to explore an alternative path.
+                                           Defaults to None.
+        branchId (str, optional): A unique identifier for the branch being explored, required if `branchFromThought` is set.
+                                  Defaults to None.
+        needsMoreThoughts (bool, optional): Set to True on a thought if the caller anticipates needing more
+                                            steps beyond the current `totalThoughts` estimate *after* this thought.
+                                            Defaults to False.
 
     Returns:
-        str: JSON string containing the Coordinator's synthesized response and status.
+        str: The Coordinator agent's synthesized response based on specialist contributions for the current `thought`.
+             Includes guidance for the caller on potential next steps (e.g., suggestions for revision or branching
+             based on the specialists' analysis). The caller uses this response to formulate the *next* thought.
     """
     global app_context
     if not app_context or not app_context.team:
@@ -651,10 +693,8 @@ async def sequentialthinking(thought: str, thoughtNumber: int, totalThoughts: in
              logger.info("Successfully re-initialized team and context.")
         except Exception as init_err:
              logger.critical(f"Failed to re-initialize Agno team during tool call: {init_err}", exc_info=True)
-             return json.dumps({
-                 "error": "Critical Error: Application context not available and re-initialization failed.",
-                 "status": "critical_failure"
-             }, indent=2, ensure_ascii=False)
+             # Return only the error message string
+             return f"Critical Error: Application context not available and re-initialization failed: {init_err}"
              # Or raise Exception("Critical Error: Application context not available.")
 
     MIN_TOTAL_THOUGHTS = 5 # Keep a minimum suggestion
@@ -730,23 +770,25 @@ async def sequentialthinking(thought: str, thoughtNumber: int, totalThoughts: in
         # Call the team's arun method. The coordinator agent will handle it.
         team_response = await app_context.team.arun(input_prompt)
 
-        coordinator_response = team_response.content if hasattr(team_response, 'content') else str(team_response)
+        # Ensure coordinator_response is a string, default to empty string if None
+        coordinator_response_content = team_response.content if hasattr(team_response, 'content') else None
+        coordinator_response = str(coordinator_response_content) if coordinator_response_content is not None else ""
+
         logger.info(f"Coordinator finished processing thought #{thoughtNumber}.")
         logger.debug(f"Coordinator Raw Response:\n{coordinator_response}")
 
 
         # --- Guidance for Next Step (Coordinate Mode) ---
-        additional_guidance = "\n\nGuidance for next step:"
-        next_thought_num = current_input_thought.thoughtNumber + 1
+        additional_guidance = "\n\nGuidance for next step:" # Initialize
 
         if not current_input_thought.nextThoughtNeeded:
-             additional_guidance = "\n\nThis is the final thought based on current estimates or your signal. Review the Coordinator's final synthesis."
+            # Keep the message for the final thought concise
+            additional_guidance = "\n\nThis is the final thought. Review the Coordinator's final synthesis."
         else:
-            additional_guidance += " Review the Coordinator's synthesized response above."
-            additional_guidance += "\n**Revision/Branching:** Did the Coordinator recommend revising a previous thought ('RECOMMENDATION: Revise thought #X...')? If so, use `isRevision=True` and `revisesThought=X` in your next call."
-            additional_guidance += " Did the Coordinator suggest exploring alternatives ('SUGGESTION: Consider branching...')? If so, consider using `branchFromThought=Y` and `branchId='new-branch-Z'`."
-            additional_guidance += "\n**Next Thought:** Based on the Coordinator's output and the overall goal, formulate the next logical thought. Address any specific points raised by the Coordinator."
-            additional_guidance += "\n**ToT Principle:** If the Coordinator highlighted multiple viable paths or unresolved alternatives, consider initiating parallel branches (using distinct `branchId`s originating from the same `branchFromThought`) in subsequent steps to explore them, aiming for later evaluation/synthesis."
+            # Start guidance text for non-final thoughts
+            additional_guidance += "\n- **Revision/Branching:** Look for 'RECOMMENDATION: Revise thought #X...' or 'SUGGESTION: Consider branching...' in the response."
+            additional_guidance += " Use `isRevision=True`/`revisesThought=X` for revisions or `branchFromThought=Y`/`branchId='...'` for branching accordingly."
+            additional_guidance += "\n- **Next Thought:** Based on the Coordinator's response, formulate the next logical thought, addressing any points raised."
 
 
         # --- Build Result ---
@@ -754,7 +796,8 @@ async def sequentialthinking(thought: str, thoughtNumber: int, totalThoughts: in
             "processedThoughtNumber": current_input_thought.thoughtNumber,
             "estimatedTotalThoughts": current_input_thought.totalThoughts,
             "nextThoughtNeeded": current_input_thought.nextThoughtNeeded,
-            "coordinatorResponse": coordinator_response + additional_guidance, # Coordinator's synthesized response + guidance
+            # Ensure both parts are strings before concatenating
+            "coordinatorResponse": coordinator_response + str(additional_guidance),
             "branches": list(app_context.branches.keys()),
             "thoughtHistoryLength": len(app_context.thought_history),
             "branchDetails": {
@@ -768,21 +811,17 @@ async def sequentialthinking(thought: str, thoughtNumber: int, totalThoughts: in
             "status": "success"
         }
 
-        return json.dumps(result_data, indent=2, ensure_ascii=False)
+        # Return only the coordinatorResponse string
+        return result_data["coordinatorResponse"]
 
     except ValidationError as e:
         logger.error(f"Validation Error processing tool call: {e}")
-        # Provide detailed validation error back to the caller
-        return json.dumps({
-            "error": f"Input validation failed: {e}",
-            "status": "validation_error"
-        }, indent=2, ensure_ascii=False)
+        # Return only the error message string
+        return f"Input validation failed: {e}"
     except Exception as e:
         logger.exception(f"Error processing tool call") # Log full traceback
-        return json.dumps({
-            "error": f"An unexpected error occurred: {str(e)}",
-            "status": "failed"
-        }, indent=2, ensure_ascii=False)
+        # Return only the error message string
+        return f"An unexpected error occurred: {str(e)}"
 
 # --- Main Execution ---
 

mcp_server_mas_sequential_thinking-0.2.3.dist-info/METADATA

@@ -0,0 +1,329 @@
+Metadata-Version: 2.4
+Name: mcp-server-mas-sequential-thinking
+Version: 0.2.3
+Summary: MCP Agent Implementation for Sequential Thinking
+Author-email: Frad LEE <fradser@gmail.com>
+Requires-Python: >=3.10
+Requires-Dist: agno
+Requires-Dist: asyncio
+Requires-Dist: exa-py
+Requires-Dist: groq
+Requires-Dist: mcp
+Requires-Dist: python-dotenv
+Provides-Extra: dev
+Requires-Dist: black; extra == 'dev'
+Requires-Dist: isort; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Sequential Thinking Multi-Agent System (MAS) ![](https://img.shields.io/badge/A%20FRAD%20PRODUCT-WIP-yellow)
+
+[![smithery badge](https://smithery.ai/badge/@FradSer/mcp-server-mas-sequential-thinking)](https://smithery.ai/server/@FradSer/mcp-server-mas-sequential-thinking) [![Twitter Follow](https://img.shields.io/twitter/follow/FradSer?style=social)](https://twitter.com/FradSer) [![Python Version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/) [![Framework](https://img.shields.io/badge/Framework-Agno-orange.svg)](https://github.com/cognitivecomputations/agno)
+
+English | [简体中文](README.zh-CN.md)
+
+This project implements an advanced sequential thinking process using a **Multi-Agent System (MAS)** built with the **Agno** framework and served via **MCP**. It represents a significant evolution from simpler state-tracking approaches by leveraging coordinated, specialized agents for deeper analysis and problem decomposition.
+
+## Overview
+
+This server provides a sophisticated `sequentialthinking` tool designed for complex problem-solving. Unlike [its predecessor](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking), this version utilizes a true Multi-Agent System (MAS) architecture where:
+
+- **A Coordinating Agent** (the `Team` object in `coordinate` mode) manages the workflow.
+- **Specialized Agents** (Planner, Researcher, Analyzer, Critic, Synthesizer) handle specific sub-tasks based on their defined roles and expertise.
+- Incoming thoughts are actively **processed, analyzed, and synthesized** by the agent team, not just logged.
+- The system supports complex thought patterns, including **revisions** of previous steps and **branching** to explore alternative paths.
+- Integration with external tools like **Exa** (via the Researcher agent) allows for dynamic information gathering.
+- Robust **Pydantic** validation ensures data integrity for thought steps.
+- Detailed **logging** tracks the process, including agent interactions (handled by the coordinator).
+
+The goal is to achieve a higher quality of analysis and a more nuanced thinking process than possible with a single agent or simple state tracking by harnessing the power of specialized roles working collaboratively.
+
+## Key Differences from Original Version (TypeScript)
+
+This Python/Agno implementation marks a fundamental shift from the original TypeScript version:
+
+| Feature/Aspect      | Python/Agno Version (Current)                                        | TypeScript Version (Original)                        |
+| :------------------ | :------------------------------------------------------------------- | :--------------------------------------------------- |
+| **Architecture**    | **Multi-Agent System (MAS)**; Active processing by a team of agents. | **Single Class State Tracker**; Simple logging/storing. |
+| **Intelligence**    | **Distributed Agent Logic**; Embedded in specialized agents & Coordinator. | **External LLM Only**; No internal intelligence.     |
+| **Processing**      | **Active Analysis & Synthesis**; Agents *act* on the thought.      | **Passive Logging**; Merely recorded the thought.    |
+| **Frameworks**      | **Agno (MAS) + FastMCP (Server)**; Uses dedicated MAS library.     | **MCP SDK only**.                                    |
+| **Coordination**    | **Explicit Team Coordination Logic** (`Team` in `coordinate` mode).  | **None**; No coordination concept.                   |
+| **Validation**      | **Pydantic Schema Validation**; Robust data validation.            | **Basic Type Checks**; Less reliable.              |
+| **External Tools**  | **Integrated (Exa via Researcher)**; Can perform research tasks.   | **None**.                                            |
+| **Logging**         | **Structured Python Logging (File + Console)**; Configurable.      | **Console Logging with Chalk**; Basic.             |
+| **Language & Ecosystem** | **Python**; Leverages Python AI/ML ecosystem.                    | **TypeScript/Node.js**.                              |
+
+In essence, the system evolved from a passive thought *recorder* to an active thought *processor* powered by a collaborative team of AI agents.
+
+## How it Works (Coordinate Mode)
+
+1.  **Initiation:** An external LLM uses the `sequential-thinking-starter` prompt to define the problem and initiate the process.
+2.  **Tool Call:** The LLM calls the `sequentialthinking` tool with the first (or subsequent) thought, structured according to the `ThoughtData` Pydantic model.
+3.  **Validation & Logging:** The tool receives the call, validates the input using Pydantic, logs the incoming thought, and updates the history/branch state via `AppContext`.
+4.  **Coordinator Invocation:** The core thought content (along with context about revisions/branches) is passed to the `SequentialThinkingTeam`'s `arun` method.
+5.  **Coordinator Analysis & Delegation:** The `Team` (acting as Coordinator) analyzes the input thought, breaks it down into sub-tasks, and delegates these sub-tasks to the *most relevant* specialist agents (e.g., Analyzer for analysis tasks, Researcher for information needs).
+6.  **Specialist Execution:** Delegated agents execute their specific sub-tasks using their instructions, models, and tools (like `ThinkingTools` or `ExaTools`).
+7.  **Response Collection:** Specialists return their results to the Coordinator.
+8.  **Synthesis & Guidance:** The Coordinator synthesizes the specialists' responses into a single, cohesive output. This output may include recommendations for revision or branching based on the specialists' findings (especially from the Critic and Analyzer). It also provides guidance for the LLM on formulating the next thought.
+9.  **Return Value:** The tool returns a JSON string containing the Coordinator's synthesized response, status, and updated context (branches, history length).
+10. **Iteration:** The calling LLM uses the Coordinator's response and guidance to formulate the next `sequentialthinking` tool call, potentially triggering revisions or branches as suggested.
+
+## Token Consumption Warning
+
+⚠️ **High Token Usage:** Due to the Multi-Agent System architecture, this tool consumes significantly **more tokens** than single-agent alternatives or the previous TypeScript version. Each `sequentialthinking` call invokes:
+
+- The Coordinator agent (the `Team` itself).
+- Multiple specialist agents (potentially Planner, Researcher, Analyzer, Critic, Synthesizer, depending on the Coordinator's delegation).
+
+This parallel processing leads to substantially higher token usage (potentially 3-6x or more per thought step) compared to single-agent or state-tracking approaches. Budget and plan accordingly. This tool prioritizes **analysis depth and quality** over token efficiency.
+
+## Prerequisites
+
+- Python 3.10+
+- Access to a compatible LLM API (configured for `agno`). The system currently supports:
+    - **Groq:** Requires `GROQ_API_KEY`.
+    - **DeepSeek:** Requires `DEEPSEEK_API_KEY`.
+    - **OpenRouter:** Requires `OPENROUTER_API_KEY`.
+    - Configure the desired provider using the `LLM_PROVIDER` environment variable (defaults to `deepseek`).
+- Exa API Key (required only if using the Researcher agent's capabilities)
+    - Set via the `EXA_API_KEY` environment variable.
+- `uv` package manager (recommended) or `pip`.
+
+## MCP Server Configuration (Client-Side)
+
+This server runs as a standard executable script that communicates via stdio, as expected by MCP. The exact configuration method depends on your specific MCP client implementation. Consult your client's documentation for details on integrating external tool servers.
+
+The `env` section within your MCP client configuration should include the API key for your chosen `LLM_PROVIDER`.
+
+```json
+{
+  "mcpServers": {
+      "mas-sequential-thinking": {
+         "command": "uvx", // Or "python", "path/to/venv/bin/python" etc.
+         "args": [
+            "mcp-server-mas-sequential-thinking" // Or the path to your main script, e.g., "main.py"
+         ],
+         "env": {
+            "LLM_PROVIDER": "deepseek", // Or "groq", "openrouter"
+            // "GROQ_API_KEY": "your_groq_api_key", // Only if LLM_PROVIDER="groq"
+            "DEEPSEEK_API_KEY": "your_deepseek_api_key", // Default provider
+            // "OPENROUTER_API_KEY": "your_openrouter_api_key", // Only if LLM_PROVIDER="openrouter"
+            "DEEPSEEK_BASE_URL": "your_base_url_if_needed", // Optional: If using a custom endpoint for DeepSeek
+            "EXA_API_KEY": "your_exa_api_key" // Only if using Exa
+         }
+      }
+   }
+}
+```
+
+## Installation & Setup
+
+### Installing via Smithery
+
+To install Sequential Thinking Multi-Agent System for Claude Desktop automatically via [Smithery](https://smithery.ai/server/@FradSer/mcp-server-mas-sequential-thinking):
+
+```bash
+npx -y @smithery/cli install @FradSer/mcp-server-mas-sequential-thinking --client claude
+```
+
+### Manual Installation
+1.  **Clone the repository:**
+    ```bash
+    git clone git@github.com:FradSer/mcp-server-mas-sequential-thinking.git
+    cd mcp-server-mas-sequential-thinking
+    ```
+
+2.  **Set Environment Variables:**
+    Create a `.env` file in the project root directory or export the variables directly into your environment:
+    ```dotenv
+    # --- LLM Configuration ---
+    # Select the LLM provider: "deepseek" (default), "groq", or "openrouter"
+    LLM_PROVIDER="deepseek"
+
+    # Provide the API key for the chosen provider:
+    # GROQ_API_KEY="your_groq_api_key"
+    DEEPSEEK_API_KEY="your_deepseek_api_key"
+    # OPENROUTER_API_KEY="your_openrouter_api_key"
+
+    # Optional: Base URL override (e.g., for custom DeepSeek endpoints)
+    # DEEPSEEK_BASE_URL="your_base_url_if_needed"
+
+    # Optional: Specify different models for Team Coordinator and Specialist Agents
+    # Defaults are set within the code based on the provider if these are not set.
+    # Example for Groq:
+    # GROQ_TEAM_MODEL_ID="llama3-70b-8192"
+    # GROQ_AGENT_MODEL_ID="llama3-8b-8192"
+    # Example for DeepSeek:
+    # DEEPSEEK_TEAM_MODEL_ID="deepseek-chat" # Note: `deepseek-reasoner` is not recommended as it doesn't support function calling
+    # DEEPSEEK_AGENT_MODEL_ID="deepseek-chat" # Recommended for specialists
+    # Example for OpenRouter:
+    # OPENROUTER_TEAM_MODEL_ID="deepseek/deepseek-r1" # Example, adjust as needed
+    # OPENROUTER_AGENT_MODEL_ID="deepseek/deepseek-chat" # Example, adjust as needed
+
+    # --- External Tools ---
+    # Required ONLY if the Researcher agent is used and needs Exa
+    EXA_API_KEY="your_exa_api_key"
+    ```
+
+    **Note on Model Selection:**
+    - The `TEAM_MODEL_ID` is used by the Coordinator (`Team` object). This role benefits from strong reasoning, synthesis, and delegation capabilities. Consider using a more powerful model (e.g., `deepseek-chat`, `claude-3-opus`, `gpt-4-turbo`) here, potentially balancing capability with cost/speed.
+    - The `AGENT_MODEL_ID` is used by the specialist agents (Planner, Researcher, etc.). These handle focused sub-tasks. A faster or more cost-effective model (e.g., `deepseek-chat`, `claude-3-sonnet`, `llama3-8b`) might be suitable, depending on task complexity and budget/performance needs.
+    - Defaults are provided in the code (e.g., in `main.py`) if these environment variables are not set. Experimentation is encouraged to find the optimal balance for your use case.
+
+3.  **Install Dependencies:**
+    It's highly recommended to use a virtual environment.
+
+    - **Using `uv` (Recommended):**
+        ```bash
+        # Install uv if you don't have it:
+        # curl -LsSf https://astral.sh/uv/install.sh | sh
+        # source $HOME/.cargo/env # Or restart your shell
+
+        # Create and activate a virtual environment (optional but recommended)
+        python -m venv .venv
+        source .venv/bin/activate # On Windows use `.venv\\Scripts\\activate`
+
+        # Install dependencies
+        uv pip install -r requirements.txt
+        # Or if a pyproject.toml exists with dependencies defined:
+        # uv pip install .
+        ```
+    - **Using `pip`:**
+        ```bash
+        # Create and activate a virtual environment (optional but recommended)
+        python -m venv .venv
+        source .venv/bin/activate # On Windows use `.venv\\Scripts\\activate`
+
+        # Install dependencies
+        pip install -r requirements.txt
+        # Or if a pyproject.toml exists with dependencies defined:
+        # pip install .
+        ```
+
+## Usage
+
+Ensure your environment variables are set and the virtual environment (if used) is active.
+
+Run the server. Choose one of the following methods:
+
+1.  **Using `uv run` (Recommended):**
+    ```bash
+    uv --directory /path/to/mcp-server-mas-sequential-thinking run mcp-server-mas-sequential-thinking
+    ```
+2.  **Directly using Python:**
+
+    ```bash
+    python main.py
+    ```
+
+The server will start and listen for requests via stdio, making the `sequentialthinking` tool available to compatible MCP clients configured to use it.
+
+### `sequentialthinking` Tool Parameters
+
+The tool expects arguments matching the `ThoughtData` Pydantic model:
+
+```python
+# Simplified representation from src/models.py
+class ThoughtData(BaseModel):
+    thought: str                 # Content of the current thought/step
+    thoughtNumber: int           # Sequence number (>=1)
+    totalThoughts: int           # Estimated total steps (>=1, suggest >=5)
+    nextThoughtNeeded: bool      # Is another step required after this?
+    isRevision: bool = False     # Is this revising a previous thought?
+    revisesThought: Optional[int] = None # If isRevision, which thought number?
+    branchFromThought: Optional[int] = None # If branching, from which thought?
+    branchId: Optional[str] = None # Unique ID for the new branch being created
+    needsMoreThoughts: bool = False # Signal if estimate is too low before last step
+```
+
+### Interacting with the Tool (Conceptual Example)
+
+An LLM would interact with this tool iteratively:
+
+1.  **LLM:** Uses a starter prompt (like `sequential-thinking-starter`) with the problem definition.
+2.  **LLM:** Calls `sequentialthinking` tool with `thoughtNumber: 1`, the initial `thought` (e.g., "Plan the analysis..."), an estimated `totalThoughts`, and `nextThoughtNeeded: True`.
+3.  **Server:** MAS processes the thought. The Coordinator synthesizes responses from specialists and provides guidance (e.g., "Analysis plan complete. Suggest researching X next. No revisions recommended yet.").
+4.  **LLM:** Receives the JSON response containing `coordinatorResponse`.
+5.  **LLM:** Formulates the next thought based on the `coordinatorResponse` (e.g., "Research X using available tools...").
+6.  **LLM:** Calls `sequentialthinking` tool with `thoughtNumber: 2`, the new `thought`, potentially updated `totalThoughts`, `nextThoughtNeeded: True`.
+7.  **Server:** MAS processes. The Coordinator synthesizes (e.g., "Research complete. Findings suggest a flaw in thought #1's assumption. RECOMMENDATION: Revise thought #1...").
+8.  **LLM:** Receives the response, notes the recommendation.
+9.  **LLM:** Formulates a revision thought.
+10. **LLM:** Calls `sequentialthinking` tool with `thoughtNumber: 3`, the revision `thought`, `isRevision: True`, `revisesThought: 1`, `nextThoughtNeeded: True`.
+11. **... and so on, potentially branching or extending the process as needed.**
+
+### Tool Response Format
+
+The tool returns a JSON string containing:
+
+```json
+{
+  "processedThoughtNumber": int,          // The thought number that was just processed
+  "estimatedTotalThoughts": int,          // The current estimate of total thoughts
+  "nextThoughtNeeded": bool,              // Whether the process indicates more steps are needed
+  "coordinatorResponse": "...",           // Synthesized output from the agent team, including analysis, findings, and guidance for the next step.
+  "branches": ["main", "branch-id-1"],  // List of active branch IDs
+  "thoughtHistoryLength": int,          // Total number of thoughts processed so far (across all branches)
+  "branchDetails": {
+    "currentBranchId": "main",            // The ID of the branch the processed thought belongs to
+    "branchOriginThought": null | int,    // The thought number where the current branch diverged (null for 'main')
+    "allBranches": {                      // Count of thoughts in each active branch
+      "main": 5,
+      "branch-id-1": 2
+     }
+  },
+  "isRevision": bool,                     // Was the processed thought a revision?
+  "revisesThought": null | int,           // Which thought number was revised (if isRevision is true)
+  "isBranch": bool,                       // Did this thought start a new branch?
+  "status": "success | validation_error | failed", // Outcome status
+  "error": null | "Error message..."     // Error details if status is not 'success'
+}
+```
+
+## Logging
+
+- Logs are written to `~/.sequential_thinking/logs/sequential_thinking.log` by default. (Configuration might be adjustable in the logging setup code).
+- Uses Python's standard `logging` module.
+- Includes a rotating file handler (e.g., 10MB limit, 5 backups) and a console handler (typically INFO level).
+- Logs include timestamps, levels, logger names, and messages, including structured representations of thoughts being processed.
+
+## Development
+
+1.  **Clone the repository:** (As in Installation)
+    ```bash
+    git clone git@github.com:FradSer/mcp-server-mas-sequential-thinking.git
+    cd mcp-server-mas-sequential-thinking
+    ```
+2.  **Set up Virtual Environment:** (Recommended)
+    ```bash
+    python -m venv .venv
+    source .venv/bin/activate # On Windows use `.venv\\Scripts\\activate`
+    ```
+3.  **Install Dependencies (including dev):**
+    Ensure your `requirements-dev.txt` or `pyproject.toml` specifies development tools (like `pytest`, `ruff`, `black`, `mypy`).
+    ```bash
+    # Using uv
+    uv pip install -r requirements.txt
+    uv pip install -r requirements-dev.txt # Or install extras if defined in pyproject.toml: uv pip install -e ".[dev]"
+
+    # Using pip
+    pip install -r requirements.txt
+    pip install -r requirements-dev.txt # Or install extras if defined in pyproject.toml: pip install -e ".[dev]"
+    ```
+4.  **Run Checks:**
+    Execute linters, formatters, and tests (adjust commands based on your project setup).
+    ```bash
+    # Example commands (replace with actual commands used in the project)
+    ruff check . --fix
+    black .
+    mypy .
+    pytest
+    ```
+5.  **Contribution:**
+    (Consider adding contribution guidelines: branching strategy, pull request process, code style).
+
+## License
+
+MIT

mcp_server_mas_sequential_thinking-0.2.3.dist-info/RECORD

@@ -0,0 +1,5 @@
+main.py,sha256=hfogjWnfhaMv8KY1LDfm4aAeh6OyAVqSwGHyAs4kJt8,47351
+mcp_server_mas_sequential_thinking-0.2.3.dist-info/METADATA,sha256=6SrRvRbzME4BHa4nCeu_9lSSUiFZdA_MnJYTnhkwDO4,19146
+mcp_server_mas_sequential_thinking-0.2.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_server_mas_sequential_thinking-0.2.3.dist-info/entry_points.txt,sha256=wY2jq_6PmuqyKQzNnL6famc7DXnQiEhVnq3umzNVNiE,64
+mcp_server_mas_sequential_thinking-0.2.3.dist-info/RECORD,,

mcp_server_mas_sequential_thinking-0.2.1.dist-info/METADATA

@@ -1,279 +0,0 @@
-Metadata-Version: 2.4
-Name: mcp-server-mas-sequential-thinking
-Version: 0.2.1
-Summary: MCP Agent Implementation for Sequential Thinking
-Author-email: Frad LEE <fradser@gmail.com>
-Requires-Python: >=3.10
-Requires-Dist: agno
-Requires-Dist: asyncio
-Requires-Dist: exa-py
-Requires-Dist: groq
-Requires-Dist: mcp
-Requires-Dist: python-dotenv
-Provides-Extra: dev
-Requires-Dist: black; extra == 'dev'
-Requires-Dist: isort; extra == 'dev'
-Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: pytest; extra == 'dev'
-Description-Content-Type: text/markdown
-
-# Sequential Thinking Multi-Agent System (MAS) ![](https://img.shields.io/badge/A%20FRAD%20PRODUCT-WIP-yellow)
-
-[![Twitter Follow](https://img.shields.io/twitter/follow/FradSer?style=social)](https://twitter.com/FradSer) [![Python Version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/) [![Framework](https://img.shields.io/badge/Framework-Agno-orange.svg)](https://github.com/cognitivecomputations/agno) 
-
-English | [简体中文](README.zh-CN.md)
-
-This project implements an advanced sequential thinking process using a **Multi-Agent System (MAS)** built with the **Agno** framework and served via **MCP**. It represents a significant evolution from simpler state-tracking approaches, leveraging coordinated specialized agents for deeper analysis and problem decomposition.
-
-## Overview
-
-This server provides a sophisticated `sequentialthinking` tool designed for complex problem-solving. Unlike [its predecessor](https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking), this version utilizes a true Multi-Agent System (MAS) architecture where:
-
-* **A Coordinating Agent** (the `Team` object in `coordinate` mode) manages the workflow.
-* **Specialized Agents** (Planner, Researcher, Analyzer, Critic, Synthesizer) handle specific sub-tasks based on their defined roles and expertise.
-* Incoming thoughts are actively **processed, analyzed, and synthesized** by the agent team, not just logged.
-* The system supports complex thought patterns including **revisions** of previous steps and **branching** to explore alternative paths.
-* Integration with external tools like **Exa** (via the Researcher agent) allows for dynamic information gathering.
-* Robust **Pydantic** validation ensures data integrity for thought steps.
-* Detailed **logging** tracks the process, including agent interactions (handled by the coordinator).
-
-The goal is to achieve a higher quality of analysis and a more nuanced thinking process than possible with a single agent or simple state tracking, by harnessing the power of specialized roles working collaboratively.
-
-## Key Differences from Original Version (TypeScript)
-
-This Python/Agno implementation marks a fundamental shift from the original TypeScript version:
-
-| Feature/Aspect      | Python/Agno Version (Current)                                        | TypeScript Version (Original)                        |
-| :------------------ | :------------------------------------------------------------------- | :--------------------------------------------------- |
-| **Architecture** | **Multi-Agent System (MAS)**; Active processing by a team of agents. | **Single Class State Tracker**; Simple logging/storing. |
-| **Intelligence** | **Distributed Agent Logic**; Embedded in specialized agents & Coordinator. | **External LLM Only**; No internal intelligence.     |
-| **Processing** | **Active Analysis & Synthesis**; Agents *act* on the thought.      | **Passive Logging**; Merely recorded the thought.    |
-| **Frameworks** | **Agno (MAS) + FastMCP (Server)**; Uses dedicated MAS library.     | **MCP SDK only**.                                    |
-| **Coordination** | **Explicit Team Coordination Logic** (`Team` in `coordinate` mode).  | **None**; No coordination concept.                   |
-| **Validation** | **Pydantic Schema Validation**; Robust data validation.            | **Basic Type Checks**; Less reliable.              |
-| **External Tools** | **Integrated (Exa via Researcher)**; Can perform research tasks.   | **None**.                                            |
-| **Logging** | **Structured Python Logging (File + Console)**; Configurable.      | **Console Logging with Chalk**; Basic.             |
-| **Language & Ecosystem** | **Python**; Leverages Python AI/ML ecosystem.                    | **TypeScript/Node.js**.                              |
-
-In essence, the system evolved from a passive thought *recorder* to an active thought *processor* powered by a collaborative team of AI agents.
-
-## How it Works (Coordinate Mode)
-
-1.  **Initiation:** An external LLM uses the `sequential-thinking-starter` prompt to define the problem and initiate the process.
-2.  **Tool Call:** The LLM calls the `sequentialthinking` tool with the first (or subsequent) thought, structured according to the `ThoughtData` model.
-3.  **Validation & Logging:** The tool receives the call, validates the input using Pydantic, logs the incoming thought, and updates the history/branch state via `AppContext`.
-4.  **Coordinator Invocation:** The core thought content (with context about revisions/branches) is passed to the `SequentialThinkingTeam`'s `arun` method.
-5.  **Coordinator Analysis & Delegation:** The `Team` (acting as Coordinator) analyzes the input thought, breaks it into sub-tasks, and delegates these sub-tasks to the *most relevant* specialist agents (e.g., Analyzer for analysis tasks, Researcher for information needs).
-6.  **Specialist Execution:** Delegated agents execute their specific sub-tasks using their instructions, models, and tools (like `ThinkingTools` or `ExaTools`).
-7.  **Response Collection:** Specialists return their results to the Coordinator.
-8.  **Synthesis & Guidance:** The Coordinator synthesizes the specialists' responses into a single, cohesive output. It may include recommendations for revision or branching based on the specialists' findings (especially the Critic and Analyzer). It also adds guidance for the LLM on formulating the next thought.
-9.  **Return Value:** The tool returns a JSON string containing the Coordinator's synthesized response, status, and updated context (branches, history length).
-10. **Iteration:** The calling LLM uses the Coordinator's response and guidance to formulate the next `sequentialthinking` tool call, potentially triggering revisions or branches as suggested.
-
-## Token Consumption Warning
-
-⚠️ **High Token Usage:** Due to the Multi-Agent System architecture, this tool consumes significantly **more tokens** than single-agent alternatives or the previous TypeScript version. Each `sequentialthinking` call invokes:
-    * The Coordinator agent (the `Team` itself).
-    * Multiple specialist agents (potentially Planner, Researcher, Analyzer, Critic, Synthesizer, depending on the Coordinator's delegation).
-
-This parallel processing leads to substantially higher token usage (potentially 3-6x or more per thought step) compared to single-agent or state-tracking approaches. Budget and plan accordingly. This tool prioritizes **analysis depth and quality** over token efficiency.
-
-## Prerequisites
-
-* Python 3.10+
-* Access to a compatible LLM API (configured for `agno`). The system now supports:
-    * **Groq:** Requires `GROQ_API_KEY`.
-    * **DeepSeek:** Requires `DEEPSEEK_API_KEY`.
-    * **OpenRouter:** Requires `OPENROUTER_API_KEY`.
-    * Configure the desired provider using the `LLM_PROVIDER` environment variable (defaults to `deepseek`).
-* Exa API Key (if using the Researcher agent's capabilities)
-    * `EXA_API_KEY` environment variable.
-* `uv` package manager (recommended) or `pip`.
-
-## MCP Server Configuration (Client-Side)
-
-This server runs as a standard executable script that communicates via stdio, as expected by MCP. The exact configuration method depends on your specific MCP client implementation. Consult your client's documentation for details.
-
-The `env` section should include the API key for your chosen `LLM_PROVIDER`.
-
-```json
-{
-  "mcpServers": {
-      "mas-sequential-thinking": {
-         "command": "uvx",
-         "args": [
-            "mcp-server-mas-sequential-thinking"
-         ],
-         "env": {
-            "LLM_PROVIDER": "deepseek", // Or "groq", "openrouter"
-            // "GROQ_API_KEY": "your_groq_api_key", // Only if LLM_PROVIDER="groq"
-            "DEEPSEEK_API_KEY": "your_deepseek_api_key", // Default provider
-            // "OPENROUTER_API_KEY": "your_openrouter_api_key", // Only if LLM_PROVIDER="openrouter"
-            "DEEPSEEK_BASE_URL": "your_base_url_if_needed", // Optional: If using a custom endpoint for DeepSeek
-            "EXA_API_KEY": "your_exa_api_key" // Only if using Exa
-         }
-      }
-   }
-}
-```
-
-## Installation & Setup
-
-1.  **Clone the repository:**
-    ```bash
-    git clone git@github.com:FradSer/mcp-server-mas-sequential-thinking.git
-    cd mcp-server-mas-sequential-thinking
-    ```
-
-2.  **Set Environment Variables:**
-    Create a `.env` file in the root directory or export the variables:
-    ```dotenv
-    # --- LLM Configuration ---
-    # Select the LLM provider: "deepseek" (default), "groq", or "openrouter"
-    LLM_PROVIDER="deepseek"
-
-    # Provide the API key for the chosen provider:
-    # GROQ_API_KEY="your_groq_api_key"
-    DEEPSEEK_API_KEY="your_deepseek_api_key"
-    # OPENROUTER_API_KEY="your_openrouter_api_key"
-
-    # Optional: Base URL override (e.g., for custom DeepSeek endpoints)
-    DEEPSEEK_BASE_URL="your_base_url_if_needed"
-
-    # Optional: Specify different models for Team Coordinator and Specialist Agents
-    # Defaults are set within the code based on the provider if these are not set.
-    # Example for Groq:
-    # GROQ_TEAM_MODEL_ID="llama3-70b-8192"
-    # GROQ_AGENT_MODEL_ID="llama3-8b-8192"
-    # Example for DeepSeek:
-    # DEEPSEEK_TEAM_MODEL_ID="deepseek-reasoner" # Recommended for coordination
-    # DEEPSEEK_AGENT_MODEL_ID="deepseek-chat"     # Recommended for specialists
-    # Example for OpenRouter:
-    # OPENROUTER_TEAM_MODEL_ID="anthropic/claude-3-haiku-20240307"
-    # OPENROUTER_AGENT_MODEL_ID="google/gemini-flash-1.5"
-
-    # --- External Tools ---
-    # Required ONLY if the Researcher agent is used and needs Exa
-    EXA_API_KEY="your_exa_api_key"
-    ```
-
-    **Note on Model Selection:**
-
-    *   The `TEAM_MODEL_ID` is used by the Coordinator (the `Team` object itself). This role requires strong reasoning, synthesis, and delegation capabilities. Using a more powerful model (like `deepseek-reasoner`, `claude-3-opus`, or `gpt-4-turbo`) is often beneficial here, even if it's slower or more expensive.
-    *   The `AGENT_MODEL_ID` is used by the specialist agents (Planner, Researcher, etc.). These agents handle more focused sub-tasks. You might choose a faster or more cost-effective model (like `deepseek-chat`, `claude-3-sonnet`, `llama3-70b`) for specialists, depending on the complexity of the tasks they typically handle and your budget/performance requirements.
-    *   The defaults provided in `main.py` (e.g., `deepseek-reasoner` for agents when using DeepSeek) are starting points. Experimentation is encouraged to find the optimal balance for your specific use case.
-
-3.  **Install Dependencies:**
-
-    * **Using `uv` (Recommended):**
-        ```bash
-        # Install uv if you don't have it:
-        # curl -LsSf [https://astral.sh/uv/install.sh](https://astral.sh/uv/install.sh) | sh
-        # source $HOME/.cargo/env # Or restart your shell
-
-        uv pip install -r requirements.txt
-        # Or if a pyproject.toml exists with dependencies:
-        # uv pip install .
-        ```
-    * **Using `pip`:**
-        ```bash
-        pip install -r requirements.txt
-        # Or if a pyproject.toml exists with dependencies:
-        # pip install .
-        ```
-
-## Usage
-
-Run the server script (assuming the main script is named `main.py` or similar based on your file structure):
-
-```bash
-python your_main_script_name.py
-```
-
-The server will start and listen for requests via stdio, making the `sequentialthinking` tool available to compatible MCP clients (like certain LLMs or testing frameworks).
-
-### `sequentialthinking` Tool Parameters
-
-The tool expects arguments matching the `ThoughtData` Pydantic model:
-
-```python
-# Simplified representation
-{
-    "thought": str,              # Content of the current thought/step
-    "thoughtNumber": int,        # Sequence number (>=1)
-    "totalThoughts": int,        # Estimated total steps (>=1, suggest >=5)
-    "nextThoughtNeeded": bool,   # Is another step required after this?
-    "isRevision": bool = False,  # Is this revising a previous thought?
-    "revisesThought": Optional[int] = None, # If isRevision, which thought number?
-    "branchFromThought": Optional[int] = None, # If branching, from which thought?
-    "branchId": Optional[str] = None, # Unique ID for the branch
-    "needsMoreThoughts": bool = False # Signal if estimate is too low before last step
-}
-```
-
-### Interacting with the Tool (Conceptual Example)
-
-An LLM would interact with this tool iteratively:
-
-1.  **LLM:** Uses `sequential-thinking-starter` prompt with the problem.
-2.  **LLM:** Calls `sequentialthinking` tool with `thoughtNumber: 1`, initial `thought` (e.g., "Plan the analysis..."), `totalThoughts` estimate, `nextThoughtNeeded: True`.
-3.  **Server:** MAS processes the thought -> Coordinator synthesizes response & provides guidance (e.g., "Analysis plan complete. Suggest researching X next. No revisions recommended yet.").
-4.  **LLM:** Receives JSON response containing `coordinatorResponse`.
-5.  **LLM:** Formulates the next thought (e.g., "Research X using Exa...") based on the `coordinatorResponse`.
-6.  **LLM:** Calls `sequentialthinking` tool with `thoughtNumber: 2`, the new `thought`, updated `totalThoughts` (if needed), `nextThoughtNeeded: True`.
-7.  **Server:** MAS processes -> Coordinator synthesizes (e.g., "Research complete. Findings suggest a flaw in thought #1's assumption. RECOMMENDATION: Revise thought #1...").
-8.  **LLM:** Receives response, sees the recommendation.
-9.  **LLM:** Formulates a revision thought.
-10. **LLM:** Calls `sequentialthinking` tool with `thoughtNumber: 3`, the revision `thought`, `isRevision: True`, `revisesThought: 1`, `nextThoughtNeeded: True`.
-11. **... and so on, potentially branching or extending as needed.**
-
-### Tool Response Format
-
-The tool returns a JSON string containing:
-
-```json
-{
-  "processedThoughtNumber": int,
-  "estimatedTotalThoughts": int,
-  "nextThoughtNeeded": bool,
-  "coordinatorResponse": "Synthesized output from the agent team, including analysis, findings, and guidance for the next step...",
-  "branches": ["list", "of", "branch", "ids"],
-  "thoughtHistoryLength": int,
-  "branchDetails": {
-    "currentBranchId": "main | branchId",
-    "branchOriginThought": null | int,
-    "allBranches": {"main": count, "branchId": count, ...}
-  },
-  "isRevision": bool,
-  "revisesThought": null | int,
-  "isBranch": bool,
-  "status": "success | validation_error | failed",
-  "error": "Error message if status is not success" // Optional
-}
-```
-
-## Logging
-
-* Logs are written to `~/.sequential_thinking/logs/sequential_thinking.log`.
-* Uses Python's standard `logging` module.
-* Includes rotating file handler (10MB limit, 5 backups) and console handler (INFO level).
-* Logs include timestamps, levels, logger names, and messages, including formatted thought representations.
-
-## Development
-
-(Add development guidelines here if applicable, e.g., setting up dev environments, running tests, linting.)
-
-1.  Clone the repository.
-2.  Set up a virtual environment.
-3.  Install dependencies, potentially including development extras:
-    ```bash
-    # Using uv
-    uv pip install -e ".[dev]"
-    # Using pip
-    pip install -e ".[dev]"
-    ```
-4.  Run linters/formatters/tests.
-
-## License
-
-MIT

mcp_server_mas_sequential_thinking-0.2.1.dist-info/RECORD

@@ -1,5 +0,0 @@
-main.py,sha256=Vm6SBMDmvFy9CwEmqI-ZqZ0YDLUgPA_E689La_Qc4Yo,44071
-mcp_server_mas_sequential_thinking-0.2.1.dist-info/METADATA,sha256=bIJGHFTRT2hldImbnA0xKyp4i8BRcc78WihpJAcMf5A,15807
-mcp_server_mas_sequential_thinking-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-mcp_server_mas_sequential_thinking-0.2.1.dist-info/entry_points.txt,sha256=wY2jq_6PmuqyKQzNnL6famc7DXnQiEhVnq3umzNVNiE,64
-mcp_server_mas_sequential_thinking-0.2.1.dist-info/RECORD,,