Scientific Computing

Create and manage multi-dimensional tensor objects with support for initialization from lists, numpy arrays, or symbolic expressions. The MCP server exposes tensor construction via standardized tools that handle shape validation, dtype inference, and memory layout optimization. Tensors serve as the foundational data structure for all downstream linear algebra and calculus operations.

Perform QR decomposition, Singular Value Decomposition (SVD), and other matrix factorizations through MCP tools that return decomposed components and analysis metadata. The server wraps scipy.linalg and numpy.linalg functions, exposing decomposition results as structured outputs that include singular values, eigenvectors, and reconstruction information for validation.

Solve algebraic and transcendental equations symbolically using SymPy's equation solver, exposed as MCP tools that accept equations and variables, returning exact symbolic solutions or numerical approximations. The server supports systems of equations, polynomial equations, and transcendental equations with multiple solution branches.

Solve linear matrix equations (Ax = b, AXB = C) and Lyapunov/Sylvester equations using scipy.linalg solvers exposed as MCP tools. The server handles dense and sparse matrices, supports multiple right-hand sides, and returns solutions with condition number and residual information for numerical validation.

Expose all scientific computing capabilities through the Model Context Protocol (MCP) as standardized tools that Claude and other LLM clients can invoke. The MCP server implements tool schemas with input validation, error handling, and structured JSON responses, enabling seamless integration of scientific computing into LLM-augmented workflows without direct code execution.

Compute eigenvalues and eigenvectors for square matrices through MCP tools that return sorted eigenvalue spectra and corresponding eigenvector bases. The implementation uses numpy.linalg.eig and scipy eigensolvers, with optional sorting and filtering by magnitude or real/imaginary components, enabling spectral analysis of linear transformations.

Compute matrix determinants, traces, ranks, and condition numbers through MCP tools that return scalar properties and numerical stability metrics. The server wraps numpy.linalg functions to provide quick analysis of matrix invertibility, volume scaling factors, and numerical conditioning without full decomposition.

Compute vector projections, orthogonal complements, and orthonormal bases using Gram-Schmidt orthogonalization and projection formulas exposed as MCP tools. The server implements projection onto subspaces, orthogonal decomposition (v = v_parallel + v_perpendicular), and basis transformation, enabling geometric analysis of vector spaces.

Transform vectors and matrices between different coordinate bases using change-of-basis matrices computed from basis vectors. The MCP tools accept a vector/matrix and two bases (old and new), computing the transformation matrix and applying it to convert coordinates, enabling analysis in natural or convenient coordinate systems.

Compute gradients of scalar functions symbolically using SymPy's differentiation engine, exposed as MCP tools that accept symbolic expressions and return gradient vectors or Jacobian matrices. The server supports partial derivatives, directional derivatives, and automatic simplification of symbolic results for analytical insight.

Compute divergence, curl, and Laplacian operators on vector and scalar fields using symbolic differentiation via SymPy, exposed as MCP tools that accept field expressions and return operator results. The server supports 2D and 3D fields with automatic coordinate system handling and symbolic simplification.

Generate 2D and 3D visualizations of scalar functions and vector fields using matplotlib and numpy, exposed as MCP tools that produce plots saved as image files or returned as base64-encoded data. The server supports surface plots, contour plots, quiver plots for vector fields, and streamline visualizations with customizable styling.

Compute definite integrals of scalar functions using numerical quadrature methods (Simpson's rule, Gaussian quadrature) exposed as MCP tools. The server wraps scipy.integrate functions to provide adaptive integration with error estimation, supporting 1D and multi-dimensional integrals with customizable tolerance and method selection.