You have two options to follow along with this guide:

1. Build the project from scratch by manually setting up the structure and copy-pasting the provided code base (src and tests folders).

2. Clone the repository, install dependencies using the command uv sync, and run the commands explained below directly to:

   • Execute the test suite
   • Build the Docker image
   • Modify and test GitHub Actions

Ship it like it's hot! 🚢🔥

MLOps (Machine Learning Operations) is all about bringing DevOps principles into machine learning, making model deployment, versioning, and monitoring more efficient. However, managing dependencies, ensuring reproducibility, and streamlining deployments can be a major headache for ML/DS teams.

That's where UV comes in—a fast, modern package manager that simplifies dependency management, build processes, and CI/CD for Python projects.

In this article, we'll explore how UV can enhance MLOps workflows through AceBet, a mock-up FastAPI app that predicts the winner of an ATP match (for demonstration purposes only—don’t bet your savings on it!). We'll cover:

• Setting up a UV-based MLOps project
• Managing dependencies and lockfiles
• Automating CI/CD with GitHub Actions
• Building and deploying with Docker

Make sure to read:

• Part 1: UV Basics
• Part 2: Advanced UV Features

When working on an MLOps project, structuring your codebase properly is crucial. We'll start by setting up a packaged application using UV:

uv init --package acebet

A packaged application follows the src-based structure, where the source code is contained within a dedicated package directory (src/acebet). This approach is beneficial for:

✅ Large applications with multiple modules
✅ Projects that need to be distributed (e.g., PyPI packages, CLI tools)
✅ Better namespace isolation, preventing import conflicts
✅ Improved testability and modularity

acebet/
├── src/
│   ├── acebet/
│   │   ├── __init__.py
│   │   ├── data_prep.py
│   │   ├── model.py
│   │   ├── predict.py
│   │   ├── api.py
│   │   └── utils.py
├── tests/
│   ├── test_model.py
├── pyproject.toml
└── README.md

This structure ensures: ✔ Encapsulation: The application is a proper Python package, avoiding accidental name conflicts.
✔ Reusability: Can be installed via pip install . or published to PyPI.
✔ Cleaner Imports: Enforces absolute imports (from acebet.utils import foo) instead of relative imports.
✔ Better CI/CD Support: Easier to package and distribute in Docker, PyPI, or GitHub Actions.

👉 For quick scripts or internal projects? Use a regular application.
👉 For scalable, maintainable, and deployable projects? Use a packaged application.

Since AceBet is a full MLOps project, we’ll use a packaged application.

Once your project is initialized, install the necessary dependencies for developing AceBet, including FastAPI and machine learning libraries like Scikit-learn:

uv add fastapi scikit-learn pandas lightgbm

UV will automatically resolve versions and install the required packages.

One of UV's key advantages is ensuring dependency reproducibility with a lockfile. This guarantees that all environments (local, staging, production) use the same dependency versions.

Once you're satisfied with the initial codebase, generate a lockfile:

uv lock

Or, if you want to sync all dependencies in one go:

uv sync

This process ensures version consistency across environments, which is an essential practice in MLOps.

Testing is just as important as model accuracy in MLOps. UV provides three different ways to manage testing tools (e.g., pytest):

For MLOps best practices, we add testing dependencies:

uv add --dev pytest

To run tests:

uv run pytest tests

👉 Best Practice: Explicitly list all required dependencies in pyproject.toml for consistent test environments.

A CI/CD pipeline ensures your models and applications remain production-ready. UV makes GitHub Actions setup seamless.

A simple workflow to run tests on every commit to main:

name: Testing
on:
  push:
    branches:
      - "main"
jobs:
  uv-example:
    name: Python
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install UV
        uses: astral-sh/setup-uv@v5
      - name: Install the project
        run: uv sync --all-extras --dev
      - name: Run tests
        run: uv run pytest tests

✅ Installs UV
✅ Syncs dependencies
✅ Runs unit tests using Pytest

A well-built Docker image ensures consistent deployment across environments. UV simplifies containerization.

FROM python:3.12-slim

# Install UV
COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/

# Copy the application into the container
COPY . /app

# Set working directory
WORKDIR /app

# Install dependencies
RUN uv sync --frozen --no-cache

# Run the FastAPI app
CMD ["/app/.venv/bin/fastapi", "run", "src/acebet/api.py", "--port", "80", "--host", "0.0.0.0"]

For production-ready builds, use a multi-stage Docker build to keep the image lightweight.

• If you need speed, lightweight builds, and a streamlined DevOps workflow, UV is the better choice. 🚀
• If you prefer a well-established but slower tool with more integrated features, Poetry remains viable. 🛠️
• For MLOps & CI/CD, UV's speed and efficiency make it the preferred option. 💡

By integrating UV into your MLOps workflow, you get a fast, reproducible, and efficient setup for managing dependencies, testing, and deployment.

With AceBet, we demonstrated how to: ✔️ Initialize a UV-based project
✔️ Manage dependencies & lockfiles
✔️ Automate testing with GitHub Actions
✔️ Build Docker images for deployment

Give UV a try—it might just replace Pip and Poetry in your workflow! 🚀

Happy Coding!