Symbolic Algebra MCP Server
A Model Context Protocol server that exposes SymPy/EinsteinPy tools so LLMs can perform symbolic mathematics, computer algebra, and general relativity calculations via tool calls.
Introduce variables and functions with assumptions and store them for later use.
Parse and store mathematical expressions, equations, matrices, and custom metrics.
Solve algebraic equations, linear/nonlinear systems, ODEs, and PDEs.
Perform calculus: differentiation, integration (indefinite/definite), simplification, and substitution.
Do vector calculus: create coordinate systems/vector fields and compute curl, divergence, and gradient.
Do tensor/general relativity: create predefined/custom metrics, search metrics, calculate tensors (Ricci, Einstein, Weyl, scalar), and print LaTeX.
Work with units: convert quantities and simplify unit expressions.
Perform matrix operations: create matrices, determinant, inverse, eigenvalues, and eigenvectors.
Print stored expressions and tensors in LaTeX.
Reset server state between computations.
Run over stdio, streamable HTTP/SSE, or Docker.
Enables containerized deployment of the MCP server through Docker images
Provides access to the server through GitHub Container Registry for easy deployment
Provides LaTeX rendering of mathematical expressions and tensors for clear visualization of symbolic mathematics
Exposes SymPy's core functionality for symbolic mathematics including equation solving, integration, differentiation, vector calculus, and tensor calculus
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Symbolic Algebra MCP Server solve x^2 - 5x + 6 = 0 for x"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Symbolic Algebra MCP Server
This library is no longer maintained. It is Apache licensed, so feel free to fork it.
Sympy-MCP is a Model Context Protocol server for allowing LLMs to autonomously perform symbolic mathematics and computer algebra. It exposes numerous tools from SymPy's core functionality to MCP clients for manipulating mathematical expressions and equations.
Why?
Language models are absolutely abysmal at symbolic manipulation. They hallucinate variables, make up random constants, permute terms and generally make a mess. But we have computer algebra systems specifically built for symbolic manipulation, so we can use tool-calling to orchestrate a sequence of transforms so that the symbolic kernel does all the heavy lifting.
While you can certainly have an LLM generate Mathematica or Python code, if you want to use the LLM as an agent or on-the-fly calculator, it's a better experience to use the MCP server and expose the symbolic tools directly.
The server exposes a subset of symbolic mathematics capabilities including algebraic equation solving, integration and differentiation, vector calculus, tensor calculus for general relativity, and both ordinary and partial differential equations.
For example, you can ask it in natural language to solve a differential equation:
Solve the damped harmonic oscillator with forcing term: the mass-spring-damper system described by the differential equation where m is mass, c is the damping coefficient, k is the spring constant, and F(t) is an external force.
$$ m\frac{d^2x}{dt^2} + c\frac{dx}{dt} + kx = F(t) $$
Or involving general relativity:
Compute the trace of the Ricci tensor $R_{\mu\nu}$ using the inverse metric $g^{\mu\nu}$ for Anti-de Sitter spacetime to determine its constant scalar curvature $R$.
Related MCP server: ReasonForge
Usage
You need uv first.
Homebrew :
brew install uvCurl :
curl -LsSf https://astral.sh/uv/install.sh | sh
Then you can install and run the server with the following commands:
# Setup the project
git clone https://github.com/sdiehl/sympy-mcp.git
cd sympy-mcp
uv sync
# Install the server to Claude Desktop
uv run mcp install server.py
# Run the server
uv run mcp run server.pyYou should see the server available in the Claude Desktop app now. For other clients, see below.
If you want a completely standalone version that just runs with a single command, you can use the following. Note this is running arbitrary code from Github, so be careful.
uv run --with https://github.com/sdiehl/sympy-mcp/releases/download/0.1/sympy_mcp-0.1.0-py3-none-any.whl python server.pyIf you want to do general relativity calculations, you need to install the einsteinpy library.
uv sync --group relativityAvailable Tools
The sympy-mcp server provides the following tools for symbolic mathematics:
Tool | Tool ID | Description |
Variable Introduction |
| Introduces a variable with specified assumptions and stores it |
Multiple Variables |
| Introduces multiple variables with specified assumptions simultaneously |
Expression Parser |
| Parses an expression string using available local variables and stores it |
LaTeX Printer |
| Prints a stored expression in LaTeX format, along with variable assumptions |
Algebraic Solver |
| Solves an equation algebraically for a given variable over a given domain |
Linear Solver |
| Solves a system of linear equations |
Nonlinear Solver |
| Solves a system of nonlinear equations |
Function Variable |
| Introduces a function variable for use in differential equations |
ODE Solver |
| Solves an ordinary differential equation |
PDE Solver |
| Solves a partial differential equation |
Standard Metric |
| Creates a predefined spacetime metric (e.g. Schwarzschild, Kerr, Minkowski) |
Metric Search |
| Searches available predefined metrics |
Tensor Calculator |
| Calculates tensors from a metric (Ricci, Einstein, Weyl tensors) |
Custom Metric |
| Creates a custom metric tensor from provided components and symbols |
Tensor LaTeX |
| Prints a stored tensor expression in LaTeX format |
Simplifier |
| Simplifies a mathematical expression using SymPy's canonicalize function |
Substitution |
| Substitutes a variable with an expression in another expression |
Integration |
| Integrates an expression with respect to a variable |
Differentiation |
| Differentiates an expression with respect to a variable |
Coordinates |
| Creates a 3D coordinate system for vector calculus operations |
Vector Field |
| Creates a vector field in the specified coordinate system |
Curl |
| Calculates the curl of a vector field |
Divergence |
| Calculates the divergence of a vector field |
Gradient |
| Calculates the gradient of a scalar field |
Unit Converter |
| Converts a quantity to given target units |
Unit Simplifier |
| Simplifies a quantity with units |
Matrix Creator |
| Creates a SymPy matrix from the provided data |
Determinant |
| Calculates the determinant of a matrix |
Matrix Inverse |
| Calculates the inverse of a matrix |
Eigenvalues |
| Calculates the eigenvalues of a matrix |
Eigenvectors |
| Calculates the eigenvectors of a matrix |
By default variables are predefined with assumptions (similar to how the symbols() function works in SymPy). Unless otherwise specified the defaut assumptions is that a variable is complex, commutative, term over the complex field $\mathbb{C}$.
Property | Value |
| true |
| true |
| true |
| false |
Claude Desktop Setup
Normally the mcp install command will automatically add the server to the claude_desktop_config.json file. If it doesn't you need to find the config file and add the following:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
Add the following to the mcpServers object, replacing /ABSOLUTE_PATH_TO_SYMPY_MCP/server.py with the absolute path to the sympy-mcp server.py file.
{
"mcpServers": {
"sympy-mcp": {
"command": "/opt/homebrew/bin/uv",
"args": [
"run",
"--with",
"einsteinpy",
"--with",
"mcp[cli]",
"--with",
"pydantic",
"--with",
"sympy",
"mcp",
"run",
"/ABSOLUTE_PATH_TO_SYMPY_MCP/server.py"
]
}
}
}Cursor Setup
In your ~/.cursor/mcp.json, add the following, where ABSOLUTE_PATH_TO_SYMPY_MCP is the path to the sympy-mcp server.py file.
{
"mcpServers": {
"sympy-mcp": {
"command": "/opt/homebrew/bin/uv",
"args": [
"run",
"--with",
"einsteinpy",
"--with",
"mcp[cli]",
"--with",
"pydantic",
"--with",
"sympy",
"mcp",
"run",
"/ABSOLUTE_PATH_TO_SYMPY_MCP/server.py"
]
}
}
}VS Code Setup
VS Code and VS Code Insiders now support MCPs in agent mode. For VS Code, you may need to enable Chat > Agent: Enable in the settings.
One-click Setup:
OR manually add the config to your settings.json (global):
{
"mcp": {
"servers": {
"sympy-mcp": {
"command": "uv",
"args": [
"run",
"--with",
"einsteinpy",
"--with",
"mcp[cli]",
"--with",
"pydantic",
"--with",
"sympy",
"mcp",
"run",
"/ABSOLUTE_PATH_TO_SYMPY_MCP/server.py"
]
}
}
}
}Click "Start" above the server config switch to agent mode in the chat, and try commands like "integrate x^2" or "solve x^2 = 1" to get started.
HTTP Transport (Streamable HTTP / SSE)
The server supports MCP over HTTP using the streamable-http transport introduced in MCP spec 2025-03-26. This replaces the legacy SSE transport and exposes a single /mcp endpoint that clients connect to over HTTP.
This is the recommended transport when running the server as a standalone process or in a container, because it allows any HTTP-capable MCP client to connect without needing to launch the server as a subprocess.
# Run locally with HTTP transport
uv run python server.py --transport streamable-http
# Override host/port
uv run python server.py --transport streamable-http --mcp-host 127.0.0.1 --mcp-port 9000The legacy --transport sse flag is still supported for backward compatibility.
A /healthcheck endpoint is also exposed that runs a full MCP protocol round-trip (initialize → tools/list → session teardown) and returns {"status": "ok", "tool_count": N}.
Running in Container
You can build and run the server using Docker locally:
# Build the Docker image
docker build -t sympy-mcp .
# Run the Docker container
docker run -p 8081:8081 sympy-mcpOr use Docker Compose from the docker/ directory:
cd docker
docker compose up -d --buildAlternatively, you can pull the pre-built image from GitHub Container Registry:
# Pull the latest image
docker pull ghcr.io/sdiehl/sympy-mcp:main
# Run the container
docker run -p 8081:8081 --rm ghcr.io/sdiehl/sympy-mcp:mainTo configure Claude Desktop to launch the Docker container, edit your claude_desktop_config.json file:
{
"mcpServers": {
"sympy-mcp": {
"command": "docker",
"args": [
"run",
"-i",
"-p",
"8081:8081",
"--rm",
"sympy-mcp"
]
}
}
}Or to use the pre-built container from GitHub:
{
"mcpServers": {
"sympy-mcp": {
"command": "docker",
"args": [
"run",
"-i",
"-p",
"8081:8081",
"--rm",
"ghcr.io/sdiehl/sympy-mcp:main"
]
}
}
}This configuration tells Claude Desktop to launch the Docker container when needed. Make sure to build the Docker image (docker build -t sympy-mcp .) before using Claude Desktop with this configuration.
The other installation methods can also be adapted to work with Docker if you change the uv command to use the docker run command instead.
Example Interaction 1 : Differential Equations
Here's an example of how the tool-calling works in a conversation with an AI assistant using this MCP server:
User: Solve the damped harmonic oscillator with forcing term: the mass-spring-damper system described by the differential equation where m is mass, c is the damping coefficient, k is the spring constant, and F(t) is an external force.
$$ m\frac{d^2x}{dt^2} + c\frac{dx}{dt} + kx = F(t) $$
Assistant: (Internal tool call) intro_many to introduce variables:
{
"variables": [
{"var_name": "t", "pos_assumptions": ["real"], "neg_assumptions": []},
{"var_name": "m", "pos_assumptions": ["real", "positive"], "neg_assumptions": []},
{"var_name": "c", "pos_assumptions": ["real", "positive"], "neg_assumptions": []},
{"var_name": "k", "pos_assumptions": ["real", "positive"], "neg_assumptions": []}
]
}Assistant: (Internal tool call) introduce_function to define x(t):
{
"func_name": "x"
}Assistant: (Internal tool call) introduce_expression to create the differential equation:
{
"expr_str": "Eq(m*Derivative(x(t), t, t) + c*Derivative(x(t), t) + k*x(t), F(t))"
}Assistant: (Internal tool call) print_latex_expression to display the equation nicely:
{
"expr_key": "expr_12"
}Result:
$$ c \frac{d}{d t} x{\left(t \right)} + k x{\left(t \right)} + m \frac{d^{2}}{d t^{2}} x{\left(t \right)} = F{\left(t \right)} $$
Assistant: (Internal tool call) introduce_function to define F(t):
{
"func_name": "F"
}Assistant: (Internal tool call) dsolve_ode to solve the differential equation:
{
"expr_key": "expr_12",
"func_name": "x"
}Result:
$$ x{\left(t \right)} = C_{1} e^{\frac{t \left(- c + \sqrt{c^{2} - 4 k m}\right)}{2 m}} + C_{2} e^{- \frac{t \left(c + \sqrt{c^{2} - 4 k m}\right)}{2 m}} + \cdots $$
Example Interaction 2: General Relativity
User: Compute the trace of the Ricci tensor $R_{\mu\nu}$ using the inverse metric $g^{\mu\nu}$ for Anti-de Sitter spacetime to determine its constant scalar curvature $R$.
Assistant: (Internal tool call) create_predefined_metric to create the Anti-de Sitter metric:
{
"metric_name": "AntiDeSitter"
}Assistant: (Internal tool call) calculate_tensor to calculate the Ricci tensor:
{
"metric_key": "metric_AntiDeSitter",
"tensor_type": "RICCI_TENSOR",
"simplify_result": true
}Assistant: (Internal tool call) print_latex_tensor to display the Ricci tensor:
{
"tensor_key": "riccitensor_metric_AntiDeSitter"
}Result:
$$ \left[\begin{matrix}3 & 0 & 0 & 0\\0 & - 3 \cos^{2}{\left(t \right)} & 0 & 0\\0 & 0 & - 3 \cos^{2}{\left(t \right)} \sinh^{2}{\left(\chi \right)} & 0\\0 & 0 & 0 & - 3 \sin^{2}{\left(\theta \right)} \cos^{2}{\left(t \right)} \sinh^{2}{\left(\chi \right)}\end{matrix}\right] $$
Assistant: (Internal tool call) calculate_tensor to calculate the Ricci scalar:
{
"metric_key": "metric_AntiDeSitter",
"tensor_type": "RICCI_SCALAR",
"simplify_result": true
}Assistant: (Internal tool call) print_latex_tensor to display the Ricci scalar:
{
"tensor_key": "ricciscalar_metric_AntiDeSitter"
}Result:
$$ -12 $$
Example Interaction 3: Coupled ODE System (Fluid Dynamics)
This example demonstrates solving a coupled system of ODEs and verifying the solution against an algebraic steady-state analysis, a task where LLMs typically hallucinate without a CAS to ground each step.
User:
Use the sympy-mcp tools to solve this symbolically. Do not compute by hand.
Two cylindrical tanks are connected by a pipe. Tank 1 has cross-sectional area A₁ = 2 m² and receives a constant inflow of Q = 0.5 m³/s. Water drains from Tank 1 into Tank 2 through a pipe with flow rate proportional to the height difference: q₁₂ = k·(h₁ - h₂) where k = 0.3 m²/s. Tank 2 has cross-sectional area A₂ = 1 m² and drains to the outside at rate q₂ = k·h₂ with the same k.
Set up and solve the coupled system of ODEs for the water heights h₁(t) and h₂(t), starting from empty tanks (h₁(0) = 0, h₂(0) = 0). Then find the steady-state heights as t → ∞ by solving the equilibrium equations algebraically, and verify they match the long-term solution of the ODEs.
Assistant: (Internal tool chain)
intro_many: introducet,k,A1,A2,Qwith real/positive assumptionsintroduce_function× 2: introduceh1(t)andh2(t)as unknown functionsintroduce_expression× 2: encode the mass-balance ODEs:
$$A_1 \frac{dh_1}{dt} = Q - k(h_1 - h_2), \quad A_2 \frac{dh_2}{dt} = k(h_1 - h_2) - k h_2$$
substitute_expression: substitute numeric values fork,A1,A2,Qdsolve_ode× 2: solve the coupled system; apply initial conditions viasubstitute_expressionintroduce_expression× 2: encode equilibrium equations (derivatives set to zero)solve_linear_system: solve the 2×2 algebraic system forh1*,h2*print_latex_expression: display both the time-domain solution and the steady-state values
Security Disclaimer
This server runs on your computer and gives the language model access to run Python logic. Notably it uses Sympy's parse_expr to parse mathematical expressions, which is uses eval under the hood, effectively allowing arbitrary code execution. By running the server, you are trusting the code that Claude generates. Running in the Docker image is slightly safer, but it's still a good idea to review the code before running it.
License
Copyright 2025 Stephen Diehl.
This project is licensed under the Apache 2.0 License. See the LICENSE file for details.
Available Tools
32 toolscalculate_curlA
Calculates the curl of a vector field using SymPy's curl function.
Args:
vector_field_key: The key of the vector field expression.
Example:
# First create a coordinate system
create_coordinate_system("R")
# Create a vector field F = (y, -x, 0)
vector_field = create_vector_field("R", "R_y", "-R_x", "0")
# Calculate curl
curl_result = calculate_curl(vector_field)
# Returns (0, 0, -2)
Returns:
A key for the curl expression.
Inputs: vector_field_key (required).
calculate_divergenceA
Calculates the divergence of a vector field using SymPy's divergence function.
Args:
vector_field_key: The key of the vector field expression.
Example:
# First create a coordinate system
create_coordinate_system("R")
# Create a vector field F = (x, y, z)
vector_field = create_vector_field("R", "R_x", "R_y", "R_z")
# Calculate divergence
div_result = calculate_divergence(vector_field)
# Returns 3
Returns:
A key for the divergence expression.
Inputs: vector_field_key (required).
calculate_gradientA
Calculates the gradient of a scalar field using SymPy's gradient function.
Args:
scalar_field_key: The key of the scalar field expression.
Example:
# First create a coordinate system
create_coordinate_system("R")
# Create a scalar field f = x^2 + y^2 + z^2
scalar_field = introduce_expression("R_x**2 + R_y**2 + R_z**2")
# Calculate gradient
grad_result = calculate_gradient(scalar_field)
# Returns (2x, 2y, 2z)
Returns:
A key for the gradient vector field expression.
Inputs: scalar_field_key (required).
calculate_tensorC
Calculates a tensor from a metric using einsteinpy.symbolic.
Inputs: metric_key (required), tensor_type (required), simplify_result.
convert_to_unitsA
Converts a quantity to the given target units using sympy.physics.units.convert_to.
Args:
expr_key: The key of the expression (previously introduced) to convert.
target_units: List of unit names as strings (e.g., ["meter", "1/second"]).
unit_system: Optional unit system (from UnitSystem enum). Defaults to SI.
The following units are available by default:
SI base units: meter, second, kilogram, ampere, kelvin, mole, candela
Length: kilometer, millimeter
Mass: gram
Energy: joule
Force: newton
Pressure: pascal
Power: watt
Electric: coulomb, volt, ohm, farad, henry
Constants: speed_of_light, gravitational_constant, planck
IMPORTANT: For compound units like meter/second, you must separate the numerator and
denominator into separate units in the list. For example:
- For meter/second: use ["meter", "1/second"]
- For newton*meter: use ["newton", "meter"]
- For kilogram*meter²/second²: use ["kilogram", "meter**2", "1/second**2"]
Example:
# Convert speed of light to kilometers per hour
expr_key = introduce_expression("speed_of_light")
result = convert_to_units(expr_key, ["kilometer", "1/hour"])
# Returns approximately 1.08e9 kilometer/hour
# Convert gravitational constant to CGS units
expr_key = introduce_expression("gravitational_constant")
result = convert_to_units(expr_key, ["centimeter**3", "1/gram", "1/second**2"], UnitSystem.CGS)
SI prefixes (femto, pico, nano, micro, milli, centi, deci, deca, hecto, kilo, mega, giga, tera)
can be used directly with base units.
Returns:
A key for the converted expression, or an error message.
Inputs: expr_key (required), target_units (required), unit_system.
create_coordinate_systemA
Creates a 3D coordinate system for vector calculus operations.
Args:
name: The name for the coordinate system.
coord_names: Optional list of coordinate names (3 names for x, y, z).
If not provided, defaults to [name+'_x', name+'_y', name+'_z'].
Example:
# Create a coordinate system
coord_sys = create_coordinate_system("R")
# Creates a coordinate system R with coordinates R_x, R_y, R_z
# Create a coordinate system with custom coordinate names
coord_sys = create_coordinate_system("C", ["rho", "phi", "z"])
Returns:
The name of the created coordinate system.
Inputs: name (required), coord_names.
create_custom_metricC
Creates a custom metric tensor from provided components and symbols.
Inputs: components (required), symbols (required), config.
create_matrixB
Creates a SymPy matrix from the provided data.
Args:
matrix_data: A list of lists representing the rows and columns of the matrix.
Each element can be a number or a string expression.
matrix_var_name: Optional name for storing the matrix. If not provided, a
sequential name will be generated.
Example:
# Create a 2x2 matrix with numeric values
matrix_key = create_matrix([[1, 2], [3, 4]], "M")
# Create a matrix with symbolic expressions (assuming x, y are defined)
matrix_key = create_matrix([["x", "y"], ["x*y", "x+y"]])
Returns:
A key for the stored matrix.
Inputs: matrix_data (required), matrix_var_name.
create_predefined_metricC
Creates a predefined spacetime metric.
Inputs: metric_name (required).
create_vector_fieldA
Creates a vector field in the specified coordinate system.
Args:
coord_sys_name: The name of the coordinate system to use.
component_x: String expression for the x-component of the vector field.
component_y: String expression for the y-component of the vector field.
component_z: String expression for the z-component of the vector field.
Example:
# First create a coordinate system
create_coordinate_system("R")
# Create a vector field F = (y, -x, z)
vector_field = create_vector_field("R", "R_y", "-R_x", "R_z")
Returns:
A key for the vector field expression.
Inputs: component_x (required), component_y (required), component_z (required), coord_sys_name (required).
differentiate_expressionA
Differentiates an expression with respect to a variable using SymPy's diff function.
Args:
expr_key: The key of the expression (previously introduced) to differentiate.
var_name: The name of the variable to differentiate with respect to.
order: The order of differentiation (default is 1 for first derivative).
Example:
# Introduce a variable
intro("x", [Assumption.REAL], [])
# Create an expression to differentiate: x^3
expr_key = introduce_expression("x**3")
# First derivative
first_deriv = differentiate_expression(expr_key, "x")
# Returns 3x²
# Second derivative
second_deriv = differentiate_expression(expr_key, "x", 2)
# Returns 6x
Returns:
A key for the differentiated expression.
Inputs: expr_key (required), var_name (required), order.
dsolve_odeA
Solves an ordinary differential equation using SymPy's dsolve function.
Args:
expr_key: The key of the expression (previously introduced) containing the differential equation.
func_name: The name of the function (previously introduced) to solve for.
hint: Optional solving method from ODEHint enum. If None, SymPy will try to determine the best method.
Example:
# First introduce a variable and a function
intro("x", [Assumption.REAL], [])
introduce_function("f")
# Create a second-order ODE: f''(x) + 9*f(x) = 0
expr_key = introduce_expression("Derivative(f(x), x, x) + 9*f(x)")
# Solve the ODE
result = dsolve_ode(expr_key, "f")
# Returns solution with sin(3*x) and cos(3*x) terms
Returns:
A LaTeX string representing the solution. Returns an error message string if issues occur.
Inputs: expr_key (required), func_name (required), hint.
integrate_expressionA
Integrates an expression with respect to a variable using SymPy's integrate function.
Args:
expr_key: The key of the expression (previously introduced) to integrate.
var_name: The name of the variable to integrate with respect to.
lower_bound: Optional lower bound for definite integration.
upper_bound: Optional upper bound for definite integration.
Example:
# Introduce a variable
intro("x", [Assumption.REAL], [])
# Create an expression to integrate: x^2
expr_key = introduce_expression("x**2")
# Indefinite integration
indefinite_result = integrate_expression(expr_key, "x")
# Returns x³/3
# Definite integration from 0 to 1
definite_result = integrate_expression(expr_key, "x", "0", "1")
# Returns 1/3
Returns:
A key for the integrated expression.
Inputs: expr_key (required), var_name (required), lower_bound, upper_bound.
introC
Introduces a sympy variable with specified assumptions and stores it.
Takes a variable name and a list of positive and negative assumptions.
Inputs: neg_assumptions (required), pos_assumptions (required), var_name (required).
introduce_expressionA
Parses a sympy expression string using available local variables and stores it. Assigns it to either a temporary name (expr_0, expr_1, etc.) or a user-specified global name.
Uses Sympy parse_expr to parse the expression string.
Applies default Sympy canonicalization rules unless canonicalize is False.
For equations (x^2 = 1) make the input string "Eq(x^2, 1") not "x^2 == 1"
Examples:
{expr_str: "Eq(x^2 + y^2, 1)"}
{expr_str: "Matrix(((25, 15, -5), (15, 18, 0), (-5, 0, 11)))"}
{expr_str: "pi+e", "expr_var_name": "z"}
Inputs: expr_str (required), canonicalize, expr_var_name.
introduce_functionB
Introduces a SymPy function variable and stores it.
Takes a function name and creates a SymPy Function object for use in defining differential equations.
Example:
{func_name: "f"} will create the function f(x), f(t), etc. that can be used in expressions
Returns:
The name of the created function.
Inputs: func_name (required).
intro_manyA
Introduces multiple sympy variables with specified assumptions and stores them.
Takes a list of VariableDefinition objects for the 'variables' parameter.
Each object in the list specifies:
- var_name: The name of the variable (string).
- pos_assumptions: A list of positive assumption strings (e.g., ["real", "positive"]).
- neg_assumptions: A list of negative assumption strings (e.g., ["complex"]).
The JSON payload for the 'variables' argument should be a direct list of these objects, for example:
```json
[
{
"var_name": "x",
"pos_assumptions": ["real", "positive"],
"neg_assumptions": ["complex"]
},
{
"var_name": "y",
"pos_assumptions": [],
"neg_assumptions": ["commutative"]
}
]
```
The assumptions must be consistent, so a real number is not allowed to be non-commutative.
Prefer this over intro() for multiple variables because it's more efficient.
Inputs: variables (required).
matrix_determinantA
Calculates the determinant of a matrix using SymPy's det method.
Args:
matrix_key: The key of the matrix to calculate the determinant for.
Example:
# Create a matrix
matrix_key = create_matrix([[1, 2], [3, 4]])
# Calculate its determinant
det_key = matrix_determinant(matrix_key)
# Results in -2
Returns:
A key for the determinant expression.
Inputs: matrix_key (required).
matrix_eigenvaluesB
Calculates the eigenvalues of a matrix using SymPy's eigenvals method.
Args:
matrix_key: The key of the matrix to calculate eigenvalues for.
Example:
# Create a matrix
matrix_key = create_matrix([[1, 2], [2, 1]])
# Calculate its eigenvalues
evals_key = matrix_eigenvalues(matrix_key)
Returns:
A key for the eigenvalues expression (usually a dictionary mapping eigenvalues to their multiplicities).
Inputs: matrix_key (required).
matrix_eigenvectorsA
Calculates the eigenvectors of a matrix using SymPy's eigenvects method.
Args:
matrix_key: The key of the matrix to calculate eigenvectors for.
Example:
# Create a matrix
matrix_key = create_matrix([[1, 2], [2, 1]])
# Calculate its eigenvectors
evecs_key = matrix_eigenvectors(matrix_key)
Returns:
A key for the eigenvectors expression (usually a list of tuples (eigenvalue, multiplicity, [eigenvectors])).
Inputs: matrix_key (required).
matrix_inverseA
Calculates the inverse of a matrix using SymPy's inv method.
Args:
matrix_key: The key of the matrix to invert.
Example:
# Create a matrix
matrix_key = create_matrix([[1, 2], [3, 4]])
# Calculate its inverse
inv_key = matrix_inverse(matrix_key)
Returns:
A key for the inverted matrix.
Inputs: matrix_key (required).
pdsolve_pdeA
Solves a partial differential equation using SymPy's pdsolve function.
Args:
expr_key: The key of the expression (previously introduced) containing the PDE.
If the expression is not an equation (Eq), it will be interpreted as
PDE = 0.
func_name: The name of the function (previously introduced) to solve for.
This should be a function of multiple variables.
Example:
# First introduce variables and a function
intro("x", [Assumption.REAL], [])
intro("y", [Assumption.REAL], [])
introduce_function("f")
# Create a PDE: 1 + 2*(ux/u) + 3*(uy/u) = 0
expr_key = introduce_expression(
"Eq(1 + 2*Derivative(f(x, y), x)/f(x, y) + 3*Derivative(f(x, y), y)/f(x, y), 0)"
)
# Solve the PDE
result = pdsolve_pde(expr_key, "f")
# Returns solution with exponential terms and arbitrary function
Returns:
A LaTeX string representing the solution. Returns an error message string if issues occur.
Inputs: expr_key (required), func_name (required), hint.
print_latex_expressionC
Prints a stored expression in LaTeX format, along with variable assumptions.
Inputs: expr_key (required).
print_latex_tensorC
Prints a stored tensor expression in LaTeX format.
Inputs: tensor_key (required).
quantity_simplify_unitsA
Simplifies a quantity with units using sympy's built-in simplify method for Quantity objects.
Args:
expr_key: The key of the expression (previously introduced) to simplify.
unit_system: Optional unit system (from UnitSystem enum). Not used with direct simplify method.
The following units are available by default:
SI base units: meter, second, kilogram, ampere, kelvin, mole, candela
Length: kilometer, millimeter
Mass: gram
Energy: joule
Force: newton
Pressure: pascal
Power: watt
Electric: coulomb, volt, ohm, farad, henry
Constants: speed_of_light, gravitational_constant, planck
Example:
# Simplify force expressed in base units
expr_key = introduce_expression("kilogram*meter/second**2")
result = quantity_simplify_units(expr_key)
# Returns newton (as N = kg·m/s²)
# Simplify a complex expression with mixed units
expr_key = introduce_expression("joule/(kilogram*meter**2/second**2)")
result = quantity_simplify_units(expr_key)
# Returns a dimensionless quantity (1)
# Simplify electrical power expression
expr_key = introduce_expression("volt*ampere")
result = quantity_simplify_units(expr_key)
# Returns watt
Example with Speed of Light:
# Introduce the speed of light
c_key = introduce_expression("speed_of_light")
# Convert to kilometers per hour
km_per_hour_key = convert_to_units(c_key, ["kilometer", "1/hour"])
# Simplify to get the numerical value
simplified_key = quantity_simplify_units(km_per_hour_key)
# Print the result
print_latex_expression(simplified_key)
# Shows the numeric value of speed of light in km/h
Returns:
A key for the simplified expression, or an error message.
Inputs: expr_key (required), unit_system.
reset_stateA
Resets the state of the SymPy MCP server.
Clears all stored variables, functions, expressions, metrics, tensors,
coordinate systems, and resets the expression counter.
Then reinitializes unit variables.
Runs after all tool calls for a given computation are done to reset the state for the next computation.
Returns:
A message confirming the reset.
Inputs: no named parameters.
search_predefined_metricsC
Searches for predefined metrics in einsteinpy.symbolic.predefined.
Inputs: query (required).
simplify_expressionA
Simplifies a mathematical expression using SymPy's simplify function.
Args:
expr_key: The key of the expression (previously introduced) to simplify.
Example:
# Introduce variables
intro("x", [Assumption.REAL], [])
intro("y", [Assumption.REAL], [])
# Create an expression to simplify: sin(x)^2 + cos(x)^2
expr_key = introduce_expression("sin(x)**2 + cos(x)**2")
# Simplify the expression
simplified = simplify_expression(expr_key)
# Returns 1
Returns:
A key for the simplified expression.
Inputs: expr_key (required).
solve_algebraicallyA
Solves an equation (expression = 0) algebraically for a given variable.
Args:
expr_key: The key of the expression (previously introduced) to be solved.
solve_for_var_name: The name of the variable (previously introduced) to solve for.
domain: The domain to solve in: Domain.COMPLEX, Domain.REAL, Domain.INTEGERS, or Domain.NATURALS. Defaults to Domain.COMPLEX.
Returns:
A LaTeX string representing the set of solutions. Returns an error message string if issues occur.
Inputs: expr_key (required), solve_for_var_name (required), domain.
solve_linear_systemA
Solves a system of linear equations using SymPy's linsolve.
Args:
expr_keys: The keys of the expressions (previously introduced) forming the system.
var_names: The names of the variables to solve for.
domain: The domain to solve in (Domain.COMPLEX, Domain.REAL, etc.). Defaults to Domain.COMPLEX.
Returns:
A LaTeX string representing the solution set. Returns an error message string if issues occur.
Inputs: expr_keys (required), var_names (required), domain.
solve_nonlinear_systemA
Solves a system of nonlinear equations using SymPy's nonlinsolve.
Args:
expr_keys: The keys of the expressions (previously introduced) forming the system.
var_names: The names of the variables to solve for.
domain: The domain to solve in (Domain.COMPLEX, Domain.REAL, etc.). Defaults to Domain.COMPLEX.
Returns:
A LaTeX string representing the solution set. Returns an error message string if issues occur.
Inputs: expr_keys (required), var_names (required), domain.
substitute_expressionA
Substitutes a variable in an expression with another expression using SymPy's subs method.
Args:
expr_key: The key of the expression to perform substitution on.
var_name: The name of the variable to substitute.
replacement_expr_key: The key of the expression to substitute in place of the variable.
Example:
# Create variables x and y
intro("x", [], [])
intro("y", [], [])
# Create expressions
expr1 = introduce_expression("x**2 + y**2")
expr2 = introduce_expression("sin(x)")
# Substitute y with sin(x) in x^2 + y^2
result = substitute_expression(expr1, "y", expr2)
# Results in x^2 + sin^2(x)
Returns:
A key for the resulting expression after substitution.
Inputs: expr_key (required), replacement_expr_key (required), var_name (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 32 tools
Most tools have distinct purposes, such as calculate_curl for vector calculus, differentiate_expression for derivatives, and solve_algebraically for equation solving. However, there is some overlap between intro and intro_many (both introduce variables) and between the various solve_* tools (linear, nonlinear, algebraic), which could cause minor confusion. Descriptions help clarify, but the boundaries are not perfectly sharp.
The tool names follow a consistent verb_noun pattern throughout, such as calculate_curl, create_coordinate_system, and simplify_expression. Minor deviations include intro and intro_many (abbreviated verbs) and reset_state (verb_noun but less descriptive), but overall the naming is predictable and readable.
With 32 tools, the count feels heavy for a symbolic algebra server, bordering on excessive. While the domain is broad (covering calculus, linear algebra, differential equations, units, etc.), the set includes many specialized tools that might be overwhelming. A more streamlined set of 15-25 tools could improve coherence without losing functionality.
The tool surface is highly complete for symbolic algebra, covering core operations like differentiation, integration, equation solving (algebraic, linear, nonlinear, ODEs, PDEs), matrix operations (determinant, eigenvalues, inverse), vector calculus (gradient, divergence, curl), unit conversion, and expression manipulation (simplify, substitute). There are no obvious gaps; agents can perform complex workflows from variable introduction to solution output.
Maintenance
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
A Model Context Protocol server for Wix AI tools
Real-time planetary signal engine and Model Context Protocol (MCP) server for autonomous AI agents.
The Mercado Pago MCP Server implements the Model Context Protocol to provide AI agents and LLMs with access to Mercado Pago's APIs and tools within compatible development environments. It acts as an intermediary that translates Mercado Pago resources into executable functions (tools) that AI applications can invoke to perform actions and automate flows. The server simplifies integration, enables using documentation to implement or improve code, and optimizes operations through natural language interactions without manual implementations.
Related MCP Servers
- AlicenseCqualityDmaintenanceA Model Context Protocol server that enables LLMs to perform precise numerical calculations by evaluating mathematical expressions.16,075 PyPI161MIT
- AlicenseNot gradedqualityDmaintenanceProvides a suite of deterministic math tools powered by SymPy to handle algebra, calculus, linear algebra, and statistics via the Model Context Protocol. It enables smaller language models to delegate complex computations to a verified symbolic backend for accurate and reliable results.Apache 2.0
- AlicenseBqualityAmaintenanceA universal mathematics MCP server that gives LLM clients full access to SageMath for symbolic calculus, number theory, linear algebra, and more, with persistent state across tool calls.40129 PyPI22MIT
- AlicenseAqualityDmaintenanceA Model Context Protocol server that exposes 8 mathematical tools (arithmetic, algebra, calculus, matrix operations, statistics, probability, unit conversions) to any MCP-compatible AI agent, enabling mathematical computations without code.815 npm1MIT