MCP Chain of Draft (CoD) Prompt Tool - A Model Context Protocol tool for efficient reasoning
This server has significant gaps in schema completeness and parameter documentation. While tool names follow verb-noun conventions (chain_of_draft_solve, math_solve, code_solve, etc.), the parameter documentation is inconsistent and many parameter descriptions lack actionable constraints. Output schemas are entirely undocumented, LLMs cannot know what structure to expect from responses. The server conflates multiple concerns in single tools (e.g., chain_of_draft_solve handles domain selection, word limit enforcement, and approach selection in one call, violating single-responsibility principle). Error handling guidance is absent. Schema validation rules (e.g., 'approach' should be constrained to 'CoD'|'CoT') are mentioned in descriptions but not formalized as enums. The Python implementation is visible but TypeScript tool definitions in src/index.ts are not fully shown in the provided code sample, making it impossible to verify complete schema definitions. Conservative scoring reflects these gaps.
Analyze the complexity of a problem. Args: problem: The problem to analyze domain: Problem domain
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)
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)
Get performance statistics for CoD vs CoT approaches. Args: domain: Filter for specific domain (optional)
Get token reduction statistics for CoD vs CoT.
No output schemas documented for any tool. LLMs cannot know the structure of responses (fields, types, nesting). This blocks downstream tool composition and forces LLMs to guess field names and types.
Parameter constraints not formalized as enums. 'approach' parameter accepts 'CoD' or 'CoT' but is defined as a free-form string (type: string, default: null). This invites hallucinated values like 'chain-of-thought' or 'cod' (lowercase). Constraint should be an enum: ['CoD', 'CoT'].
Parameter descriptions lack actionable constraints. 'max_words_per_step' has no min/max bounds. 'domain' accepts unspecified values; description says 'e.g. math, logic, code, common-sense' but doesn't state if other values are valid or what the full enum is.
Inferred effective spec: <=2025-11-25.
| Scored | Grade | Overall | Spec posture | Rubric |
|---|---|---|---|---|
| 2026-09-22 | F | 47 | <=2025-11-25 | v2 |
| 2026-03-09 | F | 45 | - | v1 |
Solve a logic problem using Chain of Draft reasoning. Args: problem: The logic problem to solve approach: Force "CoD" or "CoT" approach (default: auto-select) max_words_per_step: Maximum words per step (default: adaptive)
Solve a math problem using Chain of Draft reasoning. Args: problem: The math problem to solve approach: Force "CoD" or "CoT" approach (default: auto-select) max_words_per_step: Maximum words per step (default: adaptive)
get_token_reduction has only 1 word in description ('Get token reduction statistics for CoD vs CoT.'). This violates the 10-character minimum and provides no guidance on when to call it or what it returns.
get_performance_stats description is vague ('Get performance statistics for CoD vs CoT approaches'). No guidance on what 'performance' means (speed, accuracy, token efficiency?), what structure the response has, or when to call this vs other analysis tools.
Single-responsibility principle violated. chain_of_draft_solve handles problem solving, domain routing, word limit enforcement, approach selection (CoD vs CoT), and complexity-adaptive reasoning in one tool. This conflates concerns and makes the tool hard to compose. Consider splitting into: solve_problem (core), select_approach (auto vs forced), configure_reasoning (word limits, enforcement).
No error handling guidance in any tool description. What happens if a problem is unsolvable? If word limits conflict with reasoning depth? If the LLM provider fails? Descriptions should include recovery hints: 'If reasoning fails, try increasing max_words_per_step or switching to CoT approach.'
Specialized solver tools (math_solve, code_solve, logic_solve) are thin wrappers around chain_of_draft_solve with hardcoded domain values. They add no independent value and waste tool slots. Consolidate into chain_of_draft_solve and let domain parameter dispatch to the right logic.