Skip to main content
Glama
Chain of Draft (CoD) MCP Server

Chain of Draft (CoD) MCP Server

by stat-guy

Servidor MCP de Cadena de Borrador (CoD)

Descripción general

Este servidor MCP implementa el enfoque de razonamiento Cadena de Borrador (CoD), como se describe en el artículo de investigación "Cadena de Borrador: Pensar más rápido escribiendo menos". CoD es un paradigma novedoso que permite a los LLM generar resultados de razonamiento intermedios minimalistas pero informativos al resolver tareas, lo que reduce significativamente el uso de tokens y mantiene la precisión.

Related MCP server: Visum Thinker MCP Server

Beneficios clave

  • Eficiencia : uso de tokens significativamente reducido (tan solo el 7,6 % del CoT estándar)

  • Velocidad : Respuestas más rápidas debido a un tiempo de generación más corto

  • Ahorro de costes : menores costes de API para llamadas LLM

  • Precisión mantenida : Precisión similar o incluso mejorada en comparación con CoT

  • Flexibilidad : aplicable a diversas tareas y dominios de razonamiento.

Características

  1. Cadena central de implementación del borrador

    • Pasos de razonamiento concisos (normalmente 5 palabras o menos)

    • Cumplimiento de formato

    • Extracción de respuestas

  2. Análisis de rendimiento

    • Seguimiento del uso de tokens

    • Monitoreo de la precisión de la solución

    • Medición del tiempo de ejecución

    • Métricas de rendimiento específicas del dominio

  3. Límites de palabras adaptables

    • Estimación automática de la complejidad

    • Ajuste dinámico de los límites de palabras

    • Calibración específica del dominio

  4. Base de datos de ejemplos completa

    • Transformación de CoT a CoD

    • Ejemplos específicos de dominio (matemáticas, código, biología, física, química, rompecabezas)

    • Recuperación de ejemplos basada en la similitud de problemas

  5. Aplicación del formato

    • Posprocesamiento para garantizar el cumplimiento de los límites de palabras

    • Preservación de la estructura escalonada

    • Análisis de adherencia

  6. Enfoques de razonamiento híbrido

    • Selección automática entre CoD y CoT

    • Optimización específica del dominio

    • Selección basada en el rendimiento histórico

  7. Compatibilidad de la API de OpenAI

    • Reemplazo directo para los clientes estándar de OpenAI

    • Soporte tanto para finalizaciones como para interfaces de chat

    • Fácil integración en flujos de trabajo existentes

Configuración e instalación

Prerrequisitos

  • Python 3.10+ (para la implementación de Python)

  • Node.js 18+ (para implementación de JavaScript)

  • Clave API antrópica

Instalación de Python

  1. Clonar el repositorio

  2. Instalar dependencias:

    pip install -r requirements.txt
  3. Configurar claves API en el archivo .env :

    ANTHROPIC_API_KEY=your_api_key_here
  4. Ejecutar el servidor:

    python server.py

Instalación de JavaScript

  1. Clonar el repositorio

  2. Instalar dependencias:

    npm install
  3. Configurar claves API en el archivo .env :

    ANTHROPIC_API_KEY=your_api_key_here
  4. Ejecutar el servidor:

    node index.js

Integración de escritorio de Claude

Para integrar con Claude Desktop:

  1. Instalar Claude Desktop desde claude.ai/download

  2. Cree o edite el archivo de configuración de Claude Desktop:

    ~/Library/Application Support/Claude/claude_desktop_config.json
  3. Agregue la configuración del servidor (versión de Python):

    {
        "mcpServers": {
            "chain-of-draft": {
                "command": "python3",
                "args": ["/absolute/path/to/cod/server.py"],
                "env": {
                    "ANTHROPIC_API_KEY": "your_api_key_here"
                }
            }
        }
    }

    O para la versión JavaScript:

    {
        "mcpServers": {
            "chain-of-draft": {
                "command": "node",
                "args": ["/absolute/path/to/cod/index.js"],
                "env": {
                    "ANTHROPIC_API_KEY": "your_api_key_here"
                }
            }
        }
    }
  4. Reiniciar Claude Desktop

También puedes usar la CLI de Claude para agregar el servidor:

# For Python implementation
claude mcp add chain-of-draft -e ANTHROPIC_API_KEY="your_api_key_here" "python3 /absolute/path/to/cod/server.py"

# For JavaScript implementation
claude mcp add chain-of-draft -e ANTHROPIC_API_KEY="your_api_key_here" "node /absolute/path/to/cod/index.js"

Herramientas disponibles

El servidor Chain of Draft proporciona las siguientes herramientas:

Herramienta

Descripción

chain_of_draft_solve

Resolver un problema utilizando el razonamiento de cadena de borrador

math_solve

Resolver un problema de matemáticas con CoD

code_solve

Resolver un problema de codificación con CoD

logic_solve

Resolver un problema de lógica con CoD

get_performance_stats

Obtén estadísticas de rendimiento de CoD vs. CoT

get_token_reduction

Obtener estadísticas de reducción de tokens

analyze_problem_complexity

Analizar la complejidad del problema

Uso del desarrollador

Cliente Python

Si desea utilizar el cliente Chain of Draft directamente en su código Python:

from client import ChainOfDraftClient

# Create client 
cod_client = ChainOfDraftClient()

# Use directly
result = await cod_client.solve_with_reasoning(
    problem="Solve: 247 + 394 = ?",
    domain="math"
)

print(f"Answer: {result['final_answer']}")
print(f"Reasoning: {result['reasoning_steps']}")
print(f"Tokens used: {result['token_count']}")

Cliente JavaScript

Para aplicaciones JavaScript/Node.js:

import { Anthropic } from "@anthropic-ai/sdk";
import dotenv from "dotenv";

// Load environment variables
dotenv.config();

// Create the Anthropic client
const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// Import the Chain of Draft client
import chainOfDraftClient from './lib/chain-of-draft-client.js';

// Use the client
async function solveMathProblem() {
  const result = await chainOfDraftClient.solveWithReasoning({
    problem: "Solve: 247 + 394 = ?",
    domain: "math",
    max_words_per_step: 5
  });
  
  console.log(`Answer: ${result.final_answer}`);
  console.log(`Reasoning: ${result.reasoning_steps}`);
  console.log(`Tokens used: ${result.token_count}`);
}

solveMathProblem();

Detalles de implementación

El servidor está disponible en implementaciones de Python y JavaScript, ambas constan de varios componentes integrados:

Implementación de Python

  1. AnalyticsService : realiza un seguimiento de las métricas de rendimiento en diferentes dominios de problemas y enfoques de razonamiento.

  2. ComplexityEstimator : analiza problemas para determinar límites de palabras apropiados

  3. ExampleDatabase : administra y recupera ejemplos, transformando ejemplos de CoT al formato CoD

  4. FormatEnforcer : garantiza que los pasos de razonamiento se ajusten a los límites de palabras

  5. ReasoningSelector : elige inteligentemente entre CoD y CoT según las características del problema

Implementación de JavaScript

  1. analyticsDb : Base de datos en memoria para el seguimiento de métricas de rendimiento

  2. complexityEstimator : Analiza problemas para determinar la complejidad y los límites de palabras apropiados

  3. formatEnforcer : garantiza que los pasos de razonamiento se ajusten a los límites de palabras

  4. reasoningSelector : elige automáticamente entre CoD y CoT según las características del problema y el rendimiento histórico

Ambas implementaciones siguen los mismos principios básicos y proporcionan herramientas MCP idénticas, lo que las hace intercambiables para la mayoría de los casos de uso.

Licencia

Este proyecto es de código abierto y está disponible bajo la licencia MIT.

Available Tools

7 tools
analyze_problem_complexityC

Analyze the complexity of a problem

Inputs: problem (required), domain.

chain_of_draft_solveC

Solve a reasoning problem using Chain of Draft approach

Inputs: problem (required), domain, max_words_per_step, approach, +2 more.

code_solveC

Solve a coding problem using Chain of Draft reasoning

Inputs: problem (required), approach, max_words_per_step.

get_performance_statsC

Get performance statistics for CoD vs CoT approaches

Inputs: domain.

get_token_reductionB

Get token reduction statistics for CoD vs CoT

Inputs: no named parameters.

logic_solveC

Solve a logic problem using Chain of Draft reasoning

Inputs: problem (required), approach, max_words_per_step.

math_solveC

Solve a math problem using Chain of Draft reasoning

Inputs: problem (required), approach, max_words_per_step.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.1/5.0

    Scored across 7 tools

    Disambiguation3/5

    The tools have clear distinctions in problem domains (math, logic, code, general reasoning) but there is significant overlap between 'chain_of_draft_solve' and the domain-specific solvers (math_solve, logic_solve, code_solve), which could cause confusion about when to use the general versus specific versions. The analysis and statistics tools are clearly distinct from the solving tools.

    Naming Consistency4/5

    Most tools follow a consistent snake_case pattern with descriptive names (e.g., 'analyze_problem_complexity', 'get_performance_stats'), but there's a minor inconsistency with 'chain_of_draft_solve' using a longer prefix while others use simpler domain names. The verb usage is reasonably consistent with 'solve', 'analyze', and 'get' patterns.

    Tool Count5/5

    With 7 tools, this is well-scoped for a server focused on Chain of Draft problem-solving and analysis. The count covers solving across multiple domains plus performance analytics, without being overwhelming or too sparse for the apparent purpose.

    Completeness4/5

    The toolset provides good coverage for solving problems (math, logic, code, general) and analyzing performance/token usage, which aligns well with the CoD domain. A minor gap exists in not having tools for configuring or customizing the CoD approach (e.g., setting parameters), but core workflows are well supported.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers