Skip to main content
Glama

Symbolic Algebra MCP Server

by sdiehl

Symbolischer Algebra-MCP-Server

Sympy-MCP ist ein Model Context Protocol-Server, der es LLMs ermöglicht, symbolische Mathematik und Computeralgebra autonom auszuführen. Er stellt MCP-Clients zahlreiche Werkzeuge aus der Kernfunktionalität von SymPy zur Bearbeitung mathematischer Ausdrücke und Gleichungen zur Verfügung.

Warum?

Sprachmodelle sind bei der symbolischen Manipulation absolut miserabel. Sie täuschen Variablen vor, erfinden zufällige Konstanten, vertauschen Terme und verursachen im Allgemeinen ein Chaos. Wir verfügen jedoch über Computeralgebra-Systeme, die speziell für die symbolische Manipulation entwickelt wurden. Daher können wir Tool-Calling nutzen, um eine Abfolge von Transformationen zu orchestrieren, sodass der symbolische Kernel die ganze Arbeit übernimmt.

Sie können zwar durchaus einen LLM Mathematica- oder Python-Code generieren lassen, wenn Sie den LLM jedoch als Agent oder On-the-Fly-Rechner verwenden möchten, ist es besser, den MCP-Server zu verwenden und die symbolischen Tools direkt verfügbar zu machen.

Der Server stellt eine Teilmenge symbolischer Mathematikfunktionen bereit, darunter das Lösen algebraischer Gleichungen, Integration und Differenzierung, Vektorrechnung, Tensorrechnung für die allgemeine Relativitätstheorie sowie gewöhnliche und partielle Differentialgleichungen.

Sie können es beispielsweise in natürlicher Sprache bitten, eine Differentialgleichung zu lösen:

Lösen Sie den gedämpften harmonischen Oszillator mit dem Kraftterm: das Masse-Feder-Dämpfer-System, das durch die Differentialgleichung beschrieben wird, wobei m die Masse, c der Dämpfungskoeffizient, k die Federkonstante und F(t) eine externe Kraft ist.

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

Oder unter Einbeziehung der allgemeinen Relativitätstheorie:

Berechnen Sie die Spur des Ricci-Tensors $R_{\mu\nu}$ mithilfe der inversen Metrik $g^{\mu\nu}$ für die Anti-de-Sitter-Raumzeit, um seine konstante Skalarkrümmung $R$ zu bestimmen.

Verwendung

Sie benötigen zuerst UV .

  • Homebrew - brew install uv

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

Anschließend können Sie den Server mit den folgenden Befehlen installieren und ausführen:

# 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

Der Server sollte jetzt in der Claude Desktop-App verfügbar sein. Informationen zu anderen Clients finden Sie unten.

Wenn Sie eine vollständig eigenständige Version wünschen, die nur mit einem einzigen Befehl ausgeführt wird, können Sie Folgendes verwenden. Beachten Sie, dass hier beliebiger Code von Github ausgeführt wird. Seien Sie daher vorsichtig.

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

Wenn Sie Berechnungen zur allgemeinen Relativitätstheorie durchführen möchten, müssen Sie die Bibliothek einsteinpy installieren.

uv sync --group relativity

Verfügbare Tools

Der Sympy-MCP-Server bietet die folgenden Tools für symbolische Mathematik:

Werkzeug

Werkzeug-ID

Beschreibung

Variableneinführung

intro

Führt eine Variable mit festgelegten Annahmen ein und speichert sie

Mehrere Variablen

intro_many

Führt mehrere Variablen mit festgelegten Annahmen gleichzeitig ein

Ausdrucksparser

introduce_expression

Analysiert eine Ausdruckszeichenfolge unter Verwendung verfügbarer lokaler Variablen und speichert sie

LaTeX-Drucker

print_latex_expression

Druckt einen gespeicherten Ausdruck im LaTeX-Format zusammen mit variablen Annahmen

Algebraischer Löser

solve_algebraically

Löst eine Gleichung algebraisch für eine gegebene Variable über eine gegebene Domäne

Linearer Löser

solve_linear_system

Löst ein System linearer Gleichungen

Nichtlinearer Löser

solve_nonlinear_system

Löst ein System nichtlinearer Gleichungen

Funktionsvariable

introduce_function

Führt eine Funktionsvariable zur Verwendung in Differentialgleichungen ein

ODE-Löser

dsolve_ode

Löst eine gewöhnliche Differentialgleichung

PDE-Löser

pdsolve_pde

Löst eine partielle Differentialgleichung

Standardmetrisch

create_predefined_metric

Erstellt eine vordefinierte Raumzeitmetrik (zB Schwarzschild, Kerr, Minkowski)

Metriksuche

search_predefined_metrics

Durchsucht verfügbare vordefinierte Metriken

Tensor-Rechner

calculate_tensor

Berechnet Tensoren aus einer Metrik (Ricci-, Einstein-, Weyl-Tensoren)

Benutzerdefinierte Metrik

create_custom_metric

Erstellt einen benutzerdefinierten metrischen Tensor aus bereitgestellten Komponenten und Symbolen

Tensor LaTeX

print_latex_tensor

Druckt einen gespeicherten Tensorausdruck im LaTeX-Format

Vereinfacher

simplify_expression

Vereinfacht einen mathematischen Ausdruck mit der Canonicalize-Funktion von SymPy

Auswechslung

substitute_expression

Ersetzt eine Variable durch einen Ausdruck in einem anderen Ausdruck

Integration

integrate_expression

Integriert einen Ausdruck bezüglich einer Variablen

Differenzierung

differentiate_expression

Differenziert einen Ausdruck hinsichtlich einer Variable

Koordinaten

create_coordinate_system

Erstellt ein 3D-Koordinatensystem für Vektorrechnungsoperationen

Vektorfeld

create_vector_field

Erstellt ein Vektorfeld im angegebenen Koordinatensystem

Locken

calculate_curl

Berechnet die Rotation eines Vektorfeldes

Divergenz

calculate_divergence

Berechnet die Divergenz eines Vektorfeldes

Gradient

calculate_gradient

Berechnet den Gradienten eines Skalarfeldes

Einheitenrechner

convert_to_units

Konvertiert eine Menge in vorgegebene Zieleinheiten

Einheitenvereinfacher

quantity_simplify_units

Vereinfacht eine Menge mit Einheiten

Matrix-Ersteller

create_matrix

Erstellt eine SymPy-Matrix aus den bereitgestellten Daten

Bestimmend

matrix_determinant

Berechnet die Determinante einer Matrix

Matrixinverse

matrix_inverse

Berechnet die Inverse einer Matrix

Eigenwerte

matrix_eigenvalues

Berechnet die Eigenwerte einer Matrix

Eigenvektoren

matrix_eigenvectors

Berechnet die Eigenvektoren einer Matrix

Standardmäßig werden Variablen mit Annahmen vordefiniert (ähnlich wie die Funktion symbols() in SymPy). Sofern nicht anders angegeben, wird standardmäßig angenommen, dass eine Variable komplex, kommutativ oder ein Term über dem komplexen Körper $\mathbb{C}$ ist.

Eigentum

Wert

commutative

WAHR

complex

WAHR

finite

WAHR

infinite

FALSCH

Claude Desktop-Setup

Normalerweise fügt der Befehl mcp install den Server automatisch zur Datei claude_desktop_config.json hinzu. Andernfalls müssen Sie die Konfigurationsdatei suchen und Folgendes hinzufügen:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

  • Windows: %APPDATA%\Claude\claude_desktop_config.json

Fügen Sie dem mcpServers Objekt Folgendes hinzu und ersetzen Sie /ABSOLUTE_PATH_TO_SYMPY_MCP/server.py durch den absoluten Pfad zur Datei sympy-mcp server.py .

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

Fügen Sie in Ihrer ~/.cursor/mcp.json Folgendes hinzu, wobei ABSOLUTE_PATH_TO_SYMPY_MCP der Pfad zur Datei sympy-mcp server.py ist.

{ "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 und VS Code Insiders unterstützen jetzt MCPs im Agentenmodus . Für VS Code müssen Sie möglicherweise in den Einstellungen Chat > Agent: Enable aktivieren.

  1. Ein-Klick-Setup:

In VS Code installieren

In VS Code Insiders installieren

ODER fügen Sie die Konfiguration manuell zu Ihrer settings.json (global) hinzu:

{ "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" ] } } } }
  1. Klicken Sie über der Serverkonfiguration auf „Start“, öffnen Sie eine Python- oder Mathematikdatei, wechseln Sie im Chat in den Agentenmodus und probieren Sie Befehle wie „x^2 integrieren“ oder „x^2 = 1 lösen“ aus, um zu beginnen.

Cline-Setup

Für die Verwendung mit Cline müssen Sie den MCP-Server zunächst manuell mit den Befehlen im Abschnitt „Verwendung“ starten. Sobald der MCP-Server läuft, öffnen Sie Cline und wählen Sie oben „MCP-Server“ aus.

Wählen Sie dann „Remote-Server“ aus und fügen Sie Folgendes hinzu:

  • Servername: sympy-mcp

  • Server-URL: http://127.0.0.1:8081/sse

5ire-Einrichtung

Ein weiterer MCP-Client, der mehrere Modelle (o3, o4-mini, DeepSeek-R1 usw.) auf dem Backend unterstützt, ist 5ire.

Um die Einrichtung mit 5ire durchzuführen, öffnen Sie 5ire, gehen Sie zu Tools -> Neu und nehmen Sie die folgenden Konfigurationen vor:

  • Werkzeugschlüssel: sympy-mcp

  • Name: SymPy MCP

  • Befehl: /opt/homebrew/bin/uv run --with einsteinpy --with mcp[cli] --with pydantic --with sympy mcp run /ABSOLUTE_PATH_TO/server.py

Ersetzen Sie /ABSOLUTE_PATH_TO/server.py durch den tatsächlichen Pfad zu Ihrer Sympy-MCP-Datei server.py.

Ausführung im Container

Sie können den Server lokal mit Docker erstellen und ausführen:

# Build the Docker image docker build -t sympy-mcp . # Run the Docker container docker run -p 8081:8081 sympy-mcp

Alternativ können Sie das vorgefertigte Image aus dem GitHub Container Registry abrufen:

# Pull the latest image docker pull ghcr.io/sdiehl/sympy-mcp:latest # Run the container docker run -p 8081:8081 --rm ghcr.io/sdiehl/sympy-mcp:latest

Um Claude Desktop zum Starten des Docker-Containers zu konfigurieren, bearbeiten Sie Ihre Datei claude_desktop_config.json :

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

Oder verwenden Sie den vorgefertigten Container von GitHub:

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

Diese Konfiguration weist Claude Desktop an, den Docker-Container bei Bedarf zu starten. Stellen Sie sicher, dass Sie das Docker-Image ( docker build -t sympy-mcp . ) erstellt haben, bevor Sie Claude Desktop mit dieser Konfiguration verwenden.

Die anderen Installationsmethoden können auch für die Arbeit mit Docker angepasst werden, wenn Sie den UV-Befehl so ändern, dass stattdessen der Befehl „Docker Run“ verwendet wird.

Beispielinteraktion 1: Differentialgleichungen

Hier ist ein Beispiel, wie der Tool-Aufruf in einer Konversation mit einem KI-Assistenten über diesen MCP-Server funktioniert:

Benutzer : Lösen Sie den gedämpften harmonischen Oszillator mit dem Kraftterm: das Masse-Feder-Dämpfer-System, das durch die Differentialgleichung beschrieben wird, wobei m die Masse, c der Dämpfungskoeffizient, k die Federkonstante und F(t) eine externe Kraft ist.

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

Assistent : (Interner Toolaufruf) intro_many zum Einführen von Variablen:

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

Assistent : (Interner Tool-Aufruf) introduce_function , um x(t) zu definieren:

{ "func_name": "x" }

Assistent : (Interner Tool-Aufruf) introduce_expression zum Erstellen der Differentialgleichung:

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

Assistent : (Interner Tool-Aufruf) print_latex_expression , um die Gleichung übersichtlich anzuzeigen:

{ "expr_key": "expr_12" }

Ergebnis:

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

Assistent : (Interner Tool-Aufruf) introduce_function , um F(t) zu definieren:

{ "func_name": "F" }

Assistent : (Interner Toolaufruf) dsolve_ode zum Lösen der Differentialgleichung:

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

Ergebnis:

$$ x{\left(t \right)} = C_{1} e^{\frac{t \left(- c + \sqrt{c^{2} - 4 km}\right)}{2 m}} + C_{2} e^{- \frac{t \left(c + \sqrt{c^{2} - 4 km}\right)}{2 m}} + \cdots $$

Beispielinteraktion 2: Allgemeine Relativitätstheorie

Benutzer : Berechnen Sie die Spur des Ricci-Tensors $R_{\mu\nu}$ mithilfe der inversen Metrik $g^{\mu\nu}$ für die Anti-de-Sitter-Raumzeit, um seine konstante Skalarkrümmung $R$ zu bestimmen.

Assistent : (Interner Tool-Aufruf) create_predefined_metric zum Erstellen der Anti-de-Sitter-Metrik:

{ "metric_name": "AntiDeSitter" }

Assistent : (Interner Tool-Aufruf) calculate_tensor zur Berechnung des Ricci-Tensors:

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

Assistent : (Interner Tool-Aufruf) print_latex_tensor zum Anzeigen des Ricci-Tensors:

{ "tensor_key": "riccitensor_metric_AntiDeSitter" }

Ergebnis:

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

Assistent : (Interner Tool-Aufruf) calculate_tensor zur Berechnung des Ricci-Skalars:

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

Assistent : (Interner Tool-Aufruf) print_latex_tensor zum Anzeigen des Ricci-Skalars:

{ "tensor_key": "ricciscalar_metric_AntiDeSitter" }

Ergebnis:

$$ -12 $$

Sicherheitshinweis

Dieser Server läuft auf Ihrem Computer und ermöglicht dem Sprachmodell den Zugriff auf die Ausführung von Python-Logik. Er verwendet insbesondere Sympys parse_expr zum Parsen mathematischer Ausdrücke, wobei im Hintergrund eval verwendet wird, wodurch die Ausführung beliebigen Codes ermöglicht wird. Durch die Ausführung des Servers vertrauen Sie dem von Claude generierten Code. Die Ausführung im Docker-Image ist etwas sicherer, dennoch empfiehlt es sich, den Code vor der Ausführung zu überprüfen.

Lizenz

Copyright 2025 Stephen Diehl.

Dieses Projekt ist unter der Apache 2.0-Lizenz lizenziert. Weitere Informationen finden Sie in der Datei LICENSE .

Deploy Server
A
security – no known vulnerabilities
A
license - permissive license
A
quality - confirmed to work

remote-capable server

The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.

Ein Model Context Protocol-Server, der es LLMs ermöglicht, mithilfe der SymPy-Funktionalität zur Bearbeitung mathematischer Ausdrücke und Gleichungen autonom symbolische Mathematik und Computeralgebra durchzuführen.

  1. Warum?
    1. Verwendung
      1. Verfügbare Tools
        1. Claude Desktop-Setup
          1. Cursor-Setup
            1. VS Code-Setup
              1. Cline-Setup
                1. 5ire-Einrichtung
                  1. Ausführung im Container
                    1. Beispielinteraktion 1: Differentialgleichungen
                      1. Beispielinteraktion 2: Allgemeine Relativitätstheorie
                        1. Sicherheitshinweis
                          1. Lizenz

                            Related MCP Servers

                            • A
                              security
                              A
                              license
                              A
                              quality
                              A Model Context Protocol server that provides basic mathematical and statistical functions to LLMs, enabling them to perform accurate numerical calculations through a simple API.
                              Last updated -
                              13
                              11
                              39
                              MIT License
                            • A
                              security
                              A
                              license
                              A
                              quality
                              A Model Context Protocol server that enables LLMs to perform precise numerical calculations by evaluating mathematical expressions.
                              Last updated -
                              1
                              122
                              MIT License
                              • Linux
                              • Apple
                            • A
                              security
                              A
                              license
                              A
                              quality
                              A Model Context Protocol server that provides basic calculator functionality for LLMs, enabling them to perform mathematical operations like addition, subtraction, multiplication, division, modulo, and square root.
                              Last updated -
                              6
                              28
                              14
                              MIT License
                              • Linux
                            • A
                              security
                              F
                              license
                              A
                              quality
                              A simple server that provides basic mathematical operations (sum and subtraction) through the Model Context Protocol.
                              Last updated -
                              2
                              1

                            View all related MCP servers

                            MCP directory API

                            We provide all the information about MCP servers via our MCP API.

                            curl -X GET 'https://glama.ai/api/mcp/v1/servers/sdiehl/sympy-mcp'

                            If you have feedback or need assistance with the MCP directory API, please join our Discord server