io.github.daedalus/mcp-sympy

Fresnel S.

Prime counting function.

Simplify an expression. Args: expr: String expression to simplify Returns: Simplified expression as string

Create symbolic variables. Args: names: Comma-separated symbol names (e.g., "x, y, z") Returns: String representation of created symbols

Create a single symbolic variable. Args: name: Symbol name Returns: String representation of the symbol

Convert a string to a SymPy expression. Args: expr: String expression to convert Returns: SymPy expression as string

Simplify trigonometric expressions. Args: expr: String trigonometric expression Returns: Simplified expression

Simplify rational expressions. Args: expr: String rational expression Returns: Simplified rational expression

Simplify powers in an expression. Args: expr: String expression with powers Returns: Simplified expression

Factor an expression. Args: expr: String expression to factor Returns: Factored expression

Expand an expression. Args: expr: String expression to expand Returns: Expanded expression

Expand trigonometric expressions. Args: expr: String trigonometric expression Returns: Expanded expression Example: >>> sympy_expand_trig("sin(2*x)") "2*sin(x)*cos(x)"

Expand logarithmic expressions. Args: expr: String logarithmic expression Returns: Expanded expression Example: >>> sympy_expand_log("log(x*y)") "log(x) + log(y)"

Combine terms into a single fraction. Args: expr: String expression Returns: Combined fraction Example: >>> sympy_together("1/x + 1/y") "(x + y)/(x*y)"

Perform partial fraction decomposition. Args: expr: String rational expression Returns: Partial fractions Example: >>> sympy_apart("1/(x**2 - 1)") "1/(2*(x - 1)) - 1/(2*(x + 1))"

Cancel common factors in rational expression. Args: expr: String rational expression Returns: Canceled expression Example: >>> sympy_cancel("(x**2 - 1)/(x - 1)") "x + 1"

Solve an equation or system of equations. Args: equation: String equation variables: Comma-separated variables to solve for Returns: Solution(s) as string

Solve an equation using solveset. Args: equation: String equation variable: Variable to solve for Returns: Solution set as string

Numerically solve an equation. Args: equation: String equation variables: Comma-separated variables guesses: Comma-separated initial guesses Returns: Numerical solution

Differentiate an expression. Args: expr: String expression to differentiate variable: Variable to differentiate with respect to order: Order of derivative Returns: Derivative as string

Integrate an expression. Args: expr: String expression to integrate variable: Variable to integrate with respect to Returns: Integral as string

Compute a limit. Args: expr: String expression variable: Variable approaching the limit point: Point to approach direction: Direction ("+", "-") Returns: Limit as string

Compute series expansion. Args: expr: String expression variable: Variable to expand around point: Point to expand around order: Order of expansion Returns: Series expansion as string

Compute a sum. Args: expr: String expression to sum variable: Summation variable lower: Lower bound upper: Upper bound Returns: Sum as string Example: >>> sympy_sum("k**2", "k", "1", "5") "55"

Compute a product. Args: expr: String expression to multiply variable: Product variable lower: Lower bound upper: Upper bound Returns: Product as string Example: >>> sympy_product("k", "k", "1", "5") "120"

Compute an unevaluated sum (Sum object). Args: expr: String expression variable: Summation variable bounds: Lower and upper bound as "lower,upper" Returns: Sum object as string Example: >>> sympy_summation("k**2", "k", "1,5") "Sum(k**2, (k, 1, 5))"

Compute an unevaluated product (Product object). Args: expr: String expression variable: Product variable bounds: Lower and upper bound as "lower,upper" Returns: Product object as string Example: >>> sympy_product_expr("k", "k", "1,5") "Product(k, (k, 1, 5))"

Create a Derivative object (unevaluated). Args: expr: String expression variable: Variable to differentiate order: Order of derivative Returns: Derivative object as string Example: >>> sympy_derivative("x**2", "x") "Derivative(x**2, x)"

Create an Integral object (unevaluated). Args: expr: String expression variable: Variable to integrate Returns: Integral object as string Example: >>> sympy_integral("x**2", "x") "Integral(x**2, x)"

Create a matrix from rows. Args: rows: Semicolon-separated rows, e.g., "1,2; 3,4" Returns: Matrix as string Example: >>> sympy_matrix("1,2; 3,4") "Matrix([[1, 2], [3, 4]])"

Add two matrices. Args: matrix1: First matrix string matrix2: Second matrix string Returns: Sum matrix as string Example: >>> sympy_matrix_add("Matrix([[1, 2], [3, 4]])", "Matrix([[5, 6], [7, 8]])") "Matrix([[6, 8], [10, 12]])"

Multiply two matrices. Args: matrix1: First matrix string matrix2: Second matrix string Returns: Product matrix as string Example: >>> sympy_matrix_multiply("Matrix([[1, 2], [3, 4]])", "Matrix([[5, 6], [7, 8]])") "Matrix([[19, 22], [43, 50]])"

Compute matrix inverse. Args: matrix: Matrix string Returns: Inverse matrix as string Example: >>> sympy_matrix_inverse("Matrix([[1, 2], [3, 4]])") "Matrix([[-2, 1], [1.5, -0.5]])"

Compute matrix determinant. Args: matrix: A SymPy matrix string, e.g., "Matrix([[1, 2], [3, 4]])" Returns: The determinant as a string. Example: >>> sympy_matrix_determinant("Matrix([[1, 2], [3, 4]])") "-2"

Transpose a matrix. Args: matrix: Matrix string Returns: Transposed matrix as string Example: >>> sympy_matrix_transpose("Matrix([[1, 2], [3, 4]])") "Matrix([[1, 3], [2, 4]])"

Compute eigenvalues of a matrix. Args: matrix: Matrix string Returns: Eigenvalues as string Example: >>> sympy_matrix_eigenvals("Matrix([[1, 2], [2, 1]])") "{5: 1, -3: 1}"

Compute eigenvectors of a matrix. Args: matrix: Matrix string Returns: Eigenvectors as string Example: >>> sympy_matrix_eigenvects("Matrix([[1, 0], [0, 2]])") "(1, 1, [Matrix([[1], [0]]), Matrix([[0], [1]])])"

Create an identity matrix. Args: n: Size of the matrix Returns: Identity matrix as string Example: >>> sympy_eye(3) "Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 1]])"

Create a zero matrix. Args: rows: Number of rows cols: Number of columns (default: same as rows) Returns: Zero matrix as string Example: >>> sympy_zeros(2, 3) "Matrix([[0, 0, 0], [0, 0, 0]])"

Create a matrix of ones. Args: rows: Number of rows cols: Number of columns (default: same as rows) Returns: Matrix of ones as string Example: >>> sympy_ones(2, 3) "Matrix([[1, 1, 1], [1, 1, 1]])"

Create a diagonal matrix. Args: elements: Comma-separated diagonal elements Returns: Diagonal matrix as string Example: >>> sympy_diag("1,2,3") "Matrix([[1, 0, 0], [0, 2, 0], [0, 0, 3]])"

Convert expression to LaTeX. Args: expr: SymPy expression string Returns: LaTeX string Example: >>> sympy_latex("x**2 + sin(y)") "x^{2} + \sin{\left(y\right)}"

Convert expression to Python code. Args: expr: SymPy expression string Returns: Python code string Example: >>> sympy_python_code("x**2 + 1") "x**2 + 1"

Convert expression to MathML. Args: expr: SymPy expression string Returns: MathML string Example: >>> sympy_mathml("x**2") "<math><apply><power/><ci>x</ci><cn>2</cn></apply></math>"

Convert expression to string. Args: expr: SymPy expression string Returns: String representation Example: >>> sympy_str("x**2 + 1") "x**2 + 1"

Get repr of expression. Args: expr: SymPy expression string Returns: repr string Example: >>> sympy_repr_expr("x**2") "Pow(Symbol('x'), Integer(2))"

Create an interval. Args: start: Start value end: End value left_open: Whether left is open right_open: Whether right is open Returns: Interval as string Example: >>> sympy_interval("0", "1", true, true) "(0, 1)"

Create a finite set. Args: elements: Comma-separated elements Returns: Finite set as string Example: >>> sympy_finite_set("1,2,3,4,5") "{1, 2, 3, 4, 5}"

Compute union of two sets. Args: set1: First set set2: Second set Returns: Union as string Example: >>> sympy_union("{1,2}", "{2,3}") "{1, 2, 3}"

Compute intersection of two sets. Args: set1: First set set2: Second set Returns: Intersection as string Example: >>> sympy_intersection("{1,2,3}", "{2,3,4}") "{2, 3}"

Compute complement of set1 in set2. Args: set1: Subset set2: Universal set Returns: Complement as string Example: >>> sympy_complement("{1,2}", "{1,2,3,4}") "{3, 4}"

Toggle evaluation globally.

Evaluate expression numerically. Args: expr: Expression to evaluate n: Number of digits Returns: Numerical result Example: >>> sympy_n("pi", 10) "3.141592654"

Evaluate expression to floating point. Args: expr: Expression to evaluate n: Number of digits Returns: Float result Example: >>> sympy_evalf("sqrt(2)", 5) "1.4142"

Exponential function. Args: expr: Expression Returns: exp(expr) as string Example: >>> sympy_exp("1") "E"

Natural logarithm. Args: expr: Expression Returns: log(expr) as string Example: >>> sympy_log("E") "1"

Logarithm with specified base. Args: expr: Expression base: Logarithm base Returns: log_base(expr) as string Example: >>> sympy_log_base("100", "10") "2"

Sine function. Args: expr: Expression (in radians) Returns: sin(expr) as string Example: >>> sympy_sin("pi/2") "1"

Cosine function. Args: expr: Expression (in radians) Returns: cos(expr) as string Example: >>> sympy_cos("0") "1"

Tangent function. Args: expr: Expression (in radians) Returns: tan(expr) as string Example: >>> sympy_tan("pi/4") "1"

Hyperbolic sine. Args: expr: Expression Returns: sinh(expr) as string Example: >>> sympy_sinh("0") "0"

Hyperbolic cosine. Args: expr: Expression Returns: cosh(expr) as string Example: >>> sympy_cosh("0") "1"

Hyperbolic tangent. Args: expr: Expression Returns: tanh(expr) as string Example: >>> sympy_tanh("0") "0"

Arc sine. Args: expr: Expression (between -1 and 1) Returns: asin(expr) as string Example: >>> sympy_asin("0") "0"

Arc cosine. Args: expr: Expression (between -1 and 1) Returns: acos(expr) as string Example: >>> sympy_acos("1") "0"

Arc tangent. Args: expr: Expression Returns: atan(expr) as string Example: >>> sympy_atan("1") "pi/4"

Square root. Args: expr: Expression Returns: sqrt(expr) as string Example: >>> sympy_sqrt("4") "2"

Cube root. Args: expr: Expression Returns: cbrt(expr) as string Example: >>> sympy_cbrt("8") "2"

N-th root. Args: expr: Expression n: Root degree Returns: Root as string Example: >>> sympy_root("8", "3") "2"

Floor function. Args: expr: Expression Returns: floor(expr) as string Example: >>> sympy_floor("3.7") "3"

Ceiling function. Args: expr: Expression Returns: ceiling(expr) as string Example: >>> sympy_ceiling("3.2") "4"

Absolute value. Args: expr: Expression Returns: abs(expr) as string Example: >>> sympy_abs("-5") "5"

Factorial. Args: n: Non-negative integer Returns: n! as string Example: >>> sympy_factorial("5") "120"

Binomial coefficient. Args: n: Non-negative integer k: Non-negative integer Returns: C(n,k) as string Example: >>> sympy_binomial("5", "2") "10"

Gamma function. Args: expr: Expression Returns: Gamma(expr) as string Example: >>> sympy_gamma("5") "24"

Riemann zeta function. Args: s: Expression Returns: zeta(s) as string Example: >>> sympy_zeta("2") "pi**2/6"

Error function. Args: expr: Expression Returns: erf(expr) as string Example: >>> sympy_erf("0") "0"

Dirichlet eta function.

Polylogarithm.

Fibonacci number. Args: n: Non-negative integer Returns: F(n) as string Example: >>> sympy_fibonacci("10") "55"

Lucas number. Args: n: Non-negative integer Returns: L(n) as string Example: >>> sympy_lucas("10") "123"

Catalan number. Args: n: Non-negative integer Returns: C(n) as string Example: >>> sympy_catalan("5") "42"

Check if n is prime. Args: n: Integer Returns: "True" or "False" Example: >>> sympy_isprime("7") "True"

Return the n-th prime. Args: n: Positive integer (1-indexed) Returns: n-th prime as string Example: >>> sympy_prime("10") "29"

Return the next prime after n. Args: n: Integer Returns: Next prime as string Example: >>> sympy_nextprime("10") "11"

Return the previous prime before n. Args: n: Integer > 2 Returns: Previous prime as string Example: >>> sympy_prevprime("10") "7"

Euler's totient function. Args: n: Positive integer Returns: phi(n) as string Example: >>> sympy_totient("10") "4"

Return divisors of n. Args: n: Positive integer Returns: List of divisors Example: >>> sympy_divisors("12") "[1, 2, 3, 4, 6, 12]"

Greatest common divisor. Args: a: Integer b: Integer Returns: gcd(a, b) as string Example: >>> sympy_gcd("48", "18") "6"

Least common multiple. Args: a: Integer b: Integer Returns: lcm(a, b) as string Example: >>> sympy_lcm("4", "6") "12"

Integer factorization. Args: n: Integer Returns: Prime factorization as string Example: >>> sympy_factorint("12") "{2: 2, 3: 1}"

Create a polynomial. Args: expr: Expression variable: Variable Returns: Polynomial as string Example: >>> sympy_poly("x**2 + 2*x + 1", "x") "x**2 + 2*x + 1"

Degree of polynomial. Args: expr: Polynomial expression variable: Variable Returns: Degree as string Example: >>> sympy_degree("x**3 + x**2 + 1", "x") "3"

Find roots of polynomial. Args: expr: Polynomial expression variable: Variable Returns: Roots as string Example: >>> sympy_roots("x**2 - 4", "x") "{2: 1, -2: 1}"

Get coefficient. Args: expr: Expression x: Variable n: Power of x Returns: Coefficient as string Example: >>> sympy_coeff("3*x**2 + 2*x + 1", "x", 2) "3"

Substitute in expression. Args: expr: Expression old_new: Substitutions as "old:new,old2:new2" Returns: Substituted expression Example: >>> sympy_subs("x**2 + y", "x:2,y:3") "7"

Get atoms (atomic components) of expression. Args: expr: Expression Returns: Set of atoms Example: >>> sympy_atoms("x**2 + y") "{x, y}"

Get free symbols in expression. Args: expr: Expression Returns: Set of free symbols Example: >>> sympy_free_symbols("x**2 + y") "{x, y}"

Get arguments of expression. Args: expr: Expression Returns: Tuple of arguments Example: >>> sympy_args("x + y") "(x, y)"

Get head function of expression. Args: expr: Expression Returns: Function head Example: >>> sympy_func("x + y") "Add"

Get type of expression. Args: expr: Expression Returns: Type as string Example: >>> sympy_expr_type("x + 1") "<class 'sympy.core.add.Add'>"

Create equality. Args: lhs: Left-hand side rhs: Right-hand side Returns: Equality as string Example: >>> sympy_eq("x", "y") "Eq(x, y)"

Create inequality (not equal). Args: lhs: Left-hand side rhs: Right-hand side Returns: Neq as string Example: >>> sympy_ne("x", "y") "Ne(x, y)"

Create less than. Args: lhs: Left-hand side rhs: Right-hand side Returns: Less than as string Example: >>> sympy_lt("x", "y") "x < y"

Create less than or equal. Args: lhs: Left-hand side rhs: Right-hand side Returns: Less than or equal as string Example: >>> sympy_le("x", "y") "x <= y"

Create greater than. Args: lhs: Left-hand side rhs: Right-hand side Returns: Greater than as string Example: >>> sympy_gt("x", "y") "x > y"

Create greater than or equal. Args: lhs: Left-hand side rhs: Right-hand side Returns: Greater than or equal as string Example: >>> sympy_ge("x", "y") "x >= y"

Logical AND. Args: args: Comma-separated expressions Returns: And as string Example: >>> sympy_And("True, False") "False"

Logical OR. Args: args: Comma-separated expressions Returns: Or as string Example: >>> sympy_Or("True, False") "True"

Logical NOT. Args: expr: Boolean expression Returns: Not as string Example: >>> sympy_Not("True") "False"

Logical XOR. Args: args: Comma-separated expressions Returns: Xor as string Example: >>> sympy_Xor("True, False") "True"

Logical NAND. Args: args: Comma-separated expressions Returns: Nand as string Example: >>> sympy_Nand("True, True") "False"

Logical NOR. Args: args: Comma-separated expressions Returns: Nor as string Example: >>> sympy_Nor("False, False") "True"

Logical implication. Args: lhs: Antecedent rhs: Consequent Returns: Implies as string Example: >>> sympy_Implies("True", "False") "False"

Check if expression is satisfiable. Args: expr: Boolean expression Returns: Solution or False Example: >>> sympy_satisfiable("x & y") "{x: True, y: True}"

Create a 2D point. Args: x: x-coordinate y: y-coordinate Returns: Point as string Example: >>> sympy_Point("1", "2") "(1, 2)"

Create a 3D point. Args: x: x-coordinate y: y-coordinate z: z-coordinate Returns: Point3D as string Example: >>> sympy_Point3D("1", "2", "3") "(1, 2, 3)"

Create a line through two points. Args: point1: First point point2: Second point Returns: Line as string Example: >>> sympy_Line("(0, 0)", "(1, 1)") "Line2D(Point2D(0, 0), Point2D(1, 1))"

Create a circle. Args: center: Center point radius: Radius Returns: Circle as string Example: >>> sympy_Circle("(0, 0)", "1") "Circle(Point2D(0, 0), 1)"

Create a triangle. Args: point1: First vertex point2: Second vertex point3: Third vertex Returns: Triangle as string Example: >>> sympy_Triangle("(0, 0)", "(1, 0)", "(0, 1)") "Triangle(Point2D(0, 0), Point2D(1, 0), Point2D(0, 1))"

Create a polygon (comma-separated points).

Check if n is a perfect power.

Check if n is a perfect square.

Create Integer.

Create Float.

Create Rational.

Complex conjugate.

Imaginary part.

Real part.

Argument of complex number.

Create piecewise function (format: "expr,condition; expr2,condition2").

Fresnel C.

Solve a Diophantine equation. Args: expr: A SymPy expression equal to zero, e.g., "x**2 + y**2 - 25" (not "x**2 + y**2 = 25") Returns: Set of integer solutions as a string. Example: >>> sympy_diohyp("x**2 + y**2 - 25") "{(5, 0), (0, 5), (-5, 0), (0, -5), (3, 4), ...}"

Solve ordinary differential equation.

Check ODE solution.

Classify ODE.

The set of complex numbers.

The set of real numbers.

The set of integers.

The set of natural numbers.

The set of natural numbers (including 0).

Empty set.

Universal set.

Random matrix.

Create Wild pattern.

Create Wild function.

Match expression to pattern.

Replace in expression (format: "old,new").

Exact replacement without simplification.

Numerical simplification.

Simplify radicals.

Rationalize denominator.

Count operations.

Create multiple symbols.

Range.

Identity matrix.

Matrix rank.

Nullspace.

LU decomposition.

Expand complex.

As real and imaginary parts.

As numerator and denominator.

Groebner basis.

Horner form.

Divisor function.

Symbolic power.

Symbolic multiplication (comma-separated).

Symbolic addition (comma-separated).

Create finite set (comma-separated).

Product of sets (comma-separated).

Image set.