> This page is for version 26.09 · v1.4.0.
> For other versions, use one of these documentation indexes:
> - Latest · v1.4.0 (26.09) (default): https://docs.nvidia.com/nemo/curator/latest/llms.txt
> - Main · preview: https://docs.nvidia.com/nemo/curator/main/llms.txt
> - 26.09 · v1.4.0: https://docs.nvidia.com/nemo/curator/v26.09/llms.txt
> - 26.07 · v1.3.0: https://docs.nvidia.com/nemo/curator/v26.07/llms.txt
> - 26.04 · v1.2.0: https://docs.nvidia.com/nemo/curator/v26.04/llms.txt
> - 26.02 · v1.1.0: https://docs.nvidia.com/nemo/curator/v26.02/llms.txt
> - 25.09 · v1.0.0: https://docs.nvidia.com/nemo/curator/v25.09/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/curator/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/curator/_mcp/server.

> Build, configure, and use NeMo Curator containers in local and cluster environments

# Container Environments

NeMo Curator source releases continue, and the repository [Dockerfile](https://github.com/NVIDIA-NeMo/Curator/blob/main/docker/Dockerfile) remains maintained. Starting with the 26.09 release, NVIDIA no longer publishes NeMo Curator container images to NGC. Previously published images remain downloadable. Build an image from a source release or the `main` development branch.

## Build an Image

Build a local Docker image from a source checkout, run it, then activate and verify the Curator environment.

1. Clone the [NeMo Curator repository](https://github.com/NVIDIA-NeMo/Curator) or enter an existing checkout. Use a source release tag available in the repository for released code, or keep `main` for current development.

2. Build the image from the repository root:

   ```bash
   docker build -f docker/Dockerfile -t nemo-curator:local .
   ```

3. Start a container with a shell:

   ```bash
   docker run --gpus all -it --rm \
     -v "$PWD:/workspace" \
     -w /workspace \
     nemo-curator:local bash
   ```

4. Activate the virtual environment and verify the import:

   ```bash
   source /opt/venv/env.sh
   python -c "import nemo_curator; print(nemo_curator.__version__)"
   ```

   The command prints the installed version and exits without an import error.

Default builds use the `all` Curator extra, Python 3.13, CUDA 12.9.1, and Ubuntu 24.04. The Dockerfile installs `etcd` and `nats-server` for Dynamo and builds the Nemotron OCR C++/CUDA extension. The base image does not include FFmpeg. For audio or video, use the derived image instructions below to package system dependencies with Curator rather than updating each host. Build arguments and Dockerfile revisions can change image contents.

## Add FFmpeg for Audio or Video

Build the base image first as described in [Build an Image](#build-an-image), then create one of these Dockerfiles in the repository root. The audio image uses Ubuntu's FFmpeg package for audio resampling and PCM/WAV operations. The video image runs Curator's maintained FFmpeg builder and adds software H.264/HEVC/AV1 decoders while retaining NVENC and `libvpx-vp9` support; it omits audio codecs and WAV filters, so use it for video-only workflows.

For audio, save this as `Dockerfile.audio`:

```dockerfile
FROM nemo-curator:local
RUN apt-get update && apt-get install -y --no-install-recommends ffmpeg && rm -rf /var/lib/apt/lists/*
```

Build the image, then start a shell inside it. Add `--gpus all` when audio processing will use a GPU; omit that flag for CPU-only audio:

```bash
docker build -f Dockerfile.audio -t nemo-curator:audio .
docker run -it --rm \
  -v "$PWD:/workspace" -w /workspace \
  nemo-curator:audio bash
```

Put input data and desired results under the mounted workspace (or mount their host directories too) so files persist after the container exits.

Run the following smoke commands inside the container. They verify PCM encoding, 16 kHz resampling, and WAV output:

```bash
source /opt/venv/env.sh
ffmpeg -v error \
  -f lavfi -i "sine=frequency=1000:duration=0.1" \
  -ar 16000 -ac 1 -acodec pcm_s16le -y \
  /tmp/nemo-curator-audio-smoke.wav
ffprobe -v error \
  -show_entries stream=codec_name,sample_rate,channels \
  -of default=noprint_wrappers=1 \
  /tmp/nemo-curator-audio-smoke.wav
rm /tmp/nemo-curator-audio-smoke.wav
```

For video, save this as `Dockerfile.video`:

```dockerfile
FROM nemo-curator:local
RUN bash /opt/Curator/docker/common/install_h264_support.sh
```

Build the image and start a shell inside it:

```bash
docker build -f Dockerfile.video -t nemo-curator:video .
docker run --gpus all -it --rm \
  -v "$PWD:/workspace" -w /workspace \
  nemo-curator:video bash
```

Run these checks inside the container. Confirm that the output lists the NVENC and VP9 encoders and the software H.264 decoder used by CPU-side probing:

```bash
source /opt/venv/env.sh
ffmpeg -hide_banner -version | head -n 5
ffmpeg -encoders | grep -E "h264_nvenc|libvpx-vp9"
ffmpeg -decoders | grep -E '^[[:space:]]+V[^[:space:]]+[[:space:]]+h264[[:space:]]'
```

Keep input videos and output clips under `/workspace` (or mount their host directories too) so they persist after the container exits. Activate the Curator environment with `source /opt/venv/env.sh` before running Python commands.

`h264_nvenc` requires NVIDIA hardware with NVENC support. NVIDIA A100 and H100 GPUs do not include NVENC hardware; use `libvpx-vp9` on those GPUs. For Python package installs, the [Installation Guide](/get-started/installation#install-ffmpeg-for-audio-and-video-source-installs) also documents user-local and host-level FFmpeg options.

## Use Images on a Cluster

A local Docker tag such as `nemo-curator:local` is available only to the Docker daemon where it was built. To use the image on a cluster:

1. Push it to a registry reachable from every allocated node, or create a SquashFS image with Enroot and place it on shared storage using [these Pyxis instructions](#create-a-squashfs-image-for-pyxis). Enroot also supports registry references such as `docker://REGISTRY#PATH:TAG`; see the [Enroot import documentation](https://github.com/NVIDIA/enroot/blob/main/doc/cmd/import.md). Use an image built for the cluster's CPU architecture. For media jobs, export the corresponding audio or video image tag instead.
2. Set the cluster job's image reference or path. The SLURM examples use `CONTAINER_IMAGE`; refer to [Multi-Node Ray on SLURM](/admin/deployment/slurm-multi-node-ray), [SLURM Job Arrays](/admin/deployment/slurm-arrays), or the [SLURM tutorial](https://github.com/NVIDIA-NeMo/Curator/tree/main/tutorials/slurm).

### Create a SquashFS Image for Pyxis

On a Linux machine with Enroot and access to the local Docker daemon, export the image and copy the resulting file to storage visible to the cluster:

```bash
enroot import --output nemo-curator.sqsh dockerd://nemo-curator:local
mkdir -p /shared/containers
cp nemo-curator.sqsh /shared/containers/nemo-curator.sqsh
```

On the cluster, confirm that the file is readable and set the path used by the SLURM scripts:

```bash
ls -lh /shared/containers/nemo-curator.sqsh
export CONTAINER_IMAGE=/shared/containers/nemo-curator.sqsh
```

For a media image, replace `nemo-curator:local` with the appropriate local image tag before importing it. Ensure the image architecture matches the cluster nodes.

## Image Configuration

The current Dockerfile accepts these build-time arguments:

| Argument           | Default        | Description                                                                           |
| ------------------ | -------------- | ------------------------------------------------------------------------------------- |
| `CUDA_VER`         | `12.9.1`       | CUDA version used by the NVIDIA CUDA base image.                                      |
| `LINUX_VER`        | `ubuntu24.04`  | Linux version used by the CUDA base image.                                            |
| `CURATOR_ENV`      | `ci`           | Curator environment type passed into the build.                                       |
| `CURATOR_EXTRA`    | `all`          | Curator optional extra installed by `uv sync`; set empty to install without an extra. |
| `CURATOR_GROUPS`   | `--all-groups` | Dependency groups passed to `uv sync`.                                                |
| `NVIDIA_BUILD_ID`  | `<unknown>`    | Optional build identifier label.                                                      |
| `NVIDIA_BUILD_REF` | unset          | Optional build reference label.                                                       |

These defaults apply when you build the matching Dockerfile revision without overriding its arguments.

## Architecture Notes

Python dependencies and extras can depend on the target architecture in `pyproject.toml`. Some audio dependencies support only x86\_64 Linux. Check the package markers before building for arm64.

Ray executes NeMo Curator pipelines.