Change solution object to return host memory instead of gpu memory from libcuopt for lp and milp

.github/AGENTS.md

@@ -0,0 +1,156 @@
+# AGENTS.md - AI Coding Agent Guidelines for cuOpt
+
+> This file provides essential context for AI coding assistants (Codex, Cursor, GitHub Copilot, etc.) working with the NVIDIA cuOpt codebase.
+
+> **For setup, building, testing, and contribution guidelines, see [CONTRIBUTING.md](../CONTRIBUTING.md).**
+
+---
+
+## Project Overview
+
+**cuOpt** is NVIDIA's GPU-accelerated optimization engine for:
+- **Mixed Integer Linear Programming (MILP)**
+- **Linear Programming (LP)**
+- **Quadratic Programming (QP)**
+- **Vehicle Routing Problems (VRP)** including TSP and PDP
+
+### Architecture
+
+```
+cuopt/
+├── cpp/                    # Core C++ engine (libcuopt, libmps_parser)
+│   ├── include/cuopt/      # Public C/C++ headers
+│   ├── src/                # Implementation (CUDA kernels, algorithms)
+│   └── tests/              # C++ unit tests (gtest)
+├── python/
+│   ├── cuopt/              # Python bindings and routing API
+│   ├── cuopt_server/       # REST API server
+│   ├── cuopt_self_hosted/  # Self-hosted deployment utilities
+│   └── libcuopt/           # Python wrapper for C library
+├── ci/                     # CI/CD scripts and Docker configurations
+├── conda/                  # Conda recipes and environment files
+├── docs/                   # Documentation source
+├── datasets/               # Test datasets for LP, MIP, routing
+└── notebooks/              # Example Jupyter notebooks
+```
+
+### Supported APIs
+
+| API Type | LP | MILP | QP | Routing |
+|----------|:--:|:----:|:--:|:-------:|
+| C API    | ✓  | ✓    | ✓  | ✗       |
+| C++ API  | ✓  | ✓    | ✓  | ✓       |
+| Python   | ✓  | ✓    | ✓  | ✓       |
+| Server   | ✓  | ✓    | ✗  | ✓       |
+
+---
+
+## Coding Style and Conventions
+
+### C++ Naming Conventions
+
+- **Base style**: `snake_case` for all names (except test cases: PascalCase)
+- **Prefixes/Suffixes**:
+  - `d_` → device data variables (e.g., `d_locations_`)
+  - `h_` → host data variables (e.g., `h_data_`)
+  - `_t` → template type parameters (e.g., `i_t`, `value_t`)
+  - `_` → private member variables (e.g., `n_locations_`)
+
+```cpp
+// Example naming pattern
+template <typename i_t>
+class locations_t {
+ private:
+  i_t n_locations_{};
+  i_t* d_locations_{};  // device pointer
+  i_t* h_locations_{};  // host pointer
+};
+```
+
+### File Extensions
+
+| Extension | Usage |
+|-----------|-------|
+| `.hpp`    | C++ headers |
+| `.cpp`    | C++ source |
+| `.cu`     | CUDA C++ source (nvcc required) |
+| `.cuh`    | CUDA headers with device code |
+
+### Include Order
+
+1. Local headers
+2. RAPIDS headers
+3. Related libraries
+4. Dependencies
+5. STL
+
+### Python Style
+
+- Follow PEP 8
+- Use type hints where applicable
+- Tests use `pytest` framework
+
+### Formatting
+
+- **C++**: Enforced by `clang-format` (config: `cpp/.clang-format`)
+- **Python**: Enforced via pre-commit hooks
+- See [CONTRIBUTING.md](../CONTRIBUTING.md) for pre-commit setup
+
+---
+
+## Error Handling Patterns
+
+### Runtime Assertions
+
+```cpp
+// Use CUOPT_EXPECTS for runtime checks
+CUOPT_EXPECTS(lhs.type() == rhs.type(), "Column type mismatch");
+
+// Use CUOPT_FAIL for unreachable code paths
+CUOPT_FAIL("This code path should not be reached.");
+```
+
+### CUDA Error Checking
+
+```cpp
+// Always wrap CUDA calls
+RAFT_CUDA_TRY(cudaMemcpy(&dst, &src, num_bytes));
+```
+
+---
+
+## Memory Management Guidelines
+
+- **Never use raw `new`/`delete`** - Use RMM allocators
+- **Prefer `rmm::device_uvector<T>`** for device memory
+- **All operations should be stream-ordered** - Accept `cuda_stream_view`
+- **Views (`*_view` suffix) are non-owning** - Don't manage their lifetime
+
+---
+
+## Key Files Reference
+
+| Purpose | Location |
+|---------|----------|
+| Main build script | `build.sh` |
+| Dependencies | `dependencies.yaml` |
+| C++ formatting | `cpp/.clang-format` |
+| Conda environments | `conda/environments/` |
+| Test data download | `datasets/get_test_data.sh` |
+| CI configuration | `ci/` |
+| Version info | `VERSION` |
+
+---
+
+## Common Pitfalls
+
+| Problem | Solution |
+|---------|----------|
+| Cython changes not reflected | Rerun: `./build.sh cuopt` |
+| Missing `nvcc` | Set `$CUDACXX` or add CUDA to `$PATH` |
+| CUDA out of memory | Reduce problem size or use streaming |
+| Slow debug library loading | Device symbols cause delay; use selectively |
+
+---
+
+*For detailed setup, build instructions, testing workflows, debugging, and contribution guidelines, see [CONTRIBUTING.md](../CONTRIBUTING.md).*

.github/CODE_OF_CONDUCT.md

@@ -0,0 +1 @@
+This project has adopted the [Contributor Covenant Code of Conduct](https://docs.rapids.ai/resources/conduct/).

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,5 +1,5 @@
 ---
-name: Bug report
+name: 🐛 Bug report
 about: Create a bug report to help us improve cuOpt
 title: "[BUG]"
 labels: "? - Needs Triage, bug"

.github/ISSUE_TEMPLATE/documentation-request.md

@@ -1,5 +1,5 @@
 ---
-name: Documentation request
+name: 📚 Documentation request
 about: Report incorrect or needed documentation
 title: "[DOC]"
 labels: "? - Needs Triage, doc"

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,5 +1,5 @@
 ---
-name: Feature request
+name: 🚀 Feature request
 about: Suggest an idea for cuOpt
 title: "[FEA]"
 labels: "? - Needs Triage, feature request"

.github/ISSUE_TEMPLATE/submit-question.md

@@ -1,5 +1,5 @@
 ---
-name: Submit question
+name: ❓ Submit question
 about: Ask a general question about cuOpt
 title: "[QST]"
 labels: "? - Needs Triage, question"

.github/SECURITY.md

@@ -0,0 +1,15 @@
+Security
+---------
+NVIDIA is dedicated to the security and trust of our software products and services, including all source code repositories managed through our organization.
+
+If you need to report a security issue, please use the appropriate contact points outlined below. Please do not report security vulnerabilities through GitHub/GitLab.
+
+Reporting Potential Security Vulnerability in NVIDIA cuOpt
+----------------------------------------------------------
+To report a potential security vulnerability in NVIDIA cuOpt:
+
+- Web: [Security Vulnerability Submission Form](https://www.nvidia.com/object/submit-security-vulnerability.html)
+- E-Mail: [[email protected]](mailto:[email protected])
+- We encourage you to use the following PGP key for secure email communication: [NVIDIA public PGP Key for communication](https://www.nvidia.com/en-us/security/pgp-key)
+- Please include the following information:
+    - Product/Driver name and version/branch that contains the vulnerability

README.md

@@ -1,6 +1,15 @@
 # cuOpt - GPU accelerated Optimization Engine
 
 [![Build Status](https://github.com/NVIDIA/cuopt/actions/workflows/build.yaml/badge.svg)](https://github.com/NVIDIA/cuopt/actions/workflows/build.yaml)
+[![Version](https://img.shields.io/badge/version-26.02.00-blue)](https://github.com/NVIDIA/cuopt/releases)
+[![Documentation](https://img.shields.io/badge/docs-latest-brightgreen)](https://docs.nvidia.com/cuopt/user-guide/latest/introduction.html)
+[![Docker Hub](https://img.shields.io/badge/docker-nvidia%2Fcuopt-blue?logo=docker)](https://hub.docker.com/r/nvidia/cuopt)
+[![Examples](https://img.shields.io/badge/examples-cuopt--examples-orange)](https://github.com/NVIDIA/cuopt-examples)
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/NVIDIA/cuopt-examples/blob/cuopt_examples_launcher/cuopt_examples_launcher.ipynb)
+[![NVIDIA Launchable](https://img.shields.io/badge/NVIDIA-Launchable-76b900?logo=nvidia)](https://brev.nvidia.com/launchable/deploy?launchableID=env-2qIG6yjGKDtdMSjXHcuZX12mDNJ)
+[![Videos and Tutorials](https://img.shields.io/badge/Videos_and_Tutorials-red?logo=youtube)](https://docs.nvidia.com/cuopt/user-guide/latest/resources.html#cuopt-examples-and-tutorials-videos)
+
+
 
 NVIDIA® cuOpt™ is a GPU-accelerated optimization engine that excels in mixed integer linear programming (MILP), linear programming (LP), and vehicle routing problems (VRP). It enables near real-time solutions for large-scale challenges with millions of variables and constraints, offering
 easy integration into existing solvers and seamless deployment across hybrid and multi-cloud environments.
@@ -146,13 +155,3 @@ For current release timelines and dates, refer to the [RAPIDS Maintainers Docs](
 ## Contributing Guide
 
 Review the [CONTRIBUTING.md](CONTRIBUTING.md) file for information on how to contribute code and issues to the project.
-
-## Resources
-
-- [libcuopt (C) documentation](https://docs.nvidia.com/cuopt/user-guide/latest/cuopt-c/index.html)
-- [cuopt (Python) documentation](https://docs.nvidia.com/cuopt/user-guide/latest/cuopt-python/index.html)
-- [cuopt (Server) documentation](https://docs.nvidia.com/cuopt/user-guide/latest/cuopt-server/index.html)
-- [Examples and Notebooks](https://github.com/NVIDIA/cuopt-examples)
-- [Test cuopt with NVIDIA Launchable](https://brev.nvidia.com/launchable/deploy?launchableID=env-2qIG6yjGKDtdMSjXHcuZX12mDNJ): Examples notebooks are pulled and hosted on [NVIDIA Launchable](https://docs.nvidia.com/brev/latest/).
-- [Test cuopt on Google Colab](https://colab.research.google.com/github/nvidia/cuopt-examples/): Examples notebooks can be opened in Google Colab. Please note that you need to choose a `Runtime` as `GPU` in order to run the notebooks.
-- [cuOpt Examples and Tutorial Videos](https://docs.nvidia.com/cuopt/user-guide/latest/resources.html#cuopt-examples-and-tutorials-videos)

ci/release/update-version.sh

@@ -1,6 +1,6 @@
 #!/bin/bash
 
-# SPDX-FileCopyrightText: Copyright (c) 2022-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
 ## Usage
@@ -131,6 +131,9 @@ done
 PROJECT_FILE="docs/cuopt/source/project.json"
 sed_runner 's/\("version": "\)[0-9][0-9]\.[0-9][0-9]\.[0-9][0-9]"/\1'${NEXT_FULL_TAG}'"/g' "${PROJECT_FILE}"
 
+# Update README.md version badge
+sed_runner 's/badge\/version-[0-9]\+\.[0-9]\+\.[0-9]\+-blue/badge\/version-'${NEXT_FULL_TAG}'-blue/g' README.md
+
 # Update nightly
 sed_runner 's/'"cuopt_version: \"[0-9][0-9].[0-9][0-9]\""'/'"cuopt_version: \"${NEXT_SHORT_TAG}\""'/g' .github/workflows/nightly.yaml
 

cpp/include/cuopt/linear_programming/utilities/cython_solve.hpp

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -25,19 +25,19 @@ namespace cython {
 // aggregate for call_solve() return type
 // to be exposed to cython:
 struct linear_programming_ret_t {
-  std::unique_ptr<rmm::device_buffer> primal_solution_;
-  std::unique_ptr<rmm::device_buffer> dual_solution_;
-  std::unique_ptr<rmm::device_buffer> reduced_cost_;
+  std::vector<double> primal_solution_;
+  std::vector<double> dual_solution_;
+  std::vector<double> reduced_cost_;
   /* -- PDLP Warm Start Data -- */
-  std::unique_ptr<rmm::device_buffer> current_primal_solution_;
-  std::unique_ptr<rmm::device_buffer> current_dual_solution_;
-  std::unique_ptr<rmm::device_buffer> initial_primal_average_;
-  std::unique_ptr<rmm::device_buffer> initial_dual_average_;
-  std::unique_ptr<rmm::device_buffer> current_ATY_;
-  std::unique_ptr<rmm::device_buffer> sum_primal_solutions_;
-  std::unique_ptr<rmm::device_buffer> sum_dual_solutions_;
-  std::unique_ptr<rmm::device_buffer> last_restart_duality_gap_primal_solution_;
-  std::unique_ptr<rmm::device_buffer> last_restart_duality_gap_dual_solution_;
+  std::vector<double> current_primal_solution_;
+  std::vector<double> current_dual_solution_;
+  std::vector<double> initial_primal_average_;
+  std::vector<double> initial_dual_average_;
+  std::vector<double> current_ATY_;
+  std::vector<double> sum_primal_solutions_;
+  std::vector<double> sum_dual_solutions_;
+  std::vector<double> last_restart_duality_gap_primal_solution_;
+  std::vector<double> last_restart_duality_gap_dual_solution_;
   double initial_primal_weight_;
   double initial_step_size_;
   int total_pdlp_iterations_;
@@ -64,7 +64,7 @@ struct linear_programming_ret_t {
 };
 
 struct mip_ret_t {
-  std::unique_ptr<rmm::device_buffer> solution_;
+  std::vector<double> solution_;
 
   linear_programming::mip_termination_status_t termination_status_;
   error_type_t error_status_;

cpp/src/linear_programming/utilities/cython_solve.cu

@@ -1,6 +1,6 @@
 /* clang-format off */
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 /* clang-format on */
@@ -142,28 +142,21 @@ linear_programming_ret_t call_solve_lp(
   const bool use_pdlp_solver_mode = true;
   auto solution                   = cuopt::linear_programming::solve_lp(
     op_problem, solver_settings, problem_checking, use_pdlp_solver_mode, is_batch_mode);
+
+  // Convert device vectors to host vectors for LP solution
   linear_programming_ret_t lp_ret{
-    std::make_unique<rmm::device_buffer>(solution.get_primal_solution().release()),
-    std::make_unique<rmm::device_buffer>(solution.get_dual_solution().release()),
-    std::make_unique<rmm::device_buffer>(solution.get_reduced_cost().release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().current_primal_solution_.release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().current_dual_solution_.release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().initial_primal_average_.release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().initial_dual_average_.release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().current_ATY_.release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().sum_primal_solutions_.release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().sum_dual_solutions_.release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().last_restart_duality_gap_primal_solution_.release()),
-    std::make_unique<rmm::device_buffer>(
-      solution.get_pdlp_warm_start_data().last_restart_duality_gap_dual_solution_.release()),
+    cuopt::host_copy(solution.get_primal_solution()),
+    cuopt::host_copy(solution.get_dual_solution()),
+    cuopt::host_copy(solution.get_reduced_cost()),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().current_primal_solution_),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().current_dual_solution_),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().initial_primal_average_),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().initial_dual_average_),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().current_ATY_),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().sum_primal_solutions_),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().sum_dual_solutions_),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().last_restart_duality_gap_primal_solution_),
+    cuopt::host_copy(solution.get_pdlp_warm_start_data().last_restart_duality_gap_dual_solution_),
     solution.get_pdlp_warm_start_data().initial_primal_weight_,
     solution.get_pdlp_warm_start_data().initial_step_size_,
     solution.get_pdlp_warm_start_data().total_pdlp_iterations_,
@@ -205,7 +198,9 @@ mip_ret_t call_solve_mip(
     error_type_t::ValidationError,
     "MIP solve cannot be called on an LP problem!");
   auto solution = cuopt::linear_programming::solve_mip(op_problem, solver_settings);
-  mip_ret_t mip_ret{std::make_unique<rmm::device_buffer>(solution.get_solution().release()),
+
+  // Convert device vector to host vector for MILP solution
+  mip_ret_t mip_ret{cuopt::host_copy(solution.get_solution()),
                     solution.get_termination_status(),
                     solution.get_error_status().get_error_type(),
                     solution.get_error_status().what(),

python/cuopt/cuopt/distance_engine/waypoint_matrix_wrapper.pyx

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright (c) 2022-2025, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # noqa
+# SPDX-FileCopyrightText: Copyright (c) 2022-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved. # noqa
 # SPDX-License-Identifier: Apache-2.0
 
 # cython: profile=False
@@ -26,6 +26,8 @@ from cuopt.utilities import series_from_buf
 
 import pyarrow as pa
 
+import pyarrow as pa
+
 
 cdef class WaypointMatrix: