Compute MCP

A robust arithmetic expression evaluator implemented as an MCP (Model Context Protocol) server. This project demonstrates production-quality parser development using modern Rust techniques, comprehensive property-based testing, and adversarial test strategies.

- Complete Arithmetic:+,-,,/with correct precedence
- Scientific Notation:1e10,2.5e-3,1.23E+4
- Parentheses Grouping:(2 + 3) 4
- Decimal Numbers:3.14159,-0.5
- Unary Operators:-42,-(5 + 3),--5
- Robust Error Handling: Division by zero, malformed input, parse errors
- Deep Nesting Support: Handles complex nested expressions
- Property-Based Tested: 60+ tests covering mathematical invariants

Built using a modernPratt parserfor clean operator precedence handling:

Input String → Pest Grammar → Pratt Parser → AST → Evaluator → Result │ │ │ │ │ │ "2 + 3  4" compute.pest PrattParser Expr::Add eval_expr Ok(14.0) / \ Expr::Num(2) Expr::Mul / \ Expr::Num(3) Expr::Num(4)

# Command line tool cargo run --bin stdio_direct -- eval "2 + 3  4" cargo run --bin stdio_direct -- eval "1e10 / (2.5 + 3.7)"

# Initialize server echo '{"jsonrpc":"2.0","method":"initialize","params":{},"id":1}' | cargo run --bin stdio_direct # Batch evaluation echo '{"jsonrpc":"2.0","method":"tools/call","params":{"name":"evaluate_batch","arguments":{"expressions":["2+2","1e32","(5-3)^2"]}},"id":2}' | cargo run --bin stdio_direct

{ "mcpServers": { "compute": { "command": "/path/to/compute-mcp/target/release/stdio_direct" } } }

// Precedence preservation parse("a + b  c") == Add(a, Mul(b, c)) // Evaluation determinism eval(expr) == eval(expr) // Always same result // Mathematical laws eval(Add(a, b)) ≈ eval(Add(b, a)) // Commutativity eval(Add(Add(a, b), c)) ≈ eval(Add(a, Add(b, c))) // Associativity // Round-trip consistency eval(parse(print(ast))) ≈ eval(ast) // Error containment parse(invalid_input) == Err(_) // Never panics

# All tests cargo test # Specific test suites cargo test --test tests # Basic functionality cargo test --test adversarial_tests # Edge cases cargo test --test proptest_adversarial # Property tests # Parallel execution cargo test -- --test-threads=4

Property-based testing discovered critical issues during development:

Grammar Ambiguity: The original grammar allowed-5to parse as eitherNeg(Number(5))orNumber(-5), causing non-deterministic behavior. Fixed by removing minus signs from number literals.

Precision Edge Cases: Tests revealed floating-point precision issues with expressions like1e20 + 1 - 1e20, leading to more robust error tolerance.

Deep Nesting Limits: Found parser performance cliffs at ~40+ nesting levels, optimized for practical use cases.

use compute_mcp::; // Simple evaluation let result = evaluate("2 + 3  4")?; assert_eq!(result, 14.0); // Scientific notation let result = evaluate("1.5e3 + 2.5e2")?; assert_eq!(result, 1750.0); // Complex expressions let result = evaluate("((1 + 2)  3 - 4) / 2")?; assert_eq!(result, 2.5);

// Parse to AST for inspection let ast = parse_expression("-(2 + 3)  4")?; // Returns: Mul(Neg(Add(Number(2), Number(3))), Number(4)) // Batch processing let expressions = vec!["1+1", "22", "3/3"]; let results = evaluate_batch(&expressions); // Error handling match evaluate("10 / 0") { Err(ComputeError::DivisionByZero) => println!("Caught division by zero"), _ => unreachable!(), }

compute-mcp/ ├── Cargo.toml # Dependencies and metadata ├── src/ │ ├── lib.rs # Parser, AST, and evaluator (~350 lines) │ ├── compute.pest # Pratt parser grammar (~35 lines) │ └── bin/ │ └── stdio_direct.rs # MCP server implementation ├── tests/ │ ├── tests.rs # Unit and integration tests │ ├── adversarial_tests.rs # Edge case and stress tests │ ├── proptest_adversarial.rs # Property-based tests │ └── .proptest-regressions # Saved failing test cases └── target/ # Build artifacts

[dependencies] pest = "2.6" # Parser generator pest_derive = "2.6" # Derive macros for grammar lazy_static = "1.4" # Global parser instance mcpr = "0.2.3" # MCP protocol serde = "1.0" # JSON serialization clap = "4.4" # Command line interface [dev-dependencies] proptest = "1.6.0" # Property-based testing

This project serves as an excellent case study for:

- Modern Parser Design: Pratt parsers vs recursive descent
- Property-Based Testing: Discovering edge cases automatically
- Rust Best Practices: Error handling, type safety, zero-cost abstractions
- Protocol Implementation: MCP server development
- Mathematical Correctness: Ensuring arithmetic laws hold

Perfect for blog posts, tutorials, and educational content about robust software development.

🔮 Ready for production use with confidence backed by comprehensive testing! 🔮

This is a web browser that enables your coding agent, such as Claude Code, to visit websites on your behalf and assist you in identifying bugs or creating UI test cases.

An MCP server to help AI assistants to answer questions and generate AccelByte Extend SDK code more effectively .

Local stdio MCP server that lets AI coding agents read and maintain structured architecture, rules, and decisions directly from your repository.

Official Context7 MCP server that brings up-to-date, version-specific library documentation and code examples into AI coding prompts.

Remote, no-auth MCP server providing AI-powered codebase context and answers

Instead of direct calling MCP tools, mcpcode server transforms MCP tool calls into TypeScript programs, enabling smarter, lower-latency orchestration by LLMs.

Help agents automatically write and test stories for your UI components

Official Svelte MCP server, provides docs and suggestions on the generated code.

Supercharge your Agent with Semantic Code Intelligence and save 💰 in the process!

Execute any LLM-generated code in the YepCode secure and scalable sandbox environment and create your own MCP tools using JavaScript or Python, with full support for NPM and PyPI packages