HiGHS MCP Server

Servidor MCP HiGHS

Um servidor Model Context Protocol (MCP) que fornece capacidades de otimização de programação linear (LP) e programação inteira mista (MIP) usando o solucionador HiGHS.

Visão Geral

Este servidor MCP expõe o solucionador de otimização HiGHS através de uma interface padronizada, permitindo que assistentes de IA e outros clientes MCP resolvam problemas complexos de otimização, incluindo:

• Problemas de Programação Linear (LP)
• Problemas de Programação Inteira Mista (MIP)
• Problemas de Programação Quadrática (QP) para objetivos convexos
• Restrições de variáveis binárias e inteiras
• Otimização multiobjetivo

Requisitos

• Node.js >= 16.0.0

Instalação

npm install highs-mcp

Ou clone e compile a partir do código-fonte:

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

Uso

Como um Servidor MCP

O servidor pode ser executado diretamente:

npx highs-mcp

Ou se compilado a partir do código-fonte:

npm start

Integração com Claude

Para usar esta ferramenta com Claude, adicione-a ao seu arquivo de configuração do 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"]
    }
  }
}

Após adicionar a configuração, reinicie o Claude para carregar a ferramenta de otimização HiGHS.

Integração com Outros Clientes MCP

O servidor MCP HiGHS é compatível com qualquer cliente MCP. Algumas opções populares incluem:

• Claude Desktop: Assistente de IA da Anthropic com suporte nativo a MCP
• MCP CLI: Interface de linha de comando para testar servidores MCP
• MCP Inspector: Ferramenta baseada na web para depurar servidores MCP
• Aplicações Personalizadas: Qualquer aplicação que use o MCP SDK

API de Ferramentas

O servidor fornece uma única ferramenta: 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 Saída

{
  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 Programação Quadrática (QP)

• Apenas QP convexo: A matriz quadrática Q deve ser semidefinida positiva
• Apenas variáveis contínuas: Variáveis inteiras/binárias não são suportadas com objetivos quadráticos (sem MIQP)
• Formato: A função objetivo é: minimizar c^T x + 0.5 x^T Q x
• Especificação da matriz: Ao especificar Q, os valores devem ser dobrados para considerar o fator 0.5

Casos de Uso

1. Planejamento de Produção

Otimize cronogramas de produção para maximizar o lucro respeitando restrições 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

Minimize custos de transporte em uma rede de cadeia de suprimentos:

{
  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. Otimização de Portfólio

Otimize a alocação de investimentos com restrições de risco:

{
  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. Otimização de Portfólio com Risco (Programação Quadrática)

Minimize o risco do portfólio (variância) enquanto atinge o retorno alvo:

{
  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. Alocação de Recursos

Otimize a alocação de recursos entre projetos com restrições inteiras:

{
  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 Grandes e Esparsos

Para problemas de otimização grandes com coeficientes majoritariamente zero, use o formato esparso para melhor eficiência de memória:

{
  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 o formato esparso quando:

• O problema tiver > 1000 variáveis ou restrições
• A matriz tiver < 10% de coeficientes não nulos
• A eficiência de memória for importante

6. Opções Aprimoradas do Solucionador

Ajuste fino do comportamento do solucionador com opções abrangentes do 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
  }
}

Categorias Principais de Opções:

• Controle do Solucionador: Seleção de algoritmo, paralelização, limites de tempo
• Tolerâncias: Controle de precisão para viabilidade e otimalidade
• Opções Simplex: Estratégia, escalonamento, precificação, limites de iteração
• Opções MIP: Detecção de simetria, limites de nós, tolerâncias de gap
• Registro: Controle de saída, níveis de depuração, saída de arquivo
• Específicas do Algoritmo: Opções especializadas IPM e PDLP

Recursos

• Alto Desempenho: Construído sobre o solucionador HiGHS, um dos solucionadores de otimização open-source mais rápidos
• Suporte a Matriz Esparsa: Manipulação eficiente de problemas de grande escala com matrizes de restrição esparsas
• Segurança de Tipos: Suporte completo a TypeScript com validação Zod para tratamento robusto de erros
• Formato Compacto de Variáveis: Especificações de variáveis autocontidas com padrões inteligentes
• Tipos Flexíveis de Problemas: Suporta variáveis contínuas, inteiras e binárias
• Múltiplos Métodos de Solução: Escolha entre simplex, ponto interior e outros algoritmos
• Saída Abrangente: Retorna solução primal, valores duais e custos reduzidos

Desenvolvimento

Compilação

npm run build

Testes

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

Verificação de Tipos

npx tsc --noEmit

Contribuição

Contribuições são bem-vindas! Sinta-se à vontade para enviar um Pull Request.

Licença

Licença MIT - Copyright (c) 2024 Wilfred Springer

Projetos Relacionados

• HiGHS - O solucionador de otimização subjacente
• Model Context Protocol - A especificação do protocolo
• MCP SDK - SDK para construir servidores MCP