# Opti-MCP: Optimization MCP Server

A Model Context Protocol (MCP) server that provides tools for solving optimization problems using Google OR-Tools. This server enables AI assistants to solve Linear Programming (LP), Integer Programming (IP), Mixed-Integer Programming (MIP), and classic combinatorial optimization problems.

## Features

- **Linear Programming**: Solve continuous optimization problems with linear constraints
- **Integer/Mixed-Integer Programming**: Solve optimization problems with integer decision variables
- **Knapsack Problem**: Solve the classic 0/1 knapsack problem efficiently
- Built on Google OR-Tools for robust, production-grade optimization
- Simple JSON-based interface

## Prerequisites

- Node.js 18 or higher
- Python 3.8 or higher
- Google OR-Tools Python library

## Installation

1. Clone this repository:
```bash
git clone <your-repo-url>
cd opti-mcp
```

2. Install Node.js dependencies:
```bash
npm install
```

3. Install Python dependencies:
```bash
pip install ortools
```

4. Build the TypeScript code:
```bash
npm run build
```

## Configuration

Add to your MCP settings file (e.g., `claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "opti-mcp": {
      "command": "node",
      "args": ["/absolute/path/to/opti-mcp/dist/index.js"]
    }
  }
}
```

## Available Tools

### 1. solve_linear_program

Solves linear programming problems where all variables are continuous.

**Example: Production Planning**
```json
{
  "objective": {
    "coefficients": [3, 5],
    "maximize": true
  },
  "constraints": [
    {
      "coefficients": [1, 0],
      "upper_bound": 4
    },
    {
      "coefficients": [0, 2],
      "upper_bound": 12
    },
    {
      "coefficients": [3, 2],
      "upper_bound": 18
    }
  ],
  "variable_bounds": [[0, "Infinity"], [0, "Infinity"]]
}
```

This maximizes `3x₀ + 5x₁` subject to:
- x₀ ≤ 4
- 2x₁ ≤ 12
- 3x₀ + 2x₁ ≤ 18
- x₀, x₁ ≥ 0

### 2. solve_integer_program

Solves integer or mixed-integer programming problems.

**Example: Assignment Problem**
```json
{
  "objective": {
    "coefficients": [1, 2, 3, 4],
    "maximize": false
  },
  "constraints": [
    {
      "coefficients": [1, 1, 0, 0],
      "lower_bound": 1,
      "upper_bound": 1
    },
    {
      "coefficients": [0, 0, 1, 1],
      "lower_bound": 1,
      "upper_bound": 1
    }
  ],
  "variable_bounds": [[0, 1], [0, 1], [0, 1], [0, 1]],
  "integer_variables": [0, 1, 2, 3]
}
```

This solves an assignment problem where variables must be binary (0 or 1).

### 3. solve_knapsack

Solves the 0/1 knapsack problem.

**Example: Item Selection**
```json
{
  "values": [360, 83, 59, 130, 431, 67, 230, 52, 93, 125],
  "weights": [7, 0, 30, 22, 80, 94, 11, 81, 70, 64],
  "capacity": 850
}
```

Maximizes total value while keeping total weight ≤ capacity.

## Example Problems

### Diet Problem
Minimize cost while meeting nutritional requirements:

```json
{
  "objective": {
    "coefficients": [2.5, 1.8, 3.0, 0.5],
    "maximize": false
  },
  "constraints": [
    {
      "coefficients": [10, 5, 8, 2],
      "lower_bound": 50
    },
    {
      "coefficients": [3, 8, 1, 6],
      "lower_bound": 30
    },
    {
      "coefficients": [5, 4, 7, 3],
      "lower_bound": 40
    }
  ]
}
```

### Bin Packing
Pack items into minimum number of bins:

```json
{
  "objective": {
    "coefficients": [1, 1, 1],
    "maximize": false
  },
  "constraints": [
    {
      "coefficients": [5, 0, 0],
      "upper_bound": 10
    },
    {
      "coefficients": [0, 7, 0],
      "upper_bound": 10
    },
    {
      "coefficients": [0, 0, 4],
      "upper_bound": 10
    }
  ],
  "integer_variables": [0, 1, 2]
}
```

## Response Format

All solvers return a JSON response with:

```json
{
  "status": "OPTIMAL",
  "objective_value": 34.0,
  "solution": [2.0, 6.0],
  "solve_time_ms": 15
}
```

- `status`: OPTIMAL, INFEASIBLE, UNBOUNDED, or UNKNOWN
- `objective_value`: The optimal value found (null if not optimal)
- `solution`: Array of variable values (null if not optimal)
- `solve_time_ms`: Time taken to solve in milliseconds

For knapsack problems:
```json
{
  "status": "OPTIMAL",
  "total_value": 1030,
  "total_weight": 850,
  "selected_items": [0, 2, 3, 4],
  "capacity": 850
}
```

## Development

```bash
# Watch mode for development
npm run dev

# Build for production
npm run build

# Run the server
npm start
```

## How It Works

The MCP server:
1. Receives optimization problems via MCP tool calls
2. Translates them into Python scripts using OR-Tools
3. Executes the Python scripts
4. Returns formatted results

## Limitations

- Requires Python 3.8+ with OR-Tools installed
- Currently uses GLOP for LP and SCIP for MIP (requires SCIP installation for best performance)
- Large problems may take significant time to solve

## License

MIT

## Contributing

Contributions welcome! Please open an issue or PR.