SageMath MCP Server
SageMath MCP Server gives an LLM a sandboxed, stateful SageMath environment through MCP tools for mathematical computation, verification, plotting, and workspace management.
Execute SageMath code, including streaming output, in persistent sessions with variables and assumptions surviving across calls.
Solve equations/systems, ODEs, symbolic sums/products, simplify/expand/factor expressions, and find numeric roots.
Perform calculus: differentiation, definite/indefinite integration, limits, series expansion, and vector calculus.
Do linear algebra: matrix multiplication and operations such as determinant, inverse, eigenvalues, rank, RREF, and transpose.
Use number theory, combinatorics, boolean algebra, polynomial rings/Groebner bases, graph theory, group theory, elliptic curves, coding theory, geometry, statistics, and probability distributions.
Generate 2D, 3D, and multi-expression plots as PNG or SVG images.
Verify mathematical claims with verdicts of proved, refuted, supported, or undecided, plus evidence.
Manage named workspaces: start, list, stop, reset, interrupt, or cancel sessions; use portable workspace tokens across reconnects.
Check SageMath health, look up documentation links, and use MCP resources plus HTTP /health and /ready endpoints.
Rely on deny-by-default execution: imports, external CAS interfaces, and file/display/persistence primitives are blocked by default; container isolation is the security boundary.
Provides access to SageMath for symbolic calculus, algebra, linear algebra, differential equations, number theory, statistics, visualization, and other mathematical operations via 33 MCP tools.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@SageMath MCP Server solve x^2 - 5x + 6 = 0"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
SageMath MCP Server
A Model Context Protocol server that gives an
LLM a sandboxed mathematical subset of SageMath —
symbolic calculus, number theory, linear algebra, ODEs, plotting, combinatorics,
graphs, groups, elliptic curves, and more. Each MCP session gets a dedicated Sage
worker process, so variables, functions, and assumptions persist across tool
calls. It ships 40 MCP tools, one of which — verify_claim — re-checks a
stated result through a proof ladder and answers proved / refuted /
supported / undecided with its evidence.
Caller code is deny-by-default: the full breadth of Sage mathematics is reachable, but imports, the external CAS interfaces, and the file / display / persistence primitives are not. The policy accepts 98.9% of SageMath's own 438,124 documented doctest examples (4,259 in-scope refusals, every one attributed to a named rule; 98.9% of 433,687 on the passagemath runtime) while refusing the rest — measured on every CI run (see Security).
Full manual: USAGE.md — the tools and their parameters, how code is interpreted, and the security model in depth.
Install & run
Recommended — pip, with the passagemath Sage runtime:
pip install "sagemath-mcp[passagemath]" # on Python 3.12; ~1 GB, no Docker, no Sage build
sagemath-mcp # stdio (default)
sagemath-mcp --transport streamable-http --port 8314 # HTTP on 127.0.0.1or, with uv and nothing installed permanently,
uvx --python 3.12 --from "sagemath-mcp[passagemath]" sagemath-mcp. This is the
route every client install below takes.
Use Python 3.12 for this extra; the uvx line asks for it, and uv downloads it
when the machine has none. 3.12 is the version CI tests it on, and the newest
for which every dependency ships a wheel: on 3.13 and later memory-allocator
is compiled from source, which needs a C compiler. Without --python, uv picks
its own newest Python (3.15 at the time of writing), and the install fails there.
passagemath is a pip-installable, modularized SageMath. from sage.all import *
and the worker run unmodified; the server detects the runtime at import and
loads the matching security artifacts, so the deny-by-default policy is
equivalent on both. It is pinned exactly (passagemath-standard==10.8.13) and
exercised by its own CI lane — the whole suite plus the doctest-corpus sweep
against the pin — so a pin bump is verified end to end before it ships, and the
last two releases passed that gate on first try
(docs/passagemath_evaluation.md).
macOS and Linux; native Windows support is partial, so on Windows use the
container or WSL.
A pip install runs with your own privileges. The security policy refuses code that reaches outside mathematics, but it is not an operating-system boundary (SECURITY.md). That suits your own client on your own machine. For untrusted input, a shared host or multi-tenant use, run the container.
For isolation — the container image (SageMath is baked in):
docker run --rm \
--read-only --tmpfs /tmp:rw,size=512m --tmpfs /home/sage/.sage:rw,size=256m \
--cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 4g \
-p 127.0.0.1:8314:8314 \
ghcr.io/xbp-europe/sagemath-mcp:latestThose flags are the hardening the server expects; the port is published on
loopback deliberately — the server executes code and authenticates nobody.
docker compose up --build applies the same hardening from one reviewed file.
Released images are signed with Cosign and carry SLSA provenance and an SPDX
SBOM as registry attestations; the PyPI files carry PEP 740 attestations.
DISTRIBUTION.md
shows how to verify each.
On arm64 (Apple silicon, Graviton): the passagemath image. The monolithic
image above is published for linux/amd64 only, so on arm64 it runs under
emulation. The same server on the passagemath runtime ships as a native
linux/amd64 + linux/arm64 image, with the same hardening flags, UID and
security policy:
docker run --rm \
--read-only --tmpfs /tmp:rw,size=512m --tmpfs /home/sage/.sage:rw,size=256m \
--cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 4g \
-p 127.0.0.1:8314:8314 \
ghcr.io/xbp-europe/sagemath-mcp:latest-passagemathEvery release tag has a -passagemath twin (vX.Y.Z-passagemath), each
architecture is smoke-tested natively before it is published, and the index is
signed and attested like the primary image. It is the optional image on amd64,
where the monolithic one stays primary.
One click in a desktop MCP host (Claude Desktop and friends): download
sagemath-mcp-<version>.mcpb from the
latest release and
open it. The bundle is about 27 KB; your host installs the server and
a Sage runtime with uv on first launch, which is roughly a 1 GB download once.
macOS and Linux — native Windows is excluded because passagemath's Windows
support is partial. A bundle is a local install with your own privileges; for
untrusted or multi-tenant use run the container instead.
With a Sage you already have (PyPI):
pip install sagemath-mcp
sagemath-mcp # stdio (default)
sagemath-mcp --transport streamable-http --port 8314 # HTTP on 127.0.0.1This needs a working SageMath on the host: sage on your PATH, or in the same
environment as the server. A Sage inside a container is out of reach of a server
on the host; without a Sage of your own, use the [passagemath] extra above.
From conda-forge (Linux and macOS, next to conda-forge's Sage):
conda install -c conda-forge "sagemath-mcp>=0.10.1" sage
sagemath-mcpThe version floor matters: earlier releases cannot start a worker on
conda-forge's sage unless its environment is activated, which an MCP client
does not do, and without the floor the solver may pick one. That sage is
10.10, the release the security artifacts are generated from.
Source install, Docker Compose, and the Kubernetes Helm chart are in USAGE.md.
Related MCP server: math-logic-mcp
Connect an MCP client
One command or one click each. Every route below installs a Sage runtime alongside the server, so there is nothing else to set up.
Claude Desktop — download sagemath-mcp-<version>.mcpb from the
latest release and
open it. One click, no config file.
Claude Code — as a plugin from this repository's marketplace, inside a session:
/plugin install sagemath-mcp --marketplace XBP-Europe/sagemath-mcpor as a plain MCP server:
claude mcp add sagemath -- uvx --python 3.12 --from "sagemath-mcp[passagemath]" sagemath-mcpGemini CLI — the repository is itself an extension:
gemini extensions install https://github.com/XBP-Europe/sagemath-mcpCodex CLI
codex mcp add sagemath -- uvx --python 3.12 --from "sagemath-mcp[passagemath]" sagemath-mcpThen ask for some mathematics — the examples below are a good start.
Three things worth knowing. These need uv on your
PATH, and the first launch downloads about 1 GB of Sage wheels, cached
afterwards. Already have sage? Drop [passagemath] from the specification and
it will use yours. Installed from conda-forge? Register the environment's own
executable, for example claude mcp add sagemath -- ~/miniforge3/envs/sage/bin/sagemath-mcp;
it finds the sage beside it without the environment being activated. And an install of any of these runs with your own privileges;
for untrusted or shared use, run the container and point the client at it.
Pinning a release, HTTP transport and the full client reference are in USAGE.md.
Try it
Prompts a client can run once the server is connected:
Damped harmonic oscillator — "Solve
x'' + 2·x' + 5·x = 0withx(0)=1,x'(0)=0, then verify the solution satisfies the ODE."General relativity — "On the hyperbolic upper half-plane with metric
(dx² + dy²)/y², compute the Ricci scalar and confirm it is a constant negative curvature."Coupled two-tank system — "Solve the linear ODE system for two mixing tanks, then take the long-term limit of each concentration."
Each builds an object once and explores it across calls — the case for
evaluate_sage and its persistent session.
The 40 tools
The math tools use SageMath as the backend; parameters and examples for the most-used ones are in USAGE.md.
Category | Tools |
Core execution |
|
Verification |
|
Calculus |
|
Algebra |
|
Linear algebra |
|
Differential equations |
|
Number theory |
|
Combinatorics |
|
Graph / group theory |
|
Elliptic curves / coding |
|
Polynomials / boolean / geometry |
|
Statistics / probability |
|
Visualization |
|
Numeric methods / vector calculus |
|
Session control |
|
Named workspaces |
|
Diagnostics |
|
Plus HTTP /health and /ready endpoints and 3 MCP resources (session
snapshots, monitoring metrics, doc links). Prefer interrupt_sage_session over
cancel_sage_session — it stops a computation while keeping the session's
variables.
How it works
┌─────────────────────────────────────────────────────────────┐
│ MCP Client (Claude Desktop, Gemini CLI, Codex CLI, ...) │
└───────────────────────────┬─────────────────────────────────┘
│ MCP protocol (stdio or HTTP)
▼
┌─────────────────────────────────────────────────────────────┐
│ app.py + tools/ --- FastMCP 4.x │
│ ┌─────────────┐ ┌──────────────┐ │
│ │ 40 MCP Tools│ │ 3 Resources │ manager.py routes each │
│ └─────────────┘ └──────────────┘ client to its worker │
└───────────────────────────┬─────────────────────────────────┘
▼ one subprocess per session
┌─────────────────────────────────────────────────────────────┐
│ _sage_worker.py --- allowlist.py + security.py │
│ AST validation, then exec() in a persistent namespace │
│ (vars, functions and classes survive across calls) │
└─────────────────────────────────────────────────────────────┘Request flow: MCP client → a tool in tools/ →
SageSessionManager.get() → SageSession.evaluate() → JSON request to
the _sage_worker.py subprocess → AST validation → exec() in the persistent
namespace → JSON response.
Process isolation — each session runs Sage in its own subprocess; a crash or timeout in one cannot affect another.
Stateful sessions — variables, functions, and assumptions persist across calls, enabling multi-step workflows.
Deny-by-default — a name is refused unless the generated allowlist offers it or the caller's own code bound it. A helper a future SageMath adds is refused until someone reviews it, rather than reachable the day it lands.
Security
The AST validator is defence in depth against accidents and casual misuse — it
is not a boundary against determined adversarial code. The container is the
security boundary. The server has no authentication, so every default is
loopback: --host defaults to 127.0.0.1, the default transport is stdio, and
Compose / Helm keep the endpoint off the network. Put something that
authenticates in front of it before exposing it.
What the policy enforces: an allowlist (caller code may read only a name the
server offers or the caller itself bound); no imports by default; eval /
exec / compile and runtime string evaluation blocked; dunder access blocked;
the external CAS interfaces and every file / network / persistence primitive
removed from the namespace, by provenance rather than by name; and the sage
package tree closed to caller code, so a helper is reached by its own name or
not at all. The container adds
a read-only root, dropped capabilities, no-new-privileges, the default
seccomp profile, and memory ceilings. Compose adds a fork (PID) ceiling;
Kubernetes has no per-pod equivalent in the pod spec, so on the chart that is
the node's podPidsLimit rather than something the chart can set.
Full threat model and the complete blocked / allowed tables: SECURITY.md and USAGE.md § Security model.
Docs & more
USAGE.md — the full manual: every tool, how code is interpreted, deployment, and the security model.
docs/mcp_quickstart.md — a first-session walk-through.
CHANGELOG.md · ROADMAP.md · CONTRIBUTING.md · SECURITY.md · SUPPORT.md — what "supported" means, release cadence, where to ask. PRIVACY.md — what the server keeps (nothing leaves the machine it runs on).
Requirements
Python 3.12+ and a SageMath runtime (the container image bundles SageMath 10.10;
otherwise sage on PATH, or the [passagemath] extra). Built on
FastMCP 4.x.
Contributing
Issues and pull requests welcome — see CONTRIBUTING.md. Run
make lint, make typecheck and make test before pushing
(git config core.hooksPath .githooks wires the pre-push check). Roadmap and open work: ROADMAP.md.
Questions go to GitHub Discussions;
SUPPORT.md says what to expect.
Citing
If this server is part of published work, cite it via CITATION.cff — GitHub renders it as Cite this repository in the sidebar, with APA and BibTeX. Cite SageMath itself as well; it does the mathematics.
License
MIT — see LICENSE. SageMath itself is GPL-2.0-or-later and is used as a separate runtime; no SageMath source is redistributed in this repository.
Available Tools
40 toolsboolean_algebra_operationBoolean Algebra OperationAIdempotent
Boolean polynomials over GF(2): evaluate, list variables, degree, and zero/one tests. Prefer this over evaluate_sage for boolean algebra.
Inputs: operation (required), expression (required), session, num_variables. Returns: object
calculate_expressionCalculate ExpressionBIdempotent
Evaluate a SageMath expression and return numeric/string forms
Inputs: expression (required), session. Returns: object
cancel_sage_sessionCancel Sage SessionADestructiveIdempotent
Cancel any running Sage computation and restart the worker
Inputs: session. Returns: message
check_sage_healthCheck Sage HealthAIdempotent
Probe whether SageMath evaluation works right now: starts (or reuses) the workspace's worker, evaluates 1+1, and reports readiness and latency. Reports failure in the result instead of erroring, so it is always safe to call
Inputs: session. Returns: object
coding_theory_operationCoding Theory OperationAIdempotent
Error-correcting codes: length, dimension, minimum distance, rate and generator matrix for Hamming and generalized Reed-Solomon codes. Prefer this over evaluate_sage for code parameters.
Inputs: code_type (required), operation (required), session. Returns: object
combinatorics_operationCombinatorics OperationAIdempotent
Combinatorics: binomial coefficients, permutations, combinations, integer partitions, factorial, Catalan, Fibonacci and Bell numbers. Prefer this over evaluate_sage for any of these.
Inputs: n (required), operation (required), k, session. Returns: object
differentiate_expressionDifferentiate ExpressionAIdempotent
Differentiate an expression with respect to a variable
Inputs: expression (required), order, session, variable. Returns: object
distribution_operationDistribution OperationBIdempotent
Probability distribution operations: PDF, CDF, quantile, mean, variance, sampling
Inputs: operation (required), parameters (required), distribution (required), n, +2 more. Returns: object
elliptic_curve_operationElliptic Curve OperationAIdempotent
Elliptic curves over Q: rank, torsion order, discriminant, j-invariant, conductor and generators, from Weierstrass coefficients. Prefer this over evaluate_sage for curve invariants.
Inputs: operation (required), coefficients (required), session. Returns: object
evaluate_sageEvaluate SageA
Run SageMath code in a persistent session; variables persist across calls. Caller code is deny-by-default -- ordinary mathematics is allowed, but imports, external CAS interfaces and file/display/persistence calls are refused.
LAST RESORT for a single self-contained calculation: a dedicated tool exists for most of those and should be preferred, because it validates arguments and returns a typed result instead of a repr string. One exception overrides that steer -- the dedicated tools evaluate in a FRESH namespace and cannot see variables you defined here, so any multi-step workflow that builds an object once and then explores it (a graph and its invariants, a number field, a matrix decomposition) belongs in evaluate_sage across as many calls as it takes. For a one-off, reach for one of these first:
calculus: differentiate_expression, integrate_expression, limit_expression, series_expansion, symbolic_sum, solve_ode
algebra: solve_equation, simplify_expression, expand_expression, factor_expression, find_root
linear algebra: matrix_operation (determinant, inverse, eigenvalues, rank, rref, transpose), matrix_multiply
discrete: number_theory_operation, combinatorics_operation (binomial, partitions, catalan, fibonacci, bell), graph_operation, group_operation
specialised: elliptic_curve_operation, coding_theory_operation, polynomial_ring_operation, boolean_algebra_operation, geometry_operation, vector_calculus_operation
data: statistics_summary, distribution_operation
plots: plot_expression, plot3d_expression, plot_multi_expression
Use evaluate_sage only for what those do not cover, for example:
Transforms: var('t s'); laplace(sin(t), t, s); inverse_laplace(1/(s^2+1), s, t) Modular arithmetic: Mod(17, 5); power_mod(3, 100, 97) Recurrences: var('n'); f = function('f'); desolve_rec(f(n+2)-f(n+1)-f(n), f, [0, 1]) Continued fractions: continued_fraction(pi).convergents()[:10] Number fields: K. = NumberField(x^3 - 2); K.class_number() Any multi-step work that builds on values defined earlier in the same session, since the dedicated tools cannot see them.
Inputs: code (required), session, timeout, want_latex, +1 more. Returns: latex, result, stdout, elapsed_ms, +1 more
evaluate_sage_streamingEvaluate Sage StreamingA
Execute SageMath code and stream intermediate print() output line by line. Final result is returned as usual.
Inputs: code (required), session, timeout_seconds. Returns: latex, result, stdout, elapsed_ms, +1 more
expand_expressionExpand ExpressionCIdempotent
Expand a mathematical expression
Inputs: expression (required), session. Returns: object
factor_expressionFactor ExpressionCIdempotent
Factor a mathematical expression or integer
Inputs: expression (required), session. Returns: object
find_rootFind RootAIdempotent
Find a numeric root of an expression or equation in a given interval
Inputs: expression (required), session, variable, lower_bound, +1 more. Returns: object
geometry_operationGeometry OperationAIdempotent
Computational geometry on point sets: euclidean distance, polygon area, polytope volume, convex hull vertices and convexity tests. Prefer this over evaluate_sage for these.
Inputs: points (required), operation (required), session. Returns: object
graph_operationGraph OperationBIdempotent
Graph theory: create named graphs and compute properties (chromatic_number, is_connected, diameter, etc.)
Inputs: graph (required), operation (required), source, target, +1 more. Returns: object
group_operationGroup OperationAIdempotent
Group theory: construct groups and query properties (order, is_abelian, center, etc.)
Inputs: group (required), operation (required), session. Returns: object
integrate_expressionIntegrate ExpressionAIdempotent
Integrate an expression (indefinite or definite with bounds)
Inputs: expression (required), session, variable, lower_bound, +1 more. Returns: object
interrupt_sage_sessionInterrupt Sage SessionAIdempotent
Interrupt a running Sage computation while keeping variables defined so far
Inputs: session. Returns: message
limit_expressionLimit ExpressionCIdempotent
Compute the limit of an expression
Inputs: expression (required), point, session, variable, +1 more. Returns: object
list_sage_sessionsList Sage SessionsARead-onlyIdempotent
List the named Sage workspaces belonging to this client
Inputs: no named parameters. Returns: object
lookup_sage_docLookup Sage DocARead-onlyIdempotent
Documentation links for a SageMath name, plus whether this server offers that name to evaluate_sage caller code
Inputs: symbol (required). Returns: object
matrix_multiplyMatrix MultiplyBIdempotent
Multiply two matrices and return the result as nested lists
Inputs: matrix_a (required), matrix_b (required), session. Returns: object
matrix_operationMatrix OperationAIdempotent
Linear algebra on one matrix: determinant, inverse, eigenvalues, rank, reduced row echelon form, transpose. Prefer this over evaluate_sage.
Inputs: matrix (required), operation (required), session. Returns: object
number_theory_operationNumber Theory OperationAIdempotent
Number theory: primality testing, integer factorisation, the next prime above n, gcd and lcm. Prefer this over evaluate_sage for any of these.
Inputs: a (required), operation (required), b, session. Returns: object
plot3d_expressionPlot3D ExpressionBIdempotent
Plot a 3D surface of a two-variable expression as a rendered image
Inputs: expression (required), session, x_variable, y_variable, +5 more.
plot_expressionPlot ExpressionAIdempotent
Plot an expression and return it as a rendered image (PNG or SVG)
Inputs: expression (required), session, variable, range_max, +2 more.
plot_multi_expressionPlot Multi ExpressionAIdempotent
Plot multiple expressions overlaid on a single 2D graph, as a rendered image
Inputs: expressions (required), session, variable, range_max, +2 more.
polynomial_ring_operationPolynomial Ring OperationCIdempotent
Polynomial ring operations: construct rings and compute Groebner bases, ideals, quotients
Inputs: operation (required), ring_vars (required), polynomials (required), session, +1 more. Returns: object
reset_sage_sessionReset Sage SessionBDestructiveIdempotent
Reset the SageMath session state for the current MCP session
Inputs: session. Returns: message
series_expansionSeries ExpansionAIdempotent
Compute a Taylor/Laurent series expansion
Inputs: expression (required), order, point, session, +1 more. Returns: object
simplify_expressionSimplify ExpressionCIdempotent
Simplify a mathematical expression
Inputs: expression (required), session. Returns: object
solve_equationSolve EquationBIdempotent
Solve an equation or system of equations
Inputs: equation (required), session, variable. Returns: object
solve_odeSolve OdeAIdempotent
Solve an ordinary differential equation of any order, returning the general solution with arbitrary constants. Prefer this over evaluate_sage.
Inputs: equation (required), session, function, variable. Returns: object
start_sage_sessionStart Sage SessionAIdempotent
Start a named Sage workspace with its own independent variables
Inputs: name (required). Returns: A started workspace plus the portable handle that addresses it. The handle is a…
statistics_summaryStatistics SummaryAIdempotent
Descriptive statistics for a list of numbers: mean, median, population and sample variance and standard deviation, min and max. Prefer this over evaluate_sage for summary statistics.
Inputs: data (required), session. Returns: object
stop_sage_sessionStop Sage SessionBDestructiveIdempotent
Stop a named Sage workspace and release its worker
Inputs: name (required). Returns: message
symbolic_sumSymbolic SumAIdempotent
Closed form of a symbolic sum or product over an index variable, including infinite series. Prefer this over evaluate_sage for summations.
Inputs: expression (required), lower, upper, product, +2 more. Returns: object
vector_calculus_operationVector Calculus OperationCIdempotent
Vector calculus operations: gradient, divergence, curl, laplacian
Inputs: operation (required), expression (required), session, variables. Returns: object
verify_claimVerify ClaimAIdempotent
Independently re-check a stated mathematical claim and report how far the evidence goes: proved, refuted, supported or undecided.
Use this to verify your own algebra before presenting it. The claim is a single comparison in Sage syntax -- an equality, an inequality, or anything that evaluates to True/False:
integral(x^2/(e^x-1), x, 0, oo) == 2*zeta(3) sin(x)^2 + cos(x)^2 == 1 pi < 22/7 e^pi != pi^e
The check climbs a ladder: Sage's symbolic prover, the exact difference ((lhs-rhs).simplify_full().is_zero()), exact arithmetic over QQbar/AA when the claim is constant, then certified interval arithmetic and numeric sampling over the free variables. Verdicts are honest by construction: 'proved' and 'refuted' are exact decisions ('refuted' always exhibits its counterexample or certified enclosure); 'supported' means the numeric evidence is consistent with the claim without proving it, and says how many samples at what precision; 'undecided' means every rung was inconclusive -- it never means false.
Exactness is never assumed. Decimal literals are read exactly (0.1 means 1/10, never the 53-bit double), and a comparison whose operands are machine floats (RR/RDF/CC, an .n() result) is reported as 'supported' over inexact numbers, never as an exact proof -- state it over ZZ/QQ/QQbar or symbolically for an exact verdict. The session's active assumptions (assume(x > 0), assume(x, 'integer')) are honored: a sampled counterexample must lie inside the stated domain, and any verdict that relied on an assumption names it in the evidence.
Inputs: claim (required), samples, session, timeout, +1 more. Returns: Outcome of independently re-checking a stated mathematical claim. The honesty r…
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 40 tools
Most tools have distinct domain prefixes (calculus, linear algebra, number theory), but several boundaries blur: evaluate_sage vs evaluate_sage_streaming vs calculate_expression all execute/evaluate Sage code, and factor_expression overlaps with number_theory_operation's integer factorization. The 'operation' suffix on eleven tools makes their exact scope harder to distinguish at a glance.
The majority follow verb_noun (solve_equation, integrate_expression, start_sage_session), but there are notable deviations: the eleven 'X_operation' tools are noun_noun, matrix_multiply is noun_verb, and series_expansion/symbolic_sum are noun phrases. All names are snake_case and readable, so the inconsistency is moderate rather than chaotic.
Forty tools is well above the 25+ threshold and will burden an agent's tool-selection step, even though SageMath's breadth justifies many of them. Several 'operation' tools could be consolidated (e.g., one linear_algebra tool) without losing clarity.
The surface covers calculus, algebra, linear algebra, number theory, combinatorics, graph/group theory, elliptic curves, coding theory, geometry, statistics, distributions, plotting, and session management. Missing dedicated tools like Laplace transforms or matrix addition are reachable through evaluate_sage, so there are no dead ends; only minor gaps remain.
Maintenance
Related MCP Connectors
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Stateless agentic tools over MCP: concept extraction, long-context, knowledge graph, planning.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceA tool server that processes mathematical expressions via Multi-Chain Protocol (MCP), allowing LLMs to solve math problems through tool integration.MIT
- AlicenseAqualityDmaintenanceMCP server that gives small LLMs verified symbolic-math & logic tools.62Apache 2.0
- AlicenseAqualityDmaintenanceA Model Context Protocol server that exposes 8 mathematical tools (arithmetic, algebra, calculus, matrix operations, statistics, probability, unit conversions) to any MCP-compatible AI agent, enabling mathematical computations without code.815 npm1MIT
- AlicenseNot gradedqualityCmaintenanceExposes the full SageMath computer algebra system to LLM clients through MCP tools for symbolic mathematics, solving, calculus, plotting, and number theory.73 npm1Creative Commons Zero v1.0 Universal