HiGHS MCP Server

A Model Context Protocol (MCP) server that provides linear programming (LP) and mixed-integer programming (MIP) optimization capabilities using theHiGHS solver.

git clone https://github.com/wspringer/highs-mcp.git cd highs-mcp npm install npm run build

{ "mcpServers": { "highs": { "command": "npx", "args": ["highs-mcp"] } } }

After adding the configuration, restart Claude to load the HiGHS optimization tool.

The HiGHS MCP server is compatible with any MCP client. Some popular options include:

- Claude Desktop: Anthropic's AI assistant with native MCP support
- MCP CLI: Command-line interface for testing MCP servers
- MCP Inspector: Web-based tool for debugging MCP servers
- Custom Applications: Any application using theMCP SDK

{ problem: { sense: 'minimize' | 'maximize', objective: { linear?: number[], // Linear coefficients (optional if quadratic is provided) quadratic?: { // Quadratic terms for convex QP (optional) // Dense format: dense?: number[][] // Symmetric positive semidefinite matrix Q // OR Sparse format: sparse?: { rows: number[], // Row indices (0-indexed) cols: number[], // Column indices (0-indexed) values: number[], // Values of Q matrix shape: [number, number] // [num_variables, num_variables] } } }, variables: Array<{ name?: string, // Variable name (optional, defaults to x1, x2, etc.) lb?: number, // Lower bound (optional, defaults to 0) ub?: number, // Upper bound (optional, defaults to +∞, except binary gets 1) type?: 'cont' | 'int' | 'bin' // Variable type (optional, defaults to 'cont') }>, constraints: { // Dense format (for small problems): dense?: number[][], // 2D array where each row is a constraint // OR Sparse format (for large problems with many zeros): sparse?: { rows: number[], // Row indices of non-zero coefficients (0-indexed) cols: number[], // Column indices of non-zero coefficients (0-indexed) values: number[], // Non-zero coefficient values shape: [number, number] // [num_constraints, num_variables] }, sense: Array<'<=' | '>=' | '='>, // Constraint directions rhs: number[] // Right-hand side values } }, options?: { // Solver Control time_limit?: number, // Time limit in seconds presolve?: 'off' | 'choose' | 'on', solver?: 'simplex' | 'choose' | 'ipm' | 'pdlp', parallel?: 'off' | 'choose' | 'on', threads?: number, // Number of threads (0=automatic) random_seed?: number, // Random seed for reproducibility // Tolerances primal_feasibility_tolerance?: number, // Default: 1e-7 dual_feasibility_tolerance?: number, // Default: 1e-7 ipm_optimality_tolerance?: number, // Default: 1e-8 infinite_cost?: number, // Default: 1e20 infinite_bound?: number, // Default: 1e20 // Simplex Options simplex_strategy?: number, // 0-4: algorithm strategy simplex_scale_strategy?: number, // 0-5: scaling strategy simplex_dual_edge_weight_strategy?: number, // -1 to 2: pricing simplex_iteration_limit?: number, // Max iterations // MIP Options mip_detect_symmetry?: boolean, // Detect symmetry mip_max_nodes?: number, // Max branch-and-bound nodes mip_rel_gap?: number, // Relative gap tolerance mip_abs_gap?: number, // Absolute gap tolerance mip_feasibility_tolerance?: number, // MIP feasibility tolerance // Logging output_flag?: boolean, // Enable solver output log_to_console?: boolean, // Console logging highs_debug_level?: number, // 0-4: debug verbosity // Algorithm-specific ipm_iteration_limit?: number, // IPM max iterations pdlp_scaling?: boolean, // PDLP scaling pdlp_iteration_limit?: number, // PDLP max iterations // File I/O write_solution_to_file?: boolean, // Write solution to file solution_file?: string, // Solution file path write_solution_style?: number // Solution format style } }

{ status: 'optimal' | 'infeasible' | 'unbounded' | string, objective_value: number, solution: number[], // Solution values for each variable dual_solution: number[], // Dual values for constraints variable_duals: number[] // Reduced costs for variables }

- Convex QP only: The quadratic matrix Q must be positive semidefinite
- Continuous variables only: Integer/binary variables are not supported with quadratic objectives (no MIQP)
- Format: Objective function is: minimize c^T x + 0.5 x^T Q x
- Matrix specification: When specifying Q, values should be doubled to account for the 0.5 factor

Optimize production schedules to maximize profit while respecting resource constraints:

{ problem: { sense: 'maximize', objective: { linear: [25, 40] // Profit per unit }, variables: [ { name: 'ProductA' }, // Product A (defaults: cont, [0, +∞)) { name: 'ProductB' } // Product B (defaults: cont, [0, +∞)) ], constraints: { dense: [ [2, 3], // Machine hours per unit [1, 2] // Labor hours per unit ], sense: ['<=', '<='], rhs: [100, 80] // Available machine/labor hours } } }

Minimize transportation costs across a supply chain network:

{ problem: { sense: 'minimize', objective: { linear: [12.5, 14.2, 13.8, 11.9, 8.4, 9.1, 10.5, 6.2] }, variables: [ { name: 'S1_W1' }, { name: 'S1_W2' }, { name: 'S2_W1' }, { name: 'S2_W2' }, { name: 'W1_C1' }, { name: 'W1_C2' }, { name: 'W2_C1' }, { name: 'W2_C2' } // All default to: cont, [0, +∞) ], constraints: { // Supply, flow conservation, and demand constraints (dense format) dense: [ [1, 1, 0, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 0, 0, 0], [1, 0, 1, 0, -1, -1, 0, 0], [0, 1, 0, 1, 0, 0, -1, -1], [0, 0, 0, 0, 1, 0, 1, 0], [0, 0, 0, 0, 0, 1, 0, 1] ], sense: ['<=', '<=', '=', '=', '>=', '>='], rhs: [50, 40, 0, 0, 30, 25] // Supply, conservation, demand } } }

Optimize investment allocation with risk constraints:

{ problem: { sense: 'maximize', objective: { linear: [0.08, 0.12, 0.10, 0.15] // Expected returns }, variables: [ { name: 'Bonds', ub: 0.4 }, // Max 40% in bonds { name: 'Stocks', ub: 0.6 }, // Max 60% in stocks { name: 'RealEstate', ub: 0.3 }, // Max 30% in real estate { name: 'Commodities', ub: 0.2 } // Max 20% in commodities // All default to: cont, lb=0 ], constraints: { dense: [ [1, 1, 1, 1], // Total allocation = 100% [0.02, 0.15, 0.08, 0.20] // Risk constraint ], sense: ['=', '<='], rhs: [1, 0.10] // Exactly 100% allocated, max 10% risk } } }

4. Portfolio Optimization with Risk (Quadratic Programming)

Minimize portfolio risk (variance) while achieving target return:

{ problem: { sense: 'minimize', objective: { // Quadratic: minimize portfolio variance (risk) quadratic: { dense: [ // Covariance matrix (×2 for 0.5 factor) [0.2, 0.04, 0.02], [0.04, 0.1, 0.04], [0.02, 0.04, 0.16] ] } }, variables: [ { name: 'Stock_A', lb: 0 }, { name: 'Stock_B', lb: 0 }, { name: 'Stock_C', lb: 0 } ], constraints: { dense: [ [1, 1, 1], // Sum of weights = 1 [0.1, 0.12, 0.08] // Expected return >= target ], sense: ['=', '>='], rhs: [1, 0.1] // 100% allocation, min 10% return } } }

Optimize resource allocation across projects with integer constraints:

{ problem: { sense: 'maximize', objective: { linear: [100, 150, 80] // Value per project }, variables: [ { name: 'ProjectA', type: 'bin' }, // Binary: select or not { name: 'ProjectB', type: 'bin' }, // Binary: select or not { name: 'ProjectC', type: 'bin' } // Binary: select or not // Binary defaults to [0, 1] bounds ], constraints: { dense: [ [5, 8, 3], // Resource requirements [2, 3, 1] // Time requirements ], sense: ['<=', '<='], rhs: [10, 5] // Available resources/time } } }

For large optimization problems with mostly zero coefficients, use the sparse format for better memory efficiency:

{ problem: { sense: 'minimize', objective: { linear: [1, 2, 3, 4] // Minimize x1 + 2x2 + 3x3 + 4x4 }, variables: [ {}, {}, {}, {} // All default to: cont, [0, +∞) ], constraints: { // Sparse format: only specify non-zero coefficients sparse: { rows: [0, 0, 1, 1], // Row indices cols: [0, 2, 1, 3], // Column indices values: [1, 1, 1, 1], // Non-zero values shape: [2, 4] // 2 constraints, 4 variables }, // Represents: x1 + x3 >= 2, x2 + x4 >= 3 sense: ['>=', '>='], rhs: [2, 3] } } }

- Problem has > 1000 variables or constraints
- Matrix has < 10% non-zero coefficients
- Memory efficiency is important

Fine-tune solver behavior with comprehensive HiGHS options:

{ problem: { sense: 'minimize', objective: { linear: [1, 1] }, variables: [{}, {}], constraints: { dense: [[1, 1]], sense: ['>='], rhs: [1] } }, options: { // Algorithm Control solver: 'simplex', simplex_strategy: 1, // Dual simplex simplex_dual_edge_weight_strategy: 1, // Devex pricing simplex_scale_strategy: 2, // Equilibration scaling // Performance Tuning parallel: 'on', threads: 4, simplex_iteration_limit: 10000, // Tolerances primal_feasibility_tolerance: 1e-8, dual_feasibility_tolerance: 1e-8, // Debugging output_flag: true, log_to_console: true, highs_debug_level: 1, // MIP Control (for integer problems) mip_detect_symmetry: true, mip_max_nodes: 5000, mip_rel_gap: 0.001 } }

- Solver Control: Algorithm selection, parallelization, time limits
- Tolerances: Precision control for feasibility and optimality
- Simplex Options: Strategy, scaling, pricing, iteration limits
- MIP Options: Symmetry detection, node limits, gap tolerances
- Logging: Output control, debugging levels, file output
- Algorithm-specific: IPM and PDLP specialized options

- High Performance: Built on the HiGHS solver, one of the fastest open-source optimization solvers
- Sparse Matrix Support: Efficient handling of large-scale problems with sparse constraint matrices
- Type Safety: Full TypeScript support with Zod validation for robust error handling
- Compact Variable Format: Self-contained variable specifications with smart defaults
- Flexible Problem Types: Supports continuous, integer, and binary variables
- Multiple Solver Methods: Choose between simplex, interior point, and other algorithms
- Comprehensive Output: Returns primal solution, dual values, and reduced costs

npm test # Run tests once npm run test:watch # Run tests in watch mode npm run test:ui # Run tests with UI

Contributions are welcome! Please feel free to submit a Pull Request.

MIT License - Copyright (c) 2024 Wilfred Springer

- HiGHS- The underlying optimization solver
- Model Context Protocol- The protocol specification
- MCP SDK- SDK for building MCP servers

A hosted API /MCP platform providing developer-friendly JSON endpoints for user-agent parsing, postal code search with spatial queries, country/subdivision lookup, cryptographic hashing, IP geolocation, email risk scoring, and more.