analyze_problem_complexity

Instructions

Implementation Reference

• server.py:189-215 (handler)

  Primary handler function for the 'analyze_problem_complexity' tool in the Python FastMCP server. Decorated with @app.tool() for automatic registration and schema inference. Delegates to complexity_estimator for analysis.

  @app.tool()
  async def analyze_problem_complexity(
      problem: str,
      domain: str = "general"
  ) -> str:
      """Analyze the complexity of a problem.
      
      Args:
          problem: The problem to analyze
          domain: Problem domain
      """
      analysis = complexity_estimator.analyze_problem(problem, domain)
      
      result = f"Complexity Analysis for {domain} problem:\n\n"
      result += f"Word count: {analysis['word_count']}\n"
      result += f"Sentence count: {analysis['sentence_count']}\n"
      result += f"Words per sentence: {analysis['words_per_sentence']:.1f}\n"
      result += f"Complexity indicators found: {analysis['indicator_count']}\n"
      
      if analysis['found_indicators']:
          result += f"Indicators: {', '.join(analysis['found_indicators'])}\n"
      
      result += f"Question count: {analysis['question_count']}\n"
      result += f"\nEstimated complexity score: {analysis['estimated_complexity']}\n"
      result += f"Recommended word limit per step: {analysis['estimated_complexity']}\n"
      
      return result

• complexity.py:108-148 (helper)

  Core helper method performing detailed problem complexity analysis, computing metrics like word count, indicators, sentences, and estimated complexity score. Called by the handler.

  def analyze_problem(self, problem, domain="general"):
      """
      Provide a detailed analysis of problem complexity factors.
      Useful for debugging and understanding complexity estimates.
      """
      base_limit = self.domain_base_limits.get(domain.lower(), 5)
      
      # Word count analysis
      word_count = len(problem.split())
      length_factor = min(word_count / 50, 2)
      
      # Indicator analysis
      indicators = self.complexity_indicators.get(domain.lower(), [])
      found_indicators = [ind for ind in indicators if ind.lower() in problem.lower()]
      indicator_count = len(found_indicators)
      indicator_factor = min(1 + (indicator_count * 0.2), 1.8)
      
      # Question mark analysis
      question_count = problem.count("?")
      question_factor = 1 + (question_count * 0.2)
      
      # Sentence complexity
      sentences = [s for s in problem.split(".") if s.strip()]
      words_per_sentence = word_count / max(len(sentences), 1)
      sentence_complexity_factor = min(words_per_sentence / 15, 1.5)
      
      return {
          "domain": domain,
          "base_limit": base_limit,
          "word_count": word_count,
          "length_factor": length_factor,
          "indicator_count": indicator_count,
          "found_indicators": found_indicators,
          "indicator_factor": indicator_factor,
          "question_count": question_count,
          "question_factor": question_factor,
          "sentence_count": len(sentences),
          "words_per_sentence": words_per_sentence,
          "sentence_complexity_factor": sentence_complexity_factor,
          "estimated_complexity": max(3, min(round(base_limit * max(length_factor, indicator_factor, question_factor, sentence_complexity_factor)), 10))
      }

• index.js:551-568 (schema)

  Tool schema definition in JavaScript MCP server, specifying input parameters and descriptions for tool discovery.

  const COMPLEXITY_TOOL = {
    name: "analyze_problem_complexity",
    description: "Analyze the complexity of a problem",
    inputSchema: {
      type: "object",
      properties: {
        problem: {
          type: "string",
          description: "The problem to analyze"
        },
        domain: {
          type: "string",
          description: "Problem domain"
        }
      },
      required: ["problem"]
    }
  };

• index.js:739-762 (handler)

  Handler implementation in JavaScript MCP server for dispatching and executing the tool using inline complexityEstimator.

  // Complexity analysis
  if (name === "analyze_problem_complexity") {
    const analysis = complexityEstimator.analyzeProblem(args.problem, args.domain || "general");
    
    let result = `Complexity Analysis for ${args.domain || "general"} problem:\n\n`;
    result += `Word count: ${analysis.word_count}\n`;
    result += `Sentence count: ${analysis.sentence_count}\n`;
    result += `Words per sentence: ${analysis.words_per_sentence.toFixed(1)}\n`;
    result += `Complexity indicators found: ${analysis.indicator_count}\n`;
    
    if (analysis.found_indicators && analysis.found_indicators.length > 0) {
      result += `Indicators: ${analysis.found_indicators.join(", ")}\n`;
    }
    
    result += `Question count: ${analysis.question_count}\n`;
    result += `\nEstimated complexity score: ${analysis.estimated_complexity}\n`;
    result += `Recommended word limit per step: ${analysis.estimated_complexity}\n`;
    
    return {
      content: [{
        type: "text",
        text: result
      }]
    };

• index.js:110-167 (helper)

  Inline helper object in JS with analyzeProblem method mirroring the Python ComplexityEstimator, providing core analysis logic.

  const complexityEstimator = {
    domainBaseLimits: {
      math: 6,
      logic: 5,
      common_sense: 4,
      physics: 7,
      chemistry: 6,
      biology: 5,
      code: 8,
      puzzle: 5,
      general: 5
    },
    complexityIndicators: {
      math: ['integral', 'derivative', 'equation', 'theorem', 'calculus', 'polynomial', 'algorithm'],
      logic: ['if-then', 'premise', 'fallacy', 'syllogism', 'deduction', 'induction'],
      physics: ['velocity', 'acceleration', 'quantum', 'momentum', 'thermodynamics'],
      code: ['function', 'algorithm', 'recursive', 'complexity', 'optimization', 'edge case']
    },
    analyzeProblem: function(problem, domain) {
      const wordCount = problem.split(/\s+/).filter(Boolean).length;
      const sentences = problem.split(/[.!?]+/).filter(Boolean);
      const sentenceCount = sentences.length;
      const wordsPerSentence = sentenceCount > 0 ? wordCount / sentenceCount : 0;
      
      // Count indicators
      const indicators = this.complexityIndicators[domain] || this.complexityIndicators.general || [];
      const lowerProblem = problem.toLowerCase();
      const foundIndicators = indicators.filter(i => lowerProblem.includes(i.toLowerCase()));
      
      // Count questions
      const questionCount = (problem.match(/\?/g) || []).length;
      
      // Estimate complexity
      let complexity = this.domainBaseLimits[domain] || this.domainBaseLimits.general;
      
      // Adjust for length
      if (wordCount > 100) complexity += 2;
      else if (wordCount > 50) complexity += 1;
      
      // Adjust for sentences
      if (wordsPerSentence > 20) complexity += 1;
      
      // Adjust for indicators
      complexity += Math.min(3, foundIndicators.length);
      
      // Adjust for questions
      complexity += Math.min(2, questionCount);
      
      return {
        word_count: wordCount,
        sentence_count: sentenceCount,
        words_per_sentence: wordsPerSentence,
        indicator_count: foundIndicators.length,
        found_indicators: foundIndicators,
        question_count: questionCount,
        estimated_complexity: complexity
      };
    }