mathmethods-mcp 0.1.0__py3-none-any.whl

mathmethods/__init__.py

@@ -0,0 +1,7 @@
+"""MathematicalMethods MCP server.
+
+Exposes the vendored numerical-methods core as Model Context Protocol (MCP)
+tools for LLM agents.
+"""
+
+__version__ = "0.1.0"

mathmethods/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running the MCP server with ``python -m mathmethods``."""
+
+from mathmethods.server import run
+
+if __name__ == "__main__":
+    run()

mathmethods/compiler.py

@@ -0,0 +1,202 @@
+"""Hardened math expression validation for the MCP server.
+
+The vendored math core trusts the strings it receives. Since MCP tools are
+driven by an LLM (which can be tricked by prompt injection), this module adds
+defense in depth before any string reaches the math core:
+
+- Length cap (mitigates denial-of-service on pathological inputs)
+- Symbol whitelist (no undeclared variables)
+- Function whitelist (only standard math functions)
+- Notation normalization (``e^x`` -> ``E**x``, ``sen`` -> ``sin``, ``^`` -> ``**``)
+- Strict lexical check BEFORE parsing (this is what stops code execution)
+
+**Important:** SymPy's ``sympify`` evaluates strings with ``eval`` internally
+and, on some versions, allows attribute access and ``__import__`` (verified:
+``sympify("__import__('os').system('echo HACK')")`` executes the command).
+Therefore the lexical whitelist below runs FIRST and rejects any token that is
+not a number, an allowed variable/constant or an allowed function name, as well
+as any ``.`` or ``__``. Only after that gate is it safe to call ``sympify``.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Callable, Iterable, Sequence
+
+import sympy as sp
+
+MAX_EXPRESSION_LENGTH = 200
+
+# Reject integer literals with more than this many digits to keep sympify's
+# eager evaluation (e.g. factorial(99999999)) from exhausting memory.
+MAX_INTEGER_DIGITS = 6
+
+# SymPy canonical function names allowed inside expressions.
+ALLOWED_FUNCTIONS: frozenset[str] = frozenset(
+    {
+        # trigonometric
+        "sin", "cos", "tan", "cot", "sec", "csc",
+        "asin", "acos", "atan", "acot", "asec", "acsc", "atan2",
+        "sinh", "cosh", "tanh", "coth", "sech", "csch",
+        "asinh", "acosh", "atanh",
+        # exponential / logarithmic / roots
+        "exp", "log", "ln", "sqrt", "cbrt", "root",
+        # absolute value / sign / rounding
+        "Abs", "sign", "floor", "ceiling", "frac",
+        # gamma family
+        "gamma", "loggamma", "factorial", "binomial", "subfactorial",
+        # special functions
+        "erf", "erfc", "erfi",
+        "Min", "Max",
+    }
+)
+
+# Numeric constants always available regardless of the allowed symbol list.
+_BUILTIN_CONSTANTS = {"e": sp.E, "pi": sp.pi, "E": sp.E}
+
+_SINGLE_VAR = re.compile(r"(?<![A-Za-z0-9_])[eE]\^")
+# Unicode letters (incl. Greek symbols like α, β) start identifiers; digits
+# and leading underscores are rejected by the lexical gate.
+_IDENTIFIER_RE = re.compile(r"[^\W\d_]\w*", re.UNICODE)
+_NUMBER_RE = re.compile(r"(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?")
+_ALLOWED_PUNCTUATION = set("()+-,*/%<>!=:")
+
+# Logic keywords SymPy understands; harmless in expressions.
+_LOGIC_KEYWORDS = frozenset({"and", "or", "not"})
+
+
+def normalize(expr: str) -> str:
+    """Normalize common math notations to SymPy syntax.
+
+    Converts ``e^x`` / ``e^(-x)`` into ``E**x`` / ``E**(-x)`` (the old
+    ``exp(`` replacement left unbalanced parentheses), ``sen`` into ``sin``,
+    ``ln`` into ``log`` and every remaining ``^`` into ``**``.
+    """
+    out = expr.replace("sen", "sin")
+    out = out.replace("ln", "log")
+    out = _SINGLE_VAR.sub("E**", out)
+    out = out.replace("^", "**")
+    return out
+
+
+def _check_lexical(expr: str, allowed_identifiers: set[str]) -> None:
+    """Reject any token that is not a number, variable, constant or allowed
+    function, and any attribute access (``.`` / ``__``).
+
+    Runs *before* ``sympify`` so arbitrary Python code can never be evaluated.
+    """
+    allowed_words = (
+        allowed_identifiers
+        | set(ALLOWED_FUNCTIONS)
+        | set(_BUILTIN_CONSTANTS)
+        | _LOGIC_KEYWORDS
+    )
+
+    i, n = 0, len(expr)
+    while i < n:
+        ch = expr[i]
+        if ch.isspace():
+            i += 1
+            continue
+
+        number = _NUMBER_RE.match(expr, i)
+        if number:
+            text = number.group()
+            int_part = text.split(".")[0].split("e")[0].split("E")[0].lstrip("+-")
+            if len(int_part) > MAX_INTEGER_DIGITS:
+                raise ValueError(
+                    f"Integer literal too large ({len(int_part)} digits, max {MAX_INTEGER_DIGITS})."
+                )
+            i = number.end()
+            continue
+
+        ident = _IDENTIFIER_RE.match(expr, i)
+        if ident:
+            token = ident.group()
+            if token not in allowed_words:
+                raise ValueError(f"Unknown or forbidden token: {token}")
+            i = ident.end()
+            continue
+
+        if ch in _ALLOWED_PUNCTUATION:
+            i += 1
+            continue
+        if ch == ".":
+            raise ValueError("Attribute access is not allowed.")
+        if ch == "_":
+            raise ValueError("Underscore identifiers are not allowed.")
+        raise ValueError(f"Invalid character: {ch!r}")
+
+
+def validate(expr_str: str, variables: Sequence[str] = ("x",)) -> str:
+    """Validate a math expression string and return its normalized form.
+
+    Raises ``ValueError`` if the expression is too long, malformed, uses
+    forbidden functions or references symbols outside ``variables``.
+    """
+    if not expr_str or not expr_str.strip():
+        raise ValueError("Expression cannot be empty.")
+    if len(expr_str) > MAX_EXPRESSION_LENGTH:
+        raise ValueError(
+            f"Expression too long ({len(expr_str)} chars, max {MAX_EXPRESSION_LENGTH})."
+        )
+
+    normalized = normalize(expr_str)
+
+    _check_lexical(normalized, {str(name) for name in variables})
+
+    local_dict: dict[str, sp.Symbol] = {}
+    for name in variables:
+        local_dict[str(name)] = sp.Symbol(str(name), real=True)
+    local_dict.update(_BUILTIN_CONSTANTS)
+
+    try:
+        expr = sp.sympify(normalized, locals=local_dict)
+    except Exception as exc:  # SymPy raises a variety of parse errors
+        raise ValueError(f"Invalid math expression: {exc}") from exc
+
+    allowed_symbols = {str(name) for name in variables}
+    extra = {str(sym) for sym in expr.free_symbols} - allowed_symbols
+    if extra:
+        raise ValueError(f"Unknown symbol(s): {sorted(extra)}")
+
+    for fn in expr.atoms(sp.Function):
+        name = fn.func.__name__
+        if name not in ALLOWED_FUNCTIONS:
+            raise ValueError(f"Function not allowed: {name}")
+
+    return normalized
+
+
+def compile_callable(
+    expr_str: str,
+    variables: Sequence[str] = ("x",),
+    modules: Sequence[str] = ("numpy",),
+) -> Callable:
+    """Validate an expression and return a vectorized NumPy callable.
+
+    The returned callable accepts the variable(s) in the same order as
+    ``variables`` (a single callable for one variable, multiple positional
+    arguments for several variables).
+    """
+    normalized = validate(expr_str, variables)
+    symbols = [sp.Symbol(str(name), real=True) for name in variables]
+    local_dict = {str(name): sym for name, sym in zip(variables, symbols, strict=True)}
+    local_dict.update(_BUILTIN_CONSTANTS)
+    expr = sp.sympify(normalized, locals=local_dict)
+    return sp.lambdify(symbols, expr, modules=list(modules))
+
+
+def sanitize_and_check(
+    expr_str: str, variables: Iterable[str] = ("x",)
+) -> tuple[str, sp.Expr]:
+    """Return ``(normalized_str, parsed_expr)`` after validation.
+
+    Useful for tests and for callers that need the symbolic expression too.
+    """
+    normalized = validate(expr_str, list(variables))
+    symbols = [sp.Symbol(str(name), real=True) for name in variables]
+    local_dict = {str(name): sym for name, sym in zip(variables, symbols, strict=True)}
+    local_dict.update(_BUILTIN_CONSTANTS)
+    expr = sp.sympify(normalized, locals=local_dict)
+    return normalized, expr

mathmethods/core/__init__.py

@@ -0,0 +1,36 @@
+"""Vendored numerical-methods core.
+
+These modules are vendored from ``modeladoYsimulacion-web/backend/app/methods``
+so this MCP server is fully self-contained and publishable. Keep them in sync
+with the upstream repo when that code changes.
+"""
+
+from . import (
+    differentiation,
+    dynamic_1d,
+    dynamic_2d_conservative,
+    dynamic_2d_lanchester,
+    dynamic_2d_linear,
+    dynamic_2d_non_homogeneous,
+    dynamic_2d_nonlinear,
+    integration,
+    interpolation,
+    monte_carlo,
+    ode,
+    root_finding,
+)
+
+__all__ = [
+    "differentiation",
+    "dynamic_1d",
+    "dynamic_2d_conservative",
+    "dynamic_2d_lanchester",
+    "dynamic_2d_linear",
+    "dynamic_2d_non_homogeneous",
+    "dynamic_2d_nonlinear",
+    "integration",
+    "interpolation",
+    "monte_carlo",
+    "ode",
+    "root_finding",
+]

mathmethods/core/differentiation.py

@@ -0,0 +1,122 @@
+"""
+Derivación Numérica - Diferencias Finitas
+- Primera derivada
+- Segunda derivada
+"""
+import sympy as sp
+import warnings
+from typing import Dict
+from typing import Dict, Callable
+from .utils import safe_sympify
+
+class DifferentiationService:
+    
+    # --- TUS MÉTODOS ORIGINALES (INTACTOS POR COMPATIBILIDAD) ---
+    @staticmethod
+    def compilar_funcion(texto_funcion: str) -> Callable:
+        """Convierte string a función callable."""
+        try:
+            x = sp.Symbol('x')
+            expr = safe_sympify(texto_funcion, allowed_symbols=['x'])
+            return sp.lambdify(x, expr, 'numpy'), expr
+        except Exception as e:
+            raise ValueError(f"Error compilando función: {str(e)}")
+    
+    @staticmethod
+    def diferencias_finitas(f: Callable, x_val: float, h: float = 1e-5, precision: int = 8) -> Dict:
+        """Calcula primera y segunda derivada con diferencias centrales."""
+        f1_aprox = (f(x_val + h) - f(x_val - h)) / (2 * h)
+        f2_aprox = (f(x_val + h) - 2*f(x_val) + f(x_val - h)) / (h**2)
+        return {
+            "x": round(x_val, precision), "h": round(h, precision),
+            "primera_derivada": {"aproximada": round(f1_aprox, precision), "formula": "(f(x+h) - f(x-h)) / (2h)"},
+            "segunda_derivada": {"aproximada": round(f2_aprox, precision), "formula": "(f(x+h) - 2f(x) + f(x-h)) / h²"}
+        }
+    
+    @staticmethod
+    def diferencias_finitas_con_exacto(f_str: str, x_val: float, h: float = 1e-5, precision: int = 8) -> Dict:
+        """Calcula derivadas numéricas Y las compara con exactas."""
+        f, expr = DifferentiationService.compilar_funcion(f_str)
+        x = sp.Symbol('x')
+        df1_expr = sp.diff(expr, x)
+        df2_expr = sp.diff(df1_expr, x)
+        f1_exacta = float(df1_expr.subs(x, x_val).evalf())
+        f2_exacta = float(df2_expr.subs(x, x_val).evalf())
+        f1_aprox = (f(x_val + h) - f(x_val - h)) / (2 * h)
+        f2_aprox = (f(x_val + h) - 2*f(x_val) + f(x_val - h)) / (h**2)
+        # Aquí también deberíamos usar .evalf() si queremos máxima precisión, pero el problema
+        # estaba en el pre-redondeo que hacíamos para la nueva web.
+        error_1 = abs(f1_exacta - f1_aprox)
+        error_2 = abs(f2_exacta - f2_aprox)
+        return {
+            "x": round(x_val, precision), "h": round(h, precision),
+            "primera_derivada": {"numerica": round(f1_aprox, precision), "exacta": round(f1_exacta, precision), "error": round(error_1, 8), "formula_numerica": "(f(x+h) - f(x-h)) / (2h)"},
+            "segunda_derivada": {"numerica": round(f2_aprox, precision), "exacta": round(f2_exacta, precision), "error": round(error_2, 8), "formula_numerica": "(f(x+h) - 2f(x) + f(x-h)) / h²"}
+        }
+
+    # --- NUESTRO MÉTODO NUEVO UNIFICADO (ACTUALIZADO PARA FORMATOS) ---
+    @staticmethod
+    def calcular_diferencias_completas(func_str: str, x_val: float, h: float, precision: int = 8) -> Dict:
+        """Calcula diferencias Progresivas, Regresivas y Centrales enviando error crudo."""
+        try:
+            # Tratamiento especial para 'log' en SymPy (por defecto es ln)
+            # si el usuario escribe 'log10', SymPy lo manejará. 'ln' es el estándar.
+            
+            x_sym = sp.Symbol('x')
+            diccionario_local = {'e': sp.E, 'pi': sp.pi}
+            expr = safe_sympify(func_str, local_dict=diccionario_local, allowed_symbols=['x'])
+            f = sp.lambdify(x_sym, expr, 'numpy')
+            
+            dev_expr = sp.diff(expr, x_sym)
+            dev_exacta = float(dev_expr.subs(x_sym, x_val).evalf()) 
+            
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                fx = float(f(x_val))
+                fx_mas_h = float(f(x_val + h))
+                fx_menos_h = float(f(x_val - h))
+
+            progresiva = (fx_mas_h - fx) / h
+            regresiva = (fx - fx_menos_h) / h
+            central = (fx_mas_h - fx_menos_h) / (2 * h)
+            
+            dev2_expr = sp.diff(dev_expr, x_sym)
+            dev2_exacta = float(dev2_expr.subs(x_sym, x_val).evalf())
+            segunda_central = (fx_mas_h - 2*fx + fx_menos_h) / (h**2)
+
+            return {
+                "x_evaluado": round(x_val, precision),
+                "h_usado": h,
+                "f_x": round(fx, precision),
+                "derivada_exacta": round(dev_exacta, precision),
+                "segunda_derivada_exacta": round(dev2_exacta, precision),
+                "resultados": [
+                    {
+                        "metodo": "Diferencia Progresiva",
+                        "formula": "[f(x+h) - f(x)] / h",
+                        "valor": round(progresiva, precision),
+                        # CONEXIÓN: Enviamos el error crudo sin redondear
+                        "error_raw": abs(dev_exacta - progresiva)
+                    },
+                    {
+                        "metodo": "Diferencia Regresiva",
+                        "formula": "[f(x) - f(x-h)] / h",
+                        "valor": round(regresiva, precision),
+                        "error_raw": abs(dev_exacta - regresiva)
+                    },
+                    {
+                        "metodo": "Diferencia Central",
+                        "formula": "[f(x+h) - f(x-h)] / 2h",
+                        "valor": round(central, precision),
+                        "error_raw": abs(dev_exacta - central)
+                    },
+                    {
+                        "metodo": "Segunda Derivada (Central)",
+                        "formula": "[f(x+h) - 2f(x) + f(x-h)] / h²",
+                        "valor": round(segunda_central, precision),
+                        "error_raw": abs(dev2_exacta - segunda_central)
+                    }
+                ]
+            }
+        except Exception as e:
+            raise ValueError(f"Error evaluando la función: {str(e)}")