Cruncher MCP

La calculadora científica construida como un servidor de Protocolo de Contexto de Modelo (MCP)

Documentación

Cruncher: El Servidor MCP de Calculadora Científica

Una potente calculadora científica para tu asistente de IA, construida como un servidor de Protocolo de Contexto de Modelo (MCP). Cruncher permite a clientes de IA compatibles (como Claude Desktop) realizar cálculos matemáticos complejos, gestionar memoria, realizar análisis estadísticos y acceder a constantes científicas con una interfaz simple, segura y estandarizada.

🌟 La Promesa de Pureza (Cero Dependencias)

Cruncher está construido como una herramienta altamente educativa y extremadamente ligera. Logra funciones potentes sin incorporar bibliotecas externas pesadas (sin mathjs, sin zod, sin @modelcontextprotocol/sdk). Todo se maneja utilizando capacidades nativas de Node.js:

Evaluación Segura de Expresiones: En lugar de depender de mathjs o del peligroso eval(), Cruncher utiliza new Function() protegido por una estricta lista blanca Regex que garantiza que solo números y operadores matemáticos puedan pasar.
Validación de Entrada: En lugar de bibliotecas de esquemas pesadas como Zod, una función de validación recursiva personalizada aplica rígidamente las entradas de IA contra esquemas JSON directamente.
Protección por Tiempo de Espera: En lugar de gestores de procesos complejos, aprovecha worker_threads de Node.js para generar cálculos. Si una IA solicita un factorial de bucle de millones, el hilo principal termina fácilmente al trabajador después de un tiempo de espera estricto (3 segundos por defecto). Este tiempo de espera es configurable mediante la variable de entorno CRUNCHER_TIMEOUT (en milisegundos), asegurando que el servidor permanezca receptivo incluso durante cargas computacionales pesadas.
Precisión de Punto Flotante: En lugar de usar decimal.js, resuelve el clásico error matemático de JS (0.1 + 0.2 = 0.30000000000000004) mediante lógica dinámica de escalado de enteros bajo el capó.

📚 Un Enfoque Educativo hacia MCP

Este proyecto sirve como un excelente recurso de aprendizaje para desarrolladores que buscan comprender profundamente el Protocolo de Contexto de Modelo (MCP). Debido a que evita deliberadamente usar el @modelcontextprotocol/sdk oficial, toda la implementación del protocolo MCP, el manejo de mensajes JSON-RPC, las validaciones de entrada y el formato de errores están expuestos en JavaScript plano.

Leer cruncher.js proporciona una visión transparente e incomparable de exactamente cómo un servidor MCP se comunica a través de stdio, analiza las solicitudes entrantes (initialize, tools/list, tools/call) y responde al cliente de IA, desmitificando la "magia" que los SDK suelen ocultar.

¿Qué es el Protocolo de Contexto de Modelo?

El Protocolo de Contexto de Modelo (MCP) es un estándar abierto que permite a las aplicaciones de IA conectarse de manera segura con fuentes de datos y herramientas externas. Piénsalo como una API universal para IA. Al implementar Cruncher como un servidor MCP, cualquier IA que entienda MCP puede obtener instantáneamente potentes capacidades de calculadora integradas sin integraciones personalizadas.

✨ Características

Cruncher proporciona un conjunto completo de funciones de calculadora construidas completamente desde cero sin dependencias pesadas:

Arquitectura Robusta:
- Cero Dependencias: Se basa puramente en bibliotecas estándar de Node.js.
- Validación Estricta de Entrada: El validador de esquemas personalizado previene alucinaciones de IA y datos inválidos.
- Protección contra Bucles Infinitos: Utiliza worker_threads de Node.js con un tiempo de espera estricto de 3 segundos para evitar que cálculos complejos congelen el servidor.
- Matemática Decimal Precisa: Utiliza un enfoque de escalado de enteros para prevenir errores clásicos de punto flotante en JS (por ejemplo, 0.1 + 0.2 === 0.3).
Exposición de Herramientas por Niveles: Tres niveles (minimal, standard por defecto, full) para optimizar el uso de tokens de contexto.
Aritmética Básica: Suma, Resta, Multiplicación, División, Módulo.
Evaluación de Expresiones: Calcula de forma segura cadenas matemáticas completas en texto plano (por ejemplo, (5 + 3) * 10 / 2).
Potencias y Raíces: Exponenciación (a^b), Raíz Cuadrada.
Teoría de Números: Factorial (n!).
Trigonometría: Seno, Coseno, Tangente, Arcoseno (asin), Arcocoseno (acos) y Arcotangente (atan) (con soporte para grados y radianes).
Logaritmos: Logaritmo Base-10 y Logaritmo Natural (ln).
Funciones Estadísticas: Suma, Promedio, Mediana, Mínimo, Máximo, Rango, Conteo, Varianza y Desviación Estándar para arreglos de números.
Funciones de Porcentaje: Cálculos de porcentaje-de, cambio porcentual y porcentaje inverso.
Conversión de Unidades: Más de 80 conversiones en 8 categorías (longitud, peso, temperatura, área, volumen, tiempo, velocidad, almacenamiento digital).
Funciones de Conveniencia: Valor Absoluto.
Constantes: Acceso fácil a constantes de Matemáticas (pi, e, tau, phi, sqrt2, euler_mascheroni), Física (c, g, G, h, k, R) y Química (NA, e_charge, m_e, m_p).
Funciones de Memoria: M+, M-, MR (Recuperación de Memoria) y MC (Borrado de Memoria) - solo nivel completo.

🚀 Instalación y Uso

Pon Cruncher en funcionamiento con Claude Desktop en solo unos minutos.

Paso 1: Requisitos Previos

Asegúrate de tener Node.js (versión 18.0.0 o superior) instalado en tu sistema. Puedes descargarlo desde nodejs.org.

Paso 1: Inicio Rápido con npm

Recomendado: Instala vía npm y úsalo directamente:

npx @slbdn/cruncher-mcp

Esto descarga y ejecuta automáticamente la versión más reciente.

Paso 2: Configurar Claude Desktop

Recomendado: Usa el paquete npm para actualizaciones automáticas:

{
  "mcpServers": {
    "cruncher": {
      "command": "npx",
      "args": ["-y", "@slbdn/cruncher-mcp"]
    }
  }
}

Paso 3: Archivo Manual (Alternativa)

Si prefieres descargar el archivo manualmente en su lugar:

Descarga el archivo cruncher.js directamente desde GitHub.
Colócalo en una ubicación permanente (por ejemplo, C:\mcp-servers\cruncher.js o /home/user/mcp-servers/cruncher.js).
Localiza el archivo de configuración de Claude Desktop:
- Windows: %APPDATA%\Claude\claude_desktop_config.json
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Agrega la configuración del servidor apuntando a tu archivo descargado:
```
{
  "mcpServers": {
    "cruncher": {
      "command": "node",
      "args": ["C:/Users/YOUR_USERNAME/mcp-servers/cruncher.js"],
      "env": {
        "CRUNCHER_TOOL_SET": "standard"
      }
    }
  }
}
```
Nota para usuarios de macOS/Linux: Usa una ruta de estilo POSIX, por ejemplo, "/home/YOUR_USERNAME/mcp-servers/cruncher.js". Asegúrate de que tu ejecutable node esté en el PATH de tu sistema.

Paso 4: ¡Empieza a Calcular!

Guarda el archivo de configuración y cierra por completo la aplicación Claude Desktop.
Reinicia Claude Desktop. Se conectará automáticamente al servidor Cruncher.
¡Empieza a hacer preguntas!

OpenWebUI (Anteriormente Ollama WebUI)

OpenWebUI admite nativamente la conexión a servidores MCP de stdio.

Opción A: Usando el paquete npm

Ve a Panel de Administración > Configuración > Herramientas > Servidores MCP.
Haz clic en Agregar Servidor.
Nómbralo "Cruncher", selecciona Comando e ingresa npx, establece Args a @slbdn/cruncher-mcp.

Opción B: Usando el archivo descargado

Ve a Panel de Administración > Configuración > Herramientas > Servidores MCP.
Haz clic en Agregar Servidor.
Nómbralo "Cruncher", selecciona stdio, usa node como comando y /path/to/cruncher.js como argumento.

IDE Cursor

Puedes darle a la IA integrada de Cursor la capacidad de ejecutar matemáticas y calcular hashes.

Opción A: Usando el paquete npm

Abre Configuración de Cursor (icono de engranaje) > Funciones > Servidores MCP.
Haz clic en + Agregar Nuevo Servidor MCP.
Establece Tipo a command, Nombre a cruncher y Comando a npx @slbdn/cruncher-mcp.

Opción B: Usando el archivo descargado

Abre Configuración de Cursor (icono de engranaje) > Funciones > Servidores MCP.
Haz clic en + Agregar Nuevo Servidor MCP.
Establece Tipo a command, Nombre a cruncher y Comando a node /path/to/cruncher.js.

Cline (Extensión de VS Code)

Si usas Cline para codificación agéntica en VS Code, abre el archivo de configuración MCP (cline_mcp_settings.json) y agrega:

Opción A: Usando el paquete npm

{
  "mcpServers": {
    "cruncher": {
      "command": "npx",
      "args": ["-y", "@slbdn/cruncher-mcp"]
    }
  }
}

Opción B: Usando el archivo descargado

{
  "mcpServers": {
    "cruncher": {
      "command": "node",
      "args": ["/path/to/cruncher.js"],
      "env": {
        "CRUNCHER_TOOL_SET": "standard"
      }
    }
  }
}

Goose (Agente de Terminal)

Goose es un asistente de IA ligero basado en terminal que admite completamente MCP.

Opción A: Usando el paquete npm

Edita ~/.goose/config.yaml (o la configuración local del proyecto).
Agrega una nueva entrada de servidor:

mcpServers:
  cruncher:
    command: npx
    args:
      - -y
      - "@slbdn/cruncher-mcp"

Opción B: Usando el archivo descargado

Edita ~/.goose/config.yaml (o la configuración local del proyecto).
Agrega una nueva entrada de servidor:

mcpServers:
  cruncher:
    command: node
    args:
      - "/path/to/cruncher.js"
    env:
      CRUNCHER_TOOL_SET: "standard"

Reinicia Goose. Ahora puedes pedirle a Goose que ejecute cálculos como evaluate_expression o median directamente.

Editor Zed (Panel de IA)

El panel de IA integrado de Zed admite conexiones MCP.

Opción A: Usando el paquete npm

Abre Configuración → IA → Servidores MCP.
Haz clic en Agregar Servidor y completa:
- Nombre: cruncher
- Comando: npx
- Args: @slbdn/cruncher-mcp
Guarda. La IA de Zed ahora puede llamar a Cruncher para aritmética y estadísticas precisas.

Opción B: Usando el archivo descargado

Abre Configuración → IA → Servidores MCP.
Haz clic en Agregar Servidor y completa:
- Nombre: cruncher
- Comando: node
- Args: /absolute/path/to/cruncher.js
- Env (opcional): CRUNCHER_TOOL_SET=standard
Guarda. La IA de Zed ahora puede llamar a Cruncher para aritmética y estadísticas precisas.

LM Studio (LLM Local + MCP)

LM Studio ejecuta LLMs completamente sin conexión y ahora incluye un cliente MCP.

Opción A: Usando el paquete npm

Abre Configuración → MCP en LM Studio.
Haz clic en Agregar Servidor y proporciona:
- Ejecutable: npx
- Argumentos: @slbdn/cruncher-mcp
Confirma. Tu modelo privado ahora puede delegar matemáticas a Cruncher sin ningún tráfico de red.

Opción B: Usando el archivo descargado

Abre Configuración → MCP en LM Studio.
Haz clic en Agregar Servidor y proporciona:
- Ejecutable: node
- Argumentos: /absolute/path/to/cruncher.js
- Entorno (opcional): CRUNCHER_TOOL_SET=standard
Confirma. Tu modelo privado (por ejemplo, Llama 3, DeepSeek-V2) ahora puede delegar matemáticas a Cruncher sin ningún tráfico de red.

Configuración de LibreChat

Si estás usando LibreChat, puedes agregar la siguiente configuración a tu archivo librechat.yaml:

Opción A: Usando el paquete npm

  cruncher:
    type: stdio
    command: npx
    args:
      - -y
      - "@slbdn/cruncher-mcp"

Opción B: Usando el archivo descargado

  cruncher:
    type: stdio
    command: node
    args:
      - "/opt/mcp/cruncher.js"
    env:
      CRUNCHER_TIMEOUT: "5000"

Preguntas de Ejemplo para Claude

"¿Cuál es el ángulo en grados cuyo seno es 0.5?"

"Calcula el promedio, la mediana y el rango de estos números: [15, 22, 8, 41, 19, 30]"

"¿Cuánto es 2 elevado a la potencia de 10?"

"¿Cuál es la desviación estándar de [10, 12, 8, 14, 6]?"

"¿Cuánto es el 15% de 240?"

"Una acción pasó de $50 a $75. ¿Cuál es el cambio porcentual?"

"¿Cuál es la varianza de las calificaciones [85, 92, 78, 90, 88]?"

"Calcula el rango de valores en [3, 7, 2, 9, 1]"

"Evalúa la expresión: sin(pi/4) + sqrt(16) + log10(100)"

"¿Cuánto es 10 factorial?"

"¿Cuánto es 17 módulo 5?"

Ejemplos de Nivel Completo (con CRUNCHER_TOOL_SET=full):

"Guarda 99 en memoria, suma 5, luego recupera el total."

"¿Cuál es el percentil 75 de [10, 20, 30, 40, 50]?"

"Convierte 11010 de binario a decimal."

"Lote: raíz cuadrada de 144, suma 10, luego eleva a la potencia 2."

"Cambia las funciones trigonométricas al modo radianes."

"Borra la caché de resultados y muestra estadísticas de caché."

"Recupera lo que está en memoria, luego resta 15 y guarda el resultado."

"¿Cuál es el percentil 95 de [23, 45, 12, 67, 89, 34, 56, 78, 90, 11]?"

"Convierte 0xFF de hexadecimal a binario."

📋 Herramientas Disponibles

Cruncher expone sus funciones como herramientas MCP individuales. Aquí está la lista completa:

Nombre de la herramienta	Descripción	Argumentos
Aritmética básica
`evaluate_expression`	Evalúa una expresión matemática en texto plano (p. ej., `(5 + 3) * 10 / 2`).	`expression` (cadena)
`add`	Suma dos números (a + b).	`a` (número), `b` (número)
`subtract`	Resta el segundo número del primero (a - b).	`a` (número), `b` (número)
`multiply`	Multiplica dos números (a * b).	`a` (número), `b` (número)
`divide`	Divide el primer número entre el segundo (a / b).	`a` (número), `b` (número)
`modulo`	Calcula el resto (a mod b).	`a` (número), `b` (número)
Potencias y raíces
`power`	Calcula a elevado a la potencia de b (a^b).	`base` (número), `exponent` (número)
`sqrt`	Calcula la raíz cuadrada de un valor.	`value` (número)
Teoría de números
`factorial`	Calcula el factorial de un entero no negativo (n!).	`n` (número, entero no negativo)
Conversión de unidades
`convert_unit`	Convierte entre unidades comunes. 8 categorías, más de 80 unidades.	`value` (número), `category` (cadena), `from` (cadena), `to` (cadena)
Conversión de bases (nivel completo)
`convert_base`	Convierte entre bases 2, 8, 10, 16.	`value` (cadena), `from_base` (2, 8, 10, 16), `to_base` (2, 8, 10, 16)
Trigonometría
`sine`	Calcula el seno de un ángulo.	`angle` (número), `unit` (grados/radianes, opcional)
`cosine`	Calcula el coseno de un ángulo.	`angle` (número), `unit` (grados/radianes, opcional)
`tangent`	Calcula la tangente de un ángulo.	`angle` (número), `unit` (grados/radianes, opcional)
`asin`	Calcula el seno inverso (arcoseno) de un valor. Devuelve un ángulo.	`value` (número), `unit` (grados/radianes, opcional)
`acos`	Calcula el coseno inverso (arcocoseno) de un valor. Devuelve un ángulo.	`value` (número), `unit` (grados/radianes, opcional)
`atan`	Calcula la tangente inversa (arcotangente) de un valor. Devuelve un ángulo.	`value` (número), `unit` (grados/radianes, opcional)
Logaritmos
`logarithm`	Calcula el logaritmo en base 10 de un valor.	`value` (número)
`natural_log`	Calcula el logaritmo natural (base e) de un valor.	`value` (número)
Funciones estadísticas
`sum`	Calcula la suma de un arreglo de números.	`numbers` (arreglo de números)
`avg`	Calcula el promedio de un arreglo de números.	`numbers` (arreglo de números)
`median`	Calcula la mediana de un arreglo de números.	`numbers` (arreglo de números)
`min`	Encuentra el valor mínimo en un arreglo de números.	`numbers` (arreglo de números)
`max`	Encuentra el valor máximo en un arreglo de números.	`numbers` (arreglo de números)
`count`	Cuenta el número de elementos en un arreglo.	`numbers` (arreglo de números)
`range`	Calcula el rango (máx - mín) de un arreglo.	`numbers` (arreglo de números)
`percentile`	Calcula el valor en un percentil dado (0-100). Nivel completo.	`numbers` (arreglo de números), `percentile` (número, 0-100)
`variance`	Varianza de un arreglo. Muestra (n-1) o población (n).	`numbers` (arreglo de números), `population` (booleano, opcional)
`std_dev`	Desviación estándar. Muestra (n-1) o población (n).	`numbers` (arreglo de números), `population` (booleano, opcional)
`percentage_of`	¿Qué es X% de Y? p. ej., 15% de 200 = 30.	`percent` (número), `total` (número)
`percentage_change`	% de cambio de A a B. p. ej., 50→80 = 60%.	`from` (número), `to` (número)
`percentage_reverse`	X es ¿Y% de qué? p. ej., 30 es 15% de 200.	`value` (número), `percent` (número)
Otros
`absolute`	Calcula el valor absoluto de un número.	`value` (número)
Constantes
`get_constant`	Devuelve el valor de una constante matemática, física o química.	`name` ("pi", "e", "tau", "phi", "sqrt2", "euler_mascheroni", "c", "g", "G", "h", "k", "R", "NA", "e_charge", "m_e", "m_p")
Funciones de memoria (nivel completo)
`memory_clear`	Limpia la memoria de la calculadora (MC).	(sin argumentos)
`memory_recall`	Recupera el valor almacenado en memoria (MR).	(sin argumentos)
`memory_add`	Suma un valor a la memoria actual (M+).	`value` (número)
`memory_subtract`	Resta un valor de la memoria actual (M-).	`value` (número)
Modo de ángulo (nivel estándar)
`set_angle_mode`	Establece el modo de ángulo global (predeterminado: grados).	`unit` ("degrees" o "radians")
`get_angle_mode`	Obtiene el modo de ángulo actual.	(sin argumentos)
Herramientas de administración (nivel completo)
`batch`	Ejecuta múltiples llamadas a herramientas de forma secuencial.	`operations` (arreglo de {tool, arguments})
`cache_clear`	Limpia la caché de cálculo.	(sin argumentos)
`cache_info`	Muestra estadísticas de la caché.	(sin argumentos)

⚙️ Configuración

Variables de entorno

Variable	Predeterminado	Descripción
`CRUNCHER_TIMEOUT`	`3000`	Tiempo de espera de ejecución del hilo de trabajo (ms). Rango 100-60000
`CRUNCHER_TOOL_SET`	`standard`	Controla la exposición de herramientas: `minimal` (5), `standard` (34 predeterminado), `full` (43)

Niveles de herramientas - Referencia completa

Cruncher expone 3 niveles mediante la variable de entorno CRUNCHER_TOOL_SET. Cada nivel es un superconjunto estricto del anterior.

Resumen de niveles

Nivel	Herramientas	Caso de uso
Mínimo (5)	Solo aritmética básica	Calculadoras ligeras, agentes matemáticos simples
Estándar (34 - predeterminado)	Todo el mínimo + trigonometría, estadísticas, constantes, conversión de unidades	Matemáticas de propósito general para asistentes de IA
Completo (43)	Todo el estándar + memoria, lote, caché, conversión de bases, estadísticas avanzadas	Usuarios avanzados, flujos de trabajo de múltiples pasos

Nivel mínimo (5 herramientas)

Todas las herramientas se ejecutan en el hilo de trabajo con protección de tiempo de espera.

#	Herramienta	Descripción
1	`evaluate_expression`	Evalúa una cadena de expresión matemática
2	`add`	Suma (a + b)
3	`subtract`	Resta (a - b)
4	`multiply`	Multiplicación (a × b)
5	`divide`	División (a ÷ b)

Nivel estándar (34 herramientas - incluye las 5 del mínimo)

#	Herramienta	Categoría
6	`sqrt`	Raíz cuadrada
7	`power`	Exponenciación (a^b)
8	`absolute`	Valor absoluto
9	`modulo`	Resto (a mod b)
10	`factorial`	Factorial (n!)
11	`logarithm`	Logaritmo en base 10
12	`natural_log`	Logaritmo natural (ln)
13	`get_constant`	Obtener constantes físicas/matemáticas
14-16	`sine`, `cosine`, `tangent`	Trigonometría
17-19	`asin`, `acos`, `atan`	Trigonometría inversa
20	`set_angle_mode`	Alternar grados/radianes (global)
21	`get_angle_mode`	Verificar el modo de ángulo actual
22-25	`sum`, `avg`, `min`, `max`	Estadísticas básicas
26	`count`	Contar elementos
27	`variance`	Varianza (muestra o población)
28	`std_dev`	Desviación estándar (muestra o población)
29	`percentage_of`	X% de Y
30	`percentage_change`	% de cambio A→B
31	`percentage_reverse`	X es ¿Y% de qué?
32	`median`	Valor mediano
33	`range`	Rango (máx - mín)
34	`convert_unit`	Más de 80 conversiones de unidades, 8 categorías

Nivel completo (43 herramientas - incluye las 34 del estándar)

#	Herramienta	Categoría
35	`percentile`	Valor en el percentil N
36	`convert_base`	Conversión de base 2/8/10/16
37	`memory_add`	Sumar al total acumulado
38	`memory_subtract`	Restar del total acumulado
39	`memory_recall`	Obtener el valor de memoria actual
40	`memory_clear`	Restablecer memoria a cero
41	`batch`	Ejecutar hasta 50 operaciones en una sola llamada
42	`cache_clear`	Limpiar caché de resultados
43	`cache_info`	Mostrar estadísticas de caché

Coincidencia difusa de nombres de herramientas

Si el LLM llama a una herramienta que no existe, Cruncher usa la distancia de Levenshtein para encontrar la coincidencia más cercana y la sugiere:

Error tipográfico	Sugerencia	Tipo de coincidencia
`fact`	`factorial`	Coincidencia de prefijo
`fac`	`factorial`	Coincidencia de prefijo
`sinn`	`sine`	Error tipográfico de 1 carácter
`squrt`	`sqrt`	Transposición
`adddd`	`add`	Letras adicionales
`divid`	`divide`	Sufijo faltante
`totally_wrong`	(ninguno)	Demasiado diferente - sin sugerencia

Formato de respuesta:

{
  "error": {
    "code": -32601,
    "message": "Tool 'fact' not found. Did you mean 'factorial'?"
  }
}

Funciones integradas extendidas de evaluate_expression

Más allá de la aritmética básica, evaluate_expression admite estas funciones de forma nativa:

Función	Descripción	Ejemplo	Resultado
`sin(x)`	Seno (radianes, siempre en expresiones)	`sin(pi / 2)`	1
`cos(x)`	Coseno (radianes, siempre en expresiones)	`cos(pi)`	-1
`tan(x)`	Tangente (radianes)	`tan(pi / 4)`	~1
`asin(x)`	Arcoseno (resultado en radianes)	`asin(1)`	π/2
`acos(x)`	Arcocoseno (resultado en radianes)	`acos(0)`	π/2
`atan(x)`	Arcotangente (resultado en radianes)	`atan(1)`	π/4
`sqrt(x)`	Raíz cuadrada	`sqrt(144)`	12
`log10(x)`	Logaritmo en base 10	`log10(1000)`	3
`ln(x)`	Logaritmo natural (base e)	`ln(e)`	1
`log(x, b)`	Logaritmo en base arbitraria	`log(8, 2)`	3
`abs(x)`	Valor absoluto	`abs(-5)`	5
`round(x)`	Redondear al entero más cercano	`round(3.7)`	4
`floor(x)`	Redondear hacia abajo	`floor(3.9)`	3
`ceil(x)`	Redondear hacia arriba	`ceil(3.1)`	4
`min(a,b,...)`	Valor mínimo	`min(3, 1, 4)`	1
`max(a,b,...)`	Valor máximo	`max(3, 1, 4)`	4

Combina libremente: sin(pi/6) + sqrt(16) + log10(100) = 6.5

Mensajes de error mejorados

Los errores de dominio ahora te indican qué salió mal:

sqrt(-1) → "Verifica: sqrt(negativo), log(negativo/cero), asin/acos fuera de [-1,1]"
1/0 → "Verifica división por cero o desbordamiento"
asin(5) → "asin/acos fuera de [-1,1]"

Constantes en expresiones

Ahora puedes usar nombres de constantes matemáticas y físicas directamente dentro de evaluate_expression:

Constante	Descripción	Valor
`pi`	π (razón del círculo)	3.14159...
`e`	Número de Euler	2.71828...
`tau`	τ = 2π	6.28318...
`phi`	Razón áurea (φ)	1.61803...
`sqrt2`	√2	1.41421...
`euler_mascheroni`	Euler-Mascheroni (γ)	0.57721...
`c`	Velocidad de la luz (m/s)	299792458
`g`	Gravedad (m/s2)	9.80665
`G`	Constante gravitacional	6.6743e-11
`h`	Constante de Planck (J·s)	6.62607015e-34
`k`	Constante de Boltzmann (J/K)	1.380649e-23
`R`	Constante de los gases ideales (J/mol·K)	8.314462618
`NA`	Constante de Avogadro (1/mol)	6.02214076e23
`e_charge`	Carga elemental (C)	1.602176634e-19
`m_e`	Masa del electrón (kg)	9.1093837015e-31
`m_p`	Masa del protón (kg)	1.67262192369e-27

Ejemplos:

2 * pi * 5       → 31.4159...
phi ^ 2          → 2.61803...
G * 1e11         → 6.6743
sqrt2 * sqrt2    → 2
e * e            → 7.38906...
c * 2            → 599584916

Reglas:

Usa operadores explícitos: 2 * pi funciona, 2pi no (sin multiplicación implícita)
Las constantes coexisten con la notación científica: 1e6 y e * 2 funcionan correctamente
Los nombres de constantes más largos coinciden primero: euler_mascheroni no se convertirá en 299792458uler_mascheroni

Exposición de Herramientas por Niveles

La variable de entorno CRUNCHER_TOOL_SET te permite optimizar el uso de tokens de contexto exponiendo solo las herramientas que realmente necesitas:

Nivel	Herramientas	Presupuesto de Tokens	Caso de Uso
`minimal`	5	~160 tokens	Aritmética básica. Toda la matemática compleja mediante `evaluate_expression`
`standard`	34	~1,150 tokens	Aritmética, trigonometría, estadística, porcentajes, constantes, conversión de unidades (predeterminado)
`full`	43	~1,500 tokens	Estándar + memoria, conversión de bases, percentiles, lote, caché

Nota: Incluso en modo minimal, evaluate_expression maneja matemática compleja - las herramientas individuales (sin, sqrt, etc.) simplemente no se registran como llamadas MCP de herramientas separadas. Esto ahorra hasta 90% en tokens de contexto.

Ejemplo de configuración MCP (claude_desktop_config.json):

{
  "mcpServers": {
    "cruncher-minimal": {
      "command": "node",
      "args": ["/path/to/cruncher.js"],
      "env": { "CRUNCHER_TOOL_SET": "minimal" }
    }
  }
}

⛏️ Cómo Funciona (Para Desarrolladores)

Cruncher es una aplicación JavaScript Node.js simple que se comunica a través de entrada/salida estándar (stdio). Esto lo convierte en un servidor MCP ligero, portátil y seguro. El flujo completo para una sola llamada de herramienta se ve así:

Inicialización: Al iniciar, el servidor escucha una solicitud initialize del cliente MCP y responde con sus capacidades e información de versión (v1.2.31).
Descubrimiento de Herramientas: El cliente envía una solicitud tools/list, y el servidor responde con la lista completa de herramientas de calculadora disponibles y sus inputSchema, que define los argumentos requeridos y sus tipos.
Validación de Entrada: Antes de ejecutar cualquier herramienta, el servidor ejecuta una función recursiva personalizada validateArguments contra el inputSchema de la herramienta. Esto garantiza que los campos requeridos estén presentes, los tipos sean correctos (número, cadena, matriz), los valores de enumeración sean válidos y se respeten las restricciones de mínimo/máximo - todo sin ninguna biblioteca externa.
Ejecución en Hilo de Trabajo: Una vez validada, la llamada de herramienta se transfiere a un worker_thread de Node.js aislado. Esto protege completamente el hilo principal (y su comunicación stdio) de ser bloqueado por un cálculo de larga duración o infinito.
Protección por Tiempo de Espera: Un temporizador configurable (CRUNCHER_TIMEOUT, predeterminado 3000ms) vigila el hilo de trabajo. Si el hilo de trabajo tarda demasiado, el hilo principal lo termina forzosamente mediante worker.terminate() y devuelve un error -32000 al cliente de IA.
Matemática Segura y Resultado: El hilo de trabajo ejecuta la función de manejo usando safeMath (escalado de enteros) para aritmética segura con decimales, luego publica el resultado de vuelta al hilo principal, que formatea y escribe la respuesta final JSON-RPC 2.0 a stdout.

🤝 Contribuciones

¡Las contribuciones son bienvenidas! Si deseas agregar una nueva función, corregir un error o mejorar la documentación, no dudes en abrir un issue o enviar una solicitud de extracción.

📜 Licencia

Este proyecto está licenciado bajo la Licencia MIT.