HiGHS MCP Server

Proporciona capacidades de optimización de programación lineal (LP) y programación mixta-entera (MIP) utilizando el solucionador HiGHS.

GitHub

Prueba este MCPPatrocinado

Documentación

HiGHS MCP Server

Un servidor de Model Context Protocol (MCP) que proporciona capacidades de optimización de programación lineal (LP) y programación entera mixta (MIP) utilizando el solucionador HiGHS.

Descripción general

Este servidor MCP expone el solucionador de optimización HiGHS a través de una interfaz estandarizada, permitiendo que asistentes de IA y otros clientes MCP resuelvan problemas de optimización complejos, incluyendo:

Problemas de programación lineal (LP)
Problemas de programación entera mixta (MIP)
Problemas de programación cuadrática (QP) para objetivos convexos
Restricciones de variables binarias y enteras
Optimización multiobjetivo

Requisitos

Node.js >= 16.0.0

Instalación

npm install highs-mcp

O clonar y compilar desde el código fuente:

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

Uso

Como servidor MCP

El servidor se puede ejecutar directamente:

npx highs-mcp

O si se compila desde el código fuente:

npm start

Integración con Claude

Para usar esta herramienta con Claude, agrégala a tu archivo de configuración de Claude:

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

Después de agregar la configuración, reinicia Claude para cargar la herramienta de optimización HiGHS.

Integración con otros clientes MCP

El servidor MCP de HiGHS es compatible con cualquier cliente MCP. Algunas opciones populares incluyen:

Claude Desktop: El asistente de IA de Anthropic con soporte nativo de MCP
MCP CLI: Interfaz de línea de comandos para probar servidores MCP
MCP Inspector: Herramienta basada en web para depurar servidores MCP
Aplicaciones personalizadas: Cualquier aplicación que utilice el MCP SDK

API de herramientas

El servidor proporciona una única herramienta: optimize-mip-lp-tool

Esquema de entrada

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

Esquema de salida

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

Notas sobre programación cuadrática (QP)

Solo QP convexa: La matriz cuadrática Q debe ser semidefinida positiva
Solo variables continuas: Las variables enteras/binarias no son compatibles con objetivos cuadráticos (sin MIQP)
Formato: La función objetivo es: minimizar c^T x + 0.5 x^T Q x
Especificación de la matriz: Al especificar Q, los valores deben duplicarse para tener en cuenta el factor 0.5

Casos de uso

1. Planificación de producción

Optimiza los programas de producción para maximizar las ganancias respetando las restricciones de recursos:

{
  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. Transporte/Logística

Minimiza los costos de transporte en una red de cadena de suministro:

{
  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. Optimización de carteras

Optimiza la asignación de inversiones con restricciones de riesgo:

{
  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. Optimización de carteras con riesgo (programación cuadrática)

Minimiza el riesgo de la cartera (varianza) mientras se logra el rendimiento objetivo:

{
  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. Asignación de recursos

Optimiza la asignación de recursos entre proyectos con restricciones enteras:

{
  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. Problemas dispersos grandes

Para problemas de optimización grandes con coeficientes mayormente cero, utiliza el formato disperso para una mejor eficiencia de memoria:

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

Utiliza el formato disperso cuando:

El problema tiene > 1000 variables o restricciones
La matriz tiene < 10% de coeficientes distintos de cero
La eficiencia de memoria es importante

6. Opciones mejoradas del solucionador

Ajusta el comportamiento del solucionador con opciones completas de HiGHS:

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

Categorías de opciones clave:

Control del solucionador: Selección de algoritmo, paralelización, límites de tiempo
Tolerancias: Control de precisión para factibilidad y optimalidad
Opciones de símplex: Estrategia, escalado, precios, límites de iteraciones
Opciones de MIP: Detección de simetría, límites de nodos, tolerancias de brecha
Registro: Control de salida, niveles de depuración, salida de archivos
Específicas del algoritmo: Opciones especializadas de IPM y PDLP

Características

Alto rendimiento: Construido sobre el solucionador HiGHS, uno de los solucionadores de optimización de código abierto más rápidos
Soporte de matrices dispersas: Manejo eficiente de problemas a gran escala con matrices de restricción dispersas
Seguridad de tipos: Soporte completo de TypeScript con validación Zod para un manejo robusto de errores
Formato de variables compacto: Especificaciones de variables autocontenidas con valores predeterminados inteligentes
Tipos de problemas flexibles: Admite variables continuas, enteras y binarias
Múltiples métodos de solución: Elige entre símplex, punto interior y otros algoritmos
Salida completa: Devuelve la solución primal, los valores duales y los costos reducidos

Desarrollo

Compilación

npm run build

Pruebas

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

Verificación de tipos

npx tsc --noEmit

HiGHS MCP Server

Documentación

HiGHS MCP Server

Descripción general

Requisitos

Instalación

Uso

Como servidor MCP

Integración con Claude

Integración con otros clientes MCP

API de herramientas

Esquema de entrada

Esquema de salida

Notas sobre programación cuadrática (QP)

Casos de uso

1. Planificación de producción

2. Transporte/Logística

3. Optimización de carteras

4. Optimización de carteras con riesgo (programación cuadrática)

5. Asignación de recursos

5. Problemas dispersos grandes

6. Opciones mejoradas del solucionador

Características

Desarrollo

Compilación

Pruebas

Verificación de tipos

Contribuciones

Licencia

Proyectos relacionados