Skip to main content
Glama
wspringer

HiGHS MCP Server

by wspringer
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Remote

HiGHS MCP Server

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

Overview

This MCP server exposes the HiGHS optimization solver through a standardized interface, allowing AI assistants and other MCP clients to solve complex optimization problems including:

  • Linear Programming (LP) problems

  • Mixed-Integer Programming (MIP) problems

  • Quadratic Programming (QP) problems for convex objectives

  • Binary and integer variable constraints

  • Multi-objective optimization

Requirements

  • Node.js >= 16.0.0

Installation

npm install highs-mcp

Or clone and build from source:

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

Usage

As an MCP Server

The server can be run directly:

npx highs-mcp

Or if built from source:

npm start

Integration with Claude

To use this tool with Claude, add it to your Claude configuration file:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json Windows: %APPDATA%\Claude\claude_desktop_config.json Linux: ~/.config/Claude/claude_desktop_config.json

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

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

Integration with Other MCP Clients

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 the MCP SDK

Tool API

The server provides a single tool: optimize-mip-lp-tool

Input Schema

{ 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 } }

Output Schema

{ 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 }

Notes on Quadratic Programming (QP)

  • 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

Use Cases

1. Production Planning

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 } } }

2. Transportation/Logistics

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 } } }

3. Portfolio Optimization

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 } } }

5. Resource Allocation

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 } } }

5. Large Sparse Problems

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] } } }

Use sparse format when:

  • Problem has > 1000 variables or constraints

  • Matrix has < 10% non-zero coefficients

  • Memory efficiency is important

6. Enhanced Solver Options

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 } }

Key Option Categories:

  • 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

Features

  • 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

Development

Building

npm run build

Testing

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

Type Checking

npx tsc --noEmit

Contributing

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

License

MIT License - Copyright (c) 2024 Wilfred Springer

Related Projects

This server cannot be installed

-
security - not tested
A
license - permissive license
-
quality - not tested

How are these scores calculated?

Resources

New MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/wspringer/highs-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server