Open Search MCP

Instructions

Implementation Reference

• src/tools/research/thinking-analysis-tools.ts:193-222 (handler)

  The execute handler function for decompose_thinking tool. It takes a problem and optional method, creates a decomposition structure with components and relationships, and returns structured output or error.

  execute: async (args: ToolInput): Promise<ToolOutput> => {
    try {
      const { problem, method = 'hierarchical' } = args;
      
      const decomposition = {
        problem,
        method,
        components: [
          { level: 1, component: `${problem} - Component 1` },
          { level: 2, component: `${problem} - Component 2` }
        ],
        relationships: ['Component dependencies', 'Sequential relationships']
      };
  
      return {
        success: true,
        data: decomposition,
        metadata: {
          tool: 'decompose_thinking',
          timestamp: new Date().toISOString()
        }
      };
    } catch (error) {
      return {
        success: false,
        error: `Problem decomposition failed: ${error instanceof Error ? error.message : String(error)}`,
        data: null
      };
    }
  }

• src/tools/research/thinking-analysis-tools.ts:177-192 (schema)

  Input schema for decompose_thinking tool defining problem (required string) and optional method (enum: hierarchical, functional, temporal).

  inputSchema: {
    type: 'object',
    properties: {
      problem: {
        type: 'string',
        description: 'Complex problem or topic to decompose'
      },
      method: {
        type: 'string',
        enum: ['hierarchical', 'functional', 'temporal'],
        description: 'Decomposition method',
        default: 'hierarchical'
      }
    },
    required: ['problem']
  },

• src/tools/research/thinking-analysis-tools.ts:172-223 (registration)

  Local registration of the decompose_thinking tool within the registerThinkingAnalysisTools function, including name, description, schema, and handler.

  registry.registerTool({
    name: 'decompose_thinking',
    description: 'Break down complex problems into manageable components',
    category: 'research',
    source: 'Thinking Analysis Engine',
    inputSchema: {
      type: 'object',
      properties: {
        problem: {
          type: 'string',
          description: 'Complex problem or topic to decompose'
        },
        method: {
          type: 'string',
          enum: ['hierarchical', 'functional', 'temporal'],
          description: 'Decomposition method',
          default: 'hierarchical'
        }
      },
      required: ['problem']
    },
    execute: async (args: ToolInput): Promise<ToolOutput> => {
      try {
        const { problem, method = 'hierarchical' } = args;
        
        const decomposition = {
          problem,
          method,
          components: [
            { level: 1, component: `${problem} - Component 1` },
            { level: 2, component: `${problem} - Component 2` }
          ],
          relationships: ['Component dependencies', 'Sequential relationships']
        };
  
        return {
          success: true,
          data: decomposition,
          metadata: {
            tool: 'decompose_thinking',
            timestamp: new Date().toISOString()
          }
        };
      } catch (error) {
        return {
          success: false,
          error: `Problem decomposition failed: ${error instanceof Error ? error.message : String(error)}`,
          data: null
        };
      }
    }
  });

• src/index.ts:255-255 (registration)

  Top-level registration call in main server initialization that registers the thinking analysis tools group including decompose_thinking.

  registerThinkingAnalysisTools(this.toolRegistry);   // 4 tools: deep_research, visualize_thinking, decompose_thinking, check_research_saturation