Instructions

Agentic Workflow Orchestration: Guides through complex tasks by breaking them into precise, manageable, traceable steps.
Automatic smart thinking process: Avoids over-questionning users about their intention and just figures it out how to proceed.
Iterative Refinement: Assesses success of each step and self-corrects if necessary, adapting to new information or errors (failure, empty results, etc).
Tool Recommendation: Suggests relevantly specific available tools (`tool_recommendation`) to execute planned actions or gather necessary information.
Proactive Planning: Utilizes `left_to_be_done` for explicit future state management and task estimation.

Implementation Reference

• sequential_thinking/mcp_server.py:11-63 (handler)

  The core handler function for the 'think' tool. It is decorated with @mcp.tool() for registration and implements the logging of sequential thoughts, tool recommendations, and task planning. The function signature defines the input schema.

  @mcp.tool()
  def think(
      thread_purpose: str,
      thought: str,
      thought_index: int,
      tool_recommendation: str | None = "None",
      left_to_be_done: str | None = "None",
  ) -> str:
      """Logs a thought step for agentic problem-solving, tracking reasoning, tools, and future plans.
      Start a new thread for each user message.
  
      # Capabilities
      - Workflow Orchestration: Breaks complex tasks into manageable steps.
      - Iterative Refinement: Self-corrects based on new info or errors.
      - Tool Recommendation: Suggests specific tools for the next action.
      - Forward Planning: Tracks remaining tasks via `left_to_be_done`.
  
      Args:
          thread_purpose: Short objective/topic for the thread.
          thought: Current reasoning or action description.
          thought_index: Monotonically increasing step number (1, 2, 3...).
          tool_recommendation: Tool to call next, or 'None'.
          left_to_be_done: Remaining steps/sub-goals, or 'None'.
      Returns: Confirmation of log.
  
      # Example
      1) User: "I keep hearing about central banks, but I don't understand what they are and how they work."
      2) think(
          thread_purpose="Explain Central Banks",
          thought="The user needs a comprehensive explanation of central banks. I need to identify their core definition, key roles (monetary policy, financial stability, currency issuance), and operational mechanisms (interest rates, reserves). I should search for a structured overview to ensure I don't miss major aspects like the Federal Reserve or ECB as examples.",
          thought_index=1,
          tool_recommendation="search_web",
          left_to_be_done="1. Search for 'how central banks work' and key functions. 2. Synthesize findings into a clear explanation. 3. Create a visual graph of the banking system structure if possible. 4. Present final answer."
      )
      3) call search_web(query="how central banks work and their main functions")
      4) think(
          thread_purpose="Explain Central Banks",
          thought="Search results clarify that central banks manage currency stability, control inflation via interest rates, and act as lenders of last resort. I have enough textual information. Now, to make this easier to understand, I should create a graph representing the flow of money and influence between the central bank, commercial banks, and the economy.",
          thought_index=2,
          tool_recommendation="create_graph",
          left_to_be_done="Create a graph showing Central Bank -> Commercial Banks -> Public/Economy relations."
      )
      5) call create_graph(data=...)
      6) Final Response: "Here is an explanation of central banks..." (Task complete, no further think call needed).
      """
      log = f"Thread purpose: {thread_purpose}\nThought {thought_index} logged."
      if tool_recommendation and tool_recommendation.lower() != "none":
          log += f" Recommended tool: {tool_recommendation}."
      extra_log = f"{log}\nThought: {thought}"
      if left_to_be_done and left_to_be_done.lower() != "none":
          extra_log += f"\nNext: {left_to_be_done}"
      logger.info(extra_log)
      return log

• sequential_thinking/mcp_server.py:8-8 (registration)

  Creation of the FastMCP server instance where tools like 'think' are registered.

  mcp: FastMCP[Any] = FastMCP("Sequential Thinking")

• sequential_thinking/mcp_server.py:12-18 (schema)

  Input schema defined by the function parameters of the 'think' tool.

  def think(
      thread_purpose: str,
      thought: str,
      thought_index: int,
      tool_recommendation: str | None = "None",
      left_to_be_done: str | None = "None",
  ) -> str: