cue-ai 0.3.0

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-c/resources/examples.md

@@ -0,0 +1,291 @@
+# LP/MILP: C API Examples
+
+## Required Headers
+
+```c
+#include <cuopt/linear_programming/cuopt_c.h>   // Core API
+#include <cuopt/linear_programming/constants.h> // Parameter name macros (CUOPT_TIME_LIMIT, etc.)
+```
+
+## Parameter Setting Functions
+
+**Important:** Use the correct function for each parameter type:
+
+| Function | Use For | Example |
+|----------|---------|---------|
+| `cuOptSetFloatParameter` | Float params (tolerances, time_limit) | `cuOptSetFloatParameter(settings, CUOPT_TIME_LIMIT, 60.0)` |
+| `cuOptSetIntegerParameter` | Integer params (log_to_console, method) | `cuOptSetIntegerParameter(settings, CUOPT_LOG_TO_CONSOLE, 1)` |
+| `cuOptSetParameter` | String params | `cuOptSetParameter(settings, "custom_param", "value")` |
+
+**Common mistake:** Using non-existent function names like `cuOptSetIntParameter` (correct: `cuOptSetIntegerParameter`).
+
+---
+
+## Simple LP
+
+```c
+/*
+ * Solve: minimize  -0.2*x1 + 0.1*x2
+ *        subject to  3.0*x1 + 4.0*x2 <= 5.4
+ *                    2.7*x1 + 10.1*x2 <= 4.9
+ *                    x1, x2 >= 0
+ */
+#include <cuopt/linear_programming/cuopt_c.h>
+#include <cuopt/linear_programming/constants.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+    cuOptOptimizationProblem problem = NULL;
+    cuOptSolverSettings settings = NULL;
+    cuOptSolution solution = NULL;
+
+    cuopt_int_t num_variables = 2;
+    cuopt_int_t num_constraints = 2;
+
+    // Constraint matrix in CSR format
+    cuopt_int_t row_offsets[] = {0, 2, 4};
+    cuopt_int_t column_indices[] = {0, 1, 0, 1};
+    cuopt_float_t values[] = {3.0, 4.0, 2.7, 10.1};
+
+    // Objective coefficients
+    cuopt_float_t objective_coefficients[] = {-0.2, 0.1};
+
+    // Constraint bounds (lower <= Ax <= upper)
+    cuopt_float_t constraint_upper_bounds[] = {5.4, 4.9};
+    cuopt_float_t constraint_lower_bounds[] = {-CUOPT_INFINITY, -CUOPT_INFINITY};
+
+    // Variable bounds
+    cuopt_float_t var_lower_bounds[] = {0.0, 0.0};
+    cuopt_float_t var_upper_bounds[] = {CUOPT_INFINITY, CUOPT_INFINITY};
+
+    // Variable types
+    char variable_types[] = {CUOPT_CONTINUOUS, CUOPT_CONTINUOUS};
+
+    cuopt_int_t status;
+
+    // Create problem
+    status = cuOptCreateRangedProblem(
+        num_constraints, num_variables, CUOPT_MINIMIZE,
+        0.0,  // objective offset
+        objective_coefficients,
+        row_offsets, column_indices, values,
+        constraint_lower_bounds, constraint_upper_bounds,
+        var_lower_bounds, var_upper_bounds,
+        variable_types,
+        &problem
+    );
+    if (status != CUOPT_SUCCESS) {
+        printf("Error creating problem: %d\n", status);
+        return 1;
+    }
+
+    // Create and configure solver settings
+    cuOptCreateSolverSettings(&settings);
+    cuOptSetFloatParameter(settings, CUOPT_ABSOLUTE_PRIMAL_TOLERANCE, 0.0001);
+    cuOptSetFloatParameter(settings, CUOPT_TIME_LIMIT, 60.0);
+
+    // Solve
+    status = cuOptSolve(problem, settings, &solution);
+    if (status != CUOPT_SUCCESS) {
+        printf("Error solving: %d\n", status);
+        goto cleanup;
+    }
+
+    // Get results
+    cuopt_float_t time, objective_value;
+    cuopt_int_t termination_status;
+
+    cuOptGetSolveTime(solution, &time);
+    cuOptGetTerminationStatus(solution, &termination_status);
+    cuOptGetObjectiveValue(solution, &objective_value);
+
+    printf("Status: %d\n", termination_status);
+    printf("Time: %f s\n", time);
+    printf("Objective: %f\n", objective_value);
+
+    // Get solution values
+    cuopt_float_t* sol = malloc(num_variables * sizeof(cuopt_float_t));
+    cuOptGetPrimalSolution(solution, sol);
+    printf("x1 = %f\n", sol[0]);
+    printf("x2 = %f\n", sol[1]);
+    free(sol);
+
+cleanup:
+    cuOptDestroyProblem(&problem);
+    cuOptDestroySolverSettings(&settings);
+    cuOptDestroySolution(&solution);
+    return (status == CUOPT_SUCCESS) ? 0 : 1;
+}
+```
+
+## MILP (with integer variables)
+
+```c
+/*
+ * Same as LP but x1 is integer
+ */
+#include <cuopt/linear_programming/cuopt_c.h>
+#include <cuopt/linear_programming/constants.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main() {
+    cuOptOptimizationProblem problem = NULL;
+    cuOptSolverSettings settings = NULL;
+    cuOptSolution solution = NULL;
+
+    cuopt_int_t num_variables = 2;
+    cuopt_int_t num_constraints = 2;
+
+    cuopt_int_t row_offsets[] = {0, 2, 4};
+    cuopt_int_t column_indices[] = {0, 1, 0, 1};
+    cuopt_float_t values[] = {3.0, 4.0, 2.7, 10.1};
+
+    cuopt_float_t objective_coefficients[] = {-0.2, 0.1};
+    cuopt_float_t constraint_upper[] = {5.4, 4.9};
+    cuopt_float_t constraint_lower[] = {-CUOPT_INFINITY, -CUOPT_INFINITY};
+    cuopt_float_t var_lower[] = {0.0, 0.0};
+    cuopt_float_t var_upper[] = {CUOPT_INFINITY, CUOPT_INFINITY};
+
+    // x1 = INTEGER, x2 = CONTINUOUS
+    char variable_types[] = {CUOPT_INTEGER, CUOPT_CONTINUOUS};
+
+    cuopt_int_t status = cuOptCreateRangedProblem(
+        num_constraints, num_variables, CUOPT_MINIMIZE, 0.0,
+        objective_coefficients,
+        row_offsets, column_indices, values,
+        constraint_lower, constraint_upper,
+        var_lower, var_upper,
+        variable_types, &problem
+    );
+    if (status != CUOPT_SUCCESS) {
+        printf("Error creating problem: %d\n", status);
+        return 1;
+    }
+
+    cuOptCreateSolverSettings(&settings);
+    cuOptSetFloatParameter(settings, CUOPT_MIP_ABSOLUTE_TOLERANCE, 0.0001);
+    cuOptSetFloatParameter(settings, CUOPT_MIP_RELATIVE_GAP, 0.01);
+    cuOptSetFloatParameter(settings, CUOPT_TIME_LIMIT, 120.0);
+
+    status = cuOptSolve(problem, settings, &solution);
+    if (status != CUOPT_SUCCESS) {
+        printf("Error solving: %d\n", status);
+        goto cleanup;
+    }
+
+    if (solution != NULL) {
+        cuopt_float_t objective_value;
+        cuOptGetObjectiveValue(solution, &objective_value);
+        printf("Objective: %f\n", objective_value);
+
+        cuopt_float_t* sol = malloc(num_variables * sizeof(cuopt_float_t));
+        if (sol == NULL) {
+            printf("Error: memory allocation failed\n");
+            status = -1;
+            goto cleanup;
+        }
+        cuOptGetPrimalSolution(solution, sol);
+        printf("x1 (integer) = %f\n", sol[0]);
+        printf("x2 (continuous) = %f\n", sol[1]);
+        free(sol);
+    }
+
+cleanup:
+    cuOptDestroyProblem(&problem);
+    cuOptDestroySolverSettings(&settings);
+    cuOptDestroySolution(&solution);
+    return (status == CUOPT_SUCCESS) ? 0 : 1;
+}
+```
+
+## Build & Run
+
+```bash
+# Set paths (conda example)
+export INCLUDE_PATH="${CONDA_PREFIX}/include"
+export LIB_PATH="${CONDA_PREFIX}/lib"
+
+# Compile
+gcc -I${INCLUDE_PATH} -L${LIB_PATH} -o lp_example lp_example.c -lcuopt
+
+# Run
+LD_LIBRARY_PATH=${LIB_PATH}:$LD_LIBRARY_PATH ./lp_example
+```
+
+## Constants Reference
+
+```c
+// Optimization sense
+CUOPT_MINIMIZE
+CUOPT_MAXIMIZE
+
+// Variable types
+CUOPT_CONTINUOUS
+CUOPT_INTEGER
+
+// Special values
+CUOPT_INFINITY      // Use for unbounded
+-CUOPT_INFINITY     // Use for no lower bound
+
+// Return codes
+CUOPT_SUCCESS       // 0
+```
+
+## Parameter Name Constants (from constants.h)
+
+```c
+// Float parameters (use with cuOptSetFloatParameter)
+CUOPT_TIME_LIMIT                    // "time_limit"
+CUOPT_ABSOLUTE_PRIMAL_TOLERANCE     // "absolute_primal_tolerance"
+CUOPT_ABSOLUTE_DUAL_TOLERANCE       // "absolute_dual_tolerance"
+CUOPT_RELATIVE_PRIMAL_TOLERANCE     // "relative_primal_tolerance"
+CUOPT_RELATIVE_DUAL_TOLERANCE       // "relative_dual_tolerance"
+CUOPT_MIP_ABSOLUTE_GAP              // "mip_absolute_gap"
+CUOPT_MIP_RELATIVE_GAP              // "mip_relative_gap"
+CUOPT_MIP_ABSOLUTE_TOLERANCE        // "mip_absolute_tolerance"
+CUOPT_MIP_RELATIVE_TOLERANCE        // "mip_relative_tolerance"
+CUOPT_MIP_INTEGRALITY_TOLERANCE     // "mip_integrality_tolerance"
+
+// Integer parameters (use with cuOptSetIntegerParameter)
+CUOPT_LOG_TO_CONSOLE                // "log_to_console"
+CUOPT_ITERATION_LIMIT               // "iteration_limit"
+CUOPT_METHOD                        // "method" (see CUOPT_METHOD_* values)
+CUOPT_PDLP_SOLVER_MODE              // "pdlp_solver_mode" (see CUOPT_PDLP_SOLVER_MODE_* values)
+CUOPT_PRESOLVE                      // "presolve"
+CUOPT_NUM_CPU_THREADS               // "num_cpu_threads"
+CUOPT_NUM_GPUS                      // "num_gpus"
+
+// Method values (for CUOPT_METHOD)
+CUOPT_METHOD_CONCURRENT             // 0 - Run multiple methods concurrently
+CUOPT_METHOD_PDLP                   // 1 - PDLP solver
+CUOPT_METHOD_DUAL_SIMPLEX           // 2 - Dual simplex
+CUOPT_METHOD_BARRIER                // 3 - Barrier method
+
+// PDLP solver mode values (for CUOPT_PDLP_SOLVER_MODE)
+CUOPT_PDLP_SOLVER_MODE_STABLE1      // 0
+CUOPT_PDLP_SOLVER_MODE_STABLE2      // 1
+CUOPT_PDLP_SOLVER_MODE_METHODICAL1  // 2
+CUOPT_PDLP_SOLVER_MODE_FAST1        // 3
+CUOPT_PDLP_SOLVER_MODE_STABLE3      // 4
+```
+
+> **Complete list:** See `cpp/include/cuopt/linear_programming/constants.h` for all 50+ parameter constants including termination status codes, constraint senses, and file format constants.
+
+---
+
+## Additional References (tested in CI)
+
+For more complete C examples with full error handling, see:
+
+| Resource | Location |
+|----------|----------|
+| **Constants Header** | `cpp/include/cuopt/linear_programming/constants.h` |
+| C API Header | `cpp/include/cuopt/linear_programming/cuopt_c.h` |
+| C API Documentation | `docs/cuopt/source/cuopt-c/lp-qp-milp/lp-qp-milp-c-api.rst` |
+| Simple LP Example | `docs/cuopt/source/cuopt-c/lp-qp-milp/examples/simple_lp_example.c` |
+| Simple MILP Example | `docs/cuopt/source/cuopt-c/lp-qp-milp/examples/simple_milp_example.c` |
+| MPS File Example | `docs/cuopt/source/cuopt-c/lp-qp-milp/examples/mps_file_example.c` |
+
+The `constants.h` header contains all parameter name macros, termination status codes, method values, and constraint sense constants.

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-c/skill-card.md

@@ -0,0 +1,40 @@
+## Description: <br>
+LP, MILP, and QP (beta) with cuOpt — C API only. Use when the user is embedding LP, MILP, or QP in C/C++. <br>
+
+This skill is ready for commercial/non-commercial use. <br>
+
+## Owner: NVIDIA <br>
+
+### License/Terms of Use: <br>
+Apache 2.0 <br>
+## Use Case: <br>
+Developers and engineers embedding linear programming, mixed-integer linear programming, or quadratic programming solvers into C/C++ applications using the NVIDIA cuOpt C API. <br>
+
+### Deployment Geography for Use: <br>
+Global <br>
+
+## Known Risks and Mitigations: <br>
+Risk: Review before execution as proposals could introduce incorrect or misleading guidance into skills. <br>
+Mitigation: Review and scan skill before deployment. <br>
+
+## Reference(s): <br>
+- [cuOpt User Guide](https://docs.nvidia.com/cuopt/user-guide/latest/introduction.html) <br>
+- [cuOpt API Reference](https://docs.nvidia.com/cuopt/user-guide/latest/api.html) <br>
+- [cuOpt Examples Repository](https://github.com/NVIDIA/cuopt-examples) <br>
+- [C API Examples (resources/examples.md)](resources/examples.md) <br>
+
+
+## Skill Output: <br>
+**Output Type(s):** [Code, Shell commands, Configuration instructions] <br>
+**Output Format:** [Markdown with inline C code blocks] <br>
+**Output Parameters:** [1D] <br>
+**Other Properties Related to Output:** [None] <br>
+
+## Skill Version(s): <br>
+26.06.00 (source: frontmatter) <br>
+
+## Ethical Considerations: <br>
+NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal team to ensure this skill meets requirements for the relevant industry and use case and addresses unforeseen product misuse. <br>
+
+(For Release on NVIDIA Platforms Only) <br>
+Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns [here](https://app.intigriti.com/programs/nvidia/nvidiavdp/detail). <br>

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-c/skill.oms.sig

@@ -0,0 +1 @@
+{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"x509CertificateChain":{"certificates":[{"rawBytes":"MIICgzCCAgmgAwIBAgIUKIyS7SxNteQIiWzK1dWj85E6520wCgYIKoZIzj0EAwMwVTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjEpMCcGA1UEAwwgTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBJQ0EgMDEwHhcNMjYwNDAxMDAwMDAwWhcNMjgwNDIyMTUzMzA5WjBUMQswCQYDVQQGEwJVUzEbMBkGA1UECgwSTlZJRElBIENvcnBvcmF0aW9uMSgwJgYDVQQDDB9OVklESUEgQWdlbnQgU2tpbGxzIFNpZ25pbmcgMDAxMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEYoRM9bQl/dGlwSRNi6bTpIJUXH8Nv9GciP6LSflJYYMLCc296kpyuTSsk5ddbAWiDcFX3C/ydX3jwc+qCLYP6uHy9XphyLjOQ27Yb2J6rBLVtRBS1mgGco/Gr7fL6ODco4GaMIGXMB0GA1UdDgQWBBRQ/5ZW3nJ6lmo9SVk7I15o7UGmpTAfBgNVHSMEGDAWgBRPGpILxMBBleJSsBGjrMKsby1CgjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDA3BggrBgEFBQcBAQQrMCkwJwYIKwYBBQUHMAGGG2h0dHA6Ly9vY3NwLm5kaXMubnZpZGlhLmNvbTAKBggqhkjOPQQDAwNoADBlAjAUygu/GiOCIXrgGr4SmLgeEVDcEitfFUv7ALbvLVGVyMysB3mxmO/uInZfXzWcJZsCMQDxuoxj4ZmO30jhkPIcCxGFCOvnUsnfU3TfGcouYm4M6iRpbKvtVnHPiy4bi6pcKf0="},{"rawBytes":"MIICiDCCAg6gAwIBAgIUZsIuSv9NkpJCNqtYEfCouVv5BzowCgYIKoZIzj0EAwMwUTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjElMCMGA1UEAwwcTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBDQTAgFw0yNjA0MDEwMDAwMDBaGA85OTk5MTIzMTIzNTk1OVowVTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjEpMCcGA1UEAwwgTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBJQ0EgMDEwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASI72cR3ctKGg4VWnB3bNja6g1Z2PnOmFEopkPof+QeIcPk9rT+g9MjJnq51EQXL93a7C2GJ9J985G4o2V85VD7wJ1RaXhluHW2rf3y8bQGeAYaKMr5s/hUgn+M3/9WlWejgaAwgZ0wHQYDVR0OBBYEFE8akgvEwEGV4lKwEaOswqxvLUKCMB8GA1UdIwQYMBaAFItnoAjjfuCEUvzyvWyI2vOGvwPjMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMDcGCCsGAQUFBwEBBCswKTAnBggrBgEFBQcwAYYbaHR0cDovL29jc3AubmRpcy5udmlkaWEuY29tMAoGCCqGSM49BAMDA2gAMGUCMQCeIMMfAbyzPDacw2MxG+Yt1cikrJX/DVxiGfXuHmkkXn6VgSzE79+lkqDErpVO2gYCMCNEColOyvUvkzZGUEI1hQ3PfMgi3FIo9tHoBKMw4/wGBLFpu/0ubtmbBXM6/UMOEw=="},{"rawBytes":"MIICRTCCAcygAwIBAgIUeJdY3rV86EdvFmG7L8LJBsyQFYkwCgYIKoZIzj0EAwMwUTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjElMCMGA1UEAwwcTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBDQTAgFw0yNjA0MDEwMDAwMDBaGA85OTk5MTIzMTIzNTk1OVowUTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjElMCMGA1UEAwwcTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBDQTB2MBAGByqGSM49AgEGBSuBBAAiA2IABAYpiXCDjJ9NT2eSDhyHJVSw1Tbze18cGG2F/578oWvHxg23eQAhNRYdq88i1iOshZSO6C29doKui5Xpmo/7Ctw9Sx4PP2RzOmIuOLCuTdNtKcTRwi4GEsd5BAFvWj42M6NjMGEwHQYDVR0OBBYEFItnoAjjfuCEUvzyvWyI2vOGvwPjMB8GA1UdIwQYMBaAFItnoAjjfuCEUvzyvWyI2vOGvwPjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMAoGCCqGSM49BAMDA2cAMGQCMCwtAjWLaNwgGWNCgdyNoTyvNhqWRECRJV2r3+7w8g0PL6NHLOsbkgE09BH95h8XlgIwTaQmbbUh2ChAJ5TA1wRiVDnCcvbzHlZl2jM2FcwQQZlk19LOAbyGMRixbu2Ww/rj"}]},"tlogEntries":[]},"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.in-toto+json","signatures":[{"sig":"MGYCMQCadaoppHf9aW3be5GbVQFEKpZ0v/B+UB0akfR1D3QT2izEDk4m5700Bv4cpvFRG04CMQC09EHEKgu41uA/H7DOE2TZxc76xZ3IcET8xI1PcwGSnWrMuaZC1GZ0ezAVkbXasVY=","keyid":""}]}}

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: cuopt-numerical-optimization-api-cli
+version: "26.08.00"
+description: LP, MILP, and QP (beta) with cuOpt — CLI only (MPS files, cuopt_cli). Use when the user is solving LP, MILP, or QP from MPS via command line.
+---
+
+
+# cuOpt Numerical Optimization — CLI
+
+Solve LP, MILP, and QP problems from MPS files via `cuopt_cli`. The same command, options, and MPS workflow apply across all three; QP uses the standard MPS quadratic-objective extension.
+
+Confirm problem type and formulation (variables, objective, constraints, variable types) before coding.
+
+This skill is **CLI only** (MPS input).
+
+## Basic usage
+
+```bash
+# Solve LP or MILP from MPS file
+cuopt_cli problem.mps
+
+# With options
+cuopt_cli problem.mps --time-limit 120 --mip-relative-tolerance 0.01
+```
+
+## Common options
+
+```bash
+cuopt_cli --help
+
+# Time limit (seconds)
+cuopt_cli problem.mps --time-limit 120
+
+# MIP gap tolerance (stop when within X% of optimal)
+cuopt_cli problem.mps --mip-relative-tolerance 0.001
+
+# MIP absolute tolerance
+cuopt_cli problem.mps --mip-absolute-tolerance 0.0001
+
+# Presolve, iteration limit, method
+cuopt_cli problem.mps --presolve --iteration-limit 10000 --method 1
+```
+
+## MPS format (required sections, in order)
+
+1. **NAME** — problem name
+2. **ROWS** — N (objective), L/G/E (constraints)
+3. **COLUMNS** — variable names, row names, coefficients
+4. **RHS** — right-hand side values
+5. **BOUNDS** (optional) — LO, UP, FX, BV, LI, UI
+6. **ENDATA**
+
+Integer variables: use `'MARKER' 'INTORG'` before and `'MARKER' 'INTEND'` after the integer columns.
+
+## QP via CLI (beta)
+
+Quadratic objectives extend the standard MPS workflow — same `cuopt_cli` command, same options. Check `cuopt_cli --help` for QP-specific flags and the repo docs at `docs/cuopt/source/cuopt-cli/` for the quadratic-objective MPS format.
+
+**QP rules:**
+- **MINIMIZE only.** For maximization, negate the objective coefficients (and Q entries) in the MPS file.
+- **Continuous variables only** — do not mix integer markers with quadratic objectives.
+
+## Troubleshooting
+
+- **Failed to parse MPS** — Check ENDATA, section order (NAME, ROWS, COLUMNS, RHS, [BOUNDS], ENDATA), integer markers.
+- **Infeasible** — Check constraint directions (L/G/E) and RHS values.
+
+## Examples
+
+- [assets/README.md](assets/README.md) — Build/run for sample MPS files
+- [lp_simple](assets/lp_simple/) — Minimal LP (PROD_X, PROD_Y, two constraints)
+- [lp_production](assets/lp_production/) — Production planning: chairs + tables, wood/labor
+- [milp_facility](assets/milp_facility/) — Facility location with binary open/close
+
+## Getting the CLI
+
+CLI is included with the Python package (`cuopt`). Install via pip or conda; then run `cuopt_cli --help` to verify.

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/assets/README.md

@@ -0,0 +1,21 @@
+# Assets — sample MPS files
+
+Sample MPS files for use with `cuopt_cli`. Use as reference; do not edit in place.
+
+| File | Type | Description |
+|------|------|-------------|
+| [lp_production](lp_production/) | LP | Production planning: chairs + tables, wood/labor |
+| [milp_facility](milp_facility/) | MILP | Facility location with binary open/close |
+| [lp_simple](lp_simple/) | LP | Minimal LP (PROD_X, PROD_Y, two constraints) |
+
+**Run:** From each subdir or with path: `cuopt_cli lp_simple/sample.mps` (or `cuopt_cli production.mps`, etc.). See the skill for options (`--time-limit`, `--mip-relative-tolerance`, etc.).
+
+## Test CLI
+
+With conda env `cuopt` activated, from this `assets/` directory:
+
+```bash
+cuopt_cli lp_simple/sample.mps --time-limit 10
+```
+
+Use the same pattern for the other MPS files; for MILP, add e.g. `--mip-relative-gap 0.01`.

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/assets/lp_production/README.md

@@ -0,0 +1,5 @@
+# Production LP (MPS)
+
+Production planning: maximize 40*chairs + 30*tables subject to wood and labor limits.
+
+**Run:** `cuopt_cli production.mps` or `cuopt_cli production.mps --time-limit 30`

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/assets/lp_production/production.mps

@@ -0,0 +1,16 @@
+NAME          PRODUCTION
+ROWS
+ N  PROFIT
+ L  WOOD
+ L  LABOR
+COLUMNS
+    CHAIRS    PROFIT           -40.0
+    CHAIRS    WOOD               2.0
+    CHAIRS    LABOR              4.0
+    TABLES    PROFIT           -30.0
+    TABLES    WOOD               3.0
+    TABLES    LABOR              2.0
+RHS
+    RHS1      WOOD             240.0
+    RHS1      LABOR            200.0
+ENDATA

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/assets/lp_simple/README.md

@@ -0,0 +1,5 @@
+# Minimal LP (MPS)
+
+Maximize 40*PROD_X + 30*PROD_Y subject to resource constraints. Two variables, two constraints.
+
+**Run:** `cuopt_cli sample.mps` or `cuopt_cli sample.mps --time-limit 30`

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/assets/lp_simple/sample.mps

@@ -0,0 +1,19 @@
+NAME          PRODUCTION_LP
+ROWS
+ N  PROFIT
+ L  RES_A
+ L  RES_B
+COLUMNS
+    PROD_X    PROFIT              -40.0
+    PROD_X    RES_A                 2.0
+    PROD_X    RES_B                 4.0
+    PROD_Y    PROFIT              -30.0
+    PROD_Y    RES_A                 3.0
+    PROD_Y    RES_B                 2.0
+RHS
+    RHS1      RES_A               120.0
+    RHS1      RES_B               100.0
+BOUNDS
+ LO BND1      PROD_X                0.0
+ LO BND1      PROD_Y                0.0
+ENDATA

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/assets/milp_facility/README.md

@@ -0,0 +1,5 @@
+# Facility location MILP (MPS)
+
+Facility location with binary open/close variables. Integer markers: INTORG / INTEND.
+
+**Run:** `cuopt_cli facility.mps --time-limit 60 --mip-relative-tolerance 0.01`

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/assets/milp_facility/facility.mps

@@ -0,0 +1,27 @@
+NAME          FACILITY
+ROWS
+ N  COST
+ G  DEMAND1
+ L  CAP1
+ L  CAP2
+COLUMNS
+    MARKER    'MARKER'         'INTORG'
+    OPEN1     COST             100.0
+    OPEN1     CAP1             -50.0
+    OPEN2     COST             150.0
+    OPEN2     CAP2             -70.0
+    MARKER    'MARKER'         'INTEND'
+    SHIP11    COST               5.0
+    SHIP11    DEMAND1            1.0
+    SHIP11    CAP1               1.0
+    SHIP21    COST               7.0
+    SHIP21    DEMAND1            1.0
+    SHIP21    CAP2               1.0
+RHS
+    RHS1      DEMAND1           30.0
+BOUNDS
+ BV BND1      OPEN1
+ BV BND1      OPEN2
+ LO BND1      SHIP11             0.0
+ LO BND1      SHIP21             0.0
+ENDATA

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/skill-card.md

@@ -0,0 +1,39 @@
+## Description: <br>
+LP, MILP, and QP (beta) with cuOpt — CLI only (MPS files, cuopt_cli). Use when the user is solving LP, MILP, or QP from MPS via command line. <br>
+
+This skill is ready for commercial/non-commercial use. <br>
+
+## Owner: NVIDIA <br>
+
+### License/Terms of Use: <br>
+Apache 2.0 <br>
+## Use Case: <br>
+Developers and engineers use this skill to solve linear programming (LP), mixed-integer linear programming (MILP), and quadratic programming (QP) problems from MPS files via the cuopt_cli command-line interface. <br>
+
+### Deployment Geography for Use: <br>
+Global <br>
+
+## Known Risks and Mitigations: <br>
+Risk: Review before execution as proposals could introduce incorrect or misleading guidance into skills. <br>
+Mitigation: Review and scan skill before deployment. <br>
+
+## Reference(s): <br>
+- [cuOpt User Guide](https://docs.nvidia.com/cuopt/user-guide/latest/introduction.html) <br>
+- [cuOpt API Reference](https://docs.nvidia.com/cuopt/user-guide/latest/api.html) <br>
+- [cuOpt Examples](https://github.com/NVIDIA/cuopt-examples) <br>
+
+
+## Skill Output: <br>
+**Output Type(s):** [Shell commands, Configuration instructions, Code] <br>
+**Output Format:** [Markdown with inline bash code blocks] <br>
+**Output Parameters:** [1D] <br>
+**Other Properties Related to Output:** [None] <br>
+
+## Skill Version(s): <br>
+26.06.00 (source: frontmatter) <br>
+
+## Ethical Considerations: <br>
+NVIDIA believes Trustworthy AI is a shared responsibility and we have established policies and practices to enable development for a wide array of AI applications. When downloaded or used in accordance with our terms of service, developers should work with their internal team to ensure this skill meets requirements for the relevant industry and use case and addresses unforeseen product misuse. <br>
+
+(For Release on NVIDIA Platforms Only) <br>
+Please report quality, risk, security vulnerabilities or NVIDIA AI Concerns [here](https://app.intigriti.com/programs/nvidia/nvidiavdp/detail). <br>

package/resources/skills/skills/nvidia/cuopt-numerical-optimization-api-cli/skill.oms.sig

@@ -0,0 +1 @@
+{"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json","verificationMaterial":{"x509CertificateChain":{"certificates":[{"rawBytes":"MIICgzCCAgmgAwIBAgIUKIyS7SxNteQIiWzK1dWj85E6520wCgYIKoZIzj0EAwMwVTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjEpMCcGA1UEAwwgTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBJQ0EgMDEwHhcNMjYwNDAxMDAwMDAwWhcNMjgwNDIyMTUzMzA5WjBUMQswCQYDVQQGEwJVUzEbMBkGA1UECgwSTlZJRElBIENvcnBvcmF0aW9uMSgwJgYDVQQDDB9OVklESUEgQWdlbnQgU2tpbGxzIFNpZ25pbmcgMDAxMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEYoRM9bQl/dGlwSRNi6bTpIJUXH8Nv9GciP6LSflJYYMLCc296kpyuTSsk5ddbAWiDcFX3C/ydX3jwc+qCLYP6uHy9XphyLjOQ27Yb2J6rBLVtRBS1mgGco/Gr7fL6ODco4GaMIGXMB0GA1UdDgQWBBRQ/5ZW3nJ6lmo9SVk7I15o7UGmpTAfBgNVHSMEGDAWgBRPGpILxMBBleJSsBGjrMKsby1CgjAMBgNVHRMBAf8EAjAAMA4GA1UdDwEB/wQEAwIHgDA3BggrBgEFBQcBAQQrMCkwJwYIKwYBBQUHMAGGG2h0dHA6Ly9vY3NwLm5kaXMubnZpZGlhLmNvbTAKBggqhkjOPQQDAwNoADBlAjAUygu/GiOCIXrgGr4SmLgeEVDcEitfFUv7ALbvLVGVyMysB3mxmO/uInZfXzWcJZsCMQDxuoxj4ZmO30jhkPIcCxGFCOvnUsnfU3TfGcouYm4M6iRpbKvtVnHPiy4bi6pcKf0="},{"rawBytes":"MIICiDCCAg6gAwIBAgIUZsIuSv9NkpJCNqtYEfCouVv5BzowCgYIKoZIzj0EAwMwUTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjElMCMGA1UEAwwcTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBDQTAgFw0yNjA0MDEwMDAwMDBaGA85OTk5MTIzMTIzNTk1OVowVTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjEpMCcGA1UEAwwgTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBJQ0EgMDEwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASI72cR3ctKGg4VWnB3bNja6g1Z2PnOmFEopkPof+QeIcPk9rT+g9MjJnq51EQXL93a7C2GJ9J985G4o2V85VD7wJ1RaXhluHW2rf3y8bQGeAYaKMr5s/hUgn+M3/9WlWejgaAwgZ0wHQYDVR0OBBYEFE8akgvEwEGV4lKwEaOswqxvLUKCMB8GA1UdIwQYMBaAFItnoAjjfuCEUvzyvWyI2vOGvwPjMBIGA1UdEwEB/wQIMAYBAf8CAQAwDgYDVR0PAQH/BAQDAgEGMDcGCCsGAQUFBwEBBCswKTAnBggrBgEFBQcwAYYbaHR0cDovL29jc3AubmRpcy5udmlkaWEuY29tMAoGCCqGSM49BAMDA2gAMGUCMQCeIMMfAbyzPDacw2MxG+Yt1cikrJX/DVxiGfXuHmkkXn6VgSzE79+lkqDErpVO2gYCMCNEColOyvUvkzZGUEI1hQ3PfMgi3FIo9tHoBKMw4/wGBLFpu/0ubtmbBXM6/UMOEw=="},{"rawBytes":"MIICRTCCAcygAwIBAgIUeJdY3rV86EdvFmG7L8LJBsyQFYkwCgYIKoZIzj0EAwMwUTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjElMCMGA1UEAwwcTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBDQTAgFw0yNjA0MDEwMDAwMDBaGA85OTk5MTIzMTIzNTk1OVowUTELMAkGA1UEBhMCVVMxGzAZBgNVBAoMEk5WSURJQSBDb3Jwb3JhdGlvbjElMCMGA1UEAwwcTlZJRElBIEFnZW50IENhcGFiaWxpdGllcyBDQTB2MBAGByqGSM49AgEGBSuBBAAiA2IABAYpiXCDjJ9NT2eSDhyHJVSw1Tbze18cGG2F/578oWvHxg23eQAhNRYdq88i1iOshZSO6C29doKui5Xpmo/7Ctw9Sx4PP2RzOmIuOLCuTdNtKcTRwi4GEsd5BAFvWj42M6NjMGEwHQYDVR0OBBYEFItnoAjjfuCEUvzyvWyI2vOGvwPjMB8GA1UdIwQYMBaAFItnoAjjfuCEUvzyvWyI2vOGvwPjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMAoGCCqGSM49BAMDA2cAMGQCMCwtAjWLaNwgGWNCgdyNoTyvNhqWRECRJV2r3+7w8g0PL6NHLOsbkgE09BH95h8XlgIwTaQmbbUh2ChAJ5TA1wRiVDnCcvbzHlZl2jM2FcwQQZlk19LOAbyGMRixbu2Ww/rj"}]},"tlogEntries":[]},"dsseEnvelope":{"payload":"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","payloadType":"application/vnd.in-toto+json","signatures":[{"sig":"MGUCMQCGnVm0GLtfZ2rfAZEwbzG830q4c8NaPJpnFFV/DuOnCK6g17mfSUIZ3eOjKi+sd+ICMDv0mFIoR/OXYcNghpxqGbBe96s7i8WkasI/qAm/v2FZNELcpDaS/lXsZZP1KXw51Q==","keyid":""}]}}