feat(sympy tools): accept string inputs, sympify internally; return JSON-serializable results

sympy/mcp_output/mcp_plugin/mcp_service.py

@@ -13,67 +13,117 @@ from sympy.solvers import solve, linsolve
 from sympy.integrals import integrate
 from sympy.polys import Poly, factor
 from sympy.functions import sin, cos, exp
+from sympy import sympify
 mcp = FastMCP("sympy_service")
 
-@mcp.tool
-def create_symbol(name):
-    """Create symbolic variable"""
-    return symbols(name)
-
-@mcp.tool
-def expand_expression(expr):
-    """Expand expression"""
-    return expand(expr)
-
-@mcp.tool
-def simplify_expression(expr):
-    """Simplify expression"""
-    return simplify(expr)
-
-@mcp.tool
-def solve_equation(equation, variable):
-    """Solve equation"""
-    return solve(equation, variable)
-
-@mcp.tool
-def solve_linear_system(system, variables):
-    """Solve linear system of equations"""
-    return linsolve(system, variables)
-
-@mcp.tool
-def differentiate(expr, variable):
-    """Differentiate"""
-    return diff(expr, variable)
-
-@mcp.tool
-def integrate_expression(expr, variable):
-    """Integrate"""
-    return integrate(expr, variable)
-
-@mcp.tool
-def create_polynomial(coeffs, variable):
-    """Create polynomial"""
-    return Poly(coeffs, variable)
-
-@mcp.tool
-def factor_polynomial(poly):
-    """Factor polynomial"""
-    return factor(poly)
-
-@mcp.tool
-def calculate_sin(angle):
-    """Calculate sine value"""
-    return sin(angle)
-
-@mcp.tool
-def calculate_cos(angle):
-    """Calculate cosine value"""
-    return cos(angle)
-
-@mcp.tool
-def calculate_exp(value):
-    """Calculate exponential value"""
-    return exp(value)
+def _ser(x):
+    if isinstance(x, Basic):
+        return str(x)
+    if isinstance(x, (list, tuple)):
+        return [_ser(i) for i in x]
+    if isinstance(x, set):
+        return [_ser(i) for i in x]
+    if isinstance(x, dict):
+        return {k: _ser(v) for k, v in x.items()}
+    return x
+
+@mcp.tool(name="create_symbol")
+def create_symbol(name: str):
+    try:
+        res = symbols(name)
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="expand_expression")
+def expand_expression(expr: str):
+    try:
+        res = expand(sympify(expr))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="simplify_expression")
+def simplify_expression(expr: str):
+    try:
+        res = simplify(sympify(expr))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="solve_equation")
+def solve_equation(equation: str, variable: str):
+    try:
+        res = solve(sympify(equation), symbols(variable))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="solve_linear_system")
+def solve_linear_system(system: list, variables: list):
+    try:
+        eqs = [sympify(e) for e in system]
+        vars_sym = [symbols(v) for v in variables]
+        res = linsolve(eqs, vars_sym)
+        return {"success": True, "result": _ser(list(res)), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="differentiate")
+def differentiate(expr: str, variable: str):
+    try:
+        res = diff(sympify(expr), symbols(variable))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="integrate_expression")
+def integrate_expression(expr: str, variable: str):
+    try:
+        res = integrate(sympify(expr), symbols(variable))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="create_polynomial")
+def create_polynomial(coeffs: list, variable: str):
+    try:
+        res = Poly(coeffs, symbols(variable))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="factor_polynomial")
+def factor_polynomial(poly: str):
+    try:
+        res = factor(sympify(poly))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="calculate_sin")
+def calculate_sin(angle: str):
+    try:
+        res = sin(sympify(angle))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="calculate_cos")
+def calculate_cos(angle: str):
+    try:
+        res = cos(sympify(angle))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}
+
+@mcp.tool(name="calculate_exp")
+def calculate_exp(value: str):
+    try:
+        res = exp(sympify(value))
+        return {"success": True, "result": _ser(res), "error": None}
+    except Exception as e:
+        return {"success": False, "result": None, "error": str(e)}