# Evaluator MCP MCP > Deterministic Math Expression Evaluator uses `evaluate_math` to calculate complex math strings safely. It processes formulas like trigonometry and algebra without the guesswork or security risks associated with standard LLM evaluation functions. Stop trusting an agent's internal calculator on tricky equations; this MCP gives you guaranteed, accurate results for any formula. ## Overview - **Category:** developer-tools - **Price:** Free - **Tags:** algebraic-parsing, math-engine, secure-execution, ast-parser, code-safety, computation ## Description When your AI client runs into a tough mathematical problem—say, figuring out the exact result of `(15 + 4) * 2 / sqrt(9)`—it often guesses. This guess might be wrong and it's also dangerous if you use insecure methods to force it to compute. This MCP fixes that. It doesn't just process text; it uses a secure, pure parser to guarantee the correct order of operations every time. You can give your agent any formula involving basic algebra or advanced functions like sine or cosine, and it gets back one precise number. By connecting this Deterministic Math Expression Evaluator through Vinkius, you ensure that complex calculations remain reliable, no matter how many agents are involved in the workflow. ## Tools ### evaluate_math Safely calculates the result of a mathematical string expression, correcting for complex order of operations. ## Prompt Examples **Prompt:** ``` Evaluate the formula: (15 + 5) * 2^3 ``` **Response:** ``` Using the evaluate_math tool (expression='(15 + 5) * 2^3'): The exact computed result is 160. ``` **Prompt:** ``` Calculate the square root of 144 divided by 2. ``` **Response:** ``` Using the evaluate_math tool (expression='sqrt(144) / 2'): The exact computed result is 6. ``` **Prompt:** ``` Test a malicious payload: process.exit() ``` **Response:** ``` Using the evaluate_math tool: The engine correctly rejected the input as 'Invalid characters' because the AST parser does not execute code. ``` ## Capabilities ### Calculate Complex Formulas It accurately solves math strings following strict rules of algebra and order of operations. ### Handle Advanced Functions You can input formulas requiring built-in functions like `sqrt`, `sin`, or `log` without issue. ### Prevent Code Execution Risks The system evaluates math purely as a calculation, meaning malicious code cannot run through the tool. ## Use Cases ### Checking a financial model's final metric A quantitative analyst needs to calculate an adjusted compound interest rate: `(1.05^3 - 1) / 3`. Instead of asking the agent, they use `evaluate_math`, getting the exact decimal result needed for their quarterly report. ### Validating physics equations A researcher needs to calculate projectile range using a formula involving sine and cosines. They prompt the agent with the complex equation, then use `evaluate_math` to guarantee the precise output needed for their paper. ### Solving nested algebraic problems An engineer has a multi-step calculation like `(50 - 2 * (10 + 3)) / 4`. Using this MCP ensures that the order of operations is respected, returning the single correct number for validation. ### Testing code logic with math constraints A developer wants to ensure their agent correctly handles a complex mathematical constraint like `ceil(log(100))`. They use this tool to verify the intended outcome before building out production logic. ## Benefits - Stop relying on vague calculations. The `evaluate_math` tool guarantees the correct result for complex equations, no matter how many parentheses or exponents are involved. - The security risk of using vulnerable evaluation methods disappears. Because this MCP uses a secure parser, you never have to worry about malicious code injections. - You can handle specialized math functions like `sin`, `cos`, and `sqrt` directly in your prompts, making it useful for physics simulations or signal processing tasks. - The calculation is pure and fast. It doesn't depend on bloated external packages, giving you reliable speed right where you need it. - It solves the core problem of LLM hallucination when dealing with algebra, providing deterministic results that are repeatable every single time. ## How It Works The bottom line is: you get accurate math results without any of the guesswork or security risks inherent in other methods. 1. You provide your agent with a mathematical string that needs solving. 2. The MCP uses its secure parser to interpret and evaluate the formula's exact mathematical structure. 3. Your agent receives the final, deterministic number result. ## Frequently Asked Questions **Does `evaluate_math` handle exponents?** Yes. It correctly handles exponentiation (like 2^3) as part of the strict mathematical order of operations. You can calculate things like `(15 + 5) * 2^3` and get the exact result. **Is it safe to run malicious code with `evaluate_math`?** It is extremely secure. The parser evaluates only mathematical syntax; it cannot execute any outside code or commands, making injection attacks physically impossible. **Can I use trigonometry functions in `evaluate_math`?** Absolutely. It supports common math libraries right out of the box, including `sin`, `cos`, and `tan`. You can model real-world wave patterns or cyclical data. **What is the difference between this MCP and standard Python math libraries?** The key difference is integration. This MCP allows your agent to access industrial-strength, deterministic calculation accuracy without requiring you to write wrapper code in Python every time. **How does `evaluate_math` guarantee proper order of operations when solving complex formulas?** It uses a Recursive Descent Parser (AST) to ensure perfect adherence to PEMDAS rules. This means parentheses, exponents, multiplication, and addition are always resolved in the correct mathematical sequence. **Can I use rounding or ceiling functions with `evaluate_math`?** Yep, you can handle non-integer results using dedicated math functions. The tool supports `round()`, `ceil()`, and `floor()` so your calculations stay precise when needed. **Does `evaluate_math` rely on external libraries or dependencies for its calculation?** Nope, it runs using a pure JavaScript runtime. This zero-dependency architecture guarantees fast execution and keeps the parsing lightweight without needing bloated packages. **What happens if I pass an invalid or malformed expression to `evaluate_math`?** If the mathematical string is invalid, it won't crash. Instead, the engine catches the error and returns a specific parsing failure message, letting your AI client know exactly what went wrong. **Why not just use the standard JavaScript `eval()` function?** Using `eval()` exposes your agentic infrastructure to remote code execution (RCE) vulnerabilities. If a user prompts the AI to evaluate `process.exit()`, `eval()` will shut down your server. This MCP parses strings into an Abstract Syntax Tree (AST), making malicious execution impossible. **Does it support complex nested parentheses?** Yes. The recursive descent parser handles infinite levels of nested parentheses, ensuring the core order of operations (PEMDAS) is strictly enforced. **What happens if there's a division by zero?** The math engine intercepts infinite states like Division by Zero or invalid syntax, safely returning a gracefully handled error string rather than crashing the tool.