Provides linear programming (LP) and mixed-integer programming (MIP) optimization capabilities using the HiGHS solver.
A Model Context Protocol (MCP) server that provides linear programming (LP) and mixed-integer programming (MIP) optimization capabilities using the HiGHS solver.
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:
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
The server can be run directly:
npx highs-mcp
Or if built from source:
npm start
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.
The HiGHS MCP server is compatible with any MCP client. Some popular options include:
The server provides a single tool: optimize-mip-lp-tool
{
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
}
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
}
}
}
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]
}
}
}
Use sparse format when:
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:
npm run build
npm test # Run tests once
npm run test:watch # Run tests in watch mode
npm run test:ui # Run tests with UI
npx tsc --noEmit
Contributions are welcome! Please feel free to submit a Pull Request.
MIT License - Copyright (c) 2024 Wilfred Springer
Create secure tunnels to expose local servers to the internet using untun.
The ultimate open-source server for advanced Gemini API interaction with MCP, intelligently selects models.
Official MCP server for Sentry.
Enhances large language models with protein structure analysis capabilities, including active site analysis and disease-protein searches, by connecting to the RCSB Protein Data Bank.
Integrates Zeek network analysis with conversational AI clients. Requires an external Zeek installation.
Advanced code search and transformation powered by ugrep and ast-grep for modern development workflows.
Explore and interact with Swagger/OpenAPI specifications, allowing for browsing endpoints and retrieving details on API operations.
A collection of reference implementations for the Model Context Protocol (MCP), demonstrating how to give LLMs secure access to tools and data using Typescript and Python SDKs.
Interact with Odoo instances using the XML-RPC API. Requires configuration via environment variables or config files.
An example of a remote MCP server deployable on Cloudflare Workers without authentication.