de en es ja ko ru zh

Ultimath

Name: Ultimath
Author: Flupke68

by Flupke68

Overview Schema Source Related Servers Discussions Admin

TypeScript

Remote

Ultimath MCP

Deja de alucinar números. Un servidor MCP que ejecuta cada expresión matemática a través de ocho motores independientes en paralelo — simbólico exacto, aritmética de bolas, intervalo, tres flotantes de precisión arbitraria distintos, simbólico diferido e IEEE 754, cada uno con sus propios modos de fallo — y devuelve las ocho lecturas lado a lado, de modo que cuando discrepan sabes que la respuesta no es numéricamente fiable.

Motor	Qué hace
Simbólico exacto	Aritmética exacta: decide un valor en lugar de aproximarlo
Multiprecisión	Aritmética de bolas, radio riguroso arrastrado en todo el cálculo
Intervalo	Cotas inferiores/superiores rigurosas (encerramiento garantizado)
Flotante binario	Flotantes binarios de precisión arbitraria, sin GMP por debajo
PARI/GP	Construido sin GMP: sus propios núcleos enteros y trascendentes
NTL RR	Mantisa entera exacta × 2^e; solo redondean las operaciones
Simbólico diferido	Reescribe antes de evaluar: una cancelación nunca redondea
Doble IEEE-754	Punto flotante estándar de hardware

Lo que respalda cada motor

Leer ocho números es solo la mitad de la respuesta. Cada motor indica también hasta qué punto respalda el suyo — y las tres respuestas no son grados de una misma escala:

Campo	Lo que dice el motor
`"exact": true`	Tiene el valor exacto. La lectura es una truncación de él: cada dígito adicional que pides es un dígito del número, no una aproximación más cercana.
`"digits": N`	Su propia cota de error cubre los primeros `N` dígitos significativos. `0` es una respuesta real: eso es lo que la cancelación catastrófica le hace a un valor.
ninguno de los dos	No lleva ninguna cota de error. Imprimió tantos dígitos como pediste y no puede decir nada sobre ninguno de ellos.

Esa última fila no es 0, y es la razón por la que existen los demás motores. Cinco de los ocho están ahí por construcción.

En exp(pi*sqrt(163)) - 262537412640768744, un motor imprime 63 dígitos, de los cuales 34 son correctos — y no dice nada al respecto. Otros dos demuestran 33 y se detienen. Uno mantiene el valor exacto. Leer solo los ocho números no te diría cuál era cuál.

Ningún motor es consultado jamás sobre otro: cada afirmación es sobre sí mismo.

Related MCP server: mcp-abacus

El motor exacto

calcium decide una igualdad en lugar de comparar dígitos, alcanza polos que los demás solo aproximan (tan(pi/2) es uinf), y cuando los dígitos impresos son solo una truncación devuelve también la forma cerrada — sqrt(2)+1 regresa con Add(Sqrt(2), 1), en forma textual y en LaTeX, y acosh(0.5) con Div(Mul(NumberI, Pi), 3) — el valor nombrado, no el elemento de cuerpo en el que está almacenado.

La forma cerrada es de activación opcional en la API HTTP ("closed_form": true) porque demostrar una cuesta más que leer los dígitos. Este cliente siempre la solicita: citar un valor exacto es lo que promete su esquema de salida.

Herramientas

evaluate — evalúa una expresión en los ocho motores y compara. Admite aritmética, trigonometría (sin, cos, tan), exp/log (exp, ln, log), raíces y potencias (sqrt, x^y), factorial, números complejos (3+2i), bases alternativas (0xFF, 0b1010) y constantes (pi, e, razón áurea PHI).
list_functions — lista todas las funciones que exponen los motores (nombre, aridad, categoría, descripción). Opcionalmente filtra por categoría.

Las comparaciones no significan lo mismo en todos los motores. En los motores de encerramiento, !=, < y > solo son verdaderos una vez demostrados; ==, <= y >= son verdaderos en cuanto no están refutados. Un == verdadero allí no es una prueba de igualdad — calcium decide eso exactamente — pero un != verdadero es una prueba de diferencia.

La multiplicación debe ser explícita: escribe 2*pi, 2*sin(x), (a+b)*(c+d). La yuxtaposición no es un producto (2pi es un error). Las expresiones son puramente matemáticas — sin conversiones de tipo ni constructores; escribe un número complejo como 1+2i.

Configuración

Obtén una clave de API gratuita en https://ultimath.ai.
Añade el servidor a la configuración de tu cliente MCP (ejemplo para Claude Desktop):

{
  "mcpServers": {
    "ultimath": {
      "command": "npx",
      "args": ["-y", "ultimath-mcp"],
      "env": {
        "ULTIMATH_API_KEY": "your_api_key_here"
      }
    }
  }
}

Eso es todo: npx descarga y ejecuta el servidor bajo demanda.

Requisitos

Node.js ≥ 18
Una clave de API de Ultimath (ULTIMATH_API_KEY)

Enlaces

Sitio web: https://ultimath.ai
Código fuente: https://github.com/Flupke68/ultimath-mcp

Bajo el capó

Los motores de Ultimath se construyen sobre FLINT/Arb, Calcium, GMP/MPFR y MPFI — créditos completos en https://ultimath.ai/credits.

Privacidad

Ultimath almacena solo un hash de tu clave de API y métricas básicas de uso para operar y asegurar el servicio; las expresiones se evalúan, no se conservan para entrenamiento. Política completa: https://ultimath.ai/privacy/

Licencia

MIT

Available Tools

2 tools

evaluateEvaluate & cross-check a math expressionA

Read-only

Verify any numeric result that has to be trusted, via the Ultimath API (https://ultimath.ai). Use this whenever the correctness of a number matters — floating-point-sensitive expressions, catastrophic cancellation, values near singularities or branch cuts, ties, or any computation where a single method could be silently wrong. Prefer it over computing by hand or running code: it evaluates the expression on 8 independent engines (exact symbolic, multiprecision ball, interval arithmetic, three different arbitrary-precision floats, deferred symbolic rewriting, IEEE 754 double) in parallel and returns every result plus per-engine precision diagnostics, so disagreement exposes an unreliable value that a single calculation would hide.

The 8 engines are independent and each computes with its own native primitive — so divergence between them (at poles, singularities, branch cuts, or ties like round(2.5)) is the backends' real behavior, NOT a bug. Agreement across engines is a confidence signal; divergence flags a value that is convention-dependent or near a domain edge — verify it rather than trust a single column.

One engine (calcium) is exact rather than numeric: it decides a value instead of approximating it, so it reaches poles the others can only approach (tan(pi/2) is uinf), and when the printed digits are only a truncation it also returns the closed form in symbolic / symbolic_latex (sqrt(2)+1 carries Add(Sqrt(2), 1)). Prefer that closed form when quoting an exact value.

A comparison does not mean the same thing on every engine. On the enclosure engines (flint, mpfi) !=, < and > return true only once the property is PROVEN, while ==, <= and >= return true as soon as it is not disproven. So a true == there is not a proof of equality — calcium decides that one exactly — but a true != IS a proof of difference. Each pair is complementary: a == b and a != b are never both false.

A value that is real comes back as a plain real number: an engine drops a zero imaginary part only when it PROVES the value real. So a trailing +0i is NOT decoration — it means that engine did not establish realness, and a visible residue (e.g. 4.3e-17i on the double engine) is genuine numerical error. Do not strip either one when reporting a result.

Supports: arithmetic, trigonometry (sin, cos, tan), exponentials and logs (exp, ln, log), roots and powers (sqrt, x^y), factorial, complex numbers (3+2i), arbitrary bases (0xFF, 0b1010), constants (pi, e, the golden ratio PHI). Multiplication must be EXPLICIT: write 2pi, 2(3+4), (a+b)(c+d), 2sin(x) — adjacency is NOT a product (2pi is an error). Precedence, tightest first: postfix factorial ! (2^3! = 2^(3!) = 64), then powers ^, then * / %, then + -. Note: expressions are mathematical only — there are no type casts ((int)x) or constructors (complex(1,2)); write a complex number as 1+2i or (re, im). Call list_functions for the authoritative list of available functions.

Name	Required	Description
`format`	No	Output format (default 'fixed')
`precision`	No	Decimal digits of precision (default 50). The ceiling is the PLAN behind the key — the free beta caps at 50 and refuses more — and 999 above every plan, the length of the built-in constants.
`expression`	Yes	Math expression, e.g. '0.1 + 0.2', 'sin(pi/4)', 'sqrt(2)^2 - 2', '2pi', '2(3+4)', 'factorial(10)'

Output Schema

Name	Required	Description
`ms`	No
`trace`	No
`result`	No	The retained reading — read `accuracy` before quoting any of its digits
`engines`	Yes	Per-engine results, compare to detect floating-point error
`inexact`	Yes	True if any engine emitted a warning (precision loss or domain issue somewhere)
`accuracy`	No	What the reading is worth once the other engines have been read against it. `exact` and `proved` are different KINDS of fact and stand together here
`angle_unit`	No
`expression`	Yes

TDQS

A5/5.0

Behavior5/5

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

The description explains nontrivial behavior far beyond the readOnlyHint annotation: engine divergence is real behavior, not a bug; comparison semantics differ per engine (e.g., `!=` can be a proof of difference while `==` is not a proof of equality); and trailing `+0i` indicates unproven realness rather than decoration. This is precisely the kind of behavioral nuance an agent needs.

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

Conciseness5/5

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

The description is long but every section earns its place: purpose, when-to-use, engine behavior, comparison semantics, realness, syntax, and precedence are all distinct and clearly organized. It is front-loaded with the core purpose and usage guidance before diving into technical details.

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

Completeness5/5

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

Given the tool's complexity, the description is unusually complete. It covers return content (per-engine results and precision diagnostics), engine semantics, exact closed-form output, precision limits, supported operations, syntax constraints, and points to list_functions for the authoritative list. Nothing essential is missing for an agent to invoke it correctly.

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

Parameters5/5

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

Schema coverage is 100%, but the description adds substantial meaning beyond the schema: explicit-multiplication rules, precedence order, complex-number syntax, unsupported constructs like type casts, the precision ceiling tied to the plan, and examples. This makes the expression parameter far more usable than the schema alone.

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

Purpose5/5

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

The description opens with a specific verb and resource: 'Verify any numeric result that has to be trusted, via the Ultimath API.' It clearly states what the tool does, names its multi-engine evaluation behavior, and differentiates it from computing by hand, running code, and the sibling list_functions tool.

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

Usage Guidelines5/5

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

It gives explicit when-to-use guidance: 'Use this whenever the correctness of a number matters,' and enumerates concrete scenarios such as floating-point-sensitive expressions, cancellation, singularities, branch cuts, and ties. It also says 'Prefer it over computing by hand or running code,' directly routing the agent away from alternatives.

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

list_functionsList available functionsA

Read-only

List all mathematical functions available via the Ultimath API (https://ultimath.ai). Returns name, arity, category, and description for each function. Use this to discover what functions you can pass to the evaluate tool. Optionally filter by category (algebraic, trigonometric, hyperbolic, exponential, special, rounding, introspection). Every function is available on all 8 engines, but each computes it with its own native primitive — so results may diverge at poles, branch cuts, or ties, and that divergence is honest backend behavior, not a bug.

Name	Required	Description	Default
`category`	No	Filter by category, e.g. 'special', 'trigonometric'. Omit to list all.

TDQS

A4.7/5.0

Behavior5/5

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

Beyond the readOnlyHint annotation, the description reveals important behavioral nuances: every function exists on all 8 engines but is computed via native primitives, so results may diverge at poles, branch cuts, or ties, and that divergence is intended backend behavior. This is rich, honest context that an agent needs before trusting listed functions.

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

Conciseness5/5

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

The description is front-loaded with purpose and return fields, then usage guidance, then filter options, then behavioral caveats. Every sentence earns its place; there is no filler or repetition of schema/annotation content.

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

Completeness5/5

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

For a simple read-only list tool with one optional parameter and no output schema, the description provides everything an agent needs: what it lists, what each entry contains, how to filter, how it relates to evaluate, and a warning about cross-engine divergence. No material gap remains.

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

Parameters4/5

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

The schema already covers the single optional 'category' parameter at 100% coverage, so the baseline is 3. The description adds value by enumerating all valid category values (algebraic, trigonometric, hyperbolic, exponential, special, rounding, introspection), which is especially useful since the schema provides no enum constraint.

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

Purpose5/5

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

The description states a specific verb and resource: 'List all mathematical functions available via the Ultimath API,' and explicitly lists the returned fields (name, arity, category, description). It clearly distinguishes itself from the sibling 'evaluate' tool by framing itself as the discovery step for functions to pass to evaluate.

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

Usage Guidelines4/5

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

It explicitly tells the agent when to use this tool: 'Use this to discover what functions you can pass to the evaluate tool.' It names the sibling evaluate as the downstream consumer, but it does not explicitly state a when-not condition or directly contrast with evaluate in an 'instead' formulation.

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

Tool Schema Changelog

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

1 tool updatev0.6.0Aug 27, 2026

Changedevaluate10 fields changed

changedInput schema / properties / precision / description

Previous value: -"Decimal digits of precision (default 50). The free beta caps at 50; higher values are rejected server-side."New value: +"Decimal digits of precision (default 50). The ceiling is the PLAN behind the key — the free beta caps at 50 and refuses more — and 999 above every plan, the length of the built-in constants."

changedInput schema / properties / precision / maximum
```
Previous value: -50New value: +999
```

addedOutput schema / properties / accuracy

Added value: +{
+  "additionalProperties": false,
+  "description": "What the reading is worth once the other engines have been read against it. `exact` and `proved` are different KINDS of fact and stand together here",
+  "properties": {
+    "agree": {
+      "description": "Engines returning this same reading",
+      "type": "number"
+    },
+    "engines": {
+      "description": "Engines asked — refusals included, since a refusal is part of the answer",
+      "type": "number"
+    },
+    "exact": {
+      "description": "An agreeing engine HOLDS this value — the reading is a truncation of it",
+      "type": "boolean"
+    },
+    "proved": {
+      "description": "Leading significant digits of `result` covered by a DIFFERENT engine's own error bound. Past this point the digits were printed at the precision asked for and no engine underwrites them — quoting them is quoting one implementation. 0 is a real answer; absent means no other engine carries a bound at all, which is not the same statement",
+      "type": "number"
+    },
+    "source": {
+      "description": "Engine the reading came from",
+      "type": "string"
+    }
+  },
+  "required": [
+    "source",
+    "agree",
+    "engines"
+  ],
+  "type": "object"
+}

addedOutput schema / properties / engines / items / properties / digits

Added value: +{
+  "description": "Leading significant digits of `result` this engine backs with its OWN error bound; 0 means the bound covers none of them. With `exact` and `digits` BOTH absent, the engine carries no error bound at all and can say nothing about any digit it printed — which is not 0, and is the single most useful thing to read before trusting a number",
+  "type": "number"
+}

addedOutput schema / properties / engines / items / properties / diverges

Added value: +{
+  "description": "This engine's reading CONTRADICTS the consensus — a finding, not a formatting difference. Absent on an engine that agrees or cannot be compared",
+  "type": "boolean"
+}

addedOutput schema / properties / engines / items / properties / exact

Added value: +{
+  "description": "True when this engine holds the value EXACTLY — the reading is a truncation of the number itself, so every further digit you ask for is a digit of it. Not a very large `digits`: a different statement, never set alongside it",
+  "type": "boolean"
+}

changedOutput schema / properties / engines / items / properties / name / description

Previous value: -"Engine id: flint, dec, cpp, mpfi, or ntl"New value: +"Engine id: calcium, flint, mpfi, or cpp"

addedOutput schema / properties / engines / items / properties / symbolic

Added value: +{
+  "description": "Closed form of the value, e.g. Add(Sqrt(2), 1) — present only when the engine proved one AND the printed digits are a truncation of it",
+  "type": "string"
+}

addedOutput schema / properties / engines / items / properties / symbolic_latex

Added value: +{
+  "description": "The closed form as LaTeX",
+  "type": "string"
+}

addedOutput schema / properties / result

Added value: +{
+  "description": "The retained reading — read `accuracy` before quoting any of its digits",
+  "type": "string"
+}

1 tool updatev0.2.0Jul 5, 2026
- Changedevaluate1 field changed
  - changedOutput schema / properties / engines / items / properties / name / description
```
Previous value: -"Engine id: flint, dec, cpp, or mpfi"New value: +"Engine id: flint, dec, cpp, mpfi, or ntl"
```
2 tool updatesv0.1.5Jul 1, 2026
- First observedevaluate
- First observedlist_functions

Deploy Server

Shareable, User-Owned Context BackendPeople, applications, and agents read, write, and coordinate together in one context lake. Reach it over MCP, a CLI, a Python SDK, or REST.fulcradynamics.comAd

TDQS

A4.6/5.0

Scored 2026-08-27 16:55 across 2 tools

Disambiguation5/5

evaluate performs mathematical computation and returns multi-engine results, while list_functions only returns metadata about supported functions. There is no overlap or ambiguity between the two operations.

Naming Consistency4/5

Both names are imperative and clear, but evaluate is a bare verb while list_functions follows a verb_noun pattern. This is a minor stylistic inconsistency that does not create confusion.

Tool Count4/5

Two tools is below the typical 3–15 range, but the server's scope is narrow: one computational entry point plus one discovery helper. Each tool is necessary, so the count is slightly under but reasonable.

Completeness4/5

The core workflow is complete: discover functions with list_functions, then evaluate expressions with evaluate. Since this is a stateless computation service, lifecycle operations do not apply; the main minor gap is that supported constants are documented only in evaluate's description rather than being discoverable through list_functions.

Maintenance

ActivityStale

ResponsivenessNo issues

Resources

Related MCP Connectors

Math MCP Learning A
io.github.clouatre-labs
Educational MCP server with 17 math/stats tools, visualizations, and persistent workspace
Education & Learning Tools Research & Data Developer Tools
1725
https://math-mcp.fastmcp.app/mcp
NumProof B
io.github.projecttron
Deterministic signed verification of numeric & financial claims for AI agents & spreadsheets.
Finance Security
42
https://numproof.com/mcp
Aman-Amith-Shastry-scientific_computation_mcp A
ai.smithery
This MCP server enables users to perform scientific computations regarding linear algebra and vect…
Research & Data
2623
https://server.smithery.ai/@Aman-Amith-Shastry/scientific_computation_mcp/mcp
ActionGuard Protocol Inspector Agent B
io.github.lsendel
Diff and poisoning detection for MCP servers: catch schema drift and prompt poisoning.
Security Monitoring Developer Tools
21
https://actionguard.ai/mcp

Related MCP Servers

math-logic-mcp
Code Execution Education & Learning Tools
ismailkerimov
A
license
A
quality
D
maintenance
MCP server that gives small LLMs verified symbolic-math & logic tools.
Updated 9 months ago (2026-02-20 12:40 UTC)
6
17 PyPI
2
Apache 2.0
mcp-abacus
Developer Tools
laszlopere
A
license
A
quality
A
maintenance
Pure-Python MCP server for type-faithful calculation — evaluate expressions under fixed-point, IEEE-754 double, or exact rational arithmetic, with every answer labelled with its precision (exact vs inexact).
Updated 23 days ago (2026-10-13 12:18 UTC)
6
1
GPL 3.0
loadbench-mcp
Developer Tools
jeongho54
A
license
A
quality
D
maintenance
An MCP server that provides structural load and stability math (tipping, support reactions, beam checks) that language models often get wrong, enabling AI assistants to compute accurate engineering estimates.
Updated 4 months ago (2026-06-29 11:10 UTC)
3
MIT
calc-mcp-server
Developer Tools
slettmayer
A
license
A
quality
A
maintenance
An MCP server that performs exact arithmetic calculations, avoiding the pitfalls of float64 and unsafe eval, with resource limits for safe execution.
Updated 3 days ago (2026-11-02 10:16 UTC)
1
42 PyPI
MIT

Ultimath MCP

Lo que respalda cada motor

El motor exacto

Herramientas

Configuración

Requisitos

Enlaces

Bajo el capó

Privacidad

Licencia

Available Tools

Output Schema

TDQS

TDQS

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

math-logic-mcp

mcp-abacus

loadbench-mcp

calc-mcp-server