Vibe Math
MCP ServerFreeA local/remote high-performance Model Context Protocol (MCP) server for math-ing whilst vibing with LLMs. Built with Polars, Pandas, NumPy, SciPy, and SymPy for optimal calculation speed and comprehensive mathematical capabilities from basic arithmetic to advanced calculus and linear algebra ## Loc
Capabilities16 decomposed
symbolic-and-numerical-calculus-evaluation
Medium confidenceEvaluates derivatives and integrals using SymPy's symbolic engine with fallback to numerical methods (SciPy). Supports both symbolic differentiation/integration for closed-form solutions and numerical approximation for complex functions. Automatically selects the optimal method based on expression complexity and user intent, returning step-by-step symbolic derivations or precise numerical results with configurable precision.
Dual-mode calculus engine combining SymPy's symbolic manipulation with SciPy's numerical robustness, automatically selecting symbolic derivation when tractable and falling back to adaptive numerical quadrature for integrals that resist closed-form solutions. Exposes both intermediate symbolic steps and final numerical results in a single call.
Provides symbolic-first approach with numerical fallback (unlike pure numerical libraries like NumPy), while maintaining performance through intelligent method selection rather than attempting all symbolic paths exhaustively.
matrix-operations-with-decomposition
Medium confidencePerforms matrix algebra operations (multiply, inverse, transpose, determinant, trace) and advanced decompositions (eigenvalue, SVD, QR, Cholesky, LU) using NumPy's BLAS/LAPACK bindings for computational efficiency. Handles both dense and sparse matrices, with automatic numerical stability checks and condition number reporting for ill-conditioned systems. Decompositions return both the factorized components and reconstruction verification.
Wraps NumPy/SciPy's LAPACK bindings with automatic numerical stability diagnostics (condition numbers, reconstruction errors) and returns both factorized components and verification metrics, enabling developers to assess solution reliability without manual conditioning checks.
Faster than pure Python implementations by leveraging optimized BLAS/LAPACK, and provides stability diagnostics that pure numerical libraries omit, making it suitable for production systems where numerical reliability matters.
pivot-table-creation-with-aggregation
Medium confidenceCreates pivot tables from data with configurable row/column grouping and aggregation functions (sum, mean, count, min, max, std). Uses Pandas' pivot_table function under the hood, automatically handling missing values and providing multiple aggregation strategies. Returns a 2D table with grouped data and computed aggregates, useful for summarizing and cross-tabulating data.
Wraps Pandas' pivot_table with configurable row/column grouping and multiple aggregation functions, automatically handling missing values and returning both the pivot table and metadata about grouping/aggregation choices.
More flexible than manual grouping and aggregation; faster than loop-based summarization through vectorized Pandas operations; supports multiple aggregations simultaneously.
unit-conversion-with-angle-support
Medium confidenceConverts between units (currently focused on angle conversions: degrees ↔ radians) using mathematical constants and conversion formulas. Supports bidirectional conversion with automatic detection of input unit and output unit specification. Extensible architecture allows adding additional unit types (temperature, distance, etc.) without modifying core logic.
Provides bidirectional angle conversion (degrees ↔ radians) with automatic unit detection and extensible architecture for adding additional unit types. Uses precise mathematical constants (math.pi) for accurate conversion.
Simpler and more focused than general-purpose unit conversion libraries; integrated into the MCP server for seamless use in mathematical workflows.
advanced-rounding-with-multiple-strategies
Medium confidenceProvides multiple rounding strategies (round to nearest, floor, ceiling, truncate) using NumPy's rounding functions. Supports rounding to arbitrary decimal places or significant figures, with configurable tie-breaking behavior (banker's rounding, round-half-up). Returns both the rounded value and metadata about the rounding operation.
Provides multiple rounding strategies (round, floor, ceil, truncate) with support for both decimal places and significant figures, using NumPy's optimized functions and returning metadata about the rounding operation.
More flexible than Python's built-in round() function by supporting multiple strategies and significant figures; faster than manual rounding through NumPy vectorization.
percentage-calculations-with-multiple-modes
Medium confidenceComputes percentage operations (percentage of a value, percentage increase/decrease, percentage change) using simple arithmetic with configurable output format (decimal, percentage string). Supports both forward calculations (what is 15% of 250?) and reverse calculations (250 is what percentage of 1000?). Returns both the numerical result and formatted percentage string.
Supports multiple percentage operation modes (of, increase, decrease, change) with configurable output formatting (decimal or percentage string), returning both numerical results and formatted strings for display.
More comprehensive than simple percentage formulas by supporting multiple operation types; includes formatting for display without requiring post-processing.
expression-evaluation-with-variable-substitution
Medium confidenceEvaluates mathematical expressions (e.g., 'x**2 + 3*x + 2') with variable substitution using SymPy's expression parser and NumPy for numerical evaluation. Supports both symbolic evaluation (returning expressions) and numerical evaluation (returning floats). Handles complex expressions with multiple variables, functions (sin, cos, exp, log), and constants (pi, e).
Combines SymPy's expression parsing with NumPy's numerical evaluation, supporting both symbolic and numerical modes. Handles variable substitution transparently and supports a wide range of mathematical functions and constants.
More flexible than hardcoded formulas by accepting arbitrary expressions; safer than eval() by using SymPy's parser instead of Python's eval(); supports both symbolic and numerical evaluation modes.
linear-system-solver-with-stability-diagnostics
Medium confidenceSolves systems of linear equations (Ax = b) using NumPy's linear algebra solvers (LAPACK-backed), with automatic selection between direct solvers (LU decomposition) and iterative solvers for large sparse systems. Provides numerical stability diagnostics (condition number, residual norm) to assess solution reliability. Handles both square and overdetermined systems (least-squares).
Wraps NumPy's LAPACK-backed solvers with automatic method selection (direct vs iterative) and provides numerical stability diagnostics (condition number, residual norm). Supports both square and overdetermined systems with least-squares solutions.
Faster than manual Gaussian elimination through LAPACK; includes stability diagnostics that pure solvers omit, enabling assessment of solution reliability. Automatic method selection optimizes for both speed and accuracy.
financial-time-value-calculations
Medium confidenceComputes present value (PV), future value (FV), payment (PMT), internal rate of return (IRR), and net present value (NPV) using iterative numerical solvers (Newton-Raphson for IRR) and closed-form formulas for standard financial instruments. Handles multiple compounding frequencies and cash flow schedules, with automatic solver convergence detection and fallback strategies for edge cases.
Combines closed-form financial formulas with iterative solvers (Newton-Raphson for IRR), automatically selecting the appropriate method based on input structure and providing convergence diagnostics. Handles multiple compounding frequencies natively without requiring manual formula adjustments.
More flexible than spreadsheet functions (supports irregular cash flows and provides solver diagnostics) while remaining faster than building custom financial models from scratch; includes automatic fallback strategies when standard solvers diverge.
batch-execution-with-dependency-resolution
Medium confidenceChains multiple calculations in a single MCP request using a directed acyclic graph (DAG) execution model with automatic dependency resolution and optional parallel execution. Supports referencing prior operation results via `$operation_id.result` syntax, with the engine resolving dependencies, executing independent operations concurrently, and returning a consolidated result set. Achieves 90-95% token reduction by eliminating round-trip overhead.
Implements a DAG-based batch execution engine that resolves dependencies automatically, executes independent operations in parallel, and enables result referencing via string syntax ($operation_id.result). This eliminates the need for multiple MCP round-trips while maintaining deterministic ordering and error handling.
Achieves 90-95% token reduction compared to sequential LLM calls by batching calculations server-side; unlike simple request batching, the DAG model enables complex workflows with cross-operation dependencies while maintaining parallelism where possible.
output-mode-controlled-response-verbosity
Medium confidenceProvides five configurable output modes (full, compact, minimal, value, final) on every tool that control response verbosity and token efficiency. The engine strips metadata, null fields, and structural information based on mode selection, enabling developers to optimize token usage for their specific use case. Modes range from full debugging output (0% reduction) to terminal-only results (95% reduction).
Implements a five-tier output verbosity system available on every tool, allowing callers to trade off between debugging context and token efficiency. The 'final' mode achieves 95% token reduction by returning only the terminal result, while 'full' mode preserves all metadata for debugging.
More granular than binary verbose/quiet flags; enables fine-grained token optimization without requiring post-processing or custom response parsing. Consistent across all tools, making it predictable for chained calculations.
statistical-analysis-with-outlier-detection
Medium confidenceComputes comprehensive statistical measures (mean, median, std, min, max, sum, quartiles) and detects outliers using IQR (interquartile range) or Z-score methods. Leverages NumPy and Pandas for efficient vectorized computation, with automatic handling of missing values and configurable outlier thresholds. Returns both summary statistics and detailed outlier identification with flagging.
Combines descriptive statistics (mean, median, quartiles) with automatic outlier detection using configurable methods (IQR or Z-score), returning both summary metrics and detailed outlier identification in a single call. Handles missing values transparently and provides distribution shape metadata.
More comprehensive than basic statistical functions by including outlier detection and distribution analysis; faster than manual outlier detection loops through vectorized NumPy/Pandas operations.
array-operations-with-element-wise-broadcasting
Medium confidencePerforms element-wise array operations (add, subtract, multiply, divide, power) using NumPy's broadcasting rules, enabling operations on arrays of different shapes without explicit reshaping. Automatically aligns dimensions according to NumPy broadcasting semantics, making it easy to combine scalars with arrays or arrays of different shapes. Returns results with shape and dtype metadata.
Leverages NumPy's broadcasting semantics to enable element-wise operations on arrays of different shapes without explicit reshaping, automatically aligning dimensions and returning shape/dtype metadata for result validation.
Faster than loop-based element-wise operations through vectorization; more intuitive than manual broadcasting by automating dimension alignment according to standard NumPy rules.
array-aggregation-with-weighted-operations
Medium confidenceComputes aggregations (sumproduct, weighted average, dot product) on arrays using NumPy's optimized routines. Supports weighted aggregations where each element contributes proportionally to a weight, enabling calculations like weighted averages, weighted sums, and dot products. Handles edge cases (zero weights, empty arrays) gracefully with configurable behavior.
Provides weighted aggregation operations (weighted average, sumproduct, dot product) using NumPy's optimized routines, with automatic handling of edge cases and optional weight normalization.
More efficient than manual loop-based weighted aggregations; handles edge cases (zero weights, empty arrays) transparently without requiring custom validation logic.
array-transformation-with-normalization-and-scaling
Medium confidenceTransforms arrays using normalization (min-max scaling to [0,1]), standardization (z-score to mean=0, std=1), log transformation, and custom scaling. Applies transformations element-wise or across specified axes, with automatic handling of edge cases (zero variance, negative values for log). Returns both transformed arrays and transformation parameters (min, max, mean, std) for inverse transformation.
Provides multiple transformation methods (normalization, standardization, log, custom scaling) with automatic edge case handling and returns transformation parameters for reproducible inverse transformation. Supports both global and axis-specific transformations.
More flexible than single-method scalers by supporting multiple transformation types; includes transformation parameters for reproducibility, unlike stateless scaling functions.
correlation-matrix-computation-with-multiple-methods
Medium confidenceComputes correlation matrices using Pearson (linear correlation), Spearman (rank-based correlation), or Kendall (tau) methods. Leverages SciPy's optimized implementations for efficient computation on large datasets, with automatic handling of missing values and NaN propagation. Returns correlation matrix with p-values for statistical significance testing.
Supports multiple correlation methods (Pearson, Spearman, Kendall) with automatic p-value computation for significance testing, leveraging SciPy's optimized implementations. Handles missing values transparently using pairwise deletion.
More comprehensive than basic correlation functions by supporting multiple methods and providing p-values; faster than manual correlation computation through vectorized SciPy operations.
Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.
Related Artifactssharing capabilities
Artifacts that share capabilities with Vibe Math, ranked by overlap. Discovered automatically through the match graph.
Excelmatic
AI-Powered Excel Data Analysis and Visualization, Skip the functions—just upload, chat, and watch your data turn into insights and...
MATLAB
Easiest and most productive software environment for engineers and...
Gigasheet
Transform big data with spreadsheet ease; no-code, AI-enhanced...
Excel
** - Excel manipulation including data reading/writing, worksheet management, formatting, charts, and pivot table
Rath by Kanarie
Transform data into insights: AI-powered analysis, visualization, Python integration,...
Google Sheets Advanced
Advanced MCP server for Google Sheets with 30 tools — charts (10 types), pivot tables, conditional formatting, data validation, server-side analytics, formulas, and cell formatting.
Best For
- ✓mathematicians and engineers needing symbolic verification
- ✓students learning calculus with step-by-step explanations
- ✓researchers computing derivatives for optimization problems
- ✓data scientists performing PCA or dimensionality reduction
- ✓engineers solving systems of linear equations
- ✓researchers analyzing matrix properties for numerical stability
- ✓ML practitioners needing matrix factorization for feature extraction
- ✓business analysts summarizing operational data
Known Limitations
- ⚠Symbolic integration may timeout on highly complex expressions requiring advanced techniques
- ⚠Numerical integration accuracy depends on function smoothness and singularity handling
- ⚠No support for multivariable calculus beyond single-variable derivatives and integrals
- ⚠Series expansions limited to Taylor/Laurent series around specified points
- ⚠Dense matrix operations scale as O(n³) for n×n matrices; very large matrices (>10k×10k) require sparse matrix handling
- ⚠Eigenvalue computation for non-symmetric matrices may return complex eigenvalues; numerical precision depends on matrix conditioning
Requirements
Input / Output
UnfragileRank
UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.
Repository Details
About
A local/remote high-performance Model Context Protocol (MCP) server for math-ing whilst vibing with LLMs. Built with Polars, Pandas, NumPy, SciPy, and SymPy for optimal calculation speed and comprehensive mathematical capabilities from basic arithmetic to advanced calculus and linear algebra ## Local Installation ### IDEs [](vscode:mcp/install?%7B%22name%22%3A%22Math%22%2C%22type%22%3A%22stdio%22%2C%22command%22%3A%22uvx%22%2C%22args%22%3A%5B%22vibe-math-mcp%22%5D%7D) [](https://cursor.com/en-US/install-mcp?name=Math&config=eyJjb21tYW5kIjoidXZ4IHZpYmUtbWF0aC1tY3AifQ%3D%3D) ### Claude Desktop Open **Settings > Developer > Edit Config** and add: **For published package:** ```json { "mcpServers": { "Math": { "command": "uvx", "args": ["vibe-math-mcp"] } } } ``` ### Claude Code **Quick setup (CLI):** Published package: ```bash claude mcp add --transport stdio math -- uvx vibe-math-mcp ``` **Team setup** (create `mcp.json` in project root for shared use with Claude Code and/or IDEs) ```json { "mcpServers": { "math": { "command": "uvx", "args": ["vibe-math-mcp"] } } } ``` **Verify:** Run `claude mcp list` or use `/mcp` or view available servers in IDEs. ### Try it - "Calculate 15% of 250" → uses `percentage` - "Find determinant of [[1,2],[3,4]]" → uses `matrix_operations` - "Integrate x^2 from 0 to 1" → uses `integral` - "If I invest $1000 at 5% annual interest compounded monthly for 10 years, what will be the future value?" → uses `compound_interest` - If I was paid the square root of $69m in 10 years, what's the present value at 7% discount rate? → uses `batch_execute (calculate -> financial_calcs)` ## Output Control All tools automatically support output control for maximum flexibility and token efficiency. The LLM can specify the desired verbosity. Control response verbosity using the `output_mode` parameter (available on **every tool**): | Mode | Description | Token Savings | Use Case | | --------- | -------------------------------------------------- | ------------- | ------------------------------------------- | | `full` | Complete response with all metadata (default) | 0% (baseline) | Debugging, full context needed | | `compact` | Remove null fields, minimize whitespace | ~20-30% | Moderate reduction, preserve structure | | `minimal` | Primary value(s) only, strip metadata | ~60-70% | Fast extraction, minimal context | | `value` | Normalized `{value: X}` structure | ~70-80% | Consistent chaining, maximum simplicity | | `final` | For sequential chains, return only terminal result | ~95% | Simple calculations, predictable extraction | ## Batch Execution For multi-step workflows, `batch_execute` chains multiple calculations in a single request—**achieving 90-95% token reduction**. Reference prior outputs using `$operation_id.result` syntax, and the engine automatically handles dependency resolution and parallel execution for speed. **Perfect for:** Bond pricing, financial models, statistical pipelines, complex transformations ## Complete Tool Reference **Note:** All tool parameters include detailed descriptions with concrete examples directly in the MCP interface. Each parameter shows expected format, use cases, and sample values to make usage obvious without referring to external documentation. ### Basic Calculations | Tool | Description | | --------------- | ------------------------------------------------------------ | | `calculate` | Evaluate mathematical expressions with variable substitution | | `percentage` | Percentage calculations (of, increase, decrease, change) | | `round` | Advanced rounding (round, floor, ceil, trunc) | | `convert_units` | Unit conversions (degrees � radians) | ### Array Operations | Tool | Description | | ------------------ | ---------------------------------------------------------------- | | `array_operations` | Element-wise operations (add, subtract, multiply, divide, power) | | `array_statistics` | Statistical measures (mean, median, std, min, max, sum) | | `array_aggregate` | Aggregations (sumproduct, weighted average, dot product) | | `array_transform` | Transformations (normalise, standardise, scale, log) | ### Statistics | Tool | Description | | ------------- | ------------------------------------------------------ | | `statistics` | Comprehensive analysis (describe, quartiles, outliers) | | `pivot_table` | Create pivot tables with aggregation | | `correlation` | Correlation matrices (Pearson, Spearman) | ### Financial Mathematics | Tool | Description | | ------------------- | ------------------------------------------- | | `financial_calcs` | Time value of money (PV, FV, PMT, IRR, NPV) | | `compound_interest` | Compound interest with various frequencies | ### Linear Algebra | Tool | Description | | ---------------------- | -------------------------------------------------------------------- | | `matrix_operations` | Matrix operations (multiply, inverse, transpose, determinant, trace) | | `solve_linear_system` | Solve Ax = b systems | | `matrix_decomposition` | Decompositions (eigen, SVD, QR, Cholesky, LU) | ### Calculus | Tool | Description | | --------------- | -------------------------------------- | | `derivative` | Symbolic and numerical differentiation | | `integral` | Symbolic and numerical integration | | `limits_series` | Limits and series expansions |
Categories
Alternatives to Vibe Math
Search the Supabase docs for up-to-date guidance and troubleshoot errors quickly. Manage organizations, projects, databases, and Edge Functions, including migrations, SQL, logs, advisors, keys, and type generation, in one flow. Create and manage development branches to iterate safely, confirm costs
Compare →AI-optimized web search and content extraction via Tavily MCP.
Compare →Scrape websites and extract structured data via Firecrawl MCP.
Compare →Are you the builder of Vibe Math?
Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.
Get the weekly brief
New tools, rising stars, and what's actually worth your time. No spam.
Data Sources
Looking for something else?
Search →