Skip to content
Back to search

jacobian

Composable mathematics tools for agents

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/morluto/jacobian with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/morluto/jacobian'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/morluto--jacobian/badge.svg)](/listings/morluto--jacobian)

HTML

<a href="/listings/morluto--jacobian"><img src="/api/listings/morluto--jacobian/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

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](docs/how-to/backend-requirements.md) 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.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 171 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. **English** · [简体中文](README.zh-CN.md)
  2. <h1 align="center">Jacobian</h1>
  3. <p align="center">
  4. <strong>An executable mathematical vocabulary for agents: discover one typed operation, run it, and compose its result.</strong>
  5. </p>
  6. <p align="center">
  7. <a href="https://github.com/morluto/jacobian/actions/workflows/ci.yml"><img src="https://github.com/morluto/jacobian/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
  8. <a href="https://pypi.org/project/jacobian/"><img src="https://img.shields.io/pypi/v/jacobian" alt="PyPI"></a>
  9. <a href="https://www.npmjs.com/package/jacobian"><img src="https://img.shields.io/npm/v/jacobian" alt="npm"></a>
  10. <a href="https://pypi.org/project/jacobian/"><img src="https://img.shields.io/pypi/pyversions/jacobian" alt="Supported Python versions"></a>
  11. <a href="LICENSE"><img src="https://img.shields.io/github/license/morluto/jacobian" alt="MIT license"></a>
  12. </p>
  13. Jacobian is an MCP server that gives AI agents a searchable vocabulary of typed
  14. mathematical operations. `math.find` matches a mathematical need or inspects one
  15. exact contract, and `math.run` executes it and returns its typed result. The same
  16. mathematical library is also available through a CLI and native Python API.
  17. Each operation establishes one stable, reusable mathematical postcondition
  18. rather than prescribing a workflow or proof strategy. Results are exact where
  19. claimed and make approximation, incompleteness, or uncertainty explicit.
  20. **Jacobian's hypothesis is that mathematical reasoning benefits from an
  21. executable vocabulary of semantically scoped, bounded operations.** Rather than
  22. exposing large domain solvers or precomposed workflows, Jacobian exposes
  23. mathematical primitives that agents can search for and compose into solutions
  24. beyond what any individual operation was designed to solve. The library
  25. supplies trustworthy mathematical moves; the reasoning model decides which
  26. moves to make, how to combine their results, and when to stop. Keeping the
  27. operations semantically narrow and domain-owned preserves that search space
  28. instead of baking one proof strategy or workflow into the tools themselves.
  29. See [Executable mathematical vocabulary](docs/explanation/executable-mathematical-vocabulary.md)
  30. for what semantic atomicity means and how the operation vocabulary grows.
  31. ## Quickstart
  32. Set up Jacobian for your agents with a single command. The setup command
  33. requires Node.js 20.17+, 22.13+, or 23.5+ and `uvx` on your `PATH`.
  34. ```sh
  35. npx jacobian@latest setup
  36. ```
  37. Choose detected agents and review the changes before they are written. Setup
  38. does not install Node.js, Python, `uv`, or an agent. For automation, preview
  39. an explicit plan with `npx jacobian@latest setup --codex --dry-run`; use
  40. `--yes` only with explicit agent flags or `--all`.
  41. To refresh an existing registration explicitly, run
  42. `npx jacobian@latest upgrade` and select the agents to update. The generated
  43. launcher pins the exact release resolved by npm.
  44. Run the canonical Python MCP command without installing Jacobian globally:
  45. ```sh
  46. uvx --python 3.12 --from jacobian jacobian-mcp
  47. ```
  48. Where an MCP host requires an npm command, the npm package is a deterministic
  49. carrier for that same command:
  50. ```sh
  51. npx jacobian mcp
  52. ```
  53. For a persistent installation:
  54. ```sh
  55. python -m pip install jacobian
  56. jacobian-mcp
  57. ```
  58. That package includes Jacobian's exact maintained Python backend stack: SymPy,
  59. NetworkX, Z3, and Python-FLINT. A normal Python or npm installation
  60. therefore exposes the same built-in Python-backed operation portfolio. The
  61. tested binary-install contract is CPython 3.12 or 3.13 on glibc Linux x86-64;
  62. the release gate installs the built wheel and starts Jacobian on both Python
  63. versions. Other systems may have compatible upstream wheels, but are not part
  64. of the tested release contract yet. In particular, Alpine/musl cannot install
  65. the complete mandatory stack from PyPI.
  66. Singular and QEPCAD are optional system runtimes for a small subset of operations.
  67. The Python installation does not provision them, and ordinary operations do not
  68. require Docker. Python callers can use `jacobian.backends.check_backend`; MCP
  69. inspection reports availability in the server environment. See
  70. [backend requirements](docs/how-to/backend-requirements.md) for exact coverage
  71. and setup.
  72. The Python distribution contains the mathematical kernel, CLI, and MCP server.
  73. The npm package deterministically maps its exact package version to the
  74. corresponding `uvx` invocation.
  75. ## Compute one bounded result
  76. An ordinary operation returns mathematics first. For example,
  77. `matrix.determinant.compute` accepts one exact rational matrix and returns its
  78. determinant directly. Callers compose results by passing their typed values to a
  79. subsequent operation.
  80. For a local terminal workflow, inspect the exact installed contract and run one
  81. of its examples with the CLI:
  82. ```sh
  83. jacobian inspect integer.compute.extended_gcd
  84. jacobian run integer.compute.extended_gcd --json '{"left":"84","right":"30"}'
  85. ```
  86. The second command returns the gcd and Bézout coefficients as JSON. In an MCP
  87. host, use `math.find` in inspection mode to read the same contract and `math.run`
  88. with the same payload shape. See [Discover and invoke operations](docs/how-to/invoke-domain-operations.md)
  89. for that agent workflow.
  90. ## Available mathematics
  91. The built-in portfolio covers work in:
  92. - polynomial maps and polynomial algebra;
  93. - exact linear algebra;
  94. - graphs, paths, colorings, and isomorphism;
  95. - bounded SAT and SMT solving;
  96. - finite algebra, probability, geometry, and topology.
  97. SAT and SMT operations use the maintained Z3 Python binding directly. Use
  98. `math.find` to match the mathematical result needed, then use its inspection
  99. mode on a promising operation before calling `math.run` once.
  100. See the [domain operation library](docs/reference/domain-operation-library.md)
  101. for the maintained operation portfolio and
  102. [backend requirements](docs/how-to/backend-requirements.md).
  103. ## Status
  104. Jacobian 0.23.0 <!-- x-release-please-version --> is pre-stable. Its published package and operation contracts
  105. describe the supported surface; experimental operation contracts may change
  106. between releases.
  107. ## Documentation
  108. - [Documentation home](docs/index.md): tutorials, how-to guides, reference,
  109. and explanations
  110. - [Architecture](docs/explanation/architecture.md): runtime structure and
  111. trust boundaries
  112. - [Product model](docs/explanation/product-blueprint.md): operation contracts,
  113. ownership, and project boundaries
  114. - [Tool reference](docs/reference/tools.md): MCP resources and invocation
  115. contracts
  116. - [Backend requirements](docs/how-to/backend-requirements.md):
  117. maintained Python backends
  118. - [Remote deployment](docs/how-to/deploy-remote-mcp.md): HTTP deployment and
  119. authentication
  120. ## Contributing
  121. Jacobian uses Python 3.12, `uv`, and a small `Makefile`:
  122. ```sh
  123. make setup
  124. make affected AFFECTED_BASE=origin/main
  125. ```
  126. Read [CONTRIBUTING.md](CONTRIBUTING.md) before changing code. It documents
  127. focused test commands, verification rules, documentation placement, and
  128. pull-request expectations.
  129. ## License
  130. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.