Symbolic Algebra MCP Server

Realizar matemáticas simbólicas y álgebra computacional utilizando la biblioteca SymPy.

Documentación

Symbolic Algebra MCP Server

Sympy-MCP es un servidor de Protocolo de Contexto de Modelo (MCP) que permite a los modelos de lenguaje realizar matemática simbólica y álgebra computacional de forma autónoma. Expone numerosas herramientas del núcleo de funcionalidades de SymPy a los clientes MCP para manipular expresiones matemáticas y ecuaciones.

¿Por qué?

Los modelos de lenguaje son absolutamente pésimos en la manipulación simbólica. Alucinan variables, inventan constantes aleatorias, permutan términos y, en general, hacen un desastre. Pero tenemos sistemas de álgebra computacional construidos específicamente para la manipulación simbólica, así que podemos usar la llamada a herramientas para orquestar una secuencia de transformaciones de modo que el núcleo simbólico haga todo el trabajo pesado.

Si bien ciertamente puedes hacer que un LLM genere código de Mathematica o Python, si quieres usar el LLM como agente o calculadora sobre la marcha, es una mejor experiencia usar el servidor MCP y exponer las herramientas simbólicas directamente.

El servidor expone un subconjunto de capacidades de matemática simbólica, incluyendo resolución de ecuaciones algebraicas, integración y diferenciación, cálculo vectorial, cálculo tensorial para relatividad general, y ecuaciones diferenciales tanto ordinarias como parciales.

Por ejemplo, puedes pedirle en lenguaje natural que resuelva una ecuación diferencial:

Resuelve el oscilador armónico amortiguado con término de forzamiento: el sistema masa-resorte-amortiguador descrito por la ecuación diferencial donde m es la masa, c es el coeficiente de amortiguamiento, k es la constante del resorte y F(t) es una fuerza externa.

$$ m\frac{d^2x}{dt^2} + c\frac{dx}{dt} + kx = F(t) $$

O relacionado con relatividad general:

Calcula la traza del tensor de Ricci $R_{\mu\nu}$ usando la métrica inversa $g^{\mu\nu}$ para el espacio-tiempo Anti-de Sitter para determinar su curvatura escalar constante $R$.

Uso

Necesitas uv primero.

Homebrew : brew install uv
Curl : curl -LsSf https://astral.sh/uv/install.sh | sh

Luego puedes instalar y ejecutar el servidor con los siguientes comandos:

# 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.py

Deberías ver el servidor disponible en la aplicación de Claude Desktop ahora. Para otros clientes, consulta abajo.

Si quieres una versión completamente independiente que se ejecute con un solo comando, puedes usar lo siguiente. Nota: esto ejecuta código arbitrario de Github, así que ten cuidado.

uv run --with https://github.com/sdiehl/sympy-mcp/releases/download/0.1/sympy_mcp-0.1.0-py3-none-any.whl python server.py

Si quieres hacer cálculos de relatividad general, necesitas instalar la biblioteca einsteinpy.

uv sync --group relativity

Herramientas Disponibles

El servidor sympy-mcp proporciona las siguientes herramientas para matemática simbólica:

Herramienta	ID de Herramienta	Descripción
Introducción de Variable	`intro`	Introduce una variable con supuestos especificados y la almacena
Múltiples Variables	`intro_many`	Introduce múltiples variables con supuestos especificados simultáneamente
Analizador de Expresiones	`introduce_expression`	Analiza una cadena de expresión usando variables locales disponibles y la almacena
Impresor LaTeX	`print_latex_expression`	Imprime una expresión almacenada en formato LaTeX, junto con los supuestos de variables
Solver Algebraico	`solve_algebraically`	Resuelve una ecuación algebraicamente para una variable dada sobre un dominio dado
Solver Lineal	`solve_linear_system`	Resuelve un sistema de ecuaciones lineales
Solver No Lineal	`solve_nonlinear_system`	Resuelve un sistema de ecuaciones no lineales
Variable de Función	`introduce_function`	Introduce una variable de función para usar en ecuaciones diferenciales
Solver de EDO	`dsolve_ode`	Resuelve una ecuación diferencial ordinaria
Solver de EDP	`pdsolve_pde`	Resuelve una ecuación diferencial parcial
Métrica Estándar	`create_predefined_metric`	Crea una métrica de espacio-tiempo predefinida (p. ej., Schwarzschild, Kerr, Minkowski)
Búsqueda de Métricas	`search_predefined_metrics`	Busca métricas predefinidas disponibles
Calculadora de Tensores	`calculate_tensor`	Calcula tensores a partir de una métrica (tensores de Ricci, Einstein, Weyl)
Métrica Personalizada	`create_custom_metric`	Crea un tensor métrico personalizado a partir de componentes y símbolos proporcionados
Tensor LaTeX	`print_latex_tensor`	Imprime una expresión tensorial almacenada en formato LaTeX
Simplificador	`simplify_expression`	Simplifica una expresión matemática usando la función de canonización de SymPy
Sustitución	`substitute_expression`	Sustituye una variable con una expresión en otra expresión
Integración	`integrate_expression`	Integra una expresión con respecto a una variable
Diferenciación	`differentiate_expression`	Diferencia una expresión con respecto a una variable
Coordenadas	`create_coordinate_system`	Crea un sistema de coordenadas 3D para operaciones de cálculo vectorial
Campo Vectorial	`create_vector_field`	Crea un campo vectorial en el sistema de coordenadas especificado
Rotacional	`calculate_curl`	Calcula el rotacional de un campo vectorial
Divergencia	`calculate_divergence`	Calcula la divergencia de un campo vectorial
Gradiente	`calculate_gradient`	Calcula el gradiente de un campo escalar
Conversor de Unidades	`convert_to_units`	Convierte una cantidad a las unidades objetivo dadas
Simplificador de Unidades	`quantity_simplify_units`	Simplifica una cantidad con unidades
Creador de Matrices	`create_matrix`	Crea una matriz de SymPy a partir de los datos proporcionados
Determinante	`matrix_determinant`	Calcula el determinante de una matriz
Inversa de Matriz	`matrix_inverse`	Calcula la inversa de una matriz
Valores Propios	`matrix_eigenvalues`	Calcula los valores propios de una matriz
Vectores Propios	`matrix_eigenvectors`	Calcula los vectores propios de una matriz

Por defecto, las variables están predefinidas con supuestos (similar a cómo funciona la función symbols() en SymPy). A menos que se especifique lo contrario, el supuesto predeterminado es que una variable es compleja, conmutativa, término sobre el campo complejo $\mathbb{C}$.

Propiedad	Valor
`commutative`	true
`complex`	true
`finite`	true
`infinite`	false

Configuración de Claude Desktop

Normalmente, el comando mcp install agregará automáticamente el servidor al archivo claude_desktop_config.json. Si no lo hace, necesitas encontrar el archivo de configuración y agregar lo siguiente:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%\Claude\claude_desktop_config.json

Agrega lo siguiente al objeto mcpServers, reemplazando /ABSOLUTE_PATH_TO_SYMPY_MCP/server.py con la ruta absoluta al archivo server.py de sympy-mcp.

{
  "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"
      ]
    }
  }
}

Configuración de Cursor

En tu ~/.cursor/mcp.json, agrega lo siguiente, donde ABSOLUTE_PATH_TO_SYMPY_MCP es la ruta al archivo server.py de sympy-mcp.

{
  "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"
      ]
    }
  }
}

Configuración de VS Code

VS Code y VS Code Insiders ahora admiten MCP en modo agente. Para VS Code, es posible que necesites habilitar Chat > Agent: Enable en la configuración.

Configuración con un clic:

O agrega manualmente la configuración a tu 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"
        ]
      }
    }
  }
}

Haz clic en "Iniciar" sobre el interruptor de configuración del servidor para cambiar al modo agente en el chat, y prueba comandos como "integra x^2" o "resuelve x^2 = 1" para comenzar.

Configuración de Cline

Para usar con Cline, necesitas ejecutar manualmente el servidor MCP primero usando los comandos en la sección "Uso". Una vez que el servidor MCP esté en ejecución, abre Cline y selecciona "Servidores MCP" en la parte superior.

Luego selecciona "Servidores Remotos" y agrega lo siguiente:

Nombre del Servidor: sympy-mcp
URL del Servidor: http://127.0.0.1:8081/sse

Configuración de 5ire

Otro cliente MCP que admite múltiples modelos (o3, o4-mini, DeepSeek-R1, etc.) en el backend es 5ire.

Para configurar con 5ire, abre 5ire y ve a Herramientas -> Nueva y establece las siguientes configuraciones:

Clave de Herramienta: sympy-mcp
Nombre: SymPy MCP
Comando: /opt/homebrew/bin/uv run --with einsteinpy --with mcp[cli] --with pydantic --with sympy mcp run /ABSOLUTE_PATH_TO/server.py

Reemplaza /ABSOLUTE_PATH_TO/server.py con la ruta real a tu archivo server.py de sympy-mcp.

Transporte HTTP (HTTP Transmisible / SSE)

El servidor admite MCP sobre HTTP usando el transporte HTTP transmisible introducido en la especificación MCP 2025-03-26. Esto reemplaza el transporte SSE heredado y expone un único endpoint /mcp al que los clientes se conectan a través de HTTP.

Este es el transporte recomendado cuando se ejecuta el servidor como un proceso independiente o en un contenedor, porque permite que cualquier cliente MCP con capacidad HTTP se conecte sin necesidad de lanzar el servidor como un subproceso.

# 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 9000

El indicador heredado --transport sse todavía se admite para compatibilidad hacia atrás.

También se expone un endpoint /healthcheck que ejecuta un recorrido completo del protocolo MCP (inicializar → herramientas/listar → cierre de sesión) y devuelve {"status": "ok", "tool_count": N}.

Ejecución en Contenedor

Puedes construir y ejecutar el servidor usando Docker localmente:

# Build the Docker image
docker build -t sympy-mcp .

# Run the Docker container
docker run -p 8081:8081 sympy-mcp

O usa Docker Compose desde el directorio docker/:

cd docker
docker compose up -d --build

Alternativamente, puedes extraer la imagen preconstruida del Registro de Contenedores de GitHub:

# 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:main

Para configurar Claude Desktop para lanzar el contenedor Docker, edita tu archivo claude_desktop_config.json:

{
  "mcpServers": {
    "sympy-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "-p",
        "8081:8081",
        "--rm",
        "sympy-mcp"
      ]
    }
  }
}

O para usar el contenedor preconstruido de GitHub:

{
  "mcpServers": {
    "sympy-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "-p",
        "8081:8081",
        "--rm",
        "ghcr.io/sdiehl/sympy-mcp:main"
      ]
    }
  }
}

Esta configuración le dice a Claude Desktop que lance el contenedor Docker cuando sea necesario. Asegúrate de construir la imagen Docker (docker build -t sympy-mcp .) antes de usar Claude Desktop con esta configuración.

Los otros métodos de instalación también se pueden adaptar para funcionar con Docker si cambias el comando uv para usar el comando docker run en su lugar.

Ejemplo de Interacción 1: Ecuaciones Diferenciales

Aquí hay un ejemplo de cómo funciona la llamada a herramientas en una conversación con un asistente de IA usando este servidor MCP:

Usuario: Resuelve el oscilador armónico amortiguado con término de forzamiento: el sistema masa-resorte-amortiguador descrito por la ecuación diferencial donde m es la masa, c es el coeficiente de amortiguamiento, k es la constante del resorte y F(t) es una fuerza externa.

$$ m\frac{d^2x}{dt^2} + c\frac{dx}{dt} + kx = F(t) $$

Asistente: (Llamada interna a herramienta) intro_many para introducir 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": []}
  ]
}

Asistente: (Llamada interna a herramienta) introduce_function para definir x(t):

{
  "func_name": "x"
}

Asistente: (Llamada interna a herramienta) introduce_expression para crear la ecuación diferencial:

{
  "expr_str": "Eq(m*Derivative(x(t), t, t) + c*Derivative(x(t), t) + k*x(t), F(t))"
}

Asistente: (Llamada interna a herramienta) print_latex_expression para mostrar la ecuación de forma ordenada:

{
  "expr_key": "expr_12"
}

Resultado:

$$ 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)} $$

Asistente: (Llamada interna a herramienta) introduce_function para definir F(t):

{
  "func_name": "F"
}

Asistente: (Llamada interna a herramienta) dsolve_ode para resolver la ecuación diferencial:

{
  "expr_key": "expr_12",
  "func_name": "x"
}

Resultado:

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

Ejemplo de Interacción 2: Relatividad General

Usuario: Calcula la traza del tensor de Ricci $R_{\mu\nu}$ usando la métrica inversa $g^{\mu\nu}$ para el espacio-tiempo Anti-de Sitter para determinar su curvatura escalar constante $R$.

Asistente: (Llamada interna a herramienta) create_predefined_metric para crear la métrica Anti-de Sitter:

{
  "metric_name": "AntiDeSitter"
}

Asistente: (Llamada interna a herramienta) calculate_tensor para calcular el tensor de Ricci:

{
  "metric_key": "metric_AntiDeSitter",
  "tensor_type": "RICCI_TENSOR",
  "simplify_result": true
}

Asistente: (Llamada interna a herramienta) print_latex_tensor para mostrar el tensor de Ricci:

{
  "tensor_key": "riccitensor_metric_AntiDeSitter"
}

Resultado:

$$ \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] $$

Asistente: (Llamada interna a herramienta) calculate_tensor para calcular el escalar de Ricci:

{
  "metric_key": "metric_AntiDeSitter",
  "tensor_type": "RICCI_SCALAR",
  "simplify_result": true
}

Asistente: (Llamada interna a herramienta) print_latex_tensor para mostrar el escalar de Ricci:

{
  "tensor_key": "ricciscalar_metric_AntiDeSitter"
}

Resultado:

$$ -12 $$

Ejemplo de Interacción 3: Sistema de EDO Acoplado (Dinámica de Fluidos)

Este ejemplo demuestra la resolución de un sistema acoplado de EDOs y la verificación de la solución contra un análisis algebraico de estado estacionario — una tarea donde los LLM típicamente alucinan sin un CAS que ancle cada paso.

Usuario:

Usa las herramientas de sympy-mcp para resolver esto simbólicamente — no calcules a mano.

Dos tanques cilíndricos están conectados por una tubería. El tanque 1 tiene un área de sección transversal A₁ = 2 m² y recibe un flujo constante de entrada Q = 0.5 m³/s. El agua drena del tanque 1 al tanque 2 a través de una tubería con un caudal proporcional a la diferencia de alturas: q₁₂ = k·(h₁ - h₂) donde k = 0.3 m²/s. El tanque 2 tiene un área de sección transversal A₂ = 1 m² y drena al exterior a una tasa q₂ = k·h₂ con la misma k.

Plantea y resuelve el sistema acoplado de EDOs para las alturas de agua h₁(t) y h₂(t), partiendo de tanques vacíos (h₁(0) = 0, h₂(0) = 0). Luego encuentra las alturas en estado estacionario cuando t → ∞ resolviendo algebraicamente las ecuaciones de equilibrio, y verifica que coinciden con la solución a largo plazo de las EDOs.

Asistente: (Cadena de herramientas interna)

intro_many — introduce t, k, A1, A2, Q con supuestos reales/positivos
introduce_function × 2 — introduce h1(t) y h2(t) como funciones desconocidas
introduce_expression × 2 — codifica las EDOs de balance de masa:

$$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 — sustituye los valores numéricos para k, A1, A2, Q
dsolve_ode × 2 — resuelve el sistema acoplado; aplica las condiciones iniciales mediante substitute_expression
introduce_expression × 2 — codifica las ecuaciones de equilibrio (derivadas igualadas a cero)
solve_linear_system — resuelve el sistema algebraico 2×2 para h1*, h2*
print_latex_expression — muestra tanto la solución en el dominio del tiempo como los valores de estado estacionario

Aviso de seguridad

Este servidor se ejecuta en tu computadora y le da al modelo de lenguaje acceso para ejecutar lógica de Python. En particular, utiliza el parse_expr de Sympy para analizar expresiones matemáticas, que a su vez usa eval internamente, lo que efectivamente permite la ejecución de código arbitrario. Al ejecutar el servidor, estás confiando en el código que Claude genera. Ejecutarlo en la imagen de Docker es un poco más seguro, pero aun así es una buena idea revisar el código antes de ejecutarlo.

Licencia

Este proyecto está licenciado bajo la Licencia Apache 2.0. Consulta el archivo LICENCIA para más detalles.