mcp-structured-thinking

Instructions

Implementation Reference

• index.ts:120-137 (handler)

  MCP server request handler for the 'retrieve_relevant_thoughts' tool call. Validates arguments, extracts thought_id, and delegates to EnhancedSequentialThinkingServer.retrieveRelevantThoughts.

  case "retrieve_relevant_thoughts": {        
    if (!params.arguments) {
      console.error("ERROR: params.arguments object is undefined in retrieve_relevant_thoughts request");
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            error: "Invalid request: params.arguments object is undefined",
            status: "failed"
          })
        }],
        isError: true
      };
    }
    
    const { thought_id } = params.arguments as { thought_id: number };
    return thinkingServer.retrieveRelevantThoughts({ thought_id });
  }

• src/SequentialThinkingServer.ts:471-503 (handler)

  EnhancedSequentialThinkingServer.retrieveRelevantThoughts: Finds the specified thought by ID, retrieves related thoughts via memoryManager, and returns formatted response.

  retrieveRelevantThoughts(input: { thought_id: number }): any {
    try {
      // Find the thought
      const thought = this.findThoughtById(input.thought_id);
      if (!thought) {
        throw new Error(`Thought with ID ${input.thought_id} not found`);
      }
      
      // Get related thoughts
      const relatedThoughts = this.memoryManager.retrieveRelevantThoughts(thought);
      
      return {
        content: [{
          type: "text",
          text: JSON.stringify({
            status: "success",
            retrieval: {
              thoughtNumber: thought.thoughtNumber,
              relatedThoughtsCount: relatedThoughts.length,
              relatedThoughts: relatedThoughts.map(t => ({
                thoughtNumber: t.thoughtNumber,
                stage: t.stage,
                tags: t.tags
              }))
            }
          }, null, 2)
        }]
      };
      
    } catch (e) {
      return this.handleError(e);
    }
  }

• src/SequentialThinkingServer.ts:33-43 (helper)

  MemoryManager.retrieveRelevantThoughts: Core logic that scans long-term storage for thoughts sharing any tags with the input thought.

  retrieveRelevantThoughts(currentThought: ThoughtData): ThoughtData[] {
    const relevant: ThoughtData[] = [];
    for (const thoughts of Object.values(this.longTermStorage)) {
      for (const thought of thoughts) {
        if (thought.tags.some(tag => currentThought.tags.includes(tag))) {
          relevant.push(thought);
        }
      }
    }
    return relevant;
  }

• src/tools.ts:37-39 (schema)

  Zod schema for tool input parameters: requires positive integer thought_id.

  export const retrieveRelevantThoughtsSchema = z.object({
    thought_id: z.number().int().positive().describe("The ID of the thought to find related thoughts for")
  });

• src/tools.ts:59-64 (registration)

  Tool definition object registered in toolDefinitions array used by MCP server's ListTools handler.

  export const retrieveRelevantThoughtsTool: Tool = {
    name: "retrieve_relevant_thoughts",
    description: "Finds thoughts from long-term storage that share tags with the specified thought.",
    parameters: retrieveRelevantThoughtsSchema,
    inputSchema: zodToInputSchema(retrieveRelevantThoughtsSchema)
  };