solve_integer_program_tool
Solve optimization problems with integer or binary variables for discrete decision-making like facility location, crew scheduling, and project selection using linear programming.
Instructions
Solve an integer or mixed-integer programming problem using PuLP.
This tool solves optimization problems where some or all variables must
take integer values, which is useful for discrete decision problems.
Use cases:
- Facility location: Decide where to build warehouses or service centers
- Project selection: Choose which projects to fund (binary decisions)
- Crew scheduling: Assign integer numbers of staff to shifts
- Network design: Design networks with discrete components
- Cutting stock: Minimize waste when cutting materials
- Capital budgeting: Select investments when partial investments aren't allowed
Args:
objective: Objective function with 'sense' and 'coefficients'
variables: Variable definitions with types "continuous", "integer", or "binary"
constraints: List of linear constraints
solver: Solver to use ("CBC", "GLPK", "GUROBI", "CPLEX")
time_limit_seconds: Maximum time to spend solving (optional)
Returns:
Optimization result with integer/binary variable values
Example:
# Binary knapsack: select items to maximize value within weight limit
solve_integer_program(
objective={"sense": "maximize", "coefficients": {"item1": 10, "item2": 15}},
variables={
"item1": {"type": "binary"},
"item2": {"type": "binary"}
},
constraints=[
{"expression": {"item1": 5, "item2": 8}, "operator": "<=", "rhs": 10}
]
)
Input Schema
TableJSON Schema
| Name | Required | Description | Default |
|---|---|---|---|
| objective | Yes | ||
| variables | Yes | ||
| constraints | Yes | ||
| solver | No | CBC | |
| time_limit_seconds | No |
Implementation Reference
- The MCP tool handler function 'solve_integer_program_tool' decorated with @mcp.tool(). It wraps the solve_integer_program helper function to execute the integer programming optimization.
@mcp.tool() def solve_integer_program_tool( objective: dict[str, Any], variables: dict[str, dict[str, Any]], constraints: list[dict[str, Any]], solver: str = "CBC", time_limit_seconds: float | None = None, ) -> dict[str, Any]: """Solve an integer or mixed-integer programming problem using PuLP. This tool solves optimization problems where some or all variables must take integer values, which is useful for discrete decision problems. Use cases: - Facility location: Decide where to build warehouses or service centers - Project selection: Choose which projects to fund (binary decisions) - Crew scheduling: Assign integer numbers of staff to shifts - Network design: Design networks with discrete components - Cutting stock: Minimize waste when cutting materials - Capital budgeting: Select investments when partial investments aren't allowed Args: objective: Objective function with 'sense' and 'coefficients' variables: Variable definitions with types "continuous", "integer", or "binary" constraints: List of linear constraints solver: Solver to use ("CBC", "GLPK", "GUROBI", "CPLEX") time_limit_seconds: Maximum time to spend solving (optional) Returns: Optimization result with integer/binary variable values Example: # Binary knapsack: select items to maximize value within weight limit solve_integer_program( objective={"sense": "maximize", "coefficients": {"item1": 10, "item2": 15}}, variables={ "item1": {"type": "binary"}, "item2": {"type": "binary"} }, constraints=[ {"expression": {"item1": 5, "item2": 8}, "operator": "<=", "rhs": 10} ] ) """ result = solve_integer_program( objective, variables, constraints, solver, time_limit_seconds ) result_dict: dict[str, Any] = result return result_dict - Core helper function that parses the raw input dictionaries using Pydantic models (Objective, Variable, Constraint) and solves the integer program using PuLPSolver.
@with_resource_limits(timeout_seconds=60.0, estimated_memory_mb=100.0) def solve_integer_program( objective: dict[str, Any], variables: dict[str, dict[str, Any]], constraints: list[dict[str, Any]], solver: str = "CBC", time_limit_seconds: float | None = None, ) -> dict[str, Any]: """Solve an integer programming problem using PuLP.""" try: # Parse and validate input obj = Objective(**objective) vars_dict = {name: Variable(**var_def) for name, var_def in variables.items()} constraints_list = [Constraint(**constraint) for constraint in constraints] # Create and solve problem with integer variables pulp_solver = PuLPSolver(solver) result = pulp_solver.solve_linear_program( objective=obj, variables=vars_dict, constraints=constraints_list, time_limit=time_limit_seconds, ) return result except Exception as e: logger.error(f"Integer programming error: {e}") return { "status": "error", "error_message": f"Failed to solve integer program: {str(e)}", "objective_value": None, "variables": {}, "execution_time": 0.0, "solver_info": {}, } - src/mcp_optimizer/tools/linear_programming.py:92-197 (registration)Function that defines and registers the solve_integer_program_tool (and solve_linear_program_tool) using the @mcp.tool() decorator on the MCP instance.
def register_linear_programming_tools(mcp: FastMCP[Any]) -> None: """Register linear programming tools with the MCP server.""" @mcp.tool() def solve_linear_program_tool( objective: dict[str, Any], variables: dict[str, dict[str, Any]], constraints: list[dict[str, Any]], solver: str = "CBC", time_limit_seconds: float | None = None, ) -> dict[str, Any]: """Solve a linear programming problem using PuLP. This tool solves general linear programming problems where you want to optimize a linear objective function subject to linear constraints. Use cases: - Resource allocation: Distribute limited resources optimally - Diet planning: Create nutritionally balanced meal plans within budget - Manufacturing mix: Determine optimal product mix to maximize profit - Investment planning: Allocate capital across different investment options - Supply chain optimization: Minimize transportation and storage costs - Energy optimization: Optimize power generation and distribution Args: objective: Objective function with 'sense' ("minimize" or "maximize") and 'coefficients' (dict mapping variable names to coefficients) variables: Variable definitions mapping variable names to their properties (type: "continuous"/"integer"/"binary", lower: bound, upper: bound) constraints: List of constraints, each with 'expression' (coefficients), 'operator' ("<=", ">=", "=="), and 'rhs' (right-hand side value) solver: Solver to use ("CBC", "GLPK", "GUROBI", "CPLEX") time_limit_seconds: Maximum time to spend solving (optional) Returns: Optimization result with status, objective value, variable values, and solver info Example: # Maximize 3x + 2y subject to 2x + y <= 20, x + 3y <= 30, x,y >= 0 solve_linear_program( objective={"sense": "maximize", "coefficients": {"x": 3, "y": 2}}, variables={ "x": {"type": "continuous", "lower": 0}, "y": {"type": "continuous", "lower": 0} }, constraints=[ {"expression": {"x": 2, "y": 1}, "operator": "<=", "rhs": 20}, {"expression": {"x": 1, "y": 3}, "operator": "<=", "rhs": 30} ] ) """ result = solve_linear_program(objective, variables, constraints, solver, time_limit_seconds) result_dict: dict[str, Any] = result return result_dict @mcp.tool() def solve_integer_program_tool( objective: dict[str, Any], variables: dict[str, dict[str, Any]], constraints: list[dict[str, Any]], solver: str = "CBC", time_limit_seconds: float | None = None, ) -> dict[str, Any]: """Solve an integer or mixed-integer programming problem using PuLP. This tool solves optimization problems where some or all variables must take integer values, which is useful for discrete decision problems. Use cases: - Facility location: Decide where to build warehouses or service centers - Project selection: Choose which projects to fund (binary decisions) - Crew scheduling: Assign integer numbers of staff to shifts - Network design: Design networks with discrete components - Cutting stock: Minimize waste when cutting materials - Capital budgeting: Select investments when partial investments aren't allowed Args: objective: Objective function with 'sense' and 'coefficients' variables: Variable definitions with types "continuous", "integer", or "binary" constraints: List of linear constraints solver: Solver to use ("CBC", "GLPK", "GUROBI", "CPLEX") time_limit_seconds: Maximum time to spend solving (optional) Returns: Optimization result with integer/binary variable values Example: # Binary knapsack: select items to maximize value within weight limit solve_integer_program( objective={"sense": "maximize", "coefficients": {"item1": 10, "item2": 15}}, variables={ "item1": {"type": "binary"}, "item2": {"type": "binary"} }, constraints=[ {"expression": {"item1": 5, "item2": 8}, "operator": "<=", "rhs": 10} ] ) """ result = solve_integer_program( objective, variables, constraints, solver, time_limit_seconds ) result_dict: dict[str, Any] = result return result_dict logger.info("Registered linear programming tools") - src/mcp_optimizer/mcp_server.py:137-137 (registration)Invocation of register_linear_programming_tools(mcp) inside create_mcp_server(), which triggers the tool registration for solve_integer_program_tool.
register_linear_programming_tools(mcp) - Server creation function that orchestrates all tool registrations, including the linear programming tools containing solve_integer_program_tool.
def create_mcp_server() -> FastMCP[dict[str, str]]: """Create and configure the MCP server with optimization tools.""" # Create MCP server mcp: FastMCP[dict[str, str]] = FastMCP("MCP Optimizer") # Register all optimization tools register_linear_programming_tools(mcp) register_integer_programming_tools(mcp) register_assignment_tools(mcp) register_knapsack_tools(mcp) register_routing_tools(mcp) register_scheduling_tools(mcp) register_financial_tools(mcp) register_production_tools(mcp) register_validation_tools(mcp) # Health check resource @mcp.resource("resource://health") def health_resource() -> dict[str, Any]: """Get server health status and resource information.""" return get_health() # Resource monitoring endpoints @mcp.resource("resource://resource-stats") def resource_stats_resource() -> dict[str, Any]: """Get detailed resource usage statistics.""" return get_resource_stats() @mcp.resource("resource://resource-reset") def resource_reset_resource() -> dict[str, str]: """Reset resource monitoring statistics.""" return reset_resource_statistics() # Server info resource @mcp.resource("resource://server-info") def server_info_resource() -> dict[str, Any]: """Get comprehensive server information.""" return get_server_info() logger.info("MCP Optimizer server created and configured") logger.info( f"Configuration: max_solve_time={settings.max_solve_time}s, " f"max_memory={settings.max_memory_mb}MB, " f"max_concurrent={settings.max_concurrent_requests}" ) return mcp