Cruncher: The Scientific Calculator MCP Server

A powerful scientific calculator for your AI assistant, built as a Model Context Protocol (MCP) server. Cruncher allows compatible AI clients (like Claude Desktop) to perform complex mathematical calculations, handle memory, perform statistical analysis, and access scientific constants with a simple, secure, and standardized interface.

🌟 The Purity Promise (Zero Dependencies)

Cruncher is built as a highly educational, extremely lightweight tool. It accomplishes powerful features without pulling in any heavy external libraries (no mathjs, no zod, no @modelcontextprotocol/sdk). Everything is handled using native Node.js capabilities:

Safe Expression Evaluation: Instead of relying on mathjs or dangerous eval(), Cruncher uses new Function() guarded by a strict whitelist Regex that guarantees only numbers and math operators can pass.
Input Validation: Instead of heavy schema libraries like Zod, a custom recursive validation function rigidly enforces AI inputs against JSON Schemas directly.
Timeout Protection: Instead of complex process managers, it leverages Node.js worker_threads to spawn calculations. If an AI requests a multi-million loop factorial, the main thread easily terminates the worker after a strict timeout (default 3 seconds). This timeout is configurable via the CRUNCHER_TIMEOUT environment variable (in milliseconds), ensuring the server remains responsive even during heavy computational loads.
Floating-Point Accuracy: Instead of using decimal.js, it solves the classic JS math error (0.1 + 0.2 = 0.30000000000000004) via dynamic integer-scaling logic under the hood.

📚 An Educational Approach to MCP

This project serves as an excellent learning resource for developers looking to understand the Model Context Protocol (MCP) deeply. Because it deliberately avoids using the official @modelcontextprotocol/sdk, the entire implementation of the MCP protocol, JSON-RPC message handling, input validations, and error formatting is exposed in plain JavaScript.

Reading through cruncher.js provides unparalleled, transparent insight into exactly how an MCP server communicates over stdio, parses incoming requests (initialize, tools/list, tools/call), and responds back to the AI client-demystifying the "magic" that SDKs usually hide away.

What is the Model Context Protocol?

The Model Context Protocol (MCP) is an open standard that allows AI applications to securely connect with external data sources and tools. Think of it as a universal API for AI. By implementing Cruncher as an MCP server, any AI that understands MCP can instantly gain powerful, built-in calculator capabilities without custom integrations.

✨ Features

Cruncher provides a comprehensive set of calculator functions built completely from scratch without heavy dependencies:

Robust Architecture:
- Zero Dependencies: Relies purely on Node.js standard libraries.
- Strict Input Validation: Custom schema validator prevents AI hallucinations and invalid data.
- Infinite Loop Protection: Utilizes Node.js worker_threads with a 3-second strict timeout to prevent complex calculations from freezing the server.
- Accurate Decimal Math: Uses an integer-scaling approach to prevent classic JS floating-point errors (e.g., 0.1 + 0.2 === 0.3).
Tiered Tool Exposure: Three tiers (minimal, standard default, full) to optimize context token usage.
Basic Arithmetic: Addition, Subtraction, Multiplication, Division, Modulo.
Expression Evaluation: Safely compute entire plain-text math strings (e.g. (5 + 3) * 10 / 2).
Power & Roots: Exponentiation (a^b), Square Root.
Number Theory: Factorial (n!).
Trigonometry: Sine, Cosine, Tangent, Arcsine (asin), Arccosine (acos), and Arctangent (atan) (with support for degrees and radians).
Logarithms: Base-10 Logarithm and Natural Logarithm (ln).
Statistical Functions: Sum, Average, Median, Min, Max, Range, Count, Variance, and Standard Deviation for arrays of numbers.
Percentage Functions: Percentage-of, percentage-change, and reverse-percentage calculations.
Unit Conversion: 80+ conversions across 8 categories (length, weight, temperature, area, volume, time, speed, digital_storage).
Convenience Functions: Absolute Value.
Constants: Easy access to Math (pi, e, tau, phi, sqrt2, euler_mascheroni), Physics (c, g, G, h, k, R), and Chemistry constants (NA, e_charge, m_e, m_p).
Memory Functions: M+, M-, MR (Memory Recall), and MC (Memory Clear) - full tier only.

🚀 Installation & Usage

Get Cruncher up and running with Claude Desktop in just a few minutes.

Step 1: Prerequisites

Ensure you have Node.js (version 18.0.0 or newer) installed on your system. You can download it from nodejs.org.

Step 1: Quick Start with npm

Recommended: Install via npm and use directly:

Terminal

npx @slbdn/cruncher-mcp

This downloads and runs the latest version automatically.

Step 2: Configure Claude Desktop

Recommended: Use the npm package for automatic updates:

config.json

{
  "mcpServers": {
    "cruncher": {
      "command": "npx",
      "args": ["-y", "@slbdn/cruncher-mcp"]
    }
  }
}

Step 3: Manual File (Alternative)

If you prefer to download the file manually instead:

Download the cruncher.js file directly from GitHub.
Place it in a permanent location (e.g., C:\mcp-servers\cruncher.js or /home/user/mcp-servers/cruncher.js).
Locate the Claude Desktop configuration file:
- Windows: %APPDATA%\Claude\claude_desktop_config.json
- macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

Add the server configuration pointing to your downloaded file:

config.json

{
  "mcpServers": {
    "cruncher": {
      "command": "node",
      "args": ["C:/Users/YOUR_USERNAME/mcp-servers/cruncher.js"],
      "env": {
        "CRUNCHER_TOOL_SET": "standard"
      }
    }
  }
}

Note for macOS/Linux Users: Use a POSIX-style path, e.g., "/home/YOUR_USERNAME/mcp-servers/cruncher.js". Make sure your node executable is in your system's PATH.

Step 4: Start Calculating!

Save the configuration file and completely quit the Claude Desktop app.
Restart Claude Desktop. It will automatically connect to the Cruncher server.
Start asking questions!

OpenWebUI (Formerly Ollama WebUI)

OpenWebUI natively supports connecting to stdio MCP servers.

Option A: Using npm package

Go to Admin Panel > Settings > Tools > MCP Servers.
Click Add Server.
Name it "Cruncher", select Command and enter npx, set Args to @slbdn/cruncher-mcp.

Option B: Using downloaded file

Go to Admin Panel > Settings > Tools > MCP Servers.
Click Add Server.
Name it "Cruncher", select stdio, use node as the command, and /path/to/cruncher.js as the argument.

Cursor IDE

You can give Cursor's built-in AI the ability to run math and calculate hashes.

Option A: Using npm package

Open Cursor Settings (gear icon) > Features > MCP Servers.
Click + Add New MCP Server.
Set Type to command, Name to cruncher, and Command to npx @slbdn/cruncher-mcp.

Option B: Using downloaded file

Open Cursor Settings (gear icon) > Features > MCP Servers.
Click + Add New MCP Server.
Set Type to command, Name to cruncher, and Command to node /path/to/cruncher.js.

Cline (VS Code Extension)

If you use Cline for agentic coding in VS Code, open the MCP configuration file (cline_mcp_settings.json) and add:

Option A: Using npm package

config.json

{
  "mcpServers": {
    "cruncher": {
      "command": "npx",
      "args": ["-y", "@slbdn/cruncher-mcp"]
    }
  }
}

Option B: Using downloaded file

config.json

{
  "mcpServers": {
    "cruncher": {
      "command": "node",
      "args": ["/path/to/cruncher.js"],
      "env": {
        "CRUNCHER_TOOL_SET": "standard"
      }
    }
  }
}

Goose (Terminal Agent)

Goose is a lightweight, terminal‑based AI assistant that fully supports MCP.

Option A: Using npm package

Edit ~/.goose/config.yaml (or the local project config).
Add a new server entry:

yaml

mcpServers:
  cruncher:
    command: npx
    args:
      - -y
      - "@slbdn/cruncher-mcp"

Option B: Using downloaded file

Edit ~/.goose/config.yaml (or the local project config).
Add a new server entry:

yaml

mcpServers:
  cruncher:
    command: node
    args:
      - "/path/to/cruncher.js"
    env:
      CRUNCHER_TOOL_SET: "standard"

Restart Goose. You can now ask Goose to run calculations like evaluate_expression or median directly.

Zed Editor (AI Pane)

Zed's built‑in AI pane supports MCP connections.

Option A: Using npm package

Open Settings → AI → MCP Servers.
Click Add Server and fill in:
- Name: cruncher
- Command: npx
- Args: @slbdn/cruncher-mcp
Save. The Zed AI can now call Cruncher for precise arithmetic and statistics.

Option B: Using downloaded file

Open Settings → AI → MCP Servers.
Click Add Server and fill in:
- Name: cruncher
- Command: node
- Args: /absolute/path/to/cruncher.js
- Env (optional): CRUNCHER_TOOL_SET=standard
Save. The Zed AI can now call Cruncher for precise arithmetic and statistics.

LM Studio (Local LLM + MCP)

LM Studio runs LLMs entirely offline and now includes an MCP client.

Option A: Using npm package

Open Settings → MCP in LM Studio.
Click Add Server and provide:
- Executable: npx
- Arguments: @slbdn/cruncher-mcp
Confirm. Your private model can now offload math to Cruncher without any network traffic.

Option B: Using downloaded file

Open Settings → MCP in LM Studio.
Click Add Server and provide:
- Executable: node
- Arguments: /absolute/path/to/cruncher.js
- Environment (optional): CRUNCHER_TOOL_SET=standard
Confirm. Your private model (e.g., Llama 3, DeepSeek-V2) can now offload math to Cruncher without any network traffic.

LibreChat Configuration

If you're using LibreChat, you can add the following configuration to your librechat.yaml file:

Option A: Using npm package

yaml

  cruncher:
    type: stdio
    command: npx
    args:
      - -y
      - "@slbdn/cruncher-mcp"

Option B: Using downloaded file

yaml

  cruncher:
    type: stdio
    command: node
    args:
      - "/opt/mcp/cruncher.js"
    env:
      CRUNCHER_TIMEOUT: "5000"

Example Questions for Claude

"What is the angle in degrees whose sine is 0.5?"

"Calculate the average, median, and range of these numbers: [15, 22, 8, 41, 19, 30]"

"What is 2 raised to the power of 10?"

"What is the standard deviation of [10, 12, 8, 14, 6]?"

"What is 15% of 240?"

"A stock went from $50 to $75. What's the percentage change?"

"What is the variance of test scores [85, 92, 78, 90, 88]?"

"Calculate the range of values in [3, 7, 2, 9, 1]"

"Evaluate the expression: sin(pi/4) + sqrt(16) + log10(100)"

"What is 10 factorial?"

"What is 17 modulo 5?"

Full Tier Examples (with CRUNCHER_TOOL_SET=full):

"Store 99 in memory, add 5, then recall the total."

"What's the 75th percentile of [10, 20, 30, 40, 50]?"

"Convert 11010 from binary to decimal."

"Batch: square root of 144, add 10, then raise to power 2."

"Switch trigonometric functions to radians mode."

"Clear the result cache and show cache statistics."

"Recall what's in memory, then subtract 15 and store the result."

"What's the 95th percentile of [23, 45, 12, 67, 89, 34, 56, 78, 90, 11]?"

"Convert 0xFF from hex to binary."

📋 Available Tools

Cruncher exposes its functions as individual MCP tools. Here is the full list:

Tool Name	Description	Arguments
Basic Arithmetic
`evaluate_expression`	Evaluates a plain text math expression (e.g. `(5 + 3) * 10 / 2`).	`expression` (string)
`add`	Adds two numbers (a + b).	`a` (number), `b` (number)
`subtract`	Subtracts the second number from the first (a - b).	`a` (number), `b` (number)
`multiply`	Multiplies two numbers (a * b).	`a` (number), `b` (number)
`divide`	Divides the first number by the second (a / b).	`a` (number), `b` (number)
`modulo`	Calculates the remainder (a mod b).	`a` (number), `b` (number)
Power & Roots
`power`	Calculates a raised to the power of b (a^b).	`base` (number), `exponent` (number)
`sqrt`	Calculates the square root of a value.	`value` (number)
Number Theory
`factorial`	Calculates the factorial of a non-negative integer (n!).	`n` (number, non-negative integer)
Unit Conversion
`convert_unit`	Convert between common units. 8 categories, 80+ units.	`value` (number), `category` (string), `from` (string), `to` (string)
Base Conversion (Full Tier)
`convert_base`	Converts between bases 2, 8, 10, 16.	`value` (string), `from_base` (2, 8, 10, 16), `to_base` (2, 8, 10, 16)
Trigonometry
`sine`	Calculates the sine of an angle.	`angle` (number), `unit` (degrees/radians, optional)
`cosine`	Calculates the cosine of an angle.	`angle` (number), `unit` (degrees/radians, optional)
`tangent`	Calculates the tangent of an angle.	`angle` (number), `unit` (degrees/radians, optional)
`asin`	Calculates the inverse sine (arcsine) of a value. Returns an angle.	`value` (number), `unit` (degrees/radians, optional)
`acos`	Calculates the inverse cosine (arccosine) of a value. Returns an angle.	`value` (number), `unit` (degrees/radians, optional)
`atan`	Calculates the inverse tangent (arctangent) of a value. Returns an angle.	`value` (number), `unit` (degrees/radians, optional)
Logarithms
`logarithm`	Calculates the base-10 logarithm of a value.	`value` (number)
`natural_log`	Calculates the natural logarithm (base-e) of a value.	`value` (number)
Statistical Functions
`sum`	Calculates the sum of an array of numbers.	`numbers` (array of numbers)
`avg`	Calculates the average of an array of numbers.	`numbers` (array of numbers)
`median`	Calculates the median of an array of numbers.	`numbers` (array of numbers)
`min`	Finds the minimum value in an array of numbers.	`numbers` (array of numbers)
`max`	Finds the maximum value in an array of numbers.	`numbers` (array of numbers)
`count`	Counts the number of elements in an array.	`numbers` (array of numbers)
`range`	Calculates the range (max - min) of an array.	`numbers` (array of numbers)
`percentile`	Calculates the value at a given percentile (0-100). Full tier.	`numbers` (array of numbers), `percentile` (number, 0-100)
`variance`	Variance of an array. Sample (n-1) or population (n).	`numbers` (array of numbers), `population` (boolean, optional)
`std_dev`	Standard deviation. Sample (n-1) or population (n).	`numbers` (array of numbers), `population` (boolean, optional)
`percentage_of`	What is X% of Y? e.g., 15% of 200 = 30.	`percent` (number), `total` (number)
`percentage_change`	% change from A to B. e.g., 50→80 = 60%.	`from` (number), `to` (number)
`percentage_reverse`	X is Y% of what? e.g., 30 is 15% of 200.	`value` (number), `percent` (number)
Other
`absolute`	Calculates the absolute value of a number.	`value` (number)
Constants
`get_constant`	Returns the value of a mathematical, physical, or chemical constant.	`name` ("pi", "e", "tau", "phi", "sqrt2", "euler_mascheroni", "c", "g", "G", "h", "k", "R", "NA", "e_charge", "m_e", "m_p")
Memory Functions (Full Tier)
`memory_clear`	Clears the calculator memory (MC).	(no arguments)
`memory_recall`	Recalls the value stored in memory (MR).	(no arguments)
`memory_add`	Adds a value to the current memory (M+).	`value` (number)
`memory_subtract`	Subtracts a value from the current memory (M-).	`value` (number)
Angle Mode (Standard Tier)
`set_angle_mode`	Set global angle mode (default: degrees).	`unit` ("degrees" or "radians")
`get_angle_mode`	Get current angle mode.	(no arguments)
Admin Tools (Full Tier)
`batch`	Execute multiple tool calls sequentially.	`operations` (array of {tool, arguments})
`cache_clear`	Clear computation cache.	(no arguments)
`cache_info`	Show cache stats.	(no arguments)

⚙️ Configuration

Environment Variables

Variable	Default	Description
`CRUNCHER_TIMEOUT`	`3000`	Worker thread execution timeout (ms). Range 100-60000
`CRUNCHER_TOOL_SET`	`standard`	Controls tool exposure: `minimal` (5), `standard` (34 default), `full` (43)

Tool Tiers - Full Reference

Cruncher exposes 3 tiers via the CRUNCHER_TOOL_SET environment variable. Each tier is a strict superset of the one before it.

Tier Overview

Tier	Tools	Use Case
Minimal (5)	Core arithmetic only	Lightweight calculators, simple math agents
Standard (34 - default)	All minimal + trig, stats, constants, unit conversion	General-purpose AI assistant math
Full (43)	All standard + memory, batch, cache, base conversion, advanced stats	Power users, multi-step workflows

Minimal Tier (5 Tools)

All tools run in the worker thread with timeout protection.

#	Tool	Description
1	`evaluate_expression`	Evaluates a math expression string
2	`add`	Addition (a + b)
3	`subtract`	Subtraction (a - b)
4	`multiply`	Multiplication (a × b)
5	`divide`	Division (a ÷ b)

Standard Tier (34 Tools - includes all 5 Minimal)

#	Tool	Category
6	`sqrt`	Square root
7	`power`	Exponentiation (a^b)
8	`absolute`	Absolute value
9	`modulo`	Remainder (a mod b)
10	`factorial`	Factorial (n!)
11	`logarithm`	Base-10 logarithm
12	`natural_log`	Natural logarithm (ln)
13	`get_constant`	Fetch physical/math constants
14-16	`sine`, `cosine`, `tangent`	Trigonometry
17-19	`asin`, `acos`, `atan`	Inverse trigonometry
20	`set_angle_mode`	Toggle degrees/radians (global)
21	`get_angle_mode`	Check current angle mode
22-25	`sum`, `avg`, `min`, `max`	Basic statistics
26	`count`	Count elements
27	`variance`	Variance (sample or population)
28	`std_dev`	Standard deviation (sample or population)
29	`percentage_of`	X% of Y
30	`percentage_change`	% change A→B
31	`percentage_reverse`	X is Y% of what?
32	`median`	Median value
33	`range`	Range (max - min)
34	`convert_unit`	80+ unit conversions, 8 categories

Full Tier (43 Tools - includes all 34 Standard)

#	Tool	Category
35	`percentile`	Value at Nth percentile
36	`convert_base`	Base 2/8/10/16 conversion
37	`memory_add`	Add to running total
38	`memory_subtract`	Subtract from running total
39	`memory_recall`	Get current memory value
40	`memory_clear`	Reset memory to zero
41	`batch`	Execute up to 50 operations in one call
42	`cache_clear`	Clear result cache
43	`cache_info`	Show cache statistics

Fuzzy Tool Name Matching

If the LLM calls a tool that doesn't exist, Cruncher uses Levenshtein distance to find the closest match and suggests it:

Typo	Suggestion	Match Type
`fact`	`factorial`	Prefix match
`fac`	`factorial`	Prefix match
`sinn`	`sine`	1-char typo
`squrt`	`sqrt`	Transposition
`adddd`	`add`	Extra letters
`divid`	`divide`	Missing suffix
`totally_wrong`	(none)	Too different - no suggestion

Response format:

config.json

{
  "error": {
    "code": -32601,
    "message": "Tool 'fact' not found. Did you mean 'factorial'?"
  }
}

Extended evaluate_expression Built-ins

Beyond basic arithmetic, evaluate_expression supports these functions natively:

Function	Description	Example	Result
`sin(x)`	Sine (radians, always in expressions)	`sin(pi / 2)`	1
`cos(x)`	Cosine (radians, always in expressions)	`cos(pi)`	-1
`tan(x)`	Tangent (radians)	`tan(pi / 4)`	~1
`asin(x)`	Arc-sine (result in radians)	`asin(1)`	π/2
`acos(x)`	Arc-cosine (result in radians)	`acos(0)`	π/2
`atan(x)`	Arc-tangent (result in radians)	`atan(1)`	π/4
`sqrt(x)`	Square root	`sqrt(144)`	12
`log10(x)`	Base-10 logarithm	`log10(1000)`	3
`ln(x)`	Natural log (base e)	`ln(e)`	1
`log(x, b)`	Arbitrary base logarithm	`log(8, 2)`	3
`abs(x)`	Absolute value	`abs(-5)`	5
`round(x)`	Round to nearest int	`round(3.7)`	4
`floor(x)`	Round down	`floor(3.9)`	3
`ceil(x)`	Round up	`ceil(3.1)`	4
`min(a,b,...)`	Minimum value	`min(3, 1, 4)`	1
`max(a,b,...)`	Maximum value	`max(3, 1, 4)`	4

Combine freely: sin(pi/6) + sqrt(16) + log10(100) = 6.5

Improved Error Messages

Domain errors now tell you what went wrong:

sqrt(-1) → "Check for: sqrt(negative), log(negative/zero), asin/acos out of [-1,1]"
1/0 → "Check for division by zero or overflow"
asin(5) → "asin/acos out of [-1,1]"

Constants in Expressions

You can now use mathematical and physical constant names directly inside evaluate_expression:

Constant	Description	Value
`pi`	π (circle ratio)	3.14159...
`e`	Euler's number	2.71828...
`tau`	τ = 2π	6.28318...
`phi`	Golden ratio (φ)	1.61803...
`sqrt2`	√2	1.41421...
`euler_mascheroni`	Euler-Mascheroni (γ)	0.57721...
`c`	Speed of light (m/s)	299792458
`g`	Gravity (m/s2)	9.80665
`G`	Gravitational constant	6.6743e-11
`h`	Planck constant (J·s)	6.62607015e-34
`k`	Boltzmann constant (J/K)	1.380649e-23
`R`	Ideal gas constant (J/mol·K)	8.314462618
`NA`	Avogadro constant (1/mol)	6.02214076e23
`e_charge`	Elementary charge (C)	1.602176634e-19
`m_e`	Electron mass (kg)	9.1093837015e-31
`m_p`	Proton mass (kg)	1.67262192369e-27

Examples:

Code

2 * pi * 5       → 31.4159...
phi ^ 2          → 2.61803...
G * 1e11         → 6.6743
sqrt2 * sqrt2    → 2
e * e            → 7.38906...
c * 2            → 599584916

Rules:

Use explicit operators: 2 * pi works, 2pi does not (no implicit multiplication)
Constants coexist with scientific notation: 1e6 and e * 2 both work correctly
Longest constant names match first: euler_mascheroni won't become 299792458uler_mascheroni

Tiered Tool Exposure

The CRUNCHER_TOOL_SET environment variable lets you optimize context token usage by exposing only the tools you actually need:

Tier	Tools	Token Budget	Use Case
`minimal`	5	~160 tokens	Basic arithmetic. All complex math via `evaluate_expression`
`standard`	34	~1,150 tokens	Arithmetic, trig, stats, percentages, constants, unit conversion (default)
`full`	43	~1,500 tokens	Standard + memory, base conversion, percentile, batch, cache

Note: Even in minimal mode, evaluate_expression handles complex math - individual tools (sin, sqrt, etc.) just aren't registered as separate MCP tool calls. This saves up to 90% on context tokens.

Example MCP config (claude_desktop_config.json):

config.json

{
  "mcpServers": {
    "cruncher-minimal": {
      "command": "node",
      "args": ["/path/to/cruncher.js"],
      "env": { "CRUNCHER_TOOL_SET": "minimal" }
    }
  }
}

⛏️ How It Works (For Developers)

Cruncher is a plain Node.js JavaScript application that communicates over standard input/output (stdio). This makes it a lightweight, portable, and secure MCP server. The entire flow for a single tool call looks like this:

Initialization: On startup, the server listens for an initialize request from the MCP client and responds with its capabilities and version info (v1.2.31).
Tool Discovery: The client sends a tools/list request, and the server responds with the full list of available calculator tools and their inputSchema, which defines the required arguments and their types.
Input Validation: Before any tool is executed, the server runs a custom recursive validateArguments function against the tool's inputSchema. This ensures required fields are present, types are correct (number, string, array), enum values are valid, and min/max constraints are respected - all without any external library.
Worker Thread Execution: Once validated, the tool call is handed off to an isolated Node.js worker_thread. This completely protects the main thread (and its stdio communication) from being blocked by a long-running or infinite calculation.
Timeout Protection: A configurable timer (CRUNCHER_TIMEOUT, default 3000ms) watches the worker. If the worker takes too long, the main thread forcefully terminates it via worker.terminate() and returns a -32000 error to the AI client.
Safe Math & Result: The worker executes the handler function using safeMath (integer-scaling) for decimal-safe arithmetic, then posts the result back to the main thread, which formats and writes the final JSON-RPC 2.0 response to stdout.

🤝 Contributing

Contributions are welcome! If you'd like to add a new function, fix a bug, or improve the documentation, please feel free to open an issue or submit a pull request.

📜 License

This project is licensed under the MIT License.