Skip to main content
Glama

SageMath MCP Server

CI CodeQL Dependency audit Fuzz Release PyPI conda-forge GHCR License Python MCP FastMCP SageMath Ruff Typed Coverage Sage doctests Downloads MCP Registry Glama Signed Provenance PyPI attestations OpenSSF Scorecard DOI Dependabot Last commit

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.1

or, 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:latest

Those 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-passagemath

Every 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.1

This 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-mcp

The 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.

Install in VS Code Install in Cursor

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-mcp

or as a plain MCP server:

claude mcp add sagemath -- uvx --python 3.12 --from "sagemath-mcp[passagemath]" sagemath-mcp

Gemini CLI — the repository is itself an extension:

gemini extensions install https://github.com/XBP-Europe/sagemath-mcp

Codex CLI

codex mcp add sagemath -- uvx --python 3.12 --from "sagemath-mcp[passagemath]" sagemath-mcp

Then 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 = 0 with x(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

evaluate_sage, evaluate_sage_streaming

Verification

verify_claim

Calculus

differentiate_expression, integrate_expression, limit_expression, series_expansion

Algebra

solve_equation, simplify_expression, expand_expression, factor_expression, calculate_expression, symbolic_sum

Linear algebra

matrix_multiply, matrix_operation

Differential equations

solve_ode

Number theory

number_theory_operation

Combinatorics

combinatorics_operation

Graph / group theory

graph_operation, group_operation

Elliptic curves / coding

elliptic_curve_operation, coding_theory_operation

Polynomials / boolean / geometry

polynomial_ring_operation, boolean_algebra_operation, geometry_operation

Statistics / probability

statistics_summary, distribution_operation

Visualization

plot_expression, plot3d_expression, plot_multi_expression

Numeric methods / vector calculus

find_root, vector_calculus_operation

Session control

reset_sage_session, interrupt_sage_session, cancel_sage_session

Named workspaces

start_sage_session, list_sage_sessions, stop_sage_session

Diagnostics

check_sage_health, lookup_sage_doc

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

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 tools
boolean_algebra_operationBoolean Algebra OperationA
Idempotent

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 ExpressionB
Idempotent

Evaluate a SageMath expression and return numeric/string forms

Inputs: expression (required), session. Returns: object

cancel_sage_sessionCancel Sage SessionA
DestructiveIdempotent

Cancel any running Sage computation and restart the worker

Inputs: session. Returns: message

check_sage_healthCheck Sage HealthA
Idempotent

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 OperationA
Idempotent

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 OperationA
Idempotent

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 ExpressionA
Idempotent

Differentiate an expression with respect to a variable

Inputs: expression (required), order, session, variable. Returns: object

distribution_operationDistribution OperationB
Idempotent

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 OperationA
Idempotent

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 ExpressionC
Idempotent

Expand a mathematical expression

Inputs: expression (required), session. Returns: object

factor_expressionFactor ExpressionC
Idempotent

Factor a mathematical expression or integer

Inputs: expression (required), session. Returns: object

find_rootFind RootA
Idempotent

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 OperationA
Idempotent

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 OperationB
Idempotent

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 OperationA
Idempotent

Group theory: construct groups and query properties (order, is_abelian, center, etc.)

Inputs: group (required), operation (required), session. Returns: object

integrate_expressionIntegrate ExpressionA
Idempotent

Integrate an expression (indefinite or definite with bounds)

Inputs: expression (required), session, variable, lower_bound, +1 more. Returns: object

interrupt_sage_sessionInterrupt Sage SessionA
Idempotent

Interrupt a running Sage computation while keeping variables defined so far

Inputs: session. Returns: message

limit_expressionLimit ExpressionC
Idempotent

Compute the limit of an expression

Inputs: expression (required), point, session, variable, +1 more. Returns: object

list_sage_sessionsList Sage SessionsA
Read-onlyIdempotent

List the named Sage workspaces belonging to this client

Inputs: no named parameters. Returns: object

lookup_sage_docLookup Sage DocA
Read-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 MultiplyB
Idempotent

Multiply two matrices and return the result as nested lists

Inputs: matrix_a (required), matrix_b (required), session. Returns: object

matrix_operationMatrix OperationA
Idempotent

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 OperationA
Idempotent

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 ExpressionB
Idempotent

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 ExpressionA
Idempotent

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 ExpressionA
Idempotent

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 OperationC
Idempotent

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 SessionB
DestructiveIdempotent

Reset the SageMath session state for the current MCP session

Inputs: session. Returns: message

series_expansionSeries ExpansionA
Idempotent

Compute a Taylor/Laurent series expansion

Inputs: expression (required), order, point, session, +1 more. Returns: object

simplify_expressionSimplify ExpressionC
Idempotent

Simplify a mathematical expression

Inputs: expression (required), session. Returns: object

solve_equationSolve EquationB
Idempotent

Solve an equation or system of equations

Inputs: equation (required), session, variable. Returns: object

solve_odeSolve OdeA
Idempotent

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 SessionA
Idempotent

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 SummaryA
Idempotent

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 SessionB
DestructiveIdempotent

Stop a named Sage workspace and release its worker

Inputs: name (required). Returns: message

symbolic_sumSymbolic SumA
Idempotent

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 OperationC
Idempotent

Vector calculus operations: gradient, divergence, curl, laplacian

Inputs: operation (required), expression (required), session, variables. Returns: object

verify_claimVerify ClaimA
Idempotent

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

    B3.2/5.0

    Scored across 40 tools

    Disambiguation3/5

    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.

    Naming Consistency3/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers