Symbolischer Algebra-MCP-Server

Integrations

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

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.

Oder unter Einbeziehung der allgemeinen Relativitätstheorie:

Berechnen Sie die Spur des Ricci-Tensors Loading... mithilfe der inversen Metrik Loading... für die Anti-de-Sitter-Raumzeit, um seine konstante Skalarkrümmung Loading... 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 Loading... 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.

Ein-Klick-Setup:

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

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.

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:

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:

Beispielinteraktion 2: Allgemeine Relativitätstheorie

Benutzer : Berechnen Sie die Spur des Ricci-Tensors Loading... mithilfe der inversen Metrik Loading... für die Anti-de-Sitter-Raumzeit, um seine konstante Skalarkrümmung Loading... 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:

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:

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

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

You must be authenticated.

security – no known vulnerabilities

license - permissive license

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.

Tools

View all tools

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.

Related Resources

Reddit Discussion about this server

Related MCP Servers

Math-MCP
EthanHenrickson
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
13
TypeScript
MIT License
Calculator MCP Server
githejie
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
48
Python
MIT License
Compiler Explorer MCP
torshepherd
-
security
F
license
-
quality
A Model Context Protocol server that connects LLMs to the Compiler Explorer API, enabling them to compile code, explore compiler features, and analyze optimizations across different compilers and languages.
Last updated -
Python
MCP Python Interpreter
yzfly
A
security
F
license
A
quality
A Model Context Protocol server that allows LLMs to interact with Python environments, execute code, and manage files within a specified working directory.
Last updated -
9
8
Python

View all related MCP servers

Symbolic Algebra MCP Server