← Blog

Conectar un modelo de lenguaje a MathOperator por MCP: cálculo verificado como herramienta

2026-09-13

En la entrada anterior se defendía una división del trabajo: el modelo de lenguaje entiende, formula y explica; el motor simbólico calcula y verifica. Faltaba el cable. Desde hoy MathOperator expone su motor como servidor MCP en https://www.mathoperator.com/mcp: cualquier asistente o agente compatible puede llamar a los operadores —integrales, derivadas, límites, ecuaciones diferenciales, series, transformadas, matrices— y recibir el resultado con los pasos reales que lo produjeron. Es gratuito, no requiere registro y tiene un límite de peticiones por cliente. Este artículo explica qué es el protocolo, qué herramientas ofrece el servidor, por qué convierte la generación de soluciones en algo comprobable y, sobre todo, qué permite hacer con los problemas que exigen encadenar varios cálculos.

El protocolo. El Model Context Protocol (MCP) es un estándar abierto, publicado a finales de 2024 y adoptado desde entonces por los principales clientes de inteligencia artificial, que fija cómo un modelo de lenguaje descubre y utiliza herramientas externas. Un servidor declara sus herramientas —nombre, descripción y el esquema de sus argumentos—; el cliente (la aplicación de chat, el editor, el agente) se las presenta al modelo, que decide cuándo invocarlas; el cliente ejecuta la llamada y devuelve el resultado a la conversación. Todo viaja como JSON-RPC sobre HTTP. La consecuencia práctica es que una misma herramienta sirve, sin adaptaciones, a cualquier modelo y a cualquier aplicación que hable el protocolo: es al ecosistema de agentes lo que un puerto estándar es al hardware.

Lo que expone MathOperator. El servidor declara tres herramientas y un prompt. list_operators devuelve el catálogo con la sintaxis de entrada de cada operador y ejemplos válidos, que es lo que el modelo necesita para formular bien (las expresiones son texto plano, como x*sin(3*x) o y'' + y = 0, y(0)=1, y'(0)=0, no LaTeX). compute(operator, expression) resuelve y devuelve el resultado en LaTeX (result_latex) y en texto plano reinyectable (result_plain, que se puede pasar tal cual a otro operador), la solución paso a paso con la misma estructura que en la web (methods → steps) y la url de esa resolución, para que el lector la reproduzca con su gráfica. equivalent(a, b) es un oráculo de igualdad: decide si dos expresiones son la misma simplificando su diferencia y, si la simplificación no cierra, contrastándolas numéricamente en puntos aleatorios, con un contraejemplo cuando difieren. El prompt resolver_con_verificacion es un guion que pide al modelo descomponer, calcular, encadenar y verificar.

Qué cambia en la fiabilidad. Sin herramientas, un modelo que resuelve un problema realiza toda la manipulación algebraica dentro del texto que genera, y cada línea es una nueva oportunidad de error que nadie detecta: un signo, una constante, una identidad que se parece a la correcta. Con el motor conectado, el modelo sigue siendo quien lee el enunciado, decide la estrategia y redacta; pero cada operación que importa —integrar, derivar, resolver, transformar— la ejecuta un algoritmo determinista y vuelve con sus pasos. El resultado ya no es plausible, es reproducible: la misma llamada devuelve siempre lo mismo y cualquiera puede repetirla desde la url. Y equivalent cierra el círculo: cuando el modelo hace una manipulación por su cuenta —despejar, sustituir, agrupar—, puede someterla a una comprobación formal en lugar de «releerla». En la jerga de los sistemas de agentes, esto es un harness con verificación: el modelo propone, la herramienta dispone, y un fallo en la comprobación es una señal para reintentar, no un error silencioso que llega al usuario.

Donde más rinde: problemas de varias etapas. El valor de un catálogo de operadores no está en cada uno por separado, sino en que un mismo agente pueda encadenarlos. El ejemplo más sencillo es el área entre dos curvas, $y=x^{2}$ e $y=2x+3$: hay que saber dónde se cortan antes de integrar. El agente llama a equation con x^2 = 2*x + 3 y obtiene -1, 3; con esos límites llama a integral con (2*x+3) - x^2 from -1 to 3 y obtiene $\tfrac{32}{3}$, con los pasos de la primitiva y la regla de Barrow. Dos operadores, y el resultado de uno es literalmente la entrada del otro.

Dos caminos independientes, una comprobación. Los números de Fibonacci admiten dos derivaciones que no comparten ni un paso. Por un lado, recurrence con a(n+2)=a(n+1)+a(n), a(0)=0, a(1)=1 resuelve la recurrencia por su ecuación característica y devuelve la fórmula de Binet, $$a(n)=\frac{1}{\sqrt{5}}\left[\left(\frac{1+\sqrt{5}}{2}\right)^{n}-\left(\frac{1-\sqrt{5}}{2}\right)^{n}\right].$$ Por otro, matrix_power con [[1,1],[1,0]]^n diagonaliza la matriz y devuelve $A^{n}$ con exponente simbólico, cuya entrada superior derecha es también $F_{n}$, escrita de una forma bastante menos reconocible. Pasar ambas expresiones a equivalent devuelve equivalent: true con method: symbolic: el motor demuestra que son la misma función de $n$. Un modelo solo, ante dos expresiones así de distintas, únicamente podría opinar que coinciden.

Un resultado clásico a partir de dos operadores. La serie de Fourier de $f(x)=x^{2}$ en $(-\pi,\pi)$, que fourier_series devuelve con sus coeficientes calculados paso a paso, es $$x^{2}=\frac{\pi^{2}}{3}+\sum_{n=1}^{\infty}\frac{4(-1)^{n}}{n^{2}}\cos(nx).$$ Evaluada en $x=\pi$, donde $\cos(n\pi)=(-1)^{n}$, da $\pi^{2}=\tfrac{\pi^{2}}{3}+4\sum 1/n^{2}$, y despejando, $\sum_{n\ge1}1/n^{2}=\pi^{2}/6$: el problema de Basilea. Esa última manipulación la hace el agente; la comprueba con equivalent (pi^2/3 + 4*(pi^2/6) frente a pi^2) y, para cerrar, contrasta el valor con sums y 1/n^2, que devuelve $\pi^{2}/6$ por otra vía. Cada eslabón del razonamiento queda apoyado en un cálculo verificado o en una igualdad decidida por el motor.

Verificar una solución sustituyéndola. Con ode y y'' + y = tan(x), el motor devuelve la solución general (por variación de parámetros, con sus pasos). Un agente escéptico puede hacer lo que haría un corrector: derivar dos veces la solución con derivative —reinyectando result_plain— y pedir a equivalent que decida si $y''+y$ coincide con $\tan x$. La respuesta es true. Ese ciclo —resolver con un operador, comprobar con otros dos— es exactamente la validación independiente de la que hablaba la entrada anterior, y aquí la ejecuta el propio agente sin intervención humana.

Otras cadenas naturales. Extremos de una función: derivative, después equation sobre la derivada igualada a cero y derivative de nuevo (o limit en los extremos del dominio) para clasificar los puntos críticos. Sistemas dinámicos: matrix_diagonalize para los valores propios y matrix_power para la evolución. Señales: laplace de la entrada, álgebra en el dominio $s$ y, de vuelta, comprobación con convolution. En todos los casos el patrón es el mismo: el agente planifica, el motor calcula, equivalent arbitra.

Cómo conectarlo. La dirección del servidor es https://www.mathoperator.com/mcp; no hay clave ni registro. En Claude Code basta un comando:

claude mcp add --transport http mathoperator https://www.mathoperator.com/mcp

En Claude (web y escritorio) se añade como conector personalizado desde los ajustes, pegando la misma dirección; en ChatGPT, desde los conectores del modo de desarrollador; en Cursor, en su fichero mcp.json (en VS Code la clave es servers y la entrada lleva "type": "http"):

{ "mcpServers": { "mathoperator": { "url": "https://www.mathoperator.com/mcp" } } }

Y en un programa propio, cualquier SDK que soporte el protocolo puede usarlo. Con el SDK de Anthropic, por ejemplo, el conector remoto se declara en la propia petición y el modelo llama a las herramientas por su cuenta:

from anthropic import Anthropic

client = Anthropic()
respuesta = client.beta.messages.create(
    model="claude-opus-5",
    max_tokens=16000,
    betas=["mcp-client-2025-11-20"],
    mcp_servers=[{"type": "url", "name": "mathoperator",
                  "url": "https://www.mathoperator.com/mcp"}],
    tools=[{"type": "mcp_toolset", "mcp_server_name": "mathoperator"}],
    messages=[{"role": "user", "content": "Área entre y = x^2 e y = 2x + 3, con los pasos."}],
)

Límites y uso responsable. El servicio es el mismo motor que sirve a la web, y comparte con ella su capacidad: cada cliente dispone de un cupo de peticiones por minuto (con una ráfaga inicial) y, si lo agota, la herramienta devuelve un mensaje pidiendo esperar unos segundos, que los agentes entienden y respetan. Para integraciones de gran volumen o uso comercial, escríbenos. Lo que el servidor no hace también conviene saberlo: no interpreta lenguaje natural —esa es la parte del modelo— y no resuelve fuera del catálogo de operadores; para cada uno de ellos, list_operators es la referencia de sintaxis.

En resumen. Un modelo de lenguaje conectado a MathOperator por MCP no calcula mejor: deja de calcular y pasa a dirigir. Cada integral, derivada, ecuación o transformada la produce un algoritmo determinista con sus pasos; cada manipulación propia se somete a un oráculo de igualdad; y la solución final es una cadena de cálculos reproducibles con su enlace. Es la forma más directa de convertir una respuesta plausible en una respuesta comprobada, y está a un comando de distancia.