Skip to main content
Glama

English · 简体中文

Jacobian is an MCP server that gives AI agents a searchable vocabulary of typed mathematical operations. math.find matches a mathematical need or inspects one exact contract, and math.run executes it and returns its typed result. The same mathematical library is also available through a CLI and native Python API.

Each operation establishes one stable, reusable mathematical postcondition rather than prescribing a workflow or proof strategy. Results are exact where claimed and make approximation, incompleteness, or uncertainty explicit.

Jacobian's hypothesis is that mathematical reasoning benefits from an executable vocabulary of semantically scoped, bounded operations. Rather than exposing large domain solvers or precomposed workflows, Jacobian exposes mathematical primitives that agents can search for and compose into solutions beyond what any individual operation was designed to solve. The library supplies trustworthy mathematical moves; the reasoning model decides which moves to make, how to combine their results, and when to stop. Keeping the operations semantically narrow and domain-owned preserves that search space instead of baking one proof strategy or workflow into the tools themselves.

See Executable mathematical vocabulary for what semantic atomicity means and how the operation vocabulary grows.

Quickstart

Set up Jacobian for your agents with a single command. The setup command requires Node.js 20.17+, 22.13+, or 23.5+ and uvx on your PATH.

npx jacobian@latest setup

Choose detected agents and review the changes before they are written. Setup does not install Node.js, Python, uv, or an agent. For automation, preview an explicit plan with npx jacobian@latest setup --codex --dry-run; use --yes only with explicit agent flags or --all.

To refresh an existing registration explicitly, run npx jacobian@latest upgrade and select the agents to update. The generated launcher pins the exact release resolved by npm.

Run the canonical Python MCP command without installing Jacobian globally:

uvx --python 3.12 --from jacobian jacobian-mcp

Where an MCP host requires an npm command, the npm package is a deterministic carrier for that same command:

npx jacobian mcp

For a persistent installation:

python -m pip install jacobian
jacobian-mcp

That package includes Jacobian's exact maintained Python backend stack: SymPy, NetworkX, Z3, and Python-FLINT. A normal Python or npm installation therefore exposes the same built-in Python-backed operation portfolio. The tested binary-install contract is CPython 3.12 or 3.13 on glibc Linux x86-64; the release gate installs the built wheel and starts Jacobian on both Python versions. Other systems may have compatible upstream wheels, but are not part of the tested release contract yet. In particular, Alpine/musl cannot install the complete mandatory stack from PyPI.

Singular and QEPCAD are optional system runtimes for a small subset of operations. The Python installation does not provision them, and ordinary operations do not require Docker. Python callers can use jacobian.backends.check_backend; MCP inspection reports availability in the server environment. See backend requirements for exact coverage and setup.

The Python distribution contains the mathematical kernel, CLI, and MCP server. The npm package deterministically maps its exact package version to the corresponding uvx invocation.

Related MCP server: math-logic-mcp

Compute one bounded result

An ordinary operation returns mathematics first. For example, matrix.determinant.compute accepts one exact rational matrix and returns its determinant directly. Callers compose results by passing their typed values to a subsequent operation.

For a local terminal workflow, inspect the exact installed contract and run one of its examples with the CLI:

jacobian inspect integer.compute.extended_gcd
jacobian run integer.compute.extended_gcd --json '{"left":"84","right":"30"}'

The second command returns the gcd and Bézout coefficients as JSON. In an MCP host, use math.find in inspection mode to read the same contract and math.run with the same payload shape. See Discover and invoke operations for that agent workflow.

Available mathematics

The built-in portfolio covers work in:

  • polynomial maps and polynomial algebra;

  • exact linear algebra;

  • graphs, paths, colorings, and isomorphism;

  • bounded SAT and SMT solving;

  • finite algebra, probability, geometry, and topology.

SAT and SMT operations use the maintained Z3 Python binding directly. Use math.find to match the mathematical result needed, then use its inspection mode on a promising operation before calling math.run once.

See the domain operation library for the maintained operation portfolio and backend requirements.

Status

Jacobian 0.23.0 is pre-stable. Its published package and operation contracts describe the supported surface; experimental operation contracts may change between releases.

Documentation

Contributing

Jacobian uses Python 3.12, uv, and a small Makefile:

make setup
make affected AFFECTED_BASE=origin/main

Read CONTRIBUTING.md before changing code. It documents focused test commands, verification rules, documentation placement, and pull-request expectations.

License

MIT

Available Tools

2 tools
math.findSearch installed Jacobian math toolsA
Read-onlyIdempotent

Find or inspect public Jacobian MCP operations.

Forms:

  • query: describe one local mathematical need in ordinary language. namespace, limit, cursor, and search_mode are optional search controls. Preserve established mathematical names from the task, the supplied objects and constraints, the requested computation or decision, the full scalar, batch, or exhaustive scope, and whether the requested result is a value, witness, certificate, obstruction, profile, or complete enumeration. Do not replace a supplied named property only with its expanded definition, translate the need into catalog tags, or submit the surrounding proof goal.

  • operation_id: pass one exact operation ID to receive its authoritative input and output schemas, operator-authored examples, and current optional backend availability. Matches expose static runtime_requirements; inspection checks these runtimes in the server environment.

For matching, use namespace only when the primary operation-ID namespace is already known with high confidence. Matching returns 10 candidates by default; request up to 20 when a wider first page is useful. Follow next_cursor with the same query, namespace, and search_mode to continue; the limit may change. Ordered matches are deterministic retrieval candidates, not applicability claims; inspect a promising operation before math.run. Read operation://catalog only when the complete bulk catalog is genuinely needed.

An unknown operation ID returns kind: "error" with error.code: "UNKNOWN_OPERATION"; inspect kind even when MCP isError is false. Search with query to find an installed operation, then inspect its exact ID. Zero matches is a successful search.

Examples:

  • {"query":"exact determinant of a rational matrix","namespace":"matrix","limit":3}

  • {"operation_id":"polynomial.compute.gcd"}

Inputs: limit, query, cursor, namespace, +2 more. Returns: Closed discriminated output returned directly through MCP SDK 2.0.

math.runRun one installed Jacobian math toolA
Read-only

Run one installed math tool by ID with its typed payload. A successful call returns the operation-owned canonical mathematical value in output; a later inspected operation may accept that complete value unchanged. Read its fields to determine what the calculation established. MCP reports malformed payloads, unknown IDs, and host failures as tool errors, not as mathematical results. If the payload shape is unknown, inspect the exact operation with math.find. When it publishes an examples item, copy and adapt that item's input object as the payload; otherwise, form the payload from the input schema and its field descriptions. Do not call math.run with an empty payload merely to discover required fields; inspection is authoritative.

Timeout, incomplete search, and missing witnesses appear only in the concrete domain result that owns them; none is a mathematical conclusion by itself.

Examples:

  • {"operation_id":"integer.compute.extended_gcd","payload":{"left":"84","right":"30"}}

Inputs: payload (required), operation_id (required). Returns: The final transport envelope around one direct mathematical result.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.8/5.0

    Scored across 2 tools

    Disambiguation5/5

    math.find is clearly for discovery and inspection of operations, while math.run is clearly for executing a chosen operation. Their purposes do not overlap and the descriptions consistently direct users to inspect before running.

    Naming Consistency5/5

    Both tools follow the same math.<verb> pattern with lowercase snake_case verbs. The naming is predictable and consistent across the set.

    Tool Count4/5

    Two tools are sufficient for a dispatcher-style math catalog: one to find/inspect operations and one to run them. It is slightly below the typical 3-15 range, but the minimal surface is justified by the server's purpose.

    Completeness4/5

    The set covers the core lifecycle: search, inspect schemas/examples, and execute an operation by ID. Minor gaps exist for batch execution, composition, or direct catalog listing, but these are workable through repeated calls.

    Maintenance

    ActivityActive
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers