chain_of_draft_solve

Instructions

Implementation Reference

• server.py:36-80 (handler)

  Primary handler for the chain_of_draft_solve MCP tool. Registers the tool and handles execution by delegating to the ChainOfDraftClient.

  @app.tool()
  async def chain_of_draft_solve(
      problem: str,
      domain: str = "general",
      max_words_per_step: int = None,
      approach: str = None,
      enforce_format: bool = True,
      adaptive_word_limit: bool = True
  ) -> str:
      """Solve a reasoning problem using Chain of Draft approach.
      
      Args:
          problem: The problem to solve
          domain: Domain for context (math, logic, code, common-sense, etc.)
          max_words_per_step: Maximum words per reasoning step (default: adaptive)
          approach: Force "CoD" or "CoT" approach (default: auto-select)
          enforce_format: Whether to enforce the word limit (default: True)
          adaptive_word_limit: Adjust word limits based on complexity (default: True)
      """
      # Track execution time
      start_time = time.time()
      
      # Process the request with the client
      result = await cod_client.solve_with_reasoning(
          problem=problem,
          domain=domain,
          max_words_per_step=max_words_per_step,
          approach=approach,
          enforce_format=enforce_format,
          adaptive_word_limit=adaptive_word_limit
      )
      
      # Calculate execution time
      execution_time = (time.time() - start_time) * 1000  # ms
      
      # Format the response
      formatted_response = (
          f"Chain of {result['approach']} reasoning ({result['word_limit']} word limit):\n\n"
          f"{result['reasoning_steps']}\n\n"
          f"Final answer: {result['final_answer']}\n\n"
          f"Stats: {result['token_count']} tokens, {execution_time:.0f}ms, "
          f"complexity score: {result['complexity']}"
      )
      
      return formatted_response

• client.py:214-307 (helper)

  Core helper function implementing the Chain of Draft logic: complexity estimation, approach selection (CoD/CoT), prompt generation, LLM invocation, response extraction, format enforcement, and analytics.

  async def solve_with_reasoning(self, problem, domain="general", **kwargs):
      """
      Solve a problem using the appropriate reasoning approach.
      
      Args:
          problem: The problem text
          domain: Problem domain (math, code, logic, etc.)
          **kwargs: Additional parameters and settings
          
      Returns:
          Dictionary with reasoning steps and answer
      """
      start_time = time.time()
      
      # Override settings with kwargs
      local_settings = {**self.settings, **kwargs}
      
      # Determine complexity and select approach
      complexity = await self.complexity_estimator.estimate_complexity(problem, domain)
      
      if local_settings.get("approach"):
          # Manually specified approach
          approach = local_settings["approach"]
          approach_reason = "Manually specified"
      else:
          # Auto-select based on problem
          approach, approach_reason = await self.reasoning_selector.select_approach(
              problem, domain, complexity
          )
      
      # Determine word limit
      if local_settings["adaptive_word_limit"] and approach == "CoD":
          word_limit = complexity  # Use estimated complexity as word limit
      else:
          word_limit = local_settings["max_words_per_step"]
      
      # Get examples
      examples = await self.example_db.get_examples(domain, approach)
      
      # Create prompt based on approach
      if approach == "CoD":
          prompt = create_cod_prompt(problem, domain, word_limit, examples)
      else:
          prompt = create_cot_prompt(problem, domain, examples)
      
      # Generate response from LLM
      response = await self.client.messages.create(
          model=local_settings.get("model", "claude-3-5-sonnet-20240620"),
          max_tokens=local_settings.get("max_tokens", 500),
          system=prompt["system"],
          messages=[{"role": "user", "content": prompt["user"]}]
      )
      
      # Extract reasoning and answer
      full_response = response.content[0].text
      parts = full_response.split("####")
      
      reasoning = parts[0].strip()
      answer = parts[1].strip() if len(parts) > 1 else "No clear answer found"
      
      # Apply format enforcement if needed
      if local_settings["enforce_format"] and approach == "CoD":
          reasoning = self.format_enforcer.enforce_word_limit(reasoning, word_limit)
          adherence = self.format_enforcer.analyze_adherence(reasoning, word_limit)
      else:
          adherence = None
      
      # Record analytics
      if local_settings["track_analytics"]:
          execution_time = (time.time() - start_time) * 1000  # ms
          await self.analytics.record_inference(
              problem=problem,
              domain=domain,
              approach=approach,
              word_limit=word_limit,
              tokens_used=len(full_response.split()),
              execution_time=execution_time,
              reasoning=reasoning,
              answer=answer,
              metadata={
                  "complexity": complexity,
                  "approach_reason": approach_reason,
                  "adherence": adherence
              }
          )
      
      return {
          "reasoning_steps": reasoning,
          "final_answer": answer,
          "token_count": len(full_response.split()),
          "approach": approach,
          "complexity": complexity,
          "word_limit": word_limit
      }

• index.js:424-456 (schema)

  Input schema definition for the chain_of_draft_solve tool in the JavaScript implementation.

  const CHAIN_OF_DRAFT_TOOL = {
    name: "chain_of_draft_solve",
    description: "Solve a reasoning problem using Chain of Draft approach",
    inputSchema: {
      type: "object",
      properties: {
        problem: {
          type: "string",
          description: "The problem to solve"
        },
        domain: {
          type: "string",
          description: "Domain for context (math, logic, code, common-sense, etc.)"
        },
        max_words_per_step: {
          type: "number",
          description: "Maximum words per reasoning step"
        },
        approach: {
          type: "string",
          description: "Force 'CoD' or 'CoT' approach"
        },
        enforce_format: {
          type: "boolean",
          description: "Whether to enforce the word limit"
        },
        adaptive_word_limit: {
          type: "boolean",
          description: "Adjust word limits based on complexity"
        }
      },
      required: ["problem"]
    }

• index.js:599-614 (handler)

  Handler block for chain_of_draft_solve tool call in the JavaScript MCP server implementation. Delegates to chainOfDraftClient and formats response.

  if (name === "chain_of_draft_solve") {
    const result = await chainOfDraftClient.solveWithReasoning(args);
    
    const formattedResponse = 
      `Chain of ${result.approach} reasoning (${result.word_limit} word limit):\n\n` +
      `${result.reasoning_steps}\n\n` +
      `Final answer: ${result.final_answer}\n\n` +
      `Stats: ${result.token_count} tokens, ${result.execution_time_ms.toFixed(0)}ms, ` +
      `complexity score: ${result.complexity}`;
    
    return {
      content: [{
        type: "text",
        text: formattedResponse
      }]
    };

• index.js:308-420 (helper)

  JavaScript equivalent helper implementing Chain of Draft solving logic, mirroring the Python client.py version.

  const chainOfDraftClient = {
    async solveWithReasoning(params) {
      const {
        problem,
        domain = 'general',
        max_words_per_step = null,
        approach = null,
        enforce_format = true,
        adaptive_word_limit = true
      } = params;
      
      const startTime = Date.now();
      
      // Analyze problem complexity
      const analysis = complexityEstimator.analyzeProblem(problem, domain);
      const complexity = analysis.estimated_complexity;
      
      // Determine word limit
      let wordLimit = max_words_per_step;
      if (!wordLimit && adaptive_word_limit) {
        wordLimit = complexity;
      } else if (!wordLimit) {
        // Default based on domain
        wordLimit = complexityEstimator.domainBaseLimits[domain] || 5;
      }
      
      // Determine approach (CoD or CoT)
      const performanceStats = analyticsDb.getPerformanceByDomain(domain);
      const selectedApproach = approach || 
        reasoningSelector.selectApproach(domain, complexity, performanceStats);
      
      // Create prompt based on approach
      const prompt = selectedApproach === 'CoD' 
        ? createCodPrompt(problem, domain, [], wordLimit)
        : createCotPrompt(problem, domain, []);
      
      // Call Claude
      const response = await anthropic.messages.create({
        model: 'claude-3-sonnet-20240229',
        max_tokens: 1000,
        messages: [
          { role: 'user', content: prompt }
        ]
      });
      
      // Extract reasoning and answer
      const fullText = response.content[0].text;
      
      // Extract final answer (assuming it comes after the reasoning, often starts with "Answer:" or similar)
      let reasoningSteps = fullText;
      let finalAnswer = '';
      
      // Common patterns for final answer sections
      const answerPatterns = [
        /(?:Final Answer|Answer|Therefore):?\s*(.*?)$/is,
        /(?:In conclusion|To conclude|Thus|Hence|So),\s*(.*?)$/is,
        /(?:The answer is|The result is|The solution is)\s*(.*?)$/is
      ];
      
      // Try to extract the final answer with each pattern
      for (const pattern of answerPatterns) {
        const match = fullText.match(pattern);
        if (match && match[1]) {
          finalAnswer = match[1].trim();
          reasoningSteps = fullText.substring(0, fullText.indexOf(match[0])).trim();
          break;
        }
      }
      
      // If no pattern matched, just use the last sentence
      if (!finalAnswer) {
        const sentences = fullText.split(/[.!?]+\s+/);
        if (sentences.length > 1) {
          finalAnswer = sentences.pop().trim();
          reasoningSteps = sentences.join('. ') + '.';
        }
      }
      
      // Apply format enforcement if needed
      if (enforce_format && selectedApproach === 'CoD') {
        reasoningSteps = formatEnforcer.enforceWordLimit(reasoningSteps, wordLimit);
      }
      
      // Calculate execution time
      const executionTime = Date.now() - startTime;
      
      // Estimate token count (rough approximation)
      const tokenCount = Math.ceil(fullText.length / 4);
      
      // Record analytics
      analyticsDb.addRecord({
        problem_id: problem.substring(0, 20),
        problem_text: problem,
        domain,
        approach: selectedApproach,
        word_limit: wordLimit,
        tokens_used: tokenCount,
        execution_time_ms: executionTime,
        reasoning_steps: reasoningSteps,
        answer: finalAnswer
      });
      
      // Return result
      return {
        approach: selectedApproach,
        reasoning_steps: reasoningSteps,
        final_answer: finalAnswer,
        token_count: tokenCount,
        word_limit: wordLimit,
        complexity: complexity,
        execution_time_ms: executionTime
      };
    }