Connect your model to Nextmv with the CLI¶

In this tutorial you will learn how to use the Nextmv CLI to bring your own decision model to the Nextmv Platform, from scratch. Complete this tutorial if you:

• Have a pre-existing decision model and you want to explore the Nextmv Platform.
• Are fluent using a language of your preference, such as C++, Java, Python, etc.

To complete this tutorial, we will use three external examples, working under the principle that they are not Nextmv-created decision models. You can, and should, use your own decision model, or follow along with the examples provided:

• Sudoku authored by FICO® Xpress in Python.
• Simple LP problem authored by HiGHS in C++.
• Vehicle Routing Problem with Pickups and Deliveries authored by OR-Tools in Java.

At a high level, this tutorial will go through the following steps using the examples:

1. Nextmv-ify the decision model.
2. Push the model to Nextmv Cloud.
3. Run the model remotely.
4. Perform scenario testing.

You may follow along with the full tutorial code. Let’s dive right in 🤿.

1. Prepare the executable code¶

The decision model is composed of executable code that solves an optimization problem. Copy the desired example code to a script named:

• main.py for the Xpress example.
• main.cpp for the HiGHS example.
• src/main/java/com/google/ortools/constraintsolver/samples/VrpPickupDelivery.java for the OR-Tools example.

import xpress as xp

q = 3

starting_grid = [
    [8, 0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 3, 6, 0, 0, 0, 0, 0],
    [0, 7, 0, 0, 9, 0, 2, 0, 0],
    [0, 5, 0, 0, 0, 7, 0, 0, 0],
    [0, 0, 0, 0, 4, 5, 7, 0, 0],
    [0, 0, 0, 1, 0, 0, 0, 3, 0],
    [0, 0, 1, 0, 0, 0, 0, 6, 8],
    [0, 0, 8, 5, 0, 0, 0, 1, 0],
    [0, 9, 0, 0, 0, 0, 4, 0, 0],
]

n = q**2  # the size must be the square of the size of the subgrids
N = range(n)

p = xp.problem()

x = p.addVariables(N, N, N, vartype=xp.binary)

# define all q^2 subgrids
subgrids = {
    (h, l): [(i, j) for i in range(q * h, q * h + q) for j in range(q * l, q * l + q)]
    for h in range(q)
    for l in range(q)
}

vertical = [xp.Sum(x[i, j, k] for i in N) == 1 for j in N for k in N]
horizontal = [xp.Sum(x[i, j, k] for j in N) == 1 for i in N for k in N]
subgrid = [
    xp.Sum(x[i, j, k] for (i, j) in subgrids[h, l]) == 1
    for (h, l) in subgrids.keys()
    for k in N
]

# Assign exactly one number to each cell

assign = [xp.Sum(x[i, j, k] for k in N) == 1 for i in N for j in N]

init = [
    x[i, j, k] == 1 for k in N for i in N for j in N if starting_grid[i][j] == k + 1
]

p.addConstraint(vertical, horizontal, subgrid, assign, init)

p.optimize()

print("Solution:")

for i in N:
    for j in N:
        l = [k for k in N if p.getSolution(x[i, j, k]) >= 0.5]
        assert len(l) == 1
        print("{0:2d}".format(1 + l[0]), end="", sep="")
    print("")

// HiGHS is designed to solve linear optimization problems of the form
//
// Min (1/2)x^TQx + c^Tx + d subject to L <= Ax <= U; l <= x <= u
//
// where A is a matrix with m rows and n columns, and Q is either zero
// or positive definite. If Q is zero, HiGHS can determine the optimal
// integer-valued solution.
//
// The scalar n is num_col_
// The scalar m is num_row_
//
// The vector c is col_cost_
// The scalar d is offset_
// The vector l is col_lower_
// The vector u is col_upper_
// The vector L is row_lower_
// The vector U is row_upper_
//
// The matrix A is represented in packed vector form, either
// row-wise or column-wise: only its nonzeros are stored
//
// * The number of nonzeros in A is num_nz
//
// * The indices of the nonnzeros in the vectors of A are stored in a_index
//
// * The values of the nonnzeros in the vectors of A are stored in a_value
//
// * The position in a_index/a_value of the index/value of the first
// nonzero in each vector is stored in a_start
//
// Note that a_start[0] must be zero
//
// The matrix Q is represented in packed column form
//
// * The dimension of Q is dim_
//
// * The number of nonzeros in Q is hessian_num_nz
//
// * The indices of the nonnzeros in the vectors of A are stored in q_index
//
// * The values of the nonnzeros in the vectors of A are stored in q_value
//
// * The position in q_index/q_value of the index/value of the first
// nonzero in each column is stored in q_start
//
// Note
//
// * By default, Q is zero. This is indicated by dim_ being initialised to zero.
//
// * q_start[0] must be zero
//
#include <cassert>

#include "Highs.h"

using std::cout;
using std::endl;

int main() {
  // Create and populate a HighsModel instance for the LP
  //
  // Min    f  =  x_0 +  x_1 + 3
  // s.t.                x_1 <= 7
  //        5 <=  x_0 + 2x_1 <= 15
  //        6 <= 3x_0 + 2x_1
  // 0 <= x_0 <= 4; 1 <= x_1
  //
  // Although the first constraint could be expressed as an upper
  // bound on x_1, it serves to illustrate a non-trivial packed
  // column-wise matrix.
  //
  HighsModel model;
  model.lp_.num_col_ = 2;
  model.lp_.num_row_ = 3;
  model.lp_.sense_ = ObjSense::kMinimize;
  model.lp_.offset_ = 3;
  model.lp_.col_cost_ = {1.0, 1.0};
  model.lp_.col_lower_ = {0.0, 1.0};
  model.lp_.col_upper_ = {4.0, 1.0e30};
  model.lp_.row_lower_ = {-1.0e30, 5.0, 6.0};
  model.lp_.row_upper_ = {7.0, 15.0, 1.0e30};
  //
  // Here the orientation of the matrix is column-wise
  model.lp_.a_matrix_.format_ = MatrixFormat::kColwise;
  // a_start_ has num_col_1 entries, and the last entry is the number
  // of nonzeros in A, allowing the number of nonzeros in the last
  // column to be defined
  model.lp_.a_matrix_.start_ = {0, 2, 5};
  model.lp_.a_matrix_.index_ = {1, 2, 0, 1, 2};
  model.lp_.a_matrix_.value_ = {1.0, 3.0, 1.0, 2.0, 2.0};
  //
  // Create a Highs instance
  Highs highs;
  HighsStatus return_status;
  //
  // Pass the model to HiGHS
  return_status = highs.passModel(model);
  assert(return_status == HighsStatus::kOk);
  // If a user passes a model with entries in
  // model.lp_.a_matrix_.value_ less than (the option)
  // small_matrix_value in magnitude, they will be ignored. A logging
  // message will indicate this, and passModel will return
  // HighsStatus::kWarning
  //
  // Get a const reference to the LP data in HiGHS
  const HighsLp& lp = highs.getLp();
  //
  // Solve the model
  return_status = highs.run();
  assert(return_status == HighsStatus::kOk);
  //
  // Get the model status
  const HighsModelStatus& model_status = highs.getModelStatus();
  assert(model_status == HighsModelStatus::kOptimal);
  cout << "Model status: " << highs.modelStatusToString(model_status) << endl;
  //
  // Get the solution information
  const HighsInfo& info = highs.getInfo();
  cout << "Simplex iteration count: " << info.simplex_iteration_count << endl;
  cout << "Objective function value: " << info.objective_function_value << endl;
  cout << "Primal  solution status: "
       << highs.solutionStatusToString(info.primal_solution_status) << endl;
  cout << "Dual    solution status: "
       << highs.solutionStatusToString(info.dual_solution_status) << endl;
  cout << "Basis: " << highs.basisValidityToString(info.basis_validity) << endl;
  const bool has_values = info.primal_solution_status;
  const bool has_duals = info.dual_solution_status;
  const bool has_basis = info.basis_validity;
  //
  // Get the solution values and basis
  const HighsSolution& solution = highs.getSolution();
  const HighsBasis& basis = highs.getBasis();
  //
  // Report the primal and solution values and basis
  for (int col = 0; col < lp.num_col_; col++) {
    cout << "Column " << col;
    if (has_values) cout << "; value = " << solution.col_value[col];
    if (has_duals) cout << "; dual = " << solution.col_dual[col];
    if (has_basis)
      cout << "; status: " << highs.basisStatusToString(basis.col_status[col]);
    cout << endl;
  }
  for (int row = 0; row < lp.num_row_; row++) {
    cout << "Row    " << row;
    if (has_values) cout << "; value = " << solution.row_value[row];
    if (has_duals) cout << "; dual = " << solution.row_dual[row];
    if (has_basis)
      cout << "; status: " << highs.basisStatusToString(basis.row_status[row]);
    cout << endl;
  }

  // Now indicate that all the variables must take integer values
  model.lp_.integrality_.resize(lp.num_col_);
  for (int col = 0; col < lp.num_col_; col++)
    model.lp_.integrality_[col] = HighsVarType::kInteger;

  highs.passModel(model);
  // Solve the model
  return_status = highs.run();
  assert(return_status == HighsStatus::kOk);
  // Report the primal solution values
  for (int col = 0; col < lp.num_col_; col++) {
    cout << "Column " << col;
    if (info.primal_solution_status)
      cout << "; value = " << solution.col_value[col];
    cout << endl;
  }
  for (int row = 0; row < lp.num_row_; row++) {
    cout << "Row    " << row;
    if (info.primal_solution_status)
      cout << "; value = " << solution.row_value[row];
    cout << endl;
  }

  highs.resetGlobalScheduler(true);

  return 0;
}

package com.google.ortools.constraintsolver.samples;

import com.google.ortools.Loader;
import com.google.ortools.constraintsolver.Assignment;
import com.google.ortools.constraintsolver.FirstSolutionStrategy;
import com.google.ortools.constraintsolver.RoutingDimension;
import com.google.ortools.constraintsolver.RoutingIndexManager;
import com.google.ortools.constraintsolver.RoutingModel;
import com.google.ortools.constraintsolver.RoutingSearchParameters;
import com.google.ortools.constraintsolver.Solver;
import com.google.ortools.constraintsolver.main;
import java.util.logging.Logger;

/** Minimal Pickup & Delivery Problem (PDP).*/
public class VrpPickupDelivery {
  private static final Logger logger = Logger.getLogger(VrpPickupDelivery.class.getName());

  static class DataModel {
    public final long[][] distanceMatrix = {
        {0, 548, 776, 696, 582, 274, 502, 194, 308, 194, 536, 502, 388, 354, 468, 776, 662},
        {548, 0, 684, 308, 194, 502, 730, 354, 696, 742, 1084, 594, 480, 674, 1016, 868, 1210},
        {776, 684, 0, 992, 878, 502, 274, 810, 468, 742, 400, 1278, 1164, 1130, 788, 1552, 754},
        {696, 308, 992, 0, 114, 650, 878, 502, 844, 890, 1232, 514, 628, 822, 1164, 560, 1358},
        {582, 194, 878, 114, 0, 536, 764, 388, 730, 776, 1118, 400, 514, 708, 1050, 674, 1244},
        {274, 502, 502, 650, 536, 0, 228, 308, 194, 240, 582, 776, 662, 628, 514, 1050, 708},
        {502, 730, 274, 878, 764, 228, 0, 536, 194, 468, 354, 1004, 890, 856, 514, 1278, 480},
        {194, 354, 810, 502, 388, 308, 536, 0, 342, 388, 730, 468, 354, 320, 662, 742, 856},
        {308, 696, 468, 844, 730, 194, 194, 342, 0, 274, 388, 810, 696, 662, 320, 1084, 514},
        {194, 742, 742, 890, 776, 240, 468, 388, 274, 0, 342, 536, 422, 388, 274, 810, 468},
        {536, 1084, 400, 1232, 1118, 582, 354, 730, 388, 342, 0, 878, 764, 730, 388, 1152, 354},
        {502, 594, 1278, 514, 400, 776, 1004, 468, 810, 536, 878, 0, 114, 308, 650, 274, 844},
        {388, 480, 1164, 628, 514, 662, 890, 354, 696, 422, 764, 114, 0, 194, 536, 388, 730},
        {354, 674, 1130, 822, 708, 628, 856, 320, 662, 388, 730, 308, 194, 0, 342, 422, 536},
        {468, 1016, 788, 1164, 1050, 514, 514, 662, 320, 274, 388, 650, 536, 342, 0, 764, 194},
        {776, 868, 1552, 560, 674, 1050, 1278, 742, 1084, 810, 1152, 274, 388, 422, 764, 0, 798},
        {662, 1210, 754, 1358, 1244, 708, 480, 856, 514, 468, 354, 844, 730, 536, 194, 798, 0},
    };
    public final int[][] pickupsDeliveries = {
        {1, 6},
        {2, 10},
        {4, 3},
        {5, 9},
        {7, 8},
        {15, 11},
        {13, 12},
        {16, 14},
    };
    public final int vehicleNumber = 4;
    public final int depot = 0;
  }

  /// @brief Print the solution.
  static void printSolution(
      DataModel data, RoutingModel routing, RoutingIndexManager manager, Assignment solution) {
    // Solution cost.
    logger.info("Objective : " + solution.objectiveValue());
    // Inspect solution.
    long totalDistance = 0;
    for (int i = 0; i < data.vehicleNumber; ++i) {
      if (!routing.isVehicleUsed(solution, i)) {
        continue;
      }
      long index = routing.start(i);
      logger.info("Route for Vehicle " + i + ":");
      long routeDistance = 0;
      String route = "";
      while (!routing.isEnd(index)) {
        route += manager.indexToNode(index) + " -> ";
        long previousIndex = index;
        index = solution.value(routing.nextVar(index));
        routeDistance += routing.getArcCostForVehicle(previousIndex, index, i);
      }
      logger.info(route + manager.indexToNode(index));
      logger.info("Distance of the route: " + routeDistance + "m");
      totalDistance += routeDistance;
    }
    logger.info("Total Distance of all routes: " + totalDistance + "m");
  }

  public static void main(String[] args) throws Exception {
    Loader.loadNativeLibraries();
    // Instantiate the data problem.
    final DataModel data = new DataModel();

    // Create Routing Index Manager
    RoutingIndexManager manager =
        new RoutingIndexManager(data.distanceMatrix.length, data.vehicleNumber, data.depot);

    // Create Routing Model.
    RoutingModel routing = new RoutingModel(manager);

    // Create and register a transit callback.
    final int transitCallbackIndex =
        routing.registerTransitCallback((long fromIndex, long toIndex) -> {
          // Convert from routing variable Index to user NodeIndex.
          int fromNode = manager.indexToNode(fromIndex);
          int toNode = manager.indexToNode(toIndex);
          return data.distanceMatrix[fromNode][toNode];
        });

    // Define cost of each arc.
    routing.setArcCostEvaluatorOfAllVehicles(transitCallbackIndex);

    // Add Distance constraint.
    boolean unused = routing.addDimension(transitCallbackIndex, // transit callback index
        0, // no slack
        3000, // vehicle maximum travel distance
        true, // start cumul to zero
        "Distance");
    RoutingDimension distanceDimension = routing.getMutableDimension("Distance");
    distanceDimension.setGlobalSpanCostCoefficient(100);

    // Define Transportation Requests.
    Solver solver = routing.solver();
    for (int[] request : data.pickupsDeliveries) {
      long pickupIndex = manager.nodeToIndex(request[0]);
      long deliveryIndex = manager.nodeToIndex(request[1]);
      routing.addPickupAndDelivery(pickupIndex, deliveryIndex);
      solver.addConstraint(
          solver.makeEquality(routing.vehicleVar(pickupIndex), routing.vehicleVar(deliveryIndex)));
      solver.addConstraint(solver.makeLessOrEqual(
          distanceDimension.cumulVar(pickupIndex), distanceDimension.cumulVar(deliveryIndex)));
    }

    // Setting first solution heuristic.
    RoutingSearchParameters searchParameters =
        main.defaultRoutingSearchParameters()
            .toBuilder()
            .setFirstSolutionStrategy(FirstSolutionStrategy.Value.PARALLEL_CHEAPEST_INSERTION)
            .build();

    // Solve the problem.
    Assignment solution = routing.solveWithParameters(searchParameters);

    // Print solution on console.
    printSolution(data, routing, manager, solution);
  }
}

2. Set up requirements¶

The examples require different setups. These are the requirements that you need before compiling and running the examples.

2.1. Xpress¶

If you are following along with the full tutorial code, you should be using the original directory. In that case, run the following command in the root of your project.

uv sync

On the other hand, if you are completing this tutorial from scratch, run the following command in the root of your project.

uv init --bare # Execute if you don't have a pyproject.toml file in your project.
uv add xpress

2.2. HiGHS¶

Stand at the root of the project where you placed the main.cpp file.

• Make sure you can run g++ (C++ compiler).

• Make sure you can run cmake (CMake build system).

• Clone HiGHS from GitHub to build the solver.

  git clone https://github.com/ERGO-Code/HiGHS.git
  

• Build HiGHS, the solver itself.

  cd HiGHS
  cmake -S. -B build 
  cmake --build build --parallel
  cd ..
  

• After building, a ./HiGHS/build/lib directory should exist with the necessary libraries.

2.3. OR-Tools¶

Stand at the root of the project where you placed the src directory.

• Make sure you can run java (JDK 11 or higher).

• Make sure you can run mvn (Maven).

• Create a pom.xml file to manage dependencies.

  pom.xml

  <?xml version="1.0" encoding="UTF-8"?>
  <project xmlns="http://maven.apache.org/POM/4.0.0"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
  
      <groupId>com.google.ortools</groupId>
      <artifactId>vrp-pickup-delivery</artifactId>
      <version>1.0-SNAPSHOT</version>
      <packaging>jar</packaging>
  
      <name>VRP Pickup Delivery</name>
      <description>Vehicle Routing Problem with Pickup and Delivery using OR-Tools</description>
  
      <properties>
          <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
          <maven.compiler.source>11</maven.compiler.source>
          <maven.compiler.target>11</maven.compiler.target>
          <ortools.version>9.8.3296</ortools.version>
      </properties>
  
      <dependencies>
          <!-- OR-Tools dependency -->
          <dependency>
              <groupId>com.google.ortools</groupId>
              <artifactId>ortools-java</artifactId>
              <version>${ortools.version}</version>
          </dependency>
      </dependencies>
  
      <build>
          <plugins>
              <!-- Maven Compiler Plugin -->
              <plugin>
                  <groupId>org.apache.maven.plugins</groupId>
                  <artifactId>maven-compiler-plugin</artifactId>
                  <version>3.11.0</version>
                  <configuration>
                      <source>11</source>
                      <target>11</target>
                  </configuration>
              </plugin>
  
              <!-- Maven Exec Plugin for running the application -->
              <plugin>
                  <groupId>org.codehaus.mojo</groupId>
                  <artifactId>exec-maven-plugin</artifactId>
                  <version>3.1.0</version>
                  <configuration>
                      <mainClass>com.google.ortools.constraintsolver.samples.VrpPickupDelivery</mainClass>
                  </configuration>
              </plugin>
  
              <!-- Maven Shade Plugin for creating an executable JAR -->
              <plugin>
                  <groupId>org.apache.maven.plugins</groupId>
                  <artifactId>maven-shade-plugin</artifactId>
                  <version>3.5.1</version>
                  <executions>
                      <execution>
                          <phase>package</phase>
                          <goals>
                              <goal>shade</goal>
                          </goals>
                          <configuration>
                              <createDependencyReducedPom>false</createDependencyReducedPom>
                              <shadedArtifactAttached>false</shadedArtifactAttached>
                              <outputDirectory>.</outputDirectory>
                              <finalName>main</finalName>
                              <transformers>
                                  <transformer
                                      implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                      <mainClass>
                                          com.google.ortools.constraintsolver.samples.VrpPickupDelivery</mainClass>
                                  </transformer>
                              </transformers>
                          </configuration>
                      </execution>
                  </executions>
              </plugin>
          </plugins>
      </build>
  </project>
  

3. Compile and run the executable code¶

These are the steps for compiling and running the examples.

3.1. Xpress¶

Stand at the root of the project where you placed the main.py file. Execute the following command to run the code.

uv run main.py

FICO Xpress v9.9.1, Community, solve started 11:02:39, Jul 9, 2026
Heap usage: 755KB (peak 755KB, 58KB system)
Minimizing MILP noname using up to 10 threads and up to 32GB memory, with these control settings:
OUTPUTLOG = 1
NLPPOSTSOLVE = 1
XSLP_DELETIONCONTROL = 0
XSLP_OBJSENSE = 1
Original problem has:
      345 rows          729 cols         2937 elements       729 entities
Presolved problem has:
      141 rows          201 cols          595 elements       201 entities
LP relaxation tightened
Presolve finished in 0 seconds
Heap usage: 2355KB (peak 2355KB, 58KB system)

Coefficient range                    original                 solved        
  Coefficients   [min,max] : [ 1.00e+00,  1.00e+00] / [ 1.00e+00,  1.00e+00]
  RHS and bounds [min,max] : [ 1.00e+00,  1.00e+00] / [ 1.00e+00,  1.00e+00]
  Objective      [min,max] : [      0.0,       0.0] / [      0.0,       0.0]
Autoscaling applied standard scaling

Will try to keep branch and bound tree memory usage below 30.3GB
Starting concurrent solve with dual (1 thread)

Concurrent-Solve,   0s
            Dual        
    objective   dual inf

------- optimal --------
Concurrent statistics:
          Dual: 207 simplex iterations, 0.00s
Optimal solution found

  Its         Obj Value      S   Ninf  Nneg        Sum Inf  Time
  207           .000000      P      0     0        .000000     0
Dual solved problem
  207 simplex iterations in 0.00 seconds at time 0

Final objective                       : 0.000000000000000e+00
  Max primal violation      (abs/rel) :       0.0 /       0.0
  Max dual violation        (abs/rel) :       0.0 /       0.0
  Max complementarity viol. (abs/rel) :       0.0 /       0.0

Starting root cutting & heuristics
Deterministic mode with up to 4 additional threads

Its Type    BestSoln    BestBound   Sols    Add    Del     Gap     GInf   Time
P             .000000      .000000      1               0.0e+00        0      0
STOPPING - MIPRELSTOP target reached (MIPRELSTOP=0.0001  gap=0).
*** Search completed ***
Uncrunching matrix
Final MIP objective                   : 0.000000000000000e-01
Final MIP bound                       : 0.000000000000000e-01
  Solution time / primaldual integral :      0.02s/ 98.601964%
  Work / work units per second        :      0.02 /      1.20
  Number of solutions found / nodes   :         1 /         0
  Max primal violation      (abs/rel) :       0.0 /       0.0
  Max integer violation     (abs    ) :       0.0
Solution:
8 1 2 7 5 3 6 4 9
9 4 3 6 8 2 1 7 5
6 7 5 4 9 1 2 8 3
1 5 4 2 3 7 8 9 6
3 6 9 8 4 5 7 2 1
2 8 7 1 6 9 5 3 4
5 2 1 9 7 4 3 6 8
4 3 8 5 2 6 9 1 7
7 9 6 3 1 8 4 5 2

3.2. HiGHS¶

Stand at the root of the project where you placed the main.cpp file.

• Execute the following command to compile the code.

  g++ -std=c++11 main.cpp -o main \
    -I./HiGHS/highs \
    -I./HiGHS/build \
    -L./HiGHS/build/lib -lhighs
  

• A ./main binary should have been created.

• Execute the following command to run the code.

DYLD_LIBRARY_PATH=./HiGHS/build/lib ./main

LD_LIBRARY_PATH=./HiGHS/build/lib ./main

Running HiGHS 1.12.0 (git hash: 869cbd4df): Copyright (c) 2025 HiGHS under MIT licence terms
Cols:           1 upper bounds greater than or equal to        1e+20 are treated as +Infinity
Rows:           1 lower bounds    less than or equal to       -1e+20 are treated as -Infinity
Rows:           1 upper bounds greater than or equal to        1e+20 are treated as +Infinity
LP has 3 rows; 2 cols; 5 nonzeros
Coefficient ranges:
  Matrix  [1e+00, 3e+00]
  Cost    [1e+00, 1e+00]
  Bound   [1e+00, 4e+00]
  RHS     [5e+00, 2e+01]
Presolving model
2 rows, 2 cols, 4 nonzeros  0s
2 rows, 2 cols, 4 nonzeros  0s
Presolve reductions: rows 2(-1); columns 2(-0); nonzeros 4(-1)
Solving the presolved LP
Using EKK dual simplex solver - serial
  Iteration        Objective     Infeasibilities num(sum)
          0     4.0000013886e+00 Pr: 2(7) 0s
          2     5.7500000000e+00 Pr: 0(0) 0s

Performed postsolve
Solving the original LP from the solution after postsolve

Model status        : Optimal
Simplex   iterations: 2
Objective value     :  5.7500000000e+00
P-D objective error :  0.0000000000e+00
HiGHS run time      :          0.00
Model status: Optimal
Simplex iteration count: 2
Objective function value: 5.75
Primal  solution status: Feasible
Dual    solution status: Feasible
Basis: Valid
Column 0; value = 0.5; dual = 0; status: Basic
Column 1; value = 2.25; dual = 0; status: Basic
Row    0; value = 2.25; dual = -0; status: Basic
Row    1; value = 5; dual = 0.25; status: At lower/fixed bound
Row    2; value = 6; dual = 0.25; status: At lower/fixed bound
Cols:           1 upper bounds greater than or equal to        1e+20 are treated as +Infinity
Rows:           1 lower bounds    less than or equal to       -1e+20 are treated as -Infinity
Rows:           1 upper bounds greater than or equal to        1e+20 are treated as +Infinity
MIP has 3 rows; 2 cols; 5 nonzeros; 2 integer variables (0 binary)
Coefficient ranges:
  Matrix  [1e+00, 3e+00]
  Cost    [1e+00, 1e+00]
  Bound   [1e+00, 4e+00]
  RHS     [5e+00, 2e+01]
Presolving model
2 rows, 2 cols, 4 nonzeros  0s
2 rows, 2 cols, 4 nonzeros  0s
Presolve reductions: rows 2(-1); columns 2(-0); nonzeros 4(-1)
Objective function is integral with scale 1

Solving MIP model with:
  2 rows
  2 cols (0 binary, 2 integer, 0 implied int., 0 continuous, 0 domain fixed)
  4 nonzeros

Src: B => Branching; C => Central rounding; F => Feasibility pump; H => Heuristic;
    I => Shifting; J => Feasibility jump; L => Sub-MIP; P => Empty MIP; R => Randomized rounding;
    S => Solve LP; T => Evaluate node; U => Unbounded; X => User solution; Y => HiGHS solution;
    Z => ZI Round; l => Trivial lower; p => Trivial point; u => Trivial upper; z => Trivial zero

        Nodes      |    B&B Tree     |            Objective Bounds              |  Dynamic Constraints |       Work
Src  Proc. InQueue |  Leaves   Expl. | BestBound       BestSol              Gap |   Cuts   InLp Confl. | LpIters     Time

u       0       0         0   0.00%   -inf            9                  Large        0      0      0         0     0.0s
J       0       0         0 100.00%   -inf            6                  Large        0      0      0         0     0.0s
        1       0         1 100.00%   6               6                  0.00%        0      0      0         0     0.0s

Solving report
  Status            Optimal
  Primal bound      6
  Dual bound        6
  Gap               0% (tolerance: 0.01%)
  P-D integral      2.22166818276e-07
  Solution status   feasible
                    6 (objective)
                    0 (bound viol.)
                    0 (int. viol.)
                    0 (row viol.)
  Timing            0.01
  Max sub-MIP depth 0
  Nodes             1
  Repair LPs        0
  LP iterations     0
Column 0; value = -0
Column 1; value = 3
Row    0; value = 3
Row    1; value = 6
Row    2; value = 6

3.3. OR-Tools¶

Stand at the root of the project where you placed the src directory.

• Execute the following command to compile the code.

  mvn clean package
  

• A ./main.jar file should have been created.

• Execute the following command to run the code.

java -jar main.jar

Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Objective : 226116
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Route for Vehicle 0:
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: 0 -> 13 -> 15 -> 11 -> 12 -> 0
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Distance of the route: 1552m
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Route for Vehicle 1:
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: 0 -> 5 -> 2 -> 10 -> 16 -> 14 -> 9 -> 0
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Distance of the route: 2192m
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Route for Vehicle 2:
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: 0 -> 4 -> 3 -> 0
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Distance of the route: 1392m
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Route for Vehicle 3:
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: 0 -> 7 -> 1 -> 6 -> 8 -> 0
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Distance of the route: 1780m
Nov 26, 2025 1:26:43 PM com.google.ortools.constraintsolver.samples.VrpPickupDelivery printSolution
INFO: Total Distance of all routes: 6916m

4. Nextmv-ify the decision model¶

We are going to turn the executable decision model into a Nextmv application.

We are going to adapt the examples so that they can follow the conventions of a Nextmv application, such as:

• The app receives one, or more, inputs (problem data) through stdin or files.
• The app run can be configured through options that are received as CLI arguments.
• The app processes the inputs, and executes the decision model.
• The app produces one, or more, outputs (solutions) and prints to stdout or files.
• The app optionally produces metrics and assets (can be visual, like charts).

Start by adding the app.yaml file, which is known as the app manifest, to the root of the project. This file contains the configuration of the app.

type: python
runtime: ghcr.io/nextmv-io/runtime/python:3.11
files:
  - main.py
python:
  pip-requirements: pyproject.toml # Can be a requirements.txt
configuration:
  content:
    format: json
  options:
    items:
      - name: duration
        description: Duration for the solver, in seconds.
        required: false
        option_type: float
        default: 1
        additional_attributes:
          min: 0
          max: 10
          step: 1
        ui:
          control_type: slider

type: binary
runtime: ghcr.io/nextmv-io/runtime/default:latest
files:
  - main
  - HiGHS/build/lib/
build:
  command: bash ./build.sh
execution:
  entrypoint: main
configuration:
  content:
    format: json
  options:
    items:
      - name: duration
        description: Duration for the solver, in seconds.
        required: false
        option_type: float
        default: 1
        additional_attributes:
          min: 0
          max: 10
          step: 1
        ui:
          control_type: slider

type: java
runtime: ghcr.io/nextmv-io/runtime/java:latest
files:
  - main.jar
build:
  command: mvn clean package
execution:
  entrypoint: main.jar
configuration:
  content:
    format: multi-file
    multi-file:
      input:
        path: inputs
      output:
        solutions: outputs/solutions
        metrics: outputs/metrics.json
        assets: outputs/assets.json
  options:
    items:
      - name: vehicle_maximum_travel_distance
        description: Maximum travel distance for each vehicle, in meters.
        required: false
        option_type: float
        default: 3000
        additional_attributes:
          min: 10
          max: 10000
          step: 100
        ui:
          control_type: slider
      - name: global_span_cost_coefficient
        description: Coefficient for the global span cost in the objective function.
        required: false
        option_type: float
        default: 100
        additional_attributes:
          min: 1
          max: 10000
          step: 10
        ui:
          control_type: slider

This tutorial is not meant to discuss the app manifest in-depth, for that you can go to the manifest docs. However, these are the main attributes shown in the manifests:

• type: the examples demonstrate different types of applications.
• runtime: Xpress uses the python runtime, HiGHS uses default to execute binaries, and OR-Tools uses the java runtime to execute Java applications.
• build.command: specifies in some cases the command to build the executable code. We are going to compile an artifact for HiGHS and OR-Tools.
• execution.entrypoint: specifies the executable code to run.
• files: contains files that make up the executable code of the app. For Xpress we need the main.py, for HiGHS we are including the main binary and the required libraries, and finally for OR-Tools, we are including the main.jar file.
• python.pip-requirements: specifies for Xpress the file with the Python packages that need to be installed for the application.
• configuration.content: Xpress and HiGHS will use the json format, so they do not need additional configurations. OR-Tools will use multi-file, so additional configurations are needed. As you complete this tutorial, the difference between the two formats will become clearer.
• configuration.options: for the examples we are adding options to the application, which allow you to configure runs, with parameters such as solver duration.

Now, you can overwrite your decision model files with the Nextmv-ified version.

import nextmv
import xpress as xp

input = nextmv.load()
q = input.data["q"]
starting_grid = input.data["starting_grid"]

n = q**2  # the size must be the square of the size of the subgrids
N = range(n)

nextmv.redirect_stdout()  # Solver chatter is logged to stderr.

p = xp.problem()
p.setControl("timelimit", input.options.duration)

x = p.addVariables(N, N, N, vartype=xp.binary)

# define all q^2 subgrids
subgrids = {
    (h, l): [(i, j) for i in range(q * h, q * h + q) for j in range(q * l, q * l + q)]
    for h in range(q)
    for l in range(q)
}

vertical = [xp.Sum(x[i, j, k] for i in N) == 1 for j in N for k in N]
horizontal = [xp.Sum(x[i, j, k] for j in N) == 1 for i in N for k in N]
subgrid = [
    xp.Sum(x[i, j, k] for (i, j) in subgrids[h, l]) == 1
    for (h, l) in subgrids.keys()
    for k in N
]

# Assign exactly one number to each cell

assign = [xp.Sum(x[i, j, k] for k in N) == 1 for i in N for j in N]

init = [
    x[i, j, k] == 1 for k in N for i in N for j in N if starting_grid[i][j] == k + 1
]

p.addConstraint(vertical, horizontal, subgrid, assign, init)

p.optimize()

print("Solution:")
solution = {}
rows = []
for i in N:
    row = []
    for j in N:
        l = [k for k in N if p.getSolution(x[i, j, k]) >= 0.5]
        assert len(l) == 1
        value = 1 + l[0]
        row.append(value)
        print("{0:2d}".format(value), end="", sep="")
    rows.append(row)
    print("")

for i, row in enumerate(rows):
    solution[f"row_{i}"] = row

metrics = {
    "duration": p.attributes.time,
    "objective": p.attributes.objval,
    "num_variables": p.attributes.cols,
    "num_constraints": p.attributes.rows,
}

nextmv.write(solution=solution, metrics=metrics, options=input.options)