# Qedra (oci · ghcr.io/evgwpw/qedra) Computer algebra with verifiable answers - Trust score: 39/100 (low) - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-11-05 ## Components - mcpb · `qedra-1.109.7.11.mcpb`: 5/100, [markdown](https://verifymcp.io/servers/evgwpw-qedra/qedra.md), [page](https://verifymcp.io/servers/evgwpw-qedra/qedra) - nuget · `Qedra`: 39/100, [markdown](https://verifymcp.io/servers/evgwpw-qedra/qedra-2.md), [page](https://verifymcp.io/servers/evgwpw-qedra/qedra-2) - oci · `ghcr.io/evgwpw/qedra`: 39/100 (this document), [markdown](https://verifymcp.io/servers/evgwpw-qedra/ghcr-io-evgwpw-qedra.md), [page](https://verifymcp.io/servers/evgwpw-qedra/ghcr-io-evgwpw-qedra) ## Channel facts - Registry: `oci` - Package: `ghcr.io/evgwpw/qedra` - Version: `1.109.7.11` - Transport: `stdio` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-11-05. - **Supply Chain Security**: 0/100 - No malware scan is available for this kind of package: the supply-chain vendors we use do not cover it. This is a permanent gap in our coverage, not a finding about the package. - Known CVEs could not be checked: this artifact ships no SBOM or dependency manifest, so there is no dependency list to read. - Install-script risk not yet assessed. - Dependency health could not be checked: this artifact ships no SBOM or dependency manifest, so there is no dependency list to read. - **Provenance & Transparency**: 45/100 - Source repository is publicly reachable at the declared URL. - Provenance check failed: no build-provenance attestation is published. - Clear OSI-approved license (0BSD). - Actively maintained (last published 0 days ago). - Disclosure check failed: no security disclosure policy was found in the source repository. - **Schema Quality & AI Usability**: 71/100 - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name). - AI-judged instruction clarity (good). - Context-footprint check failed: tool/resource definitions use about 11559 tokens (~481/item across 24 items; 23 tools + 1 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 3/100 - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - **Tool Safety**: 75/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - 0 of 1 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation; "undeclare" implies "remove" and declares no destructiveHint at all, which the MCP spec reads as destructive by default. - An AI judge read all 25 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. **Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm. ## Install ### How do I install the Qedra MCP server? Qedra runs locally as a container image, launched with docker run --rm -i ghcr.io/evgwpw/qedra:1.109.7.11. Ready-made configuration for Claude, Cursor, VS Code, Codex and 3 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add evgwpw-qedra -- docker run --rm -i ghcr.io/evgwpw/qedra:1.109.7.11 ``` ### Cursor ```json { "mcpServers": { "evgwpw-qedra": { "command": "docker", "args": [ "run", "--rm", "-i", "ghcr.io/evgwpw/qedra:1.109.7.11" ] } } } ``` ### VS Code ```json { "servers": { "evgwpw-qedra": { "command": "docker", "args": [ "run", "--rm", "-i", "ghcr.io/evgwpw/qedra:1.109.7.11" ] } } } ``` ### Codex ```bash codex mcp add evgwpw-qedra -- docker run --rm -i ghcr.io/evgwpw/qedra:1.109.7.11 ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "evgwpw-qedra": { "type": "local", "command": [ "docker", "run", "--rm", "-i", "ghcr.io/evgwpw/qedra:1.109.7.11" ], "enabled": true } } } ``` ### Hermes ```yaml mcp_servers: evgwpw-qedra: command: "docker" args: ["run", "--rm", "-i", "ghcr.io/evgwpw/qedra:1.109.7.11"] ``` ### Netclaw ```json { "McpServers": { "evgwpw-qedra": { "Transport": "stdio", "Command": "docker", "Arguments": [ "run", "--rm", "-i", "ghcr.io/evgwpw/qedra:1.109.7.11" ] } } } ``` ### Other ```json { "mcpServers": { "evgwpw-qedra": { "command": "docker", "args": [ "run", "--rm", "-i", "ghcr.io/evgwpw/qedra:1.109.7.11" ] } } } ``` ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-11-05 (score 39, +1) No change was recorded against any check on this day. Stability & Change Management went from 0 to 3. That category is still filling its 30-day observation window: 0 days of observed history at the previous scan, 1 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-11-04 (score 38) First indexed and scored. ## MCP tools (23) ### `math` (~437 tokens) Run a program in the CAS math language in the persistent session: statements separated by ';' or newlines, assignments 'a := 2', functions 'f(x) := x^2', domain declarations 'x :∈ ℝ', and all CAS functions (simplify, expand, factor, diff, integrate, solve, limit, series, ...). result/pretty contain one line per statement; print() output goes to 'output'. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `code` (string, required): Program text, e.g. "f(x) := x^3 - x; factor(f(x)); solve(f(x) = 0, x)". - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `evaluate` (~376 tokens) Evaluate Lisp (Scheme-like) code in the persistent session; one or more forms, the value of each is returned (one line per form). On error, 'stack' holds the Lisp backtrace. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `code` (string, required): Lisp code, e.g. "(integrate '(* x (exp x)) 'x)". - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `simplify` (~510 tokens) Simplify an expression to canonical form. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `diff` (~543 tokens) Differentiate an expression; the result is simplified. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `order` (integer): Derivative order (default 1). - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `var` (string, required): Differentiation variable, e.g. "x". ### `integrate` (~606 tokens) Integrate an expression: indefinite, or definite when both 'from' and 'to' are given. If no antiderivative is found, status is "unknown" and result is the unevaluated integral; conditions list parameter assumptions used. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `from` (string): Lower limit for a definite integral (math language; -∞ allowed). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `to` (string): Upper limit for a definite integral (math language; ∞ allowed). - `var` (string, required): Integration variable, e.g. "x". ### `sum` (~666 tokens) Symbolic summation (step 21l.7): Faulhaber for polynomials, Gosper/Abramov for hypergeometric and rational terms, Zeilberger + rsolve for binomial sums (sum(C(n,k),k,0,n) = 2^n). The answer is a closed form, or a recurrence with initial values when no hypergeometric closed form exists (Apéry numbers); the certificate verifies the answer by direct summation. Lower bound 'from' defaults to 0; upper bound 'to' is required (usually n). Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `from` (string): Lower bound (math language; default 0). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `to` (string, required): Upper bound (math language; usually n). - `var` (string, required): Summation variable, e.g. "k". ### `linear-algebra` (~589 tokens) Exact linear algebra on a matrix (step LA.4): Jordan normal form, matrix exponential exp(A·t), symbolic matrix power A^n, a function of a matrix f(A), diagonalization, eigenvalues/eigenvectors. The matrix is given as "[[2,1],[0,2]]" in the math language. fn selects the operation: jordan_form (returns [P, J] with A = P·J·P⁻¹), jordan_blocks, mat_exp (var defaults to the built-in t; verified by d/dt E = A·E and E(0) = I), mat_power (var defaults to n; nilpotent Jordan blocks at λ=0 are written as zeros with the condition n ≥ s in 'conditions'), mat_fn (func, e.g. "exp" or a lambda), diagonalize ([P, D]), is_diagonalizable, eigenvalues, eigenvectors. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `expr` (string, required): Matrix in the math language, e.g. "[[2,1],[0,2]]". - `fn` (string, required): Operation on the matrix. - `func` (string): Function for mat_fn, e.g. "exp" or "lambda(x) x^2". - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `var` (string): Variable for mat_exp (t) or mat_power (n); defaults to the built-in. ### `linear-programming` (~664 tokens) Linear and integer linear programming (step LP.3) with exact rational arithmetic: the two-phase simplex method (Bland's rule) for LP, branch and bound for ILP. Maximize or minimize a linear objective cᵀx over linear constraints. The answer always carries a certificate verified by lp-check (independent: only multiplications and comparisons): optimal — x, value and the dual prices y with cᵀx = value = bᵀy; infeasible — a Farkas lemma certificate; unbounded — a feasible point and a ray; integer — re-solving the branch-and-bound tree. 'integer' is a vector of variable classes "int"/"bin"/"free"; when absent the problem is a plain LP. answers: (optimal x value y), (infeasible y), (unbounded x d), (unknown x value nil) when the node limit is exceeded. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `constraints` (string, required): Constraint matrix A as a matrix, e.g. "[[1,0],[0,2],[1,1]]". - `dir` (string, required): Optimization direction. - `integer` (string): Variable classes for ILP as a vector of "int"/"bin"/"free", e.g. "["bin", "bin", "int"]"; when absent — plain LP. - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `objective` (string, required): Objective coefficients c as a vector, e.g. "[3, 5]". - `relations` (string): Constraint relations as a vector of "<="/">="/"=", e.g. "["<=", ">=", "="]"; default all "<=". - `rhs` (string, required): Right-hand sides b as a vector, e.g. "[4, 12, 8]". - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `solve` (~586 tokens) Solve an equation or a system. Returns the SET of solutions (a system solution is a vector of equations x = ...); status "no-solution" means proven unsolvable; 'conditions' lists the generic-parameter conditions (e.g. a ≠ 0) under which the answer holds. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `equations` (string, required): Equation "x^2 - 5x + 6 = 0" (an expression means '= 0'), or a vector of equations "[x + y = 3, x - y = 1]". - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `vars` (string, required): Unknown "x", or a vector of unknowns "[x, y]" for a system. ### `expand` (~522 tokens) Expand products and integer powers of sums into a sum of monomials (collects like terms). Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `factor` (~540 tokens) Factor a polynomial over the integers into irreducible factors (also a rational function: numerator and denominator). Irreducible or non-polynomial input is returned unchanged with status "answer". Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `together` (~534 tokens) Combine a sum of fractions into one fraction numerator/denominator in lowest terms: 1/x + 1/y gives (x + y)/(x*y). Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `apart` (~583 tokens) Partial fraction decomposition of a rational function with respect to 'var': 1/(x^2-1) gives 1/(2(x-1)) - 1/(2(x+1)). Not a rational function in 'var' (e.g. contains sin(x)): status "error" or unchanged input. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `var` (string, required): Variable of the decomposition, e.g. "x". ### `limit` (~669 tokens) Limit of an expression as var approaches point (a number, or ∞ / -∞). Without 'side' it is the two-sided limit. If the limit is not found (it may exist, or may not, e.g. sin(1/x) at 0), status is "unknown" and result is the unevaluated limit(...); do not guess the value. Result may be ∞, -∞ or undefined. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `point` (string, required): Limit point (math language): "0", "1", "∞", "-∞", "a". - `side` (string): One-sided limit: "plus" (from the right, x→a+) or "minus" (from the left). Default: two-sided. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `var` (string, required): Limit variable, e.g. "x". ### `series` (~600 tokens) Taylor/Laurent series of an expression around a point, up to the given order (the O(...) remainder is included in the result). Series that the CAS cannot compute (essential singularities, unsupported functions): status "unknown". Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `expr` (string, required): Expression in the math language, e.g. "x^2*sin(x) + exp(-x)" (with syntax="lisp": an S-expression, e.g. "(* (^ x 2) (sin x))"). - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `order` (integer): The series is exact up to O(var^order); default 6. - `point` (string): Expansion point (math language), default "0". - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `var` (string, required): Expansion variable, e.g. "x". ### `groebner` (~617 tokens) Reduced Groebner basis of the ideal generated by polynomials, as a vector of monic polynomials. 'order' is the monomial order: lex (default; useful for elimination and solving), grlex, grevlex (usually fastest). Large systems (e.g. cyclic-6) can be slow: use timeout_s; status "timeout" means no answer, not an empty basis. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `order` (string): Monomial order, default lex. - `polys` (string, required): Polynomials, as a vector "[x^2 + y, x*y - 1]" or an array of strings; an equation a = b means a - b. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `vars` (string, required): Variables, as a vector "[x, y]" or an array of strings; the order of variables matters for lex. ### `declare` (~506 tokens) Declare a property of a symbol for the whole session: its domain or interval. It then affects simplify (sqrt(x^2) becomes x for x in positive), solve, integrate and the signs of expressions. Declarations of one symbol accumulate (they intersect): call again to add a constraint. Returns "x ∈ D"; 'assumptions' lists all active declarations. Undeclared symbols are complex numbers. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `domain` (string, required): One of: ℝ (reals), ℤ (integers), ℚ (rationals), ℕ (naturals incl. 0), ℂ (complex); positive, nonnegative, negative, nonpositive; an interval: (0, ∞), [0, 1], (0, 1], interval(-1, 1). ASCII names also… - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `symbol` (string, required): Symbol name, e.g. "x". - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `undeclare` (~340 tokens) Remove all declarations of a symbol (it becomes an arbitrary complex number again). Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `symbol` (string, required): Symbol name, e.g. "x". - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `declarations` (~179 tokens) List the active declarations of the session, one "x ∈ D" per line (also given in 'assumptions' of every response). Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. ### `equivalent` (~623 tokens) Check whether two expressions are equal. result is "true", "false" or "unknown" (status "answer"). true: proved symbolically (the difference simplifies to 0); holds where both expressions are defined. false: a counterexample is given in 'note' (a point where the values differ; sample points respect declarations, undeclared symbols are sampled as real numbers). unknown: not proved, and the numeric checks at random points agreed (this is NOT a proof); verify by other means or say that you could not decide. Returns a JSON object: status (answer | unknown | no-solution | nonelementary | error | timeout), result (S-expression), pretty (math-language form), note, conditions (when the answer is valid, e.g. a ≠ 0), assumptions, certificate (only with certificate=true), steps, warnings, output, error. Input parameters: - `a` (string, required): First expression, e.g. "sin(x)^2 + cos(x)^2". - `b` (string, required): Second expression, e.g. "1". - `certificate` (boolean): Include a verification of the answer in the 'certificate' field (default false): derivative check for integrate, substitution check for solve, equivalence check for simplify/expand/factor/together/ap… - `lang` (string): Language of step titles and comments (used with steps): "ru" (default) or "en". The rule ids and the formulas are language-independent. A step without an English translation keeps its Russian text an… - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `steps` (string): Include the step-by-step solution in the 'steps' field (a tree; titles and comments are in Russian unless lang="en"): none (default), brief (main top-level steps only), full (the whole tree: depth ≤… - `syntax` (string): Input syntax of expression arguments: "math" (default; infix: x^2, sqrt(x), pi, ∞, a = b) or "lisp" (S-expressions). - `timeout_s` (integer): Time limit in seconds (default 60, max 600). On expiry the computation is interrupted, status is "timeout"; the session stays usable. - `vars` (string): Variables to sample, e.g. "[x, y]" (optional: all free symbols are used). ### `guide` (~209 tokens) Return the on-demand LLM guide (markdown). Without 'topic': the short core (input syntax, how to read the response: status / conditions / certificates, which tool when) and the list of topic cards (the same text is the MCP resource lisp://guide). With 'topic' (e.g. "integration", "ode", "linear-algebra", "sums"): a card with 5-15 functions with exact signatures, runnable examples and pitfalls. A name from other systems (Mathematica, Maple) ("DSolve", "FactorInteger", "Eigenvalues", ...) or a tool name is accepted and returns the right card; topic "synonyms" is the whole table. An unknown topic returns an error with suggestions. Read the core once before the first calculation. Input parameters: - `topic` (string): Topic card name (e.g. "integration") or a name from another system (e.g. "DSolve"); omit for the core guide and the list of topics. ### `code` (~321 tokens) Query the Lisp source of the CAS library (lib/) instead of reading whole files; for developers and agents extending the library. kind: def (location, signature, doc comment and source of NAME), sig (one-line signature + module + first doc line; builtins too), refs (where NAME is used), callers / callees (direct, depth for transitive), module (exports and module dependencies), outline (definitions of a file with line numbers), search (top-10 definitions by name/doc words, Russian or English), deps (external names a file uses, by module), unused (definitions never referenced). Names may be qualified: module::name. Result: plain text (default, compact) or JSON text with json=true. An unknown name returns an error with similar names. Input parameters: - `arg` (string): NAME for def/sig/refs/callers/callees, module name for module, file path (lib/algnum.lisp or algnum.lisp) for outline/deps, words for search; not used by unused. - `depth` (integer): callers/callees: depth of the transitive closure (default 1). - `json` (boolean): Return JSON text instead of compact text (default false). - `kind` (string, required): Kind of query. - `max_chars` (integer): Truncate result/pretty to this many characters (default 20000, max 200000); truncation is reported in 'warnings'. - `no_body` (boolean): def: omit the source text (default false). ### `reset` (~25 tokens) Reset the session: forget all variables, functions and domain declarations. Returns status "answer". ## Diagnostics Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/evgwpw-qedra/ghcr-io-evgwpw-qedra#diagnostics ## Score history - 2026-11-05: 39 - 2026-11-04: 38 ## Common questions ### What is the Qedra MCP server? Qedra is an MCP server listed in the public MCP registry as io.github.evgwpw/qedra. Computer algebra with verifiable answers. This page covers its container image (ghcr.io/evgwpw/qedra). ### Is the Qedra MCP server safe to use? Qedra scores 39 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the Qedra MCP server expose? Qedra exposes 23 tools: math, evaluate, simplify, diff, integrate, and 18 more. Their descriptions and schemas cost roughly 11,245 tokens of context every time the server is loaded. ### Is the Qedra MCP server still maintained? Qedra is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ### What licence is the Qedra MCP server under? Qedra declares the 0BSD licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls. ## Links - GitHub Container Registry: https://ghcr.io/evgwpw/qedra - Repository: https://github.com/evgwpw/Qedra - Website: https://evgwpw.github.io/Qedra/ - Changelog RSS feed: https://verifymcp.io/servers/evgwpw-qedra/ghcr-io-evgwpw-qedra.xml - Changelog JSON feed: https://verifymcp.io/servers/evgwpw-qedra/ghcr-io-evgwpw-qedra.json - HTML version of this page: https://verifymcp.io/servers/evgwpw-qedra/ghcr-io-evgwpw-qedra