Clear Thought Server

Instructions

Implementation Reference

• src/tools/sequentialThinkingServer.ts:103-114 (handler)

  The main handler method for the sequentialthinking tool. Validates input, stores the thought in history or branches, formats and logs a colored output to console showing thought progress, and returns the validated ThoughtData.

  public processThought(input: unknown): ThoughtData {
    const validatedInput = this.validateThoughtData(input);
    
    // Store the thought for future reference
    this.storeThought(validatedInput);
    
    // Log formatted output to console
    const formattedOutput = this.formatThoughtOutput(validatedInput);
    console.error(formattedOutput);
    
    return validatedInput;
  }

• src/index.ts:212-259 (schema)

  Tool definition including name, description, and inputSchema (JSON schema for validation) for the sequentialthinking tool.

  const SEQUENTIAL_THINKING_TOOL: Tool = {
      name: "sequentialthinking",
      description: `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.
  
  When to use this tool:
  - Breaking down complex problems into steps
  - Planning and design with room for revision
  - Analysis that might need course correction
  - Problems where the full scope might not be clear initially
  - Problems that require a multi-step solution
  - Tasks that need to maintain context over multiple steps
  - Situations where irrelevant information needs to be filtered out
  
  You should:
  1. Start with an initial estimate of needed thoughts, but be ready to adjust
  2. Feel free to question or revise previous thoughts
  3. Don't hesitate to add more thoughts if needed, even at the "end"
  4. Express uncertainty when present
  5. Mark thoughts that revise previous thinking or branch into new paths
  6. Ignore information that is irrelevant to the current step
  7. Generate a solution hypothesis when appropriate
  8. Verify the hypothesis based on the Chain of Thought steps
  9. Repeat the process until satisfied with the solution
  10. Provide a single, ideally correct answer as the final output
  11. Only set next_thought_needed to false when truly done and a satisfactory answer is reached`,
      inputSchema: {
          type: "object",
          properties: {
              thought: { type: "string" },
              thoughtNumber: { type: "number", minimum: 1 },
              totalThoughts: { type: "number", minimum: 1 },
              nextThoughtNeeded: { type: "boolean" },
              isRevision: { type: "boolean" },
              revisesThought: { type: "number", minimum: 1 },
              branchFromThought: { type: "number", minimum: 1 },
              branchId: { type: "string" },
              needsMoreThoughts: { type: "boolean" },
          },
          required: [
              "thought",
              "thoughtNumber",
              "totalThoughts",
              "nextThoughtNeeded",
          ],
      },
  };

• src/models/interfaces.ts:4-14 (schema)

  TypeScript interface definition for ThoughtData, which defines the structure used for input validation and output of the sequentialthinking tool.

  export interface ThoughtData {
      thought: string;
      thoughtNumber: number;
      totalThoughts: number;
      isRevision?: boolean;
      revisesThought?: number;
      branchFromThought?: number;
      branchId?: string;
      needsMoreThoughts?: boolean;
      nextThoughtNeeded: boolean;
  }

• src/index.ts:1033-1045 (registration)

  Registration in the CallToolRequestHandler switch statement: handles tool calls to 'sequentialthinking' by invoking the processThought method on the server instance and returning JSON stringified result.

  case "sequentialthinking": {
      const result = thinkingServer.processThought(
          request.params.arguments
      );
      return {
          content: [
              {
                  type: "text",
                  text: JSON.stringify(result, null, 2),
              },
          ],
      };
  }

• src/index.ts:997-1009 (registration)

  Tool registration in the MCP server capabilities declaration, associating 'sequentialthinking' with its Tool object.

  tools: {
      sequentialthinking: SEQUENTIAL_THINKING_TOOL,
      mentalmodel: MENTAL_MODEL_TOOL,
      designpattern: DESIGN_PATTERN_TOOL,
      programmingparadigm: PROGRAMMING_PARADIGM_TOOL,
      debuggingapproach: DEBUGGING_APPROACH_TOOL,
      collaborativereasoning: COLLABORATIVE_REASONING_TOOL,
      decisionframework: DECISION_FRAMEWORK_TOOL,
      metacognitivemonitoring: METACOGNITIVE_MONITORING_TOOL,
      scientificmethod: SCIENTIFIC_METHOD_TOOL,
      structuredargumentation: STRUCTURED_ARGUMENTATION_TOOL,
      visualreasoning: VISUAL_REASONING_TOOL,
  },

• src/tools/sequentialThinkingServer.ts:8-48 (helper)

  Helper method for runtime input validation, enforcing the schema and constructing a typed ThoughtData object, throwing errors on invalid input.

  private validateThoughtData(input: unknown): ThoughtData {
    const data = input as Record<string, unknown>;
  
    if (!data.thought || typeof data.thought !== 'string') {
      throw new Error('Invalid thought: must be a string');
    }
    if (!data.thoughtNumber || typeof data.thoughtNumber !== 'number') {
      throw new Error('Invalid thoughtNumber: must be a number');
    }
    if (!data.totalThoughts || typeof data.totalThoughts !== 'number') {
      throw new Error('Invalid totalThoughts: must be a number');
    }
    if (typeof data.nextThoughtNeeded !== 'boolean') {
      throw new Error('Invalid nextThoughtNeeded: must be a boolean');
    }
  
    // Optional fields
    const isRevision = data.isRevision !== undefined ? !!data.isRevision : undefined;
    const revisesThought = data.revisesThought !== undefined && typeof data.revisesThought === 'number' 
      ? data.revisesThought as number 
      : undefined;
    const branchFromThought = data.branchFromThought !== undefined && typeof data.branchFromThought === 'number' 
      ? data.branchFromThought as number 
      : undefined;
    const branchId = data.branchId !== undefined && typeof data.branchId === 'string' 
      ? data.branchId as string 
      : undefined;
    const needsMoreThoughts = data.needsMoreThoughts !== undefined ? !!data.needsMoreThoughts : undefined;
  
    return {
      thought: data.thought as string,
      thoughtNumber: data.thoughtNumber as number,
      totalThoughts: data.totalThoughts as number,
      nextThoughtNeeded: data.nextThoughtNeeded as boolean,
      isRevision,
      revisesThought,
      branchFromThought,
      branchId,
      needsMoreThoughts
    };
  }