Skip to main content
Glama
stat-guy

Chain of Draft (CoD) MCP Server

by stat-guy

code_solve

Solve coding problems using Chain of Draft reasoning to generate minimal intermediate outputs, reducing token usage while maintaining accuracy.

Instructions

Solve a coding problem using Chain of Draft reasoning

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
problemYesThe coding problem to solve
approachNoForce 'CoD' or 'CoT' approach
max_words_per_stepNoMaximum words per reasoning step

Implementation Reference

  • Python handler for code_solve MCP tool. Registered via @app.tool() decorator. Delegates to chain_of_draft_solve with domain="code".
    @app.tool()
    async def code_solve(
        problem: str,
        approach: str = None,
        max_words_per_step: int = None
    ) -> str:
        """Solve a coding problem using Chain of Draft reasoning.
        
        Args:
            problem: The coding problem to solve
            approach: Force "CoD" or "CoT" approach (default: auto-select)
            max_words_per_step: Maximum words per step (default: adaptive)
        """
        return await chain_of_draft_solve(
            problem=problem,
            domain="code",
            approach=approach,
            max_words_per_step=max_words_per_step
        )
  • JavaScript handler for code_solve tool execution within the CallToolRequestSchema handler. Delegates to chainOfDraftClient.solveWithReasoning with domain="code".
    // Code solver
    if (name === "code_solve") {
      const result = await chainOfDraftClient.solveWithReasoning({
        ...args,
        domain: "code"
      });
      
      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
        }]
      };
  • Input schema definition for the code_solve tool in JavaScript implementation.
    const CODE_TOOL = {
      name: "code_solve",
      description: "Solve a coding problem using Chain of Draft reasoning",
      inputSchema: {
        type: "object",
        properties: {
          problem: {
            type: "string",
            description: "The coding problem to solve"
          },
          approach: {
            type: "string",
            description: "Force 'CoD' or 'CoT' approach"
          },
          max_words_per_step: {
            type: "number",
            description: "Maximum words per reasoning step"
          }
        },
        required: ["problem"]
      }
    };
  • index.js:581-591 (registration)
    Registration of code_solve (via CODE_TOOL) in the list of tools returned by ListToolsRequestSchema.
    server.setRequestHandler(ListToolsRequestSchema, async () => ({
      tools: [
        CHAIN_OF_DRAFT_TOOL,
        MATH_TOOL,
        CODE_TOOL,
        LOGIC_TOOL,
        PERFORMANCE_TOOL,
        TOKEN_TOOL,
        COMPLEXITY_TOOL
      ],
    }));
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'Chain of Draft reasoning' but does not explain what this entails, such as step-by-step reasoning, potential outputs, error handling, or computational limits. This leaves significant gaps in understanding how the tool behaves beyond its basic function.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose. It is appropriately sized and front-loaded, with no unnecessary words, though it could benefit from more detail to improve clarity and completeness.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (solving coding problems with a specific reasoning approach), no annotations, and no output schema, the description is incomplete. It fails to explain what 'Chain of Draft reasoning' is, what the output looks like, or any behavioral traits, leaving significant gaps for effective tool use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the input schema already documents all parameters ('problem', 'approach', 'max_words_per_step') with descriptions. The description does not add any additional meaning or context beyond what the schema provides, such as examples or usage tips for parameters, resulting in a baseline score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose3/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states the tool 'Solve[s] a coding problem using Chain of Draft reasoning', which provides a verb ('Solve') and resource ('coding problem') but is vague about what 'Chain of Draft reasoning' entails. It distinguishes from some siblings like 'logic_solve' or 'math_solve' by specifying 'coding problem', but the distinction from 'chain_of_draft_solve' is unclear, making the purpose somewhat ambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance is provided on when to use this tool versus alternatives. The description mentions 'Chain of Draft reasoning' but does not explain when this approach is preferred over other methods or tools like 'analyze_problem_complexity' or 'logic_solve'. This lack of context leaves usage unclear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Install Server

Other Tools

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/stat-guy/chain-of-draft'

If you have feedback or need assistance with the MCP directory API, please join our Discord server