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
- HiGHS - The underlying optimization solver
- Model Context Protocol - The protocol specification
- MCP SDK - SDK for building MCP servers