diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index f7216e8e0..90f485711 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -6,42 +6,28 @@
 ARG BASE_IMG=nvcr.io/nvidia/cuda
 ARG BASE_IMG_TAG=12.4.1-base-ubuntu22.04
 
-# Use NVIDIA cuda
 FROM $BASE_IMG:$BASE_IMG_TAG AS base
 
-ARG RELEASE_TYPE="dev"
-ARG VERSION=""
-ARG VERSION_REV="0"
-
-# Install necessary dependencies using apt-get
 RUN apt-get update && apt-get install -y \
-      wget \
       bzip2 \
       ca-certificates \
       curl \
+      git \
       libgl1-mesa-glx \
       vim \
-      git \
+      wget \
     && apt-get clean
 
-RUN wget -O Miniforge3.sh "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh" -O /tmp/miniforge.sh \
-    && bash /tmp/miniforge.sh -b -p /opt/conda \
-    && rm /tmp/miniforge.sh
-
-# Add conda to the PATH
-ENV PATH=/opt/conda/bin:$PATH
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
 
-# Install Mamba, a faster alternative to conda, within the base environment
-RUN conda install -y mamba -n base -c conda-forge
+ENV PATH=/root/.local/bin:$PATH
+ENV UV_LINK_MODE=copy
 
-COPY conda/environments/nv_ingest_environment.yml /workspace/nv_ingest_environment.yml
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv python install 3.12 \
+    && uv venv --python 3.12 /opt/nv_ingest_runtime
 
-# Create nv_ingest base environment
-RUN mamba env create -f /workspace/nv_ingest_environment.yml \
-    && conda clean --all --yes
+ENV VIRTUAL_ENV=/opt/nv_ingest_runtime
+ENV PATH=/opt/nv_ingest_runtime/bin:/root/.local/bin:$PATH
 
-# Set default shell to bash
 SHELL ["/bin/bash", "-c"]
-
-# Activate the environment (make it default for subsequent commands)
-RUN echo "source activate nv_ingest_runtime" >> ~/.bashrc
diff --git a/.devcontainer/README.md b/.devcontainer/README.md
index 7fac52549..e7371f214 100644
--- a/.devcontainer/README.md
+++ b/.devcontainer/README.md
@@ -17,7 +17,7 @@ limitations under the License.
 
 # NV-Ingest Devcontainer
 
-The nv-ingest devcontainer is provided as a quick-to-set-up development and exploration environment for use with [Visual Studio Code](https://code.visualstudio.com) (Code). The devcontainer is a lightweight container which mounts-in a Conda environment with cached packages, alleviating long Conda download times on subsequent launches. It provides a simple framework for adding developer-centric [scripts](#development-scripts), and incorporates some helpful Code plugins.
+The nv-ingest devcontainer is provided as a quick-to-set-up development and exploration environment for use with [Visual Studio Code](https://code.visualstudio.com) (Code). The devcontainer is a lightweight container with a pre-created `uv` Python environment and package cache for fast launches. It provides a simple framework for adding developer-centric [scripts](#development-scripts), and incorporates some helpful Code plugins.
 
 > [!Note]
 > NV-Ingest is also known as NVIDIA Ingest and NeMo Retriever extraction.
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
index ba78724c8..293651afb 100644
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -82,7 +82,7 @@
           "stkb.rewrap" // Wrapping all text in any language
         ],
         "settings": {
-          "cmake.cmakePath": "/tmp/.current-conda-env/bin/cmake",
+          "cmake.cmakePath": "/usr/bin/cmake",
           "C_Cpp.intelliSenseEngine": "disabled",
           "python.terminal.activateEnvironment": false,
           "files.watcherExclude": {
diff --git a/.dockerignore b/.dockerignore
index aafe911b4..fe84290c3 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,2 +1,43 @@
 # Ensure user local scripts are not included in resulting docker images that are built
 scripts/private_local
+
+# Exclude large or permission-restricted paths from build context
+.volumes/
+**/.volumes/
+models/
+outputs/
+triton_models/
+
+.cursor/
+tools/private_local/
+test_results/
+sweep_results/
+artifacts/
+
+lancedb_*/
+tools/harness/lancedb/
+
+history.db
+history.db-shm
+history.db-wal
+
+dist/
+
+.venv/
+.env/
+.env.local/
+.env.development.local/
+.env.test.local/
+.env.production.local/
+
+.env.development/
+.env.test/
+.env.production/
+
+# Keep build context small and avoid permission issues
+.git/
+**/__pycache__/
+**/*.pyc
+*.egg-info/
+**/*.egg-info/
+nemo_retriever/.venv/
diff --git a/.github/actions/determine-version/action.yml b/.github/actions/determine-version/action.yml
new file mode 100644
index 000000000..cfa51acb5
--- /dev/null
+++ b/.github/actions/determine-version/action.yml
@@ -0,0 +1,54 @@
+name: Determine Version
+description: Determine version string from inputs or generate from date
+
+inputs:
+  version:
+    description: 'Explicit version string (leave empty for auto-generation)'
+    required: false
+    default: ''
+  date-format:
+    description: 'Date format for auto-generated version'
+    required: false
+    default: '%Y.%m.%d'
+  branch-name:
+    description: 'Branch name to extract version from (for release branches)'
+    required: false
+    default: ''
+
+outputs:
+  version:
+    description: 'Determined version string'
+    value: ${{ steps.determine.outputs.version }}
+
+runs:
+  using: composite
+  steps:
+    - name: Determine version
+      id: determine
+      shell: bash
+      run: |
+        VERSION=""
+        INPUT_VERSION="${{ inputs.version }}"
+        INPUT_BRANCH_NAME="${{ inputs.branch-name }}"
+        INPUT_DATE_FORMAT="${{ inputs.date-format }}"
+
+        # Priority 1: Explicit version input
+        if [ -n "${INPUT_VERSION}" ]; then
+          VERSION="${INPUT_VERSION}"
+          echo "Using explicit version: $VERSION"
+
+        # Priority 2: Extract from branch name (for release/* branches)
+        elif [ -n "${INPUT_BRANCH_NAME}" ]; then
+          if [[ "${INPUT_BRANCH_NAME}" == release/* ]]; then
+            VERSION="${INPUT_BRANCH_NAME#release/}"
+            echo "Extracted version from branch: $VERSION"
+          fi
+        fi
+
+        # Priority 3: Generate from date
+        if [ -z "$VERSION" ]; then
+          VERSION="$(date +"${INPUT_DATE_FORMAT}")"
+          echo "Generated version from date: $VERSION"
+        fi
+
+        echo "version=$VERSION" >> $GITHUB_OUTPUT
diff --git a/.github/actions/docker-login-ngc/action.yml b/.github/actions/docker-login-ngc/action.yml
new file mode 100644
index 000000000..049a4dd54
--- /dev/null
+++ b/.github/actions/docker-login-ngc/action.yml
@@ -0,0 +1,19 @@
+name: Login to NGC Registry
+description: Authenticate with NVIDIA NGC Container Registry
+
+inputs:
+  registry:
+    description: 'Registry URL'
+    required: false
+    default: 'nvcr.io'
+  password:
+    description: 'NGC API token'
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - name: Log in to NGC Registry
+      shell: bash
+      run: |
+        echo "${{ inputs.password }}" | docker login ${{ inputs.registry }} --username "\$oauthtoken" --password-stdin
diff --git a/.github/actions/setup-docker-buildx/action.yml b/.github/actions/setup-docker-buildx/action.yml
new file mode 100644
index 000000000..84dadfe29
--- /dev/null
+++ b/.github/actions/setup-docker-buildx/action.yml
@@ -0,0 +1,24 @@
+name: Setup Docker Buildx
+description: Set up Docker Buildx with optional QEMU for multi-platform builds
+
+inputs:
+  use-qemu:
+    description: 'Enable QEMU emulation for cross-platform builds'
+    required: false
+    default: 'false'
+  platforms:
+    description: 'Platforms to support (comma-separated)'
+    required: false
+    default: 'linux/amd64'
+
+runs:
+  using: composite
+  steps:
+    - name: Set up QEMU
+      if: ${{ inputs.use-qemu == 'true' }}
+      uses: docker/setup-qemu-action@v3
+
+    - name: Set up Docker Buildx
+      uses: docker/setup-buildx-action@v3
+      with:
+        platforms: ${{ inputs.platforms }}
diff --git a/.github/workflows/ci-main.yml b/.github/workflows/ci-main.yml
new file mode 100644
index 000000000..a2bdcd529
--- /dev/null
+++ b/.github/workflows/ci-main.yml
@@ -0,0 +1,68 @@
+name: Main Branch CI
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  # Pre-commit checks
+  pre-commit:
+    name: Pre-commit Checks
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v3
+
+      - uses: pre-commit/action@v3.0.1
+
+  # Build standard Docker image
+  docker-build:
+    name: Build Docker Image (amd64)
+    uses: ./.github/workflows/reusable-docker-build.yml
+    with:
+      platform: 'linux/amd64'
+      target: 'runtime'
+      push: false
+      tags: 'nv-ingest:main-${{ github.sha }}'
+      base-image: 'ubuntu'
+      base-image-tag: 'jammy-20250415.1'
+      runner: 'linux-large-disk'
+    secrets:
+      HF_ACCESS_TOKEN: ${{ secrets.HF_ACCESS_TOKEN }}
+
+  # Test Docker image
+  docker-test:
+    name: Test Docker Image
+    needs: docker-build
+    uses: ./.github/workflows/reusable-docker-test.yml
+    with:
+      image-tag: 'nv-ingest:main-${{ github.sha }}'
+      platform: 'linux/amd64'
+      test-selection: 'full'
+      pytest-markers: 'not integration'
+      coverage: true
+      runner: 'linux-large-disk'
+
+  # Test library mode
+  library-mode-test:
+    name: Test Library Mode
+    uses: ./.github/workflows/reusable-integration-test.yml
+    with:
+      runner: 'ubuntu-latest'
+      timeout-minutes: 60
+      source-ref: 'main'
+    secrets:
+      AUDIO_FUNCTION_ID: ${{ secrets.AUDIO_FUNCTION_ID }}
+      EMBEDDING_NIM_MODEL_NAME: ${{ secrets.EMBEDDING_NIM_MODEL_NAME }}
+      NEMOTRON_PARSE_MODEL_NAME: ${{ secrets.NEMOTRON_PARSE_MODEL_NAME }}
+      NGC_API_KEY: ${{ secrets.NGC_API_KEY }}
+      NVIDIA_API_KEY: ${{ secrets.NVIDIA_API_KEY }}
+      PADDLE_HTTP_ENDPOINT: ${{ secrets.PADDLE_HTTP_ENDPOINT }}
+      VLM_CAPTION_ENDPOINT: ${{ secrets.VLM_CAPTION_ENDPOINT }}
+      VLM_CAPTION_MODEL_NAME: ${{ secrets.VLM_CAPTION_MODEL_NAME }}
+      YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT: ${{ secrets.YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT }}
+      YOLOX_HTTP_ENDPOINT: ${{ secrets.YOLOX_HTTP_ENDPOINT }}
+      YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT: ${{ secrets.YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT }}
diff --git a/.github/workflows/ci-pull-request.yml b/.github/workflows/ci-pull-request.yml
new file mode 100644
index 000000000..47667eace
--- /dev/null
+++ b/.github/workflows/ci-pull-request.yml
@@ -0,0 +1,110 @@
+name: Pull Request Validation
+
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+      - reopened
+  pull_request_target:
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - labeled
+
+concurrency:
+  group: ${{ github.workflow }}-pr-${{ github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  # Fast pre-commit checks (runs first)
+  pre-commit:
+    name: Pre-commit Checks
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v3
+
+      - uses: pre-commit/action@v3.0.1
+
+  # Docker build + test for x86_64 (single job so built image is available locally)
+  docker-build-and-test:
+    name: Build & Test Docker (amd64)
+    uses: ./.github/workflows/reusable-docker-build-and-test.yml
+    with:
+      platform: 'linux/amd64'
+      target: 'test'
+      tags: 'nv-ingest:pr-${{ github.event.pull_request.number }}'
+      base-image: 'ubuntu'
+      base-image-tag: 'jammy-20250415.1'
+      test-selection: 'full'
+      pytest-markers: 'not integration'
+      coverage: true
+      runner: 'linux-large-disk'
+    secrets:
+      HF_ACCESS_TOKEN: ${{ secrets.HF_ACCESS_TOKEN }}
+
+  # Library mode integration tests (requires approval for external contributors)
+  library-mode-check-access:
+    name: Check Library Mode Test Access
+    if: github.event_name == 'pull_request_target'
+    runs-on: ubuntu-latest
+    outputs:
+      has-access: ${{ steps.check.outputs.has-access }}
+    steps:
+      - name: Check access
+        id: check
+        run: |
+          HAS_ACCESS="false"
+          if [[ "${{ github.event.pull_request.author_association }}" == "MEMBER" ]] || \
+             [[ "${{ github.event.pull_request.author_association }}" == "COLLABORATOR" ]] || \
+             [[ "${{ github.event.pull_request.author_association }}" == "OWNER" ]] || \
+             [[ "${{ contains(github.event.pull_request.labels.*.name, 'ok-to-test') }}" == "true" ]]; then
+            HAS_ACCESS="true"
+          fi
+          echo "has-access=$HAS_ACCESS" >> $GITHUB_OUTPUT
+
+  library-mode-test:
+    name: Test Library Mode
+    needs: library-mode-check-access
+    if: |
+      github.event_name == 'pull_request_target' &&
+      needs.library-mode-check-access.outputs.has-access == 'true'
+    uses: ./.github/workflows/reusable-integration-test.yml
+    with:
+      runner: 'ubuntu-latest'
+      timeout-minutes: 60
+      source-ref: ${{ github.event.pull_request.head.sha }}
+    secrets:
+      AUDIO_FUNCTION_ID: ${{ secrets.AUDIO_FUNCTION_ID }}
+      EMBEDDING_NIM_MODEL_NAME: ${{ secrets.EMBEDDING_NIM_MODEL_NAME }}
+      NEMOTRON_PARSE_MODEL_NAME: ${{ secrets.NEMOTRON_PARSE_MODEL_NAME }}
+      NGC_API_KEY: ${{ secrets.NGC_API_KEY }}
+      NVIDIA_API_KEY: ${{ secrets.NVIDIA_API_KEY }}
+      PADDLE_HTTP_ENDPOINT: ${{ secrets.PADDLE_HTTP_ENDPOINT }}
+      VLM_CAPTION_ENDPOINT: ${{ secrets.VLM_CAPTION_ENDPOINT }}
+      VLM_CAPTION_MODEL_NAME: ${{ secrets.VLM_CAPTION_MODEL_NAME }}
+      YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT: ${{ secrets.YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT }}
+      YOLOX_HTTP_ENDPOINT: ${{ secrets.YOLOX_HTTP_ENDPOINT }}
+      YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT: ${{ secrets.YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT }}
+
+  # Summary job
+  pr-validation-complete:
+    name: PR Validation Complete
+    needs:
+      - pre-commit
+      - docker-build-and-test
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - name: Check job results
+        run: |
+          if [[ "${{ needs.pre-commit.result }}" != "success" ]] || \
+             [[ "${{ needs.docker-build-and-test.result }}" != "success" ]]; then
+            echo "One or more required jobs failed"
+            exit 1
+          fi
+          echo "All required PR checks passed!"
diff --git a/.github/workflows/conda-publish.yml b/.github/workflows/conda-publish.yml
deleted file mode 100644
index 08ed3d7df..000000000
--- a/.github/workflows/conda-publish.yml
+++ /dev/null
@@ -1,58 +0,0 @@
-name: Nv-Ingest Conda Package Publish
-
-# Trigger for pull requests and pushing to main
-on:
-  schedule:
-    # Runs every day at 11:30PM (UTC)
-    - cron: "30 23 * * *"
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-    inputs:
-      CONDA_CHANNEL:
-        description: 'The RapidsAI Conda channel the package should be pushed to'
-        required: true
-        type: choice
-        options:
-          - dev
-          - main
-      VERSION:
-        description: 'Version string for the release (e.g., 1.0.0)'
-        required: true
-
-jobs:
-  build:
-    runs-on: linux-large-disk
-    container:
-      image: rapidsai/ci-conda:cuda12.5.1-ubuntu22.04-py3.12
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          ref: main
-
-      - name: Determine CONDA_CHANNEL
-        run: |
-          echo "Github event_name: ${{ github.event_name }}"
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "Setting Conda channel to ${{ github.event.inputs.CONDA_CHANNEL }}"
-            echo "CONDA_CHANNEL=${{ github.event.inputs.CONDA_CHANNEL }}" >> $GITHUB_ENV
-          else
-            echo "CONDA_CHANNEL=dev" >> $GITHUB_ENV
-          fi
-
-      # Build the Conda packages
-      - name: Build Conda Packages
-        run: |
-          echo "Github event_name: ${{ github.event_name }}"
-          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
-            echo "Building conda package for ${{ github.event.inputs.VERSION }}"
-            RELEASE_VERSION="${{ github.event.inputs.VERSION }}" ./conda/build_conda_packages.sh
-          else
-            ./conda/build_conda_packages.sh
-          fi
-
-      # Publish nv-ingest conda packages
-      - name: Publish conda package
-        run: anaconda -t "${{ secrets.NVIDIA_CONDA_TOKEN }}" upload --force --label $CONDA_CHANNEL ./conda/output_conda_channel/linux-64/*.conda
diff --git a/.github/workflows/docker-build-arm.yml b/.github/workflows/docker-build-arm.yml
index 72b75c4ab..e46586baa 100644
--- a/.github/workflows/docker-build-arm.yml
+++ b/.github/workflows/docker-build-arm.yml
@@ -1,12 +1,7 @@
 name: Build NV-Ingest Runtime Image (arm64)
 
 on:
-  # Trigger only for pushing to main since build may take > 1 hour.
-  push:
-    branches:
-      - main
-
-  # Allows you to run this workflow manually from the Actions tab
+  # Manual-only: arm64 builds run in scheduled nightly workflow.
   workflow_dispatch:
 
 jobs:
@@ -42,7 +37,7 @@ jobs:
             SECRET_ARG="--secret id=hf_token,src=./scripts/private_local/hf_token.txt"
           fi
           docker buildx create --use
-          docker buildx build --platform linux/arm64 --load --target runtime --build-arg GIT_COMMIT=${GITHUB_SHA} --build-arg BASE_IMG=ubuntu --build-arg BASE_IMG_TAG=jammy-20250415.1 --build-arg DOWNLOAD_LLAMA_TOKENIZER=True $SECRET_ARG -t nv-ingest:latest .
+          docker buildx build --platform linux/arm64 --load --target test --build-arg GIT_COMMIT=${GITHUB_SHA} --build-arg BASE_IMG=ubuntu --build-arg BASE_IMG_TAG=jammy-20250415.1 --build-arg DOWNLOAD_LLAMA_TOKENIZER=True $SECRET_ARG -t nv-ingest:latest .
 
       - name: Cleanup HF token file
         if: always()
@@ -51,7 +46,7 @@ jobs:
       # Only test a random subset (see --random-selection) because running pytest with QEMU emulation can be very slow.
       - name: Run Pytest inside Docker container
         run: |
-          docker run --platform=linux/arm64 nv-ingest:latest pytest -rs -m "not integration" --random-selection 100 tests/service_tests client/client_tests api/api_tests
+          docker run --platform=linux/arm64 nv-ingest:latest bash -lc "python -m pip install --disable-pip-version-check 'pymilvus[milvus_lite]' && pytest -rs -m 'not integration' --random-selection 100 tests/service_tests client/client_tests api/api_tests"
 
       - name: Upload test report
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/docker-build-publish-retriever.yml b/.github/workflows/docker-build-publish-retriever.yml
new file mode 100644
index 000000000..edc2c4fc1
--- /dev/null
+++ b/.github/workflows/docker-build-publish-retriever.yml
@@ -0,0 +1,49 @@
+name: Build and Publish Retriever Image
+
+on:
+  push:
+    branches: [ main ]
+  workflow_dispatch: {}
+
+permissions:
+  contents: read
+  packages: write
+
+concurrency:
+  group: build-retriever-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  IMAGE: ghcr.io/${{ github.repository_owner }}/nemo-retriever
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v2
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to GHCR
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: ./nemo_retriever
+          file: ./nemo_retriever/Dockerfile
+          push: true
+          platforms: linux/amd64,linux/arm64
+          tags: |
+            ${{ env.IMAGE }}:latest
diff --git a/.github/workflows/docker-build.yml b/.github/workflows/docker-build.yml
index b2111c9f9..f27660e99 100644
--- a/.github/workflows/docker-build.yml
+++ b/.github/workflows/docker-build.yml
@@ -11,6 +11,10 @@ on:
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   build:
     runs-on: linux-large-disk
@@ -39,7 +43,7 @@ jobs:
           if [ -s ./scripts/private_local/hf_token.txt ]; then
             SECRET_ARG="--secret id=hf_token,src=./scripts/private_local/hf_token.txt"
           fi
-          DOCKER_BUILDKIT=1 docker build --target runtime --build-arg GIT_COMMIT=${GITHUB_SHA} --build-arg BASE_IMG=ubuntu --build-arg BASE_IMG_TAG=jammy-20250415.1 --build-arg DOWNLOAD_LLAMA_TOKENIZER=True $SECRET_ARG -t nv-ingest:latest .
+          DOCKER_BUILDKIT=1 docker build --target test --build-arg GIT_COMMIT=${GITHUB_SHA} --build-arg BASE_IMG=ubuntu --build-arg BASE_IMG_TAG=jammy-20250415.1 --build-arg DOWNLOAD_LLAMA_TOKENIZER=True $SECRET_ARG -t nv-ingest:latest .
 
       - name: Cleanup HF token file
         if: always()
@@ -47,7 +51,7 @@ jobs:
 
       - name: Run Pytest inside Docker container
         run: |
-          docker run nv-ingest:latest pytest -rs -m "not integration" --cov nv_ingest --cov nv_ingest_client --cov nv_ingest_api --cov-report term --cov-report xml:coverage.xml tests/service_tests client/client_tests api/api_tests
+          docker run nv-ingest:latest bash -lc "python -m pip install --disable-pip-version-check 'pymilvus[milvus_lite]' && pytest -rs -m 'not integration' --cov nv_ingest --cov nv_ingest_client --cov nv_ingest_api --cov-report term --cov-report xml:coverage.xml tests/service_tests client/client_tests api/api_tests"
 
       - name: Upload test report
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/docker-nightly-publish.yml b/.github/workflows/docker-nightly-publish.yml
index 210c5b4fb..f1308f459 100644
--- a/.github/workflows/docker-nightly-publish.yml
+++ b/.github/workflows/docker-nightly-publish.yml
@@ -45,7 +45,7 @@ jobs:
       - name: Build Docker image
         run: |
           docker buildx create --use
-          docker buildx build --platform linux/amd64,linux/arm64 --push --target runtime --build-arg GIT_COMMIT=${GITHUB_SHA} --build-arg DOWNLOAD_LLAMA_TOKENIZER=True --secret id=hf_token,src=./scripts/private_local/hf_token.txt -t ${{ secrets.DOCKER_REGISTRY }}/nv-ingest:${{ env.CURRENT_DATE }} .
+          docker buildx build --platform linux/amd64 --push --target runtime --build-arg GIT_COMMIT=${GITHUB_SHA} --build-arg DOWNLOAD_LLAMA_TOKENIZER=True --secret id=hf_token,src=./scripts/private_local/hf_token.txt -t ${{ secrets.DOCKER_REGISTRY }}/nv-ingest:${{ env.CURRENT_DATE }} .
 
       - name: Cleanup HF token file
         if: always()
diff --git a/.github/workflows/docker-release-publish.yml b/.github/workflows/docker-release-publish.yml
index f126a6b9d..3d99ac276 100644
--- a/.github/workflows/docker-release-publish.yml
+++ b/.github/workflows/docker-release-publish.yml
@@ -41,7 +41,7 @@ jobs:
       - name: Build Docker image
         run: |
           docker buildx create --use
-          docker buildx build --platform linux/amd64,linux/arm64 --push --target runtime --build-arg GIT_COMMIT=${GITHUB_SHA} --build-arg DOWNLOAD_LLAMA_TOKENIZER=True --secret id=hf_token,src=./scripts/private_local/hf_token.txt -t ${{ secrets.DOCKER_REGISTRY }}/nv-ingest:${{ env.SHORT_BRANCH_NAME }} .
+          docker buildx build --platform linux/amd64 --push --target runtime --build-arg GIT_COMMIT=${GITHUB_SHA} --build-arg DOWNLOAD_LLAMA_TOKENIZER=True --secret id=hf_token,src=./scripts/private_local/hf_token.txt -t ${{ secrets.DOCKER_REGISTRY }}/nv-ingest:${{ env.SHORT_BRANCH_NAME }} .
 
       - name: Cleanup HF token file
         if: always()
diff --git a/.github/workflows/docs-deploy.yml b/.github/workflows/docs-deploy.yml
new file mode 100644
index 000000000..023859880
--- /dev/null
+++ b/.github/workflows/docs-deploy.yml
@@ -0,0 +1,71 @@
+name: Documentation Deploy
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+jobs:
+  build:
+    name: Build Documentation
+    runs-on: linux-large-disk
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Setup Pages
+        uses: actions/configure-pages@v5
+
+      - name: Setup Docker Buildx
+        uses: ./.github/actions/setup-docker-buildx
+
+      - name: Build Documentation Docker Image
+        run: |
+          docker build \
+            --target docs \
+            --build-arg GIT_COMMIT=${GITHUB_SHA} \
+            -t nv-ingest-docs:latest \
+            .
+
+      - name: Run Documentation Build Container
+        run: |
+          CONTAINER_ID=$(docker run -d nv-ingest-docs:latest)
+          echo "CONTAINER_ID=$CONTAINER_ID" >> $GITHUB_ENV
+
+      - name: Wait for documentation generation
+        run: docker wait $CONTAINER_ID
+
+      - name: Copy generated docs from container
+        run: docker cp $CONTAINER_ID:/workspace/docs/site ./generated-site
+
+      - name: Clean up container
+        run: docker rm $CONTAINER_ID
+
+      - name: Upload Site Artifacts
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./generated-site
+
+  deploy:
+    name: Deploy to GitHub Pages
+    needs: build
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
diff --git a/.github/workflows/huggingface-nightly.yml b/.github/workflows/huggingface-nightly.yml
new file mode 100644
index 000000000..e285a227c
--- /dev/null
+++ b/.github/workflows/huggingface-nightly.yml
@@ -0,0 +1,257 @@
+name: huggingface-nightly-build-and-publish
+
+on:
+  schedule:
+    # Nightly at 03:17 UTC
+    - cron: "17 3 * * *"
+  workflow_dispatch:
+    inputs:
+      upload_to:
+        description: "Where to upload (none/testpypi/pypi)"
+        required: true
+        default: "testpypi"
+        type: choice
+        options:
+          - none
+          - testpypi
+          - pypi
+      skip_existing:
+        description: "Skip already-uploaded versions"
+        required: true
+        default: true
+        type: boolean
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        repo:
+          - id: nemotron-page-elements-v3
+            url: https://huggingface.co/nvidia/nemotron-page-elements-v3
+            project_subdir: ""
+          - id: nemotron-table-structure-v1
+            url: https://huggingface.co/nvidia/nemotron-table-structure-v1
+            project_subdir: ""
+          - id: nemotron-graphic-elements-v1
+            url: https://huggingface.co/nvidia/nemotron-graphic-elements-v1
+            project_subdir: ""
+          - id: llama-nemotron-embed-1b-v2
+            url: https://huggingface.co/nvidia/llama-nemotron-embed-1b-v2
+            # Repo layout matches nemotron-ocr-v1: Python project is nested under a same-named subdir.
+            project_subdir: llama-nemotron-embed-1b-v2
+          - id: llama-nemotron-rerank-1b-v2
+            url: https://huggingface.co/nvidia/llama-nemotron-rerank-1b-v2
+            project_subdir: ""
+
+    steps:
+      - name: Checkout orchestrator repo
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install git-lfs
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y git-lfs
+          git lfs install
+
+      - name: Decide upload target
+        id: target
+        shell: bash
+        run: |
+          set -euo pipefail
+          # Default for scheduled runs: testpypi
+          upload_to="testpypi"
+          skip_existing="true"
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            upload_to="${{ inputs.upload_to }}"
+            skip_existing="${{ inputs.skip_existing }}"
+          fi
+          echo "upload_to=${upload_to}" >> "$GITHUB_OUTPUT"
+          echo "skip_existing=${skip_existing}" >> "$GITHUB_OUTPUT"
+
+      - name: Build (and maybe upload)
+        env:
+          TEST_PYPI_API_TOKEN: ${{ secrets.TEST_PYPI_API_TOKEN }}
+          PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          upload_flag=""
+          repo_url="https://test.pypi.org/legacy/"
+          token_env="TEST_PYPI_API_TOKEN"
+          if [[ "${{ steps.target.outputs.upload_to }}" == "none" ]]; then
+            upload_flag=""
+          else
+            upload_flag="--upload"
+          fi
+          if [[ "${{ steps.target.outputs.upload_to }}" == "pypi" ]]; then
+            repo_url="https://upload.pypi.org/legacy/"
+            token_env="PYPI_API_TOKEN"
+          fi
+
+          skip_existing_flag=""
+          if [[ "${{ steps.target.outputs.skip_existing }}" == "true" ]]; then
+            skip_existing_flag="--skip-existing"
+          fi
+
+          python ci/scripts/nightly_build_publish.py \
+            --repo-id "${{ matrix.repo.id }}" \
+            --repo-url "${{ matrix.repo.url }}" \
+            --work-dir ".work" \
+            --dist-dir "dist-out" \
+            --project-subdir "${{ matrix.repo.project_subdir }}" \
+            ${upload_flag} \
+            --repository-url "${repo_url}" \
+            --token-env "${token_env}" \
+            ${skip_existing_flag}
+
+      - name: Upload build artifacts (GH Actions)
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-${{ matrix.repo.id }}
+          path: dist-out/${{ matrix.repo.id }}/*
+
+  build_ocr_cuda:
+    # nemotron-ocr-v1 needs nvcc/CUDA headers to build its extension.
+    # Build with Python 3.12 to match upstream package constraints and
+    # avoid producing an extension for the wrong Python ABI.
+    runs-on: ubuntu-latest
+    container:
+      # Build extension with CUDA 13 toolchain (nvcc/headers from devel image).
+      image: nvidia/cuda:13.0.0-devel-ubuntu24.04
+    steps:
+      - name: Install system deps (git, lfs, build tools)
+        shell: bash
+        run: |
+          set -euo pipefail
+          apt-get update
+          apt-get install -y --no-install-recommends \
+            ca-certificates \
+            git \
+            git-lfs \
+            build-essential \
+            ninja-build \
+            python3 \
+            python3-venv \
+            python3-pip
+          git lfs install
+
+      - name: Checkout orchestrator repo
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Decide upload target
+        id: target
+        shell: bash
+        run: |
+          set -euo pipefail
+          # Default for scheduled runs: testpypi
+          upload_to="testpypi"
+          skip_existing="true"
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            upload_to="${{ inputs.upload_to }}"
+            skip_existing="${{ inputs.skip_existing }}"
+          fi
+          echo "upload_to=${upload_to}" >> "$GITHUB_OUTPUT"
+          echo "skip_existing=${skip_existing}" >> "$GITHUB_OUTPUT"
+
+      - name: Build nemotron-ocr-v1 (and maybe upload)
+        env:
+          TEST_PYPI_API_TOKEN: ${{ secrets.TEST_PYPI_API_TOKEN }}
+          PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+          CUDA_HOME: /usr/local/cuda
+          BUILD_CPP_EXTENSION: "1"
+          BUILD_CPP_FORCE: "1"
+          TORCH_CUDA_ARCH_LIST: "8.0;8.6;8.9;9.0;10.0;12.0+PTX"
+          PIP_EXTRA_INDEX_URL: "https://download.pytorch.org/whl/cu130"
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          upload_flag=""
+          repo_url="https://test.pypi.org/legacy/"
+          token_env="TEST_PYPI_API_TOKEN"
+          if [[ "${{ steps.target.outputs.upload_to }}" == "none" ]]; then
+            upload_flag=""
+          else
+            upload_flag="--upload"
+          fi
+          if [[ "${{ steps.target.outputs.upload_to }}" == "pypi" ]]; then
+            repo_url="https://upload.pypi.org/legacy/"
+            token_env="PYPI_API_TOKEN"
+          fi
+
+          skip_existing_flag=""
+          if [[ "${{ steps.target.outputs.skip_existing }}" == "true" ]]; then
+            skip_existing_flag="--skip-existing"
+          fi
+
+          python --version
+          python ci/scripts/nightly_build_publish.py \
+            --repo-id "nemotron-ocr-v1" \
+            --repo-url "https://huggingface.co/nvidia/nemotron-ocr-v1" \
+            --work-dir ".work" \
+            --dist-dir "dist-out" \
+            --project-subdir "nemotron-ocr" \
+            --build-no-isolation \
+            --venv-pip-install "hatchling" \
+            --venv-pip-install "setuptools>=68" \
+            --venv-pip-install "torch==2.9.1" \
+            --venv-pip-install "torchvision==0.24.1" \
+            --build-env "BUILD_CPP_EXTENSION=1" \
+            --build-env "BUILD_CPP_FORCE=1" \
+            ${upload_flag} \
+            --repository-url "${repo_url}" \
+            --token-env "${token_env}" \
+            ${skip_existing_flag}
+
+          python - <<'PY'
+          import sys
+          import zipfile
+          from pathlib import Path
+
+          wheels = sorted(Path("dist-out/nemotron-ocr-v1").glob("*.whl"))
+          if not wheels:
+              raise SystemExit("No wheel found in dist-out/nemotron-ocr-v1")
+
+          py_tag = f"cpython-{sys.version_info.major}{sys.version_info.minor}"
+          matches = []
+          for wheel in wheels:
+              with zipfile.ZipFile(wheel) as zf:
+                  names = zf.namelist()
+              for name in names:
+                  if "nemotron_ocr_cpp/_nemotron_ocr_cpp." in name:
+                      matches.append((wheel.name, name))
+
+          if not matches:
+              raise SystemExit("Built wheel is missing nemotron_ocr_cpp extension artifact")
+
+          if not any(py_tag in ext for _, ext in matches):
+              formatted = "\n".join(f"{w}: {ext}" for w, ext in matches)
+              raise SystemExit(
+                  f"Built extension ABI does not match runner Python ({py_tag}). Found:\n{formatted}"
+              )
+          print("Verified nemotron_ocr_cpp extension ABI:", py_tag)
+          PY
+
+      - name: Upload build artifacts (GH Actions)
+        if: always()
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-nemotron-ocr-v1
+          path: dist-out/nemotron-ocr-v1/*
diff --git a/.github/workflows/pre-commit.yml b/.github/workflows/pre-commit.yml
index 5d90003bd..dc14ab532 100644
--- a/.github/workflows/pre-commit.yml
+++ b/.github/workflows/pre-commit.yml
@@ -5,6 +5,10 @@ on:
     push:
       branches: [main]
 
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   lint:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/pypi-nightly-publish.yml b/.github/workflows/pypi-nightly-publish.yml
index 66821b1d4..98ea26927 100644
--- a/.github/workflows/pypi-nightly-publish.yml
+++ b/.github/workflows/pypi-nightly-publish.yml
@@ -1,6 +1,5 @@
 name: Nv-Ingest Nightly PyPi Wheel Publish
 
-# Trigger for pull requests and pushing to main
 on:
   schedule:
     # Runs every day at 11:30PM (UTC)
@@ -11,25 +10,58 @@ on:
         description: 'Source branch to build wheel from'
         required: true
         default: 'main'
+        type: string
       VERSION:
         description: 'Version string for the release (e.g., 25.4.0)'
         required: true
+        default: ''
+        type: string
       RELEASE_TYPE:
         description: 'Whether the build is a nightly or release'
         required: true
+        default: dev
         type: choice
         options:
           - dev
           - release
+      upload_to:
+        description: 'Where to upload (none/testpypi/pypi)'
+        required: true
+        default: testpypi
+        type: choice
+        options:
+          - none
+          - testpypi
+          - pypi
+      skip_existing:
+        description: 'Skip already-uploaded versions'
+        required: true
+        default: true
+        type: boolean
 
 jobs:
   build:
     runs-on: linux-large-disk
-    container:
-      image: rapidsai/ci-conda:cuda12.5.1-ubuntu22.04-py3.12
     steps:
+      - name: Decide upload target
+        id: target
+        shell: bash
+        run: |
+          set -euo pipefail
+          # Default for scheduled runs: testpypi
+          upload_to="testpypi"
+          skip_existing="true"
+          if [[ "${{ github.event_name }}" == "workflow_dispatch" ]]; then
+            upload_to="${{ inputs.upload_to }}"
+            skip_existing="${{ inputs.skip_existing }}"
+          fi
+          echo "upload_to=${upload_to}" >> "$GITHUB_OUTPUT"
+          echo "skip_existing=${skip_existing}" >> "$GITHUB_OUTPUT"
+
       - name: Determine source branch and release type to use for run
+        shell: bash
         run: |
+          set -euo pipefail
           if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
             echo "Setting build source to ${{ github.event.inputs.environment }}"
             echo "ENVIRONMENT=${{ github.event.inputs.environment }}" >> $GITHUB_ENV
@@ -60,28 +92,78 @@ jobs:
         with:
           ref: ${{ env.ENVIRONMENT }}
 
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
       - name: Install build dependencies
+        shell: bash
         run: |
           pip install build twine
 
       - name: Build nv-ingest-api wheel
+        shell: bash
         run: |
           cd api && NV_INGEST_RELEASE_TYPE=${{ env.RELEASE_TYPE }} NV_INGEST_VERSION=${{ env.VERSION }} python -m build
 
       - name: Build nv-ingest-client wheel
+        shell: bash
         run: |
           cd client && NV_INGEST_RELEASE_TYPE=${{ env.RELEASE_TYPE }} NV_INGEST_VERSION=${{ env.VERSION }} python -m build
 
       - name: Build nv-ingest service wheel
+        shell: bash
         run: |
           cd src && NV_INGEST_RELEASE_TYPE=${{ env.RELEASE_TYPE }} NV_INGEST_VERSION=${{ env.VERSION }} python -m build
 
-      - name: Publish wheels to Artifactory
+      - name: Build nemo-retriever wheel
+        run: |
+          cd nemo_retriever
+          python - <<'PY'
+          from datetime import datetime, timezone
+          from pathlib import Path
+
+          Path("src/nemo_retriever/_build_info.py").write_text(
+              '"""Build metadata written by CI before packaging."""\n\n'
+              'BUILD_GIT_SHA = "${{ github.sha }}"\n'
+              f'BUILD_DATE = "{datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")}"\n',
+              encoding="utf-8",
+          )
+          PY
+          RETRIEVER_RELEASE_TYPE=${{ env.RELEASE_TYPE }} \
+          RETRIEVER_VERSION=${{ env.VERSION }} \
+          RETRIEVER_BUILD_NUMBER=${{ github.run_number }} \
+          RETRIEVER_GIT_SHA=${{ github.sha }} \
+          python -m build
+
+      - name: Publish wheels
         env:
-          ARTIFACTORY_URL: ${{ secrets.ARTIFACTORY_URL }}
-          ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
-          ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+          TEST_PYPI_API_TOKEN: ${{ secrets.TEST_PYPI_API_TOKEN }}
+          PYPI_API_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        shell: bash
         run: |
-          twine upload --repository-url $ARTIFACTORY_URL -u $ARTIFACTORY_USERNAME -p $ARTIFACTORY_PASSWORD api/dist/* \
-          && twine upload --repository-url $ARTIFACTORY_URL -u $ARTIFACTORY_USERNAME -p $ARTIFACTORY_PASSWORD client/dist/* \
-          && twine upload --repository-url $ARTIFACTORY_URL -u $ARTIFACTORY_USERNAME -p $ARTIFACTORY_PASSWORD src/dist/*
+          set -euo pipefail
+
+          upload_to="${{ steps.target.outputs.upload_to }}"
+          repository_url="https://test.pypi.org/legacy/"
+          token="${TEST_PYPI_API_TOKEN:-}"
+          if [[ "${upload_to}" == "pypi" ]]; then
+            repository_url="https://upload.pypi.org/legacy/"
+            token="${PYPI_API_TOKEN:-}"
+          fi
+
+          if [[ "${upload_to}" == "none" ]]; then
+            echo "upload_to=none; skipping package upload."
+            exit 0
+          fi
+
+          skip_existing_flag=""
+          if [[ "${{ steps.target.outputs.skip_existing }}" == "true" ]]; then
+            skip_existing_flag="--skip-existing"
+          fi
+
+          twine upload ${skip_existing_flag} --repository-url "${repository_url}" -u __token__ -p "${token}" api/dist/* \
+          && twine upload ${skip_existing_flag} --repository-url "${repository_url}" -u __token__ -p "${token}" client/dist/* \
+          && twine upload ${skip_existing_flag} --repository-url "${repository_url}" -u __token__ -p "${token}" src/dist/* \
+          && twine upload ${skip_existing_flag} --repository-url "${repository_url}" -u __token__ -p "${token}" nemo_retriever/dist/*
diff --git a/.github/workflows/release-docker.yml b/.github/workflows/release-docker.yml
new file mode 100644
index 000000000..8951a8d6d
--- /dev/null
+++ b/.github/workflows/release-docker.yml
@@ -0,0 +1,72 @@
+name: Release - Docker
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version to release (e.g., 25.4.0)'
+        required: true
+        type: string
+      source-ref:
+        description: 'Git ref to build from'
+        required: false
+        type: string
+        default: 'main'
+
+jobs:
+  determine-version:
+    name: Determine Release Version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+    steps:
+      - name: Extract version from branch or input
+        id: version
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            VERSION="${{ inputs.version }}"
+          else
+            # Extract from branch name (release/X.Y.Z -> X.Y.Z)
+            VERSION="${GITHUB_REF#refs/heads/release/}"
+          fi
+
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "Releasing version: $VERSION"
+
+  build-and-publish:
+    name: Build & Publish Multi-platform Docker Image
+    needs: determine-version
+    runs-on: linux-large-disk
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.source-ref || github.ref }}
+
+      - name: Setup Docker Buildx
+        uses: ./.github/actions/setup-docker-buildx
+        with:
+          use-qemu: 'true'
+          platforms: 'linux/amd64,linux/arm64'
+
+      - name: Login to NGC
+        uses: ./.github/actions/docker-login-ngc
+        with:
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build and Push Multi-platform Image
+        run: |
+          docker buildx create --use
+          docker buildx build \
+            --platform linux/amd64,linux/arm64 \
+            --push \
+            --target runtime \
+            --build-arg HF_ACCESS_TOKEN=${{ secrets.HF_ACCESS_TOKEN }} \
+            --build-arg DOWNLOAD_LLAMA_TOKENIZER=True \
+            --build-arg GIT_COMMIT=${GITHUB_SHA} \
+            -t ${{ secrets.DOCKER_REGISTRY }}/nv-ingest:${{ needs.determine-version.outputs.version }} \
+            .
+
+      - name: Summary
+        run: |
+          echo "Published Docker image: ${{ secrets.DOCKER_REGISTRY }}/nv-ingest:${{ needs.determine-version.outputs.version }}"
diff --git a/.github/workflows/release-pypi.yml b/.github/workflows/release-pypi.yml
new file mode 100644
index 000000000..7cd447e61
--- /dev/null
+++ b/.github/workflows/release-pypi.yml
@@ -0,0 +1,107 @@
+name: Release - PyPI
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: 'Version string for the release (e.g., 25.4.0)'
+        required: false
+        type: string
+      release-type:
+        description: 'Release type'
+        required: false
+        type: choice
+        default: 'release'
+        options:
+          - dev
+          - release
+      source-ref:
+        description: 'Git ref to build from'
+        required: false
+        type: string
+        default: 'main'
+
+jobs:
+  determine-version:
+    name: Determine Release Version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+      release-type: ${{ steps.release-type.outputs.release-type }}
+      source-ref: ${{ steps.source.outputs.source-ref }}
+    steps:
+      - name: Determine version
+        id: version
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ] && [ -n "${{ inputs.version }}" ]; then
+            VERSION="${{ inputs.version }}"
+          else
+            # Extract from branch name (release/X.Y.Z -> X.Y.Z)
+            VERSION="${GITHUB_REF#refs/heads/release/}"
+          fi
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "Releasing version: $VERSION"
+
+      - name: Determine release type
+        id: release-type
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ] && [ -n "${{ inputs.release-type }}" ]; then
+            RELEASE_TYPE="${{ inputs.release-type }}"
+          else
+            # Default to release type for release branches
+            RELEASE_TYPE="release"
+          fi
+          echo "release-type=$RELEASE_TYPE" >> $GITHUB_OUTPUT
+          echo "Release type: $RELEASE_TYPE"
+
+      - name: Determine source ref
+        id: source
+        run: |
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            SOURCE_REF="${{ inputs.source-ref }}"
+          else
+            SOURCE_REF="${GITHUB_REF}"
+          fi
+          echo "source-ref=$SOURCE_REF" >> $GITHUB_OUTPUT
+          echo "Building from: $SOURCE_REF"
+
+  build:
+    name: Build Python Wheels
+    needs: determine-version
+    uses: ./.github/workflows/reusable-pypi-build.yml
+    with:
+      version: ${{ needs.determine-version.outputs.version }}
+      release-type: ${{ needs.determine-version.outputs.release-type }}
+      source-ref: ${{ needs.determine-version.outputs.source-ref }}
+      runner: 'linux-large-disk'
+
+  publish:
+    name: Publish Python Wheels
+    needs:
+      - determine-version
+      - build
+    uses: ./.github/workflows/reusable-pypi-publish.yml
+    secrets:
+      ARTIFACTORY_URL: ${{ secrets.ARTIFACTORY_URL }}
+      ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+      ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+
+  summary:
+    name: Release Summary
+    needs:
+      - determine-version
+      - publish
+    runs-on: ubuntu-latest
+    steps:
+      - name: Summary
+        run: |
+          echo "Published Python wheels:"
+          echo "  Version: ${{ needs.determine-version.outputs.version }}"
+          echo "  Release Type: ${{ needs.determine-version.outputs.release-type }}"
+          echo "  Source: ${{ needs.determine-version.outputs.source-ref }}"
+          echo ""
+          echo "Packages:"
+          echo "  - nv-ingest-api"
+          echo "  - nv-ingest-client"
+          echo "  - nv-ingest"
+          echo "  - nemo-retriever"
diff --git a/.github/workflows/retriever-unit-tests.yml b/.github/workflows/retriever-unit-tests.yml
new file mode 100644
index 000000000..14eb87daf
--- /dev/null
+++ b/.github/workflows/retriever-unit-tests.yml
@@ -0,0 +1,30 @@
+name: Retriever Unit Tests
+
+on:
+  push:
+    branches:
+      - "**"
+  pull_request:
+
+jobs:
+  retriever-unit-tests:
+    name: Run Retriever Unit Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out repository code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Install unit test dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install pytest pandas pydantic pyyaml typer
+
+      - name: Run retriever unit tests
+        env:
+          PYTHONPATH: nemo_retriever/src
+        run: python -m pytest nemo_retriever/tests -q
diff --git a/.github/workflows/reusable-docker-build-and-test.yml b/.github/workflows/reusable-docker-build-and-test.yml
new file mode 100644
index 000000000..6e69aed19
--- /dev/null
+++ b/.github/workflows/reusable-docker-build-and-test.yml
@@ -0,0 +1,246 @@
+name: Reusable Docker Build and Test
+
+on:
+  workflow_call:
+    inputs:
+      platform:
+        description: 'Target platform (e.g., linux/amd64, linux/arm64)'
+        required: true
+        type: string
+      target:
+        description: 'Dockerfile target to build'
+        required: false
+        type: string
+        default: 'test'
+      tags:
+        description: 'Docker image tag(s), comma-separated (first tag is used for running tests)'
+        required: true
+        type: string
+      base-image:
+        description: 'Base image name (build arg BASE_IMG)'
+        required: false
+        type: string
+        default: 'ubuntu'
+      base-image-tag:
+        description: 'Base image tag (build arg BASE_IMG_TAG)'
+        required: false
+        type: string
+        default: 'jammy-20250415.1'
+      runner:
+        description: 'GitHub runner to use'
+        required: false
+        type: string
+        default: 'ubuntu-latest'
+      use-qemu:
+        description: 'Enable QEMU emulation (for cross-arch builds/runs)'
+        required: false
+        type: boolean
+        default: false
+      download-llama-tokenizer:
+        description: 'Set Docker build arg DOWNLOAD_LLAMA_TOKENIZER'
+        required: false
+        type: boolean
+        default: true
+      test-selection:
+        description: 'Test selection strategy (full or random)'
+        required: false
+        type: string
+        default: 'full'
+      random-count:
+        description: 'Number of tests to run when test-selection=random'
+        required: false
+        type: string
+        default: '100'
+      pytest-markers:
+        description: 'Pytest markers expression'
+        required: false
+        type: string
+        default: 'not integration'
+      coverage:
+        description: 'Collect coverage.xml and upload it'
+        required: false
+        type: boolean
+        default: true
+    secrets:
+      HF_ACCESS_TOKEN:
+        required: false
+
+jobs:
+  build-and-test:
+    runs-on: ${{ inputs.runner }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        if: ${{ inputs.use-qemu }}
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Create HF token file (optional)
+        env:
+          HF_ACCESS_TOKEN: ${{ secrets.HF_ACCESS_TOKEN }}
+        run: |
+          mkdir -p ./scripts/private_local
+          if [ -n "${HF_ACCESS_TOKEN}" ]; then
+            printf '%s' "${HF_ACCESS_TOKEN}" > ./scripts/private_local/hf_token.txt
+          fi
+
+      - name: Build Docker image (load locally)
+        run: |
+          set -euo pipefail
+
+          TAGS="${{ inputs.tags }}"
+          TAG_ARGS=""
+
+          sanitize_image_ref() {
+            local ref="$1"
+            local after_slash="${ref##*/}"
+
+            # Only sanitize the *tag* portion (after the last ':', and only if
+            # that ':' occurs after the last '/'). This avoids breaking
+            # registries with ports like "registry:5000/repo:tag".
+            if [[ "$after_slash" == *:* ]]; then
+              local name="${ref%:*}"
+              local tag="${ref##*:}"
+
+              # Docker tags must match [A-Za-z0-9_][A-Za-z0-9_.-]{0,127}
+              # Replace common offenders (like '/' from refs/heads/...) with '-'.
+              local safe_tag="${tag//\//-}"
+              safe_tag="${safe_tag// /-}"
+              safe_tag="${safe_tag//:/-}"
+              safe_tag="${safe_tag//[^A-Za-z0-9_.-]/-}"
+              safe_tag="${safe_tag#[-.]}" # strip leading '-' or '.'
+              safe_tag="${safe_tag:0:128}"
+
+              if [[ -z "$safe_tag" ]]; then
+                safe_tag="sha-${GITHUB_SHA}"
+                safe_tag="${safe_tag:0:128}"
+              fi
+
+              printf '%s:%s' "$name" "$safe_tag"
+              return 0
+            fi
+
+            printf '%s' "$ref"
+          }
+
+          IFS=',' read -ra TAG_ARR <<< "$TAGS"
+          for t in "${TAG_ARR[@]}"; do
+            t="$(echo "$t" | xargs)"
+            if [ -n "$t" ]; then
+              t="$(sanitize_image_ref "$t")"
+              TAG_ARGS="$TAG_ARGS -t $t"
+            fi
+          done
+
+          SECRET_ARG=""
+          if [ -f ./scripts/private_local/hf_token.txt ] && [ -s ./scripts/private_local/hf_token.txt ]; then
+            SECRET_ARG="--secret id=hf_token,src=./scripts/private_local/hf_token.txt"
+          fi
+
+          DOWNLOAD_LLAMA="True"
+          if [ "${{ inputs.download-llama-tokenizer }}" != "true" ]; then
+            DOWNLOAD_LLAMA="False"
+          fi
+
+          docker buildx build \
+            --platform "${{ inputs.platform }}" \
+            --load \
+            --target "${{ inputs.target }}" \
+            --build-arg GIT_COMMIT=${GITHUB_SHA} \
+            --build-arg BASE_IMG="${{ inputs.base-image }}" \
+            --build-arg BASE_IMG_TAG="${{ inputs.base-image-tag }}" \
+            --build-arg DOWNLOAD_LLAMA_TOKENIZER=$DOWNLOAD_LLAMA \
+            $SECRET_ARG \
+            $TAG_ARGS \
+            .
+
+      - name: Run tests inside Docker container
+        run: |
+          set -euo pipefail
+
+          TAGS="${{ inputs.tags }}"
+          PLATFORM="${{ inputs.platform }}"
+          MARKERS="${{ inputs.pytest-markers }}"
+          TEST_PATHS="tests/service_tests client/client_tests api/api_tests"
+
+          sanitize_image_ref() {
+            local ref="$1"
+            local after_slash="${ref##*/}"
+            if [[ "$after_slash" == *:* ]]; then
+              local name="${ref%:*}"
+              local tag="${ref##*:}"
+              local safe_tag="${tag//\//-}"
+              safe_tag="${safe_tag// /-}"
+              safe_tag="${safe_tag//:/-}"
+              safe_tag="${safe_tag//[^A-Za-z0-9_.-]/-}"
+              safe_tag="${safe_tag#[-.]}"
+              safe_tag="${safe_tag:0:128}"
+              if [[ -z "$safe_tag" ]]; then
+                safe_tag="sha-${GITHUB_SHA}"
+                safe_tag="${safe_tag:0:128}"
+              fi
+              printf '%s:%s' "$name" "$safe_tag"
+              return 0
+            fi
+            printf '%s' "$ref"
+          }
+
+          IFS=',' read -ra TAG_ARR <<< "$TAGS"
+          IMAGE=""
+          for t in "${TAG_ARR[@]}"; do
+            t="$(echo "$t" | xargs)"
+            if [ -n "$t" ]; then
+              IMAGE="$(sanitize_image_ref "$t")"
+              break
+            fi
+          done
+          if [ -z "$IMAGE" ]; then
+            echo "Error: no image tag found to run tests (inputs.tags was empty)"
+            exit 1
+          fi
+
+          if [ "${{ inputs.test-selection }}" != "full" ] && [ "${{ inputs.test-selection }}" != "random" ]; then
+            echo "Error: test-selection must be 'full' or 'random'"
+            exit 1
+          fi
+
+          if [ "${{ inputs.coverage }}" = "true" ]; then
+            COV_ARGS="--cov nv_ingest --cov nv_ingest_client --cov nv_ingest_api --cov-report term --cov-report xml:/tmp/coverage.xml"
+          else
+            COV_ARGS=""
+          fi
+
+          if [ "${{ inputs.test-selection }}" = "full" ]; then
+            CMD="python -m pip install --disable-pip-version-check 'pymilvus[milvus_lite]' && python -m pytest -rs -m \"$MARKERS\" $COV_ARGS $TEST_PATHS"
+          else
+            N="${{ inputs.random-count }}"
+            CMD="set -euo pipefail; \
+              python -m pip install --disable-pip-version-check 'pymilvus[milvus_lite]'; \
+              python -m pytest --collect-only -q $TEST_PATHS | grep '::' | shuf -n \"$N\" > /tmp/selected-tests.txt; \
+              python -m pytest -rs -m \"$MARKERS\" $COV_ARGS \$(cat /tmp/selected-tests.txt)"
+          fi
+
+          if [ "${{ inputs.coverage }}" = "true" ]; then
+            CID="$(docker create --platform "$PLATFORM" "$IMAGE" bash -lc "$CMD")"
+            docker start -a "$CID"
+            docker cp "$CID":/tmp/coverage.xml coverage.xml || true
+            docker rm -f "$CID"
+          else
+            docker run --rm --platform "$PLATFORM" "$IMAGE" bash -lc "$CMD"
+          fi
+
+      - name: Upload coverage report
+        if: ${{ inputs.coverage }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-xml
+          path: coverage.xml
+          if-no-files-found: warn
+
+      - name: Cleanup HF token file
+        if: always()
+        run: rm -f ./scripts/private_local/hf_token.txt
diff --git a/.github/workflows/reusable-docker-build.yml b/.github/workflows/reusable-docker-build.yml
new file mode 100644
index 000000000..8812ca020
--- /dev/null
+++ b/.github/workflows/reusable-docker-build.yml
@@ -0,0 +1,227 @@
+name: Reusable Docker Build
+
+on:
+  workflow_call:
+    inputs:
+      platform:
+        description: 'Target platform (e.g., linux/amd64, linux/arm64)'
+        required: true
+        type: string
+      target:
+        description: 'Dockerfile target to build'
+        required: false
+        type: string
+        default: 'runtime'
+      push:
+        description: 'Push image to registry'
+        required: false
+        type: boolean
+        default: false
+      tags:
+        description: 'Docker image tag(s), comma-separated'
+        required: true
+        type: string
+      base-image:
+        description: 'Base image name (build arg BASE_IMG)'
+        required: false
+        type: string
+        default: 'ubuntu'
+      base-image-tag:
+        description: 'Base image tag (build arg BASE_IMG_TAG)'
+        required: false
+        type: string
+        default: 'jammy-20250415.1'
+      runner:
+        description: 'GitHub runner to use'
+        required: false
+        type: string
+        default: 'ubuntu-latest'
+      use-qemu:
+        description: 'Enable QEMU emulation (for cross-arch builds)'
+        required: false
+        type: boolean
+        default: false
+      download-llama-tokenizer:
+        description: 'Set Docker build arg DOWNLOAD_LLAMA_TOKENIZER'
+        required: false
+        type: boolean
+        default: true
+      export-image-artifact:
+        description: 'Save the built image and upload as a workflow artifact (for use in later jobs)'
+        required: false
+        type: boolean
+        default: false
+      image-artifact-name:
+        description: 'Artifact name to upload the image tarball under'
+        required: false
+        type: string
+        default: 'docker-image'
+    secrets:
+      HF_ACCESS_TOKEN:
+        required: false
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runner }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        if: ${{ inputs.use-qemu }}
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Create HF token file (optional)
+        env:
+          HF_ACCESS_TOKEN: ${{ secrets.HF_ACCESS_TOKEN }}
+        run: |
+          mkdir -p ./scripts/private_local
+          if [ -n "${HF_ACCESS_TOKEN}" ]; then
+            printf '%s' "${HF_ACCESS_TOKEN}" > ./scripts/private_local/hf_token.txt
+          fi
+
+      - name: Build Docker image
+        run: |
+          set -euo pipefail
+
+          TAGS="${{ inputs.tags }}"
+          TAG_ARGS=""
+
+          sanitize_image_ref() {
+            local ref="$1"
+            local after_slash="${ref##*/}"
+
+            # Only sanitize the *tag* portion (after the last ':', and only if
+            # that ':' occurs after the last '/'). This avoids breaking
+            # registries with ports like "registry:5000/repo:tag".
+            if [[ "$after_slash" == *:* ]]; then
+              local name="${ref%:*}"
+              local tag="${ref##*:}"
+
+              # Docker tags must match [A-Za-z0-9_][A-Za-z0-9_.-]{0,127}
+              # Replace common offenders (like '/' from refs/heads/...) with '-'.
+              local safe_tag="${tag//\//-}"
+              safe_tag="${safe_tag// /-}"
+              safe_tag="${safe_tag//:/-}"
+              safe_tag="${safe_tag//[^A-Za-z0-9_.-]/-}"
+              safe_tag="${safe_tag#[-.]}" # strip leading '-' or '.'
+              safe_tag="${safe_tag:0:128}"
+
+              if [[ -z "$safe_tag" ]]; then
+                safe_tag="sha-${GITHUB_SHA}"
+                safe_tag="${safe_tag:0:128}"
+              fi
+
+              printf '%s:%s' "$name" "$safe_tag"
+              return 0
+            fi
+
+            printf '%s' "$ref"
+          }
+
+          IFS=',' read -ra TAG_ARR <<< "$TAGS"
+          for t in "${TAG_ARR[@]}"; do
+            t="$(echo "$t" | xargs)"
+            if [ -n "$t" ]; then
+              t="$(sanitize_image_ref "$t")"
+              TAG_ARGS="$TAG_ARGS -t $t"
+            fi
+          done
+
+          SECRET_ARG=""
+          if [ -f ./scripts/private_local/hf_token.txt ] && [ -s ./scripts/private_local/hf_token.txt ]; then
+            SECRET_ARG="--secret id=hf_token,src=./scripts/private_local/hf_token.txt"
+          fi
+
+          OUTPUT_FLAG="--load"
+          if [ "${{ inputs.push }}" = "true" ]; then
+            OUTPUT_FLAG="--push"
+          fi
+
+          DOWNLOAD_LLAMA="True"
+          if [ "${{ inputs.download-llama-tokenizer }}" != "true" ]; then
+            DOWNLOAD_LLAMA="False"
+          fi
+
+          docker buildx build \
+            --platform "${{ inputs.platform }}" \
+            $OUTPUT_FLAG \
+            --target "${{ inputs.target }}" \
+            --build-arg GIT_COMMIT=${GITHUB_SHA} \
+            --build-arg BASE_IMG="${{ inputs.base-image }}" \
+            --build-arg BASE_IMG_TAG="${{ inputs.base-image-tag }}" \
+            --build-arg DOWNLOAD_LLAMA_TOKENIZER=$DOWNLOAD_LLAMA \
+            $SECRET_ARG \
+            $TAG_ARGS \
+            .
+
+      - name: Save built image to tarball
+        if: ${{ inputs.export-image-artifact && inputs.push == false }}
+        run: |
+          set -euo pipefail
+
+          TAGS="${{ inputs.tags }}"
+
+          sanitize_image_ref() {
+            local ref="$1"
+            local after_slash="${ref##*/}"
+
+            # Only sanitize the *tag* portion (after the last ':', and only if
+            # that ':' occurs after the last '/'). This avoids breaking
+            # registries with ports like "registry:5000/repo:tag".
+            if [[ "$after_slash" == *:* ]]; then
+              local name="${ref%:*}"
+              local tag="${ref##*:}"
+
+              local safe_tag="${tag//\//-}"
+              safe_tag="${safe_tag// /-}"
+              safe_tag="${safe_tag//:/-}"
+              safe_tag="${safe_tag//[^A-Za-z0-9_.-]/-}"
+              safe_tag="${safe_tag#[-.]}" # strip leading '-' or '.'
+              safe_tag="${safe_tag:0:128}"
+
+              if [[ -z "$safe_tag" ]]; then
+                safe_tag="sha-${GITHUB_SHA}"
+                safe_tag="${safe_tag:0:128}"
+              fi
+
+              printf '%s:%s' "$name" "$safe_tag"
+              return 0
+            fi
+
+            printf '%s' "$ref"
+          }
+
+          IFS=',' read -ra TAG_ARR <<< "$TAGS"
+          IMAGE=""
+          for t in "${TAG_ARR[@]}"; do
+            t="$(echo "$t" | xargs)"
+            if [ -n "$t" ]; then
+              IMAGE="$(sanitize_image_ref "$t")"
+              break
+            fi
+          done
+
+          if [ -z "$IMAGE" ]; then
+            echo "Error: no image tag found to save (inputs.tags was empty)"
+            exit 1
+          fi
+
+          echo "Saving image: $IMAGE"
+          docker save "$IMAGE" | gzip -1 > docker-image.tar.gz
+          ls -lh docker-image.tar.gz
+
+      - name: Upload built image artifact
+        if: ${{ inputs.export-image-artifact && inputs.push == false }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: ${{ inputs.image-artifact-name }}
+          path: docker-image.tar.gz
+          if-no-files-found: error
+
+      - name: Cleanup HF token file
+        if: always()
+        run: rm -f ./scripts/private_local/hf_token.txt
diff --git a/.github/workflows/reusable-docker-test.yml b/.github/workflows/reusable-docker-test.yml
new file mode 100644
index 000000000..0227a2121
--- /dev/null
+++ b/.github/workflows/reusable-docker-test.yml
@@ -0,0 +1,116 @@
+name: Reusable Docker Test
+
+on:
+  workflow_call:
+    inputs:
+      image-tag:
+        description: 'Docker image tag to test (e.g., nv-ingest:pr-123)'
+        required: true
+        type: string
+      platform:
+        description: 'Target platform for docker run (e.g., linux/amd64, linux/arm64)'
+        required: false
+        type: string
+        default: 'linux/amd64'
+      test-selection:
+        description: 'Test selection strategy (full or random)'
+        required: false
+        type: string
+        default: 'full'
+      random-count:
+        description: 'Number of tests to run when test-selection=random'
+        required: false
+        type: string
+        default: '100'
+      pytest-markers:
+        description: 'Pytest markers expression'
+        required: false
+        type: string
+        default: 'not integration'
+      coverage:
+        description: 'Collect coverage.xml and upload it'
+        required: false
+        type: boolean
+        default: true
+      runner:
+        description: 'GitHub runner to use'
+        required: false
+        type: string
+        default: 'ubuntu-latest'
+      image-artifact-name:
+        description: 'If set, download this artifact and docker load it before running tests'
+        required: false
+        type: string
+        default: ''
+
+jobs:
+  test:
+    runs-on: ${{ inputs.runner }}
+    steps:
+      - name: Set up QEMU (for cross-arch runs)
+        if: ${{ inputs.platform != 'linux/amd64' }}
+        uses: docker/setup-qemu-action@v3
+
+      - name: Download built image artifact
+        if: ${{ inputs.image-artifact-name != '' }}
+        uses: actions/download-artifact@v4
+        with:
+          name: ${{ inputs.image-artifact-name }}
+
+      - name: Load Docker image from artifact
+        if: ${{ inputs.image-artifact-name != '' }}
+        run: |
+          set -euo pipefail
+          if [ ! -f docker-image.tar.gz ]; then
+            echo "Error: docker-image.tar.gz not found after downloading artifact '${{ inputs.image-artifact-name }}'"
+            ls -la
+            exit 1
+          fi
+          gunzip -c docker-image.tar.gz | docker load
+
+      - name: Run tests inside Docker container
+        run: |
+          set -euo pipefail
+
+          IMAGE="${{ inputs.image-tag }}"
+          PLATFORM="${{ inputs.platform }}"
+          MARKERS="${{ inputs.pytest-markers }}"
+          TEST_PATHS="tests/service_tests client/client_tests api/api_tests"
+
+          if [ "${{ inputs.test-selection }}" != "full" ] && [ "${{ inputs.test-selection }}" != "random" ]; then
+            echo "Error: test-selection must be 'full' or 'random'"
+            exit 1
+          fi
+
+          if [ "${{ inputs.coverage }}" = "true" ]; then
+            COV_ARGS="--cov nv_ingest --cov nv_ingest_client --cov nv_ingest_api --cov-report term --cov-report xml:/tmp/coverage.xml"
+          else
+            COV_ARGS=""
+          fi
+
+          if [ "${{ inputs.test-selection }}" = "full" ]; then
+            CMD="python -m pip install --disable-pip-version-check 'pymilvus[milvus_lite]' && python -m pytest -rs -m \"$MARKERS\" $COV_ARGS $TEST_PATHS"
+          else
+            N="${{ inputs.random-count }}"
+            CMD="set -euo pipefail; \
+              python -m pip install --disable-pip-version-check 'pymilvus[milvus_lite]'; \
+              python -m pytest --collect-only -q $TEST_PATHS | grep '::' | shuf -n \"$N\" > /tmp/selected-tests.txt; \
+              python -m pytest -rs -m \"$MARKERS\" $COV_ARGS \$(cat /tmp/selected-tests.txt)"
+          fi
+
+          if [ "${{ inputs.coverage }}" = "true" ]; then
+            CID="$(docker create --platform "$PLATFORM" "$IMAGE" bash -lc "$CMD")"
+            docker start -a "$CID"
+            docker cp "$CID":/tmp/coverage.xml coverage.xml || true
+            docker rm -f "$CID"
+          else
+            docker run --rm --platform "$PLATFORM" "$IMAGE" bash -lc "$CMD"
+          fi
+
+      - name: Upload coverage report
+        if: ${{ inputs.coverage }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage-xml
+          path: coverage.xml
+          if-no-files-found: warn
diff --git a/.github/workflows/reusable-integration-test.yml b/.github/workflows/reusable-integration-test.yml
new file mode 100644
index 000000000..f82b0606e
--- /dev/null
+++ b/.github/workflows/reusable-integration-test.yml
@@ -0,0 +1,112 @@
+name: Reusable Integration Tests
+
+on:
+  workflow_call:
+    inputs:
+      runner:
+        description: 'GitHub runner to use'
+        required: false
+        type: string
+        default: 'ubuntu-latest'
+      python-version:
+        description: 'Python version'
+        required: false
+        type: string
+        default: '3.12'
+      timeout-minutes:
+        description: 'Job timeout in minutes'
+        required: false
+        type: number
+        default: 60
+      source-ref:
+        description: 'Git ref to test'
+        required: false
+        type: string
+        default: 'main'
+    secrets:
+      AUDIO_FUNCTION_ID:
+        required: true
+      EMBEDDING_NIM_MODEL_NAME:
+        required: true
+      NEMOTRON_PARSE_MODEL_NAME:
+        required: true
+      NGC_API_KEY:
+        required: true
+      NVIDIA_API_KEY:
+        required: true
+      PADDLE_HTTP_ENDPOINT:
+        required: true
+      VLM_CAPTION_ENDPOINT:
+        required: true
+      VLM_CAPTION_MODEL_NAME:
+        required: true
+      YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT:
+        required: true
+      YOLOX_HTTP_ENDPOINT:
+        required: true
+      YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT:
+        required: true
+
+jobs:
+  test:
+    runs-on: ${{ inputs.runner }}
+    timeout-minutes: ${{ inputs.timeout-minutes }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.source-ref }}
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ inputs.python-version }}
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Install local packages and dependencies
+        shell: bash
+        run: |
+          uv venv .venv
+          source .venv/bin/activate
+          uv pip install -e ./src -e ./api -e ./client
+          uv pip install \
+            opencv-python \
+            llama-index-embeddings-nvidia \
+            pymilvus \
+            'pymilvus[bulk_writer, model]' \
+            'milvus-lite==2.4.12' \
+            'nvidia-riva-client==2.20.0' \
+            'unstructured-client>=0.25.9' \
+            'pypdfium2<5' \ # block pulling in breaking changes in pypdfium2 v5
+            tritonclient \
+            markitdown \
+            glom
+
+      - name: Run integration tests
+        env:
+          AUDIO_FUNCTION_ID: ${{ secrets.AUDIO_FUNCTION_ID }}
+          AUDIO_INFER_PROTOCOL: http
+          EMBEDDING_NIM_MODEL_NAME: ${{ secrets.EMBEDDING_NIM_MODEL_NAME }}
+          NEMOTRON_PARSE_MODEL_NAME: ${{ secrets.NEMOTRON_PARSE_MODEL_NAME }}
+          NGC_API_KEY: ${{ secrets.NGC_API_KEY }}
+          NVIDIA_API_KEY: ${{ secrets.NVIDIA_API_KEY }}
+          OCR_HTTP_ENDPOINT: ${{ secrets.PADDLE_HTTP_ENDPOINT }}
+          OCR_INFER_PROTOCOL: http
+          VLM_CAPTION_ENDPOINT: ${{ secrets.VLM_CAPTION_ENDPOINT }}
+          VLM_CAPTION_MODEL_NAME: ${{ secrets.VLM_CAPTION_MODEL_NAME }}
+          YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT: ${{ secrets.YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT }}
+          YOLOX_GRAPHIC_ELEMENTS_INFER_PROTOCOL: http
+          YOLOX_HTTP_ENDPOINT: ${{ secrets.YOLOX_HTTP_ENDPOINT }}
+          YOLOX_INFER_PROTOCOL: http
+          YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT: ${{ secrets.YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT }}
+          YOLOX_TABLE_STRUCTURE_INFER_PROTOCOL: http
+          NV_INGEST_PIPELINE_CONFIG_PATH: ./config/default_pipeline.yaml
+        shell: bash
+        run: |
+          source .venv/bin/activate
+          echo 'Running integration tests...'
+          unset LD_LIBRARY_PATH
+          python -m pytest -rsx tests/integration
diff --git a/.github/workflows/reusable-pypi-build.yml b/.github/workflows/reusable-pypi-build.yml
new file mode 100644
index 000000000..7f9947d1d
--- /dev/null
+++ b/.github/workflows/reusable-pypi-build.yml
@@ -0,0 +1,123 @@
+name: Reusable PyPI Build
+
+on:
+  workflow_call:
+    inputs:
+      version:
+        description: 'Version string for the release (e.g., 25.4.0)'
+        required: false
+        type: string
+        default: ''
+      release-type:
+        description: 'Release type (dev or release)'
+        required: false
+        type: string
+        default: 'dev'
+      source-ref:
+        description: 'Git ref to build from'
+        required: false
+        type: string
+        default: 'main'
+      runner:
+        description: 'GitHub runner to use'
+        required: false
+        type: string
+        default: 'linux-large-disk'
+    outputs:
+      version:
+        description: 'Version that was built'
+        value: ${{ jobs.build.outputs.version }}
+
+jobs:
+  build:
+    runs-on: ${{ inputs.runner }}
+    outputs:
+      version: ${{ steps.set-version.outputs.version }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ inputs.source-ref }}
+
+      - name: Determine version
+        id: set-version
+        run: |
+          if [ -n "${{ inputs.version }}" ]; then
+            VERSION="${{ inputs.version }}"
+          else
+            VERSION="$(date +'%Y.%m.%d')"
+          fi
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "Building version: $VERSION"
+
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Validate release type
+        run: |
+          if [[ "${{ inputs.release-type }}" != "dev" && "${{ inputs.release-type }}" != "release" ]]; then
+            echo "Error: release-type must be 'dev' or 'release'"
+            exit 1
+          fi
+
+      - name: Install build dependencies
+        run: pip install build twine
+
+      - name: Build nv-ingest-api wheel
+        run: |
+          cd api
+          NV_INGEST_RELEASE_TYPE=${{ inputs.release-type }} \
+          NV_INGEST_VERSION=${{ steps.set-version.outputs.version }} \
+          python -m build
+
+      - name: Build nv-ingest-client wheel
+        run: |
+          cd client
+          NV_INGEST_RELEASE_TYPE=${{ inputs.release-type }} \
+          NV_INGEST_VERSION=${{ steps.set-version.outputs.version }} \
+          python -m build
+
+      - name: Build nv-ingest service wheel
+        run: |
+          cd src
+          NV_INGEST_RELEASE_TYPE=${{ inputs.release-type }} \
+          NV_INGEST_VERSION=${{ steps.set-version.outputs.version }} \
+          python -m build
+
+      - name: Build nemo-retriever wheel
+        run: |
+          cd nemo_retriever
+          python - <<'PY'
+          from datetime import datetime, timezone
+          from pathlib import Path
+
+          Path("src/nemo_retriever/_build_info.py").write_text(
+              '"""Build metadata written by CI before packaging."""\n\n'
+              'BUILD_GIT_SHA = "${{ github.sha }}"\n'
+              f'BUILD_DATE = "{datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")}"\n',
+              encoding="utf-8",
+          )
+          PY
+          RETRIEVER_RELEASE_TYPE=${{ inputs.release-type }} \
+          RETRIEVER_VERSION=${{ steps.set-version.outputs.version }} \
+          RETRIEVER_BUILD_NUMBER=${{ github.run_number }} \
+          RETRIEVER_GIT_SHA=${{ github.sha }} \
+          python -m build
+
+      - name: Upload wheel artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-wheels
+          path: |
+            api/dist/*.whl
+            api/dist/*.tar.gz
+            client/dist/*.whl
+            client/dist/*.tar.gz
+            src/dist/*.whl
+            src/dist/*.tar.gz
+            nemo_retriever/dist/*.whl
+            nemo_retriever/dist/*.tar.gz
+          retention-days: 7
diff --git a/.github/workflows/reusable-pypi-publish.yml b/.github/workflows/reusable-pypi-publish.yml
new file mode 100644
index 000000000..746755db9
--- /dev/null
+++ b/.github/workflows/reusable-pypi-publish.yml
@@ -0,0 +1,41 @@
+name: Reusable PyPI Publish
+
+on:
+  workflow_call:
+    secrets:
+      ARTIFACTORY_URL:
+        required: true
+      ARTIFACTORY_USERNAME:
+        required: true
+      ARTIFACTORY_PASSWORD:
+        required: true
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Download wheel artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: python-wheels
+          path: ./dist
+
+      - name: Install twine
+        run: pip install twine
+
+      - name: Publish wheels to Artifactory
+        env:
+          ARTIFACTORY_URL: ${{ secrets.ARTIFACTORY_URL }}
+          ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+          ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+        run: |
+          # Publish all wheels
+          twine upload \
+            --repository-url $ARTIFACTORY_URL \
+            -u $ARTIFACTORY_USERNAME \
+            -p $ARTIFACTORY_PASSWORD \
+            ./dist/api/dist/* \
+            ./dist/client/dist/* \
+            ./dist/src/dist/* \
+            ./dist/nemo_retriever/dist/*
diff --git a/.github/workflows/scheduled-nightly.yml b/.github/workflows/scheduled-nightly.yml
new file mode 100644
index 000000000..4b7df6c64
--- /dev/null
+++ b/.github/workflows/scheduled-nightly.yml
@@ -0,0 +1,109 @@
+name: Nightly Builds & Publishing
+
+on:
+  schedule:
+    # Runs every day at 11:30PM UTC
+    - cron: "30 23 * * *"
+  workflow_dispatch:
+    inputs:
+      skip-docker:
+        description: 'Skip Docker build/publish'
+        required: false
+        type: boolean
+        default: false
+      skip-pypi:
+        description: 'Skip PyPI build/publish'
+        required: false
+        type: boolean
+        default: false
+
+jobs:
+  # Generate version for all nightly builds
+  determine-version:
+    name: Determine Nightly Version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+      docker-tag: ${{ steps.version.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Determine version
+        id: version
+        uses: ./.github/actions/determine-version
+        with:
+          date-format: '%Y.%m.%d'
+
+  # Build and publish Docker nightly
+  docker-build-publish:
+    name: Docker Nightly Build & Publish
+    if: ${{ !inputs.skip-docker }}
+    needs: determine-version
+    runs-on: linux-large-disk
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          ref: main
+
+      - name: Setup Docker Buildx
+        uses: ./.github/actions/setup-docker-buildx
+        with:
+          use-qemu: 'true'
+          platforms: 'linux/amd64,linux/arm64'
+
+      - name: Login to NGC
+        uses: ./.github/actions/docker-login-ngc
+        with:
+          password: ${{ secrets.DOCKER_PASSWORD }}
+
+      - name: Build and Push Multi-platform Image
+        run: |
+          docker buildx create --use
+          docker buildx build \
+            --platform linux/amd64,linux/arm64 \
+            --push \
+            --target runtime \
+            --build-arg HF_ACCESS_TOKEN=${{ secrets.HF_ACCESS_TOKEN }} \
+            --build-arg DOWNLOAD_LLAMA_TOKENIZER=True \
+            --build-arg GIT_COMMIT=${GITHUB_SHA} \
+            -t ${{ secrets.DOCKER_REGISTRY }}/nv-ingest:${{ needs.determine-version.outputs.docker-tag }} \
+            .
+
+  # Build and publish PyPI wheels
+  pypi-build:
+    name: PyPI Nightly Build
+    if: ${{ !inputs.skip-pypi }}
+    needs: determine-version
+    uses: ./.github/workflows/reusable-pypi-build.yml
+    with:
+      version: ${{ needs.determine-version.outputs.version }}
+      release-type: 'dev'
+      source-ref: 'main'
+      runner: 'linux-large-disk'
+
+  pypi-publish:
+    name: PyPI Nightly Publish
+    if: ${{ !inputs.skip-pypi }}
+    needs: pypi-build
+    uses: ./.github/workflows/reusable-pypi-publish.yml
+    secrets:
+      ARTIFACTORY_URL: ${{ secrets.ARTIFACTORY_URL }}
+      ARTIFACTORY_USERNAME: ${{ secrets.ARTIFACTORY_USERNAME }}
+      ARTIFACTORY_PASSWORD: ${{ secrets.ARTIFACTORY_PASSWORD }}
+
+  # Summary
+  nightly-complete:
+    name: Nightly Build Complete
+    needs:
+      - determine-version
+      - docker-build-publish
+      - pypi-publish
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - name: Report status
+        run: |
+          echo "Nightly build completed for version: ${{ needs.determine-version.outputs.version }}"
+          echo "Docker: ${{ needs.docker-build-publish.result }}"
+          echo "PyPI: ${{ needs.pypi-publish.result }}"
diff --git a/.github/workflows/test-library-mode.yml b/.github/workflows/test-library-mode.yml
deleted file mode 100644
index 9fd7430f2..000000000
--- a/.github/workflows/test-library-mode.yml
+++ /dev/null
@@ -1,122 +0,0 @@
-name: Test Nv-Ingest Library Mode
-
-on:
-  pull_request_target:
-    types:
-      - opened
-      - synchronize
-      - reopened
-      # Adding 'labeled' to the list of activity types that trigger this event
-      # (default: opened, synchronize, reopened) so that we can run this
-      # workflow when the 'ok-to-test' label is added.
-      # Reference: https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#pull_request_target
-      - labeled
-  push:
-    branches:
-      - main
-
-jobs:
-  build:
-    runs-on: linux-large-disk
-    container:
-      image: rapidsai/ci-conda:cuda12.5.1-ubuntu22.04-py3.12
-    steps:
-      - name: Check access
-        if:
-          ${{
-            github.event_name == 'pull_request_target' &&
-            github.event.pull_request.author_association != 'MEMBER' &&
-            github.event.pull_request.author_association != 'COLLABORATOR' &&
-            github.event.pull_request.author_association != 'OWNER' &&
-            !contains(github.event.pull_request.labels.*.name, 'ok-to-test')
-          }}
-        run: |
-          echo "Pull request author is not a collaborator or owner. Add the 'ok-to-test' label to allow tests to run."
-          exit 1
-
-      - name: Checkout code
-        uses: actions/checkout@v4
-        with:
-          # For pull_request_target, checkout the PR head SHA.
-          # For push, checkout the pushed commit SHA.
-          ref: ${{ github.event_name == 'pull_request_target' && github.event.pull_request.head.sha || github.sha }}
-
-      - name: Build Conda Packages
-        run: |
-          ./conda/build_conda_packages.sh
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: test_artifacts
-          path: |
-            ./conda/output_conda_channel
-            ./config
-            ./data
-            ./examples
-            ./tests/integration
-          retention-days: 1
-
-  test:
-    runs-on: ubuntu-latest
-    needs: build
-    timeout-minutes: 60
-    steps:
-      - name: Check access
-        if:
-          ${{
-            github.event_name == 'pull_request_target' &&
-            github.event.pull_request.author_association != 'MEMBER' &&
-            github.event.pull_request.author_association != 'COLLABORATOR' &&
-            github.event.pull_request.author_association != 'OWNER' &&
-            !contains(github.event.pull_request.labels.*.name, 'ok-to-test')
-          }}
-        run: |
-          echo "Pull request author is not a collaborator or owner. Add the 'ok-to-test' label to allow tests to run."
-          exit 1
-
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: test_artifacts # Match the upload name
-
-      - uses: conda-incubator/setup-miniconda@v3
-        with:
-          auto-update-conda: true
-
-      - name: Install Conda Packages & Dependencies
-        shell: bash -el {0}
-        run: |
-          conda create -y --name nvingest python=3.12.11
-          conda activate nvingest
-          # Install from the downloaded local channel first
-          conda install -y -c ./conda/output_conda_channel -c rapidsai -c conda-forge -c nvidia nv_ingest nv_ingest_api nv_ingest_client
-          # Install other dependencies
-          conda install -y -c conda-forge librosa
-          # Install pip dependencies
-          $CONDA/envs/nvingest/bin/python -m pip install opencv-python llama-index-embeddings-nvidia pymilvus 'pymilvus[bulk_writer, model]' 'milvus-lite==2.4.12' 'nvidia-riva-client==2.20.0' unstructured-client tritonclient markitdown glom
-
-      - name: Run integration test
-        env:
-          AUDIO_FUNCTION_ID: ${{ secrets.AUDIO_FUNCTION_ID }}
-          AUDIO_INFER_PROTOCOL: http
-          EMBEDDING_NIM_MODEL_NAME: ${{ secrets.EMBEDDING_NIM_MODEL_NAME }}
-          NEMOTRON_PARSE_MODEL_NAME: ${{ secrets.NEMOTRON_PARSE_MODEL_NAME }}
-          NGC_API_KEY: ${{ secrets.NVIDIA_API_KEY }}
-          NVIDIA_API_KEY: ${{ secrets.NVIDIA_API_KEY }}
-          OCR_HTTP_ENDPOINT: ${{ secrets.PADDLE_HTTP_ENDPOINT }}
-          OCR_INFER_PROTOCOL: http
-          VLM_CAPTION_ENDPOINT: ${{ secrets.VLM_CAPTION_ENDPOINT }}
-          VLM_CAPTION_MODEL_NAME: ${{ secrets.VLM_CAPTION_MODEL_NAME }}
-          YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT: ${{ secrets.YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT }}
-          YOLOX_GRAPHIC_ELEMENTS_INFER_PROTOCOL: http
-          YOLOX_HTTP_ENDPOINT: ${{ secrets.YOLOX_HTTP_ENDPOINT }}
-          YOLOX_INFER_PROTOCOL: http
-          YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT: ${{ secrets.YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT }}
-          YOLOX_TABLE_STRUCTURE_INFER_PROTOCOL: http
-          NV_INGEST_PIPELINE_CONFIG_PATH: ./config/default_pipeline.yaml
-        shell: bash -el {0}
-        run: |
-          echo 'Running tests...'
-          unset LD_LIBRARY_PATH  # https://github.com/pytorch/pytorch/issues/111469
-          $CONDA/envs/nvingest/bin/python -m pytest -rsx tests/integration
diff --git a/.gitignore b/.gitignore
index 18a9c446d..9cd91af5c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -131,6 +131,7 @@ celerybeat-schedule
 
 # Environments
 .env
+.helm-env
 .venv
 env/
 venv/
@@ -180,14 +181,12 @@ tags
 # End of https://www.gitignore.io/api/vim,c++,cmake,python,synology
 
 ./build
-.conda-bld
 .Dockerfile
 .tmp
 *.dirlock
 *.engine
 *.lock
 /build*/
-/conda-build/
 dask-worker-space
 data/*
 docs/source/_lib
@@ -219,14 +218,12 @@ processed_docs
 # Ignore devcontainer volumes
 .volumes
 
-# Ignore conda build output
-conda/output_conda_channel
 
 # Ignore generate docs site
 docs/site
 
 # Ignore "private_local" scripts that users might have in their local copy of nv-ingest they don't want to commit
-scripts/private_local/*
+scripts/private_local/
 
 # Test results should go to artifacts directory managed by nv-ingest-harness
 test_results/
@@ -245,3 +242,10 @@ tools/harness/lancedb/
 history.db
 history.db-shm
 history.db-wal
+
+
+lancedb/
+outputs/
+models/
+
+nemo_retriever/run_results/
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 16fc3b7ba..c3f03d508 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -29,3 +29,12 @@ repos:
     hooks:
       - id: flake8
         args: ["--max-line-length=120", "--extend-ignore=E203,E266,F403,F405,E402"]
+
+  - repo: local
+    hooks:
+      - id: validate-deployment-configs
+        name: validate deployment configs
+        entry: python ci/scripts/validate_deployment_configs.py
+        language: system
+        files: (docker-compose\.yaml|helm/values\.yaml)
+        pass_filenames: false
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7256980b3..4426b649a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,4 +1,4 @@
-# NVIDIA Ingest 26.1.0
+# NVIDIA Ingest 26.1.2
 
 ## New Features
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 1bc5a863c..1f549469e 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -137,19 +137,20 @@ issues. Look for unassigned issues and follow the steps starting from **Claim an
 
 ### Updating Dependencies
 
-- Dependencies are managed via 'Conda' and 'Pip'.
-- Dependencies are stored in .yml files
-    1. **Service Dependencies** 'conda/environments/nv_ingest_environment.yml' file.
-    2. **Client Dependencies** 'conda/environments/nv_ingest_client_environment.yml' file.
+- Dependencies are managed with `uv` and project-local `pyproject.toml` files.
+- Dependencies are stored in package definitions:
+    1. **Service Dependencies** `src/pyproject.toml`.
+    2. **Client Dependencies** `client/pyproject.toml`.
 
 - To update dependencies:
-  - Create a clean environment using the relevant .yml file.
-  - Update the dependencies using 'Conda' or 'Pip' and validate the changes.
-  - Update the .yml file by exporting the updated environment.
+  - Create a clean environment using `uv venv`.
+  - Update dependencies in the relevant `pyproject.toml` and validate the changes.
+  - Recreate the environment and install via `uv pip`.
     - For example:
       ```bash
-      conda env export --name nv_ingest_runtime --no-builds > conda/environment/nv_ingest_environment.yml
-      conda env export --name nv_ingest_client --no-builds > conda/environment/nv_ingest_client_environment.yml
+      uv venv .venv
+      source .venv/bin/activate
+      uv pip install -e ./src -e ./client -e ./api
       ```
 
 ### Common Processing Patterns
diff --git a/Dockerfile b/Dockerfile
index ae1a48bae..a0db9803b 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -5,11 +5,9 @@
 
 ARG BASE_IMG=nvcr.io/nvidia/base/ubuntu
 ARG BASE_IMG_TAG=jammy-20250619
-ARG TARGETPLATFORM
 
 FROM $BASE_IMG:$BASE_IMG_TAG AS base
 
-ARG TARGETPLATFORM
 ARG RELEASE_TYPE="dev"
 ARG VERSION=""
 ARG VERSION_REV="0"
@@ -18,22 +16,20 @@ ARG HF_ACCESS_TOKEN=""
 ARG MODEL_PREDOWNLOAD_PATH="/workspace/models/"
 
 # Embed the `git rev-parse HEAD` as a Docker metadata label
-# Allows for linking container builds to git commits
-# docker inspect nv-ingest:latest | jq '.[0].Config.Labels.git_commit' -> GIT_SHA
 ARG GIT_COMMIT
 LABEL git_commit=$GIT_COMMIT
 
-# Install necessary dependencies using apt-get
 RUN apt-get update && apt-get install -y \
       bzip2 \
       ca-certificates \
       curl \
       libgl1-mesa-glx \
       libglib2.0-0 \
+      make \
+      tini \
       wget \
     && apt-get clean
 
-# Install ffmpeg
 COPY ./docker/scripts/install_ffmpeg.sh scripts/install_ffmpeg.sh
 RUN chmod +x scripts/install_ffmpeg.sh \
     && bash scripts/install_ffmpeg.sh \
@@ -78,63 +74,25 @@ RUN sed -i 's/# deb-src/deb-src/' /etc/apt/sources.list \
        done \
     && apt-get clean
 
-RUN wget -O Miniforge3.sh "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh" -O /tmp/miniforge.sh \
-    && bash /tmp/miniforge.sh -b -p /opt/conda \
-    && rm /tmp/miniforge.sh
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
 
-# Add conda to the PATH
-ENV PATH=/opt/conda/bin:$PATH
+ENV PATH=/root/.local/bin:$PATH
+ENV UV_LINK_MODE=copy
 
-RUN if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
-      CONDA_SUBDIR=linux-aarch64; \
-    else \
-      CONDA_SUBDIR=linux-64; \
-    fi;
-
-# Install Mamba, a faster alternative to conda, within the base environment
-RUN --mount=type=cache,target=/opt/conda/pkgs \
-    --mount=type=cache,target=/root/.cache/pip \
-    conda install -y mamba conda-build==24.5.1 conda-merge -n base -c conda-forge
-
-COPY conda/environments/nv_ingest_environment.base.yml /workspace/nv_ingest_environment.base.yml
-COPY conda/environments/nv_ingest_environment.linux_64.yml /workspace/nv_ingest_environment.linux_64.yml
-COPY conda/environments/nv_ingest_environment.linux_aarch64.yml /workspace/nv_ingest_environment.linux_aarch64.yml
-
-# Create nv_ingest base environment
-RUN --mount=type=cache,target=/opt/conda/pkgs \
-    --mount=type=cache,target=/root/.cache/pip \
-    if [ "$TARGETPLATFORM" = "linux/arm64" ]; then \
-      conda-merge /workspace/nv_ingest_environment.base.yml /workspace/nv_ingest_environment.linux_aarch64.yml > /workspace/nv_ingest_environment.yml; \
-      rm /workspace/nv_ingest_environment.base.yml /workspace/nv_ingest_environment.linux_aarch64.yml; \
-    else \
-      conda-merge /workspace/nv_ingest_environment.base.yml /workspace/nv_ingest_environment.linux_64.yml > /workspace/nv_ingest_environment.yml; \
-      rm /workspace/nv_ingest_environment.base.yml /workspace/nv_ingest_environment.linux_64.yml; \
-    fi; \
-    mamba env create -f /workspace/nv_ingest_environment.yml
-
-# Set default shell to bash
-SHELL ["/bin/bash", "-c"]
-
-# Activate the environment (make it default for subsequent commands)
-RUN echo "source activate nv_ingest_runtime" >> ~/.bashrc
-
-# Install Tini via conda from the conda-forge channel
-RUN --mount=type=cache,target=/opt/conda/pkgs \
-    --mount=type=cache,target=/root/.cache/pip \
-    source activate nv_ingest_runtime \
-    && mamba install -y -c conda-forge tini
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv python install 3.12 \
+    && uv venv --python 3.12 /opt/nv_ingest_runtime
 
-# Ensure dynamically linked libraries in the conda environment are found at runtime
-ENV LD_LIBRARY_PATH=/opt/conda/envs/nv_ingest_runtime/lib:$LD_LIBRARY_PATH
+ENV VIRTUAL_ENV=/opt/nv_ingest_runtime
+ENV PATH=/opt/nv_ingest_runtime/bin:/root/.local/bin:$PATH
+ENV LD_LIBRARY_PATH=/opt/nv_ingest_runtime/lib:$LD_LIBRARY_PATH
 
-# Set the working directory in the container
 WORKDIR /workspace
 
 FROM base AS nv_ingest_install
-# Copy the module code
+
 COPY ci ci
 
-# Prevent haystack from sending telemetry data
 ENV HAYSTACK_TELEMETRY_ENABLED=False
 
 # Ensure the NV_INGEST_VERSION is PEP 440 compatible
@@ -163,26 +121,19 @@ COPY client client
 COPY src src
 RUN rm -rf ./src/nv_ingest/dist ./src/dist ./client/dist ./api/dist
 
-# Install python build from pip, version needed not present in conda
-RUN source activate nv_ingest_runtime \
-    && pip install 'build>=1.2.2'
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv pip install 'build>=1.2.2'
 
-# Add pip cache path to match conda's package cache
-RUN --mount=type=cache,target=/opt/conda/pkgs \
-    --mount=type=cache,target=/root/.cache/pip \
+RUN --mount=type=cache,target=/root/.cache/uv \
     chmod +x ./ci/scripts/build_pip_packages.sh \
-    && source activate nv_ingest_runtime \
     && ./ci/scripts/build_pip_packages.sh --type ${RELEASE_TYPE} --lib api \
     && ./ci/scripts/build_pip_packages.sh --type ${RELEASE_TYPE} --lib client \
     && ./ci/scripts/build_pip_packages.sh --type ${RELEASE_TYPE} --lib service
 
-RUN --mount=type=cache,target=/opt/conda/pkgs\
-    --mount=type=cache,target=/root/.cache/pip \
-    source activate nv_ingest_runtime \
-    && pip install ./src/dist/*.whl \
-    && pip install ./api/dist/*.whl \
-    && pip install ./client/dist/*.whl
-
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv pip install ./src/dist/*.whl \
+    && uv pip install ./api/dist/*.whl \
+    && uv pip install ./client/dist/*.whl
 
 RUN rm -rf src
 
@@ -191,48 +142,32 @@ FROM nv_ingest_install AS runtime
 COPY src/microservice_entrypoint.py ./
 COPY config/default_pipeline.yaml ./config/
 
-# Copy entrypoint script(s)
 COPY ./docker/scripts/entrypoint.sh /workspace/docker/entrypoint.sh
 COPY ./docker/scripts/entrypoint_source_ext.sh /workspace/docker/entrypoint_source_ext.sh
-
-# Copy post build triggers script
 COPY ./docker/scripts/post_build_triggers.py /workspace/docker/post_build_triggers.py
 
-RUN  --mount=type=cache,target=/root/.cache/pip \
+RUN --mount=type=cache,target=/root/.cache/uv \
     --mount=type=secret,id=hf_token,required=false \
-    source activate nv_ingest_runtime \
-    && python3 /workspace/docker/post_build_triggers.py
-
-# Remove graphviz and its dependencies to reduce image size
-RUN source activate nv_ingest_runtime && \
-    mamba remove graphviz python-graphviz --force -y && \
-    mamba uninstall gtk3 pango cairo fonts-conda-ecosystem -y
+    python3 /workspace/docker/post_build_triggers.py
 
 RUN chmod +x /workspace/docker/entrypoint.sh
 
-# Set entrypoint to tini with a custom entrypoint script
-ENTRYPOINT ["/opt/conda/envs/nv_ingest_runtime/bin/tini", "--", "/workspace/docker/entrypoint.sh"]
+ENTRYPOINT ["/usr/bin/tini", "--", "/workspace/docker/entrypoint.sh"]
+
+FROM runtime AS test
+RUN --mount=type=cache,target=/root/.cache/uv \
+    WHEEL="$(ls ./api/dist/*.whl)" \
+    && uv pip install "${WHEEL}[test]"
 
 FROM nv_ingest_install AS development
 
-RUN source activate nv_ingest_runtime && \
-    --mount=type=cache,target=/opt/conda/pkgs \
-    --mount=type=cache,target=/root/.cache/pip \
-    pip install -e ./client
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv pip install -e ./client
 
 CMD ["/bin/bash"]
 
-
 FROM nv_ingest_install AS docs
 
-# Install dependencies needed for docs generation
-# Clear stale apt lists and use --fix-missing to handle repository issues
-RUN rm -rf /var/lib/apt/lists/* \
-    && apt-get update --fix-missing \
-    && apt-get install -y --no-install-recommends make \
-    && apt-get clean \
-    && rm -rf /var/lib/apt/lists/*
-
 COPY docs docs
 
 # Docs needs all the source code present so add it to the container
@@ -240,8 +175,7 @@ COPY src src
 COPY api api
 COPY client client
 
-RUN source activate nv_ingest_runtime && \
-    pip install -r ./docs/requirements.txt
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv pip install -r ./docs/requirements.txt
 
-# Default command: Run `make docs`
-CMD ["bash", "-c", "cd /workspace/docs && source activate nv_ingest_runtime && make docs"]
+CMD ["bash", "-c", "cd /workspace/docs && make docs"]
diff --git a/README.md b/README.md
index 4f1288976..62108a83c 100644
--- a/README.md
+++ b/README.md
@@ -76,6 +76,14 @@ NeMo Retriever extraction does not do the following:
 
 For more information, see the [full NeMo Retriever Extraction documentation](https://docs.nvidia.com/nemo/retriever/extraction/overview/).
 
+## Documentation Resources
+
+- **[Official Documentation](https://docs.nvidia.com/nemo/retriever/extraction/)** - Complete user guides, API references, and deployment instructions
+- **[Getting Started Guide](https://docs.nvidia.com/nemo/retriever/extraction/overview/)** - Overview and prerequisites for production deployments
+- **[Benchmarking Guide](https://docs.nvidia.com/nemo/retriever/extraction/benchmarking/)** - Performance testing and recall evaluation framework
+- **[MIG Deployment](https://docs.nvidia.com/nemo/retriever/extraction/mig-benchmarking/)** - Multi-Instance GPU configurations for Kubernetes
+- **[API Documentation](https://docs.nvidia.com/nemo/retriever/extraction/api/)** - Python client and API reference
+
 
 ## Prerequisites
 
@@ -90,7 +98,7 @@ Library mode deployment of nv-ingest requires:
 
 - Linux operating systems (Ubuntu 22.04 or later recommended) or MacOS
 - Python 3.12
-- We strongly advise using an isolated Python virtual env, such as provided by [uv](https://docs.astral.sh/uv/getting-started/installation/) or [conda](https://github.com/conda-forge/miniforge)
+- We strongly advise using an isolated Python virtual env with [uv](https://docs.astral.sh/uv/getting-started/installation/).
 
 ### Step 1: Prepare Your Environment
 
@@ -99,7 +107,7 @@ Create a fresh Python environment to install nv-ingest and dependencies.
 ```shell
 uv venv --python 3.12 nvingest && \
   source nvingest/bin/activate && \
-  uv pip install nv-ingest==25.9.0 nv-ingest-api==25.9.0 nv-ingest-client==25.9.0 milvus-lite==2.4.12
+  uv pip install nv-ingest==26.1.2 nv-ingest-api==26.1.2 nv-ingest-client==26.1.2 milvus-lite==2.4.12
 ```
 
 Set your NVIDIA_API_KEY. If you don't have a key, you can get one on [build.nvidia.com](https://org.ngc.nvidia.com/setup/api-keys). For instructions, refer to [Generate Your NGC Keys](/docs/docs/extraction/ngc-api-key.md).
@@ -353,7 +361,6 @@ The following is a description of the folders in the GitHub repository.
 - [api](https://github.com/NVIDIA/nv-ingest/tree/main/api) — Core API logic shared across python modules
 - [ci](https://github.com/NVIDIA/nv-ingest/tree/main/ci) — Scripts used to build the nv-ingest container and other packages
 - [client](https://github.com/NVIDIA/nv-ingest/tree/main/client) — Readme, examples, and source code for the nv-ingest-cli utility
-- [conda](https://github.com/NVIDIA/nv-ingest/tree/main/conda) — Conda environment and packaging definitions
 - [config](https://github.com/NVIDIA/nv-ingest/tree/main/config) — Various .yaml files defining configuration for OTEL, Prometheus
 - [data](https://github.com/NVIDIA/nv-ingest/tree/main/data) — Sample PDFs for testing
 - [deploy](https://github.com/NVIDIA/nv-ingest/tree/main/deploy) — Brev.dev-hosted launchable
diff --git a/api/api_tests/interface/test_extract.py b/api/api_tests/interface/test_extract.py
index c9018a93c..7130ce0c4 100644
--- a/api/api_tests/interface/test_extract.py
+++ b/api/api_tests/interface/test_extract.py
@@ -140,7 +140,7 @@ def test_extract_primitives_from_pdf_integration(extract_method):
             {
                 "yolox_endpoints": (_YOLOX_GRPC_ENDPOINT, _YOLOX_HTTP_ENDPOINT),
                 "yolox_infer_protocol": _YOLOX_INFER_PROTOCOL,
-                "yolox_auth_token": _AUTH_TOKEN,
+                "auth_token": _AUTH_TOKEN,
             }
         )
     elif extract_method == "llama":
@@ -149,7 +149,7 @@ def test_extract_primitives_from_pdf_integration(extract_method):
                 "llama_api_key": os.getenv("INGEST_LLAMA_API_KEY", "dummy-api-key"),
                 "yolox_endpoints": (_YOLOX_GRPC_ENDPOINT, _YOLOX_HTTP_ENDPOINT),
                 "yolox_infer_protocol": _YOLOX_INFER_PROTOCOL,
-                "yolox_auth_token": _AUTH_TOKEN,
+                "auth_token": _AUTH_TOKEN,
             }
         )
     elif extract_method == "unstructured_io":
@@ -158,7 +158,7 @@ def test_extract_primitives_from_pdf_integration(extract_method):
                 "unstructured_io_api_key": os.getenv("INGEST_UNSTRUCTURED_IO_API_KEY", "dummy-api-key"),
                 "yolox_endpoints": (_YOLOX_GRPC_ENDPOINT, _YOLOX_HTTP_ENDPOINT),
                 "yolox_infer_protocol": _YOLOX_INFER_PROTOCOL,
-                "yolox_auth_token": _AUTH_TOKEN,
+                "auth_token": _AUTH_TOKEN,
             }
         )
     elif extract_method == "nemotron_parse":
@@ -174,7 +174,7 @@ def test_extract_primitives_from_pdf_integration(extract_method):
                 # Also include YOLOX parameters for image processing capability
                 "yolox_endpoints": (_YOLOX_GRPC_ENDPOINT, _YOLOX_HTTP_ENDPOINT),
                 "yolox_infer_protocol": _YOLOX_INFER_PROTOCOL,
-                "yolox_auth_token": _AUTH_TOKEN,
+                "auth_token": _AUTH_TOKEN,
             }
         )
 
@@ -292,7 +292,7 @@ def test_extract_pdf_with_pdfium_integration():
         extract_charts=True,
         extract_infographics=True,
         text_depth="page",
-        yolox_auth_token=auth_token,
+        auth_token=auth_token,
         yolox_endpoints=(yolox_grpc_endpoint, yolox_http_endpoint),
         yolox_infer_protocol=yolox_protocol,
     )
@@ -407,7 +407,7 @@ def test_extract_pdf_with_nemotron_parse_integration():
         text_depth="page",
         yolox_endpoints=(yolox_grpc_endpoint, yolox_http_endpoint),
         yolox_infer_protocol=yolox_protocol,
-        yolox_auth_token=auth_token,
+        auth_token=auth_token,
         nemotron_parse_endpoints=(nemo_grpc_endpoint, nemo_http_endpoint),
         nemotron_parse_protocol=nemo_protocol,
         nemotron_parse_model_name=nemo_model_name,
diff --git a/api/api_tests/interface/test_extract_unit.py b/api/api_tests/interface/test_extract_unit.py
new file mode 100644
index 000000000..91766b09e
--- /dev/null
+++ b/api/api_tests/interface/test_extract_unit.py
@@ -0,0 +1,157 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests verifying expected behavior when parsing extract args into their corresponding config schemas."""
+
+import pandas as pd
+import pytest
+
+from nv_ingest_api.interface import _build_config_from_schema
+from nv_ingest_api.internal.schemas.extract.extract_pdf_schema import (
+    NemotronParseConfigSchema,
+    PDFiumConfigSchema,
+)
+
+from nv_ingest_api.interface.extract import (
+    extract_primitives_from_pdf,
+    extract_primitives_from_pdf_nemotron_parse,
+    extract_primitives_from_pdf_pdfium,
+)
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+_YOLOX_HTTP = "http://localhost:8000/v1/infer"
+_NEMOTRON_HTTP = "http://localhost:8015/v1/chat/completions"
+
+
+# ===========================================================================
+# 1. Schema-field sanity checks
+# ===========================================================================
+
+
+def test_pdfium_config_schema_has_auth_token_field():
+    """PDFiumConfigSchema must declare 'auth_token', not 'yolox_auth_token'."""
+    assert "auth_token" in PDFiumConfigSchema.model_fields
+    assert "yolox_auth_token" not in PDFiumConfigSchema.model_fields
+
+
+def test_nemotron_parse_config_schema_has_auth_token_field():
+    """NemotronParseConfigSchema must declare 'auth_token', not 'yolox_auth_token'."""
+    assert "auth_token" in NemotronParseConfigSchema.model_fields
+    assert "yolox_auth_token" not in NemotronParseConfigSchema.model_fields
+
+
+# ===========================================================================
+# 2. _build_config_from_schema passes auth_token through
+# ===========================================================================
+
+
+def test_build_config_passes_auth_token_to_pdfium_schema():
+    """auth_token survives _build_config_from_schema when using PDFiumConfigSchema."""
+    args = {
+        "auth_token": "pdfium_secret_token",
+        "yolox_endpoints": (None, _YOLOX_HTTP),
+    }
+    result = _build_config_from_schema(PDFiumConfigSchema, args)
+    assert result["auth_token"] == "pdfium_secret_token"
+
+
+def test_build_config_passes_auth_token_to_nemotron_parse_schema():
+    """auth_token survives _build_config_from_schema when using NemotronParseConfigSchema."""
+    args = {
+        "auth_token": "nemotron_secret_token",
+        "nemotron_parse_endpoints": (None, _NEMOTRON_HTTP),
+    }
+    result = _build_config_from_schema(NemotronParseConfigSchema, args)
+    assert result["auth_token"] == "nemotron_secret_token"
+
+
+def test_build_config_passes_none_auth_token():
+    """auth_token=None (the default) is preserved in the config dict."""
+    args = {
+        "auth_token": None,
+        "yolox_endpoints": (None, _YOLOX_HTTP),
+    }
+    result = _build_config_from_schema(PDFiumConfigSchema, args)
+    assert "auth_token" in result
+    assert result["auth_token"] is None
+
+
+# ===========================================================================
+# 3. Silent-drop regression: yolox_auth_token is not a schema field
+# ===========================================================================
+
+
+def test_build_config_silently_drops_yolox_auth_token_for_pdfium():
+    """
+    Regression: the stale kwarg 'yolox_auth_token' is absent from PDFiumConfigSchema
+    and is silently filtered out by _build_config_from_schema.
+
+    This test documents the exact mechanism of the original bug: passing
+    yolox_auth_token caused the token to vanish before reaching the backend
+    because _build_config_from_schema retains only schema-defined keys.
+    """
+    args = {
+        "yolox_auth_token": "should_be_dropped",
+        "yolox_endpoints": (None, _YOLOX_HTTP),
+    }
+    result = _build_config_from_schema(PDFiumConfigSchema, args)
+    assert "yolox_auth_token" not in result
+    assert result.get("auth_token") is None
+
+
+def test_build_config_silently_drops_yolox_auth_token_for_nemotron_parse():
+    """
+    Regression: the stale kwarg 'yolox_auth_token' is absent from
+    NemotronParseConfigSchema and is silently filtered out.
+    """
+    args = {
+        "yolox_auth_token": "should_be_dropped",
+        "nemotron_parse_endpoints": (None, _NEMOTRON_HTTP),
+    }
+    result = _build_config_from_schema(NemotronParseConfigSchema, args)
+    assert "yolox_auth_token" not in result
+    assert result.get("auth_token") is None
+
+
+# ===========================================================================
+# 4. Public-API signature regression: yolox_auth_token must be rejected
+# ===========================================================================
+
+
+def test_extract_primitives_from_pdf_pdfium_rejects_yolox_auth_token():
+    """
+    Regression: extract_primitives_from_pdf_pdfium no longer accepts
+    yolox_auth_token.  Python raises TypeError before the function body runs.
+    """
+    df = pd.DataFrame()
+    with pytest.raises(TypeError, match="yolox_auth_token"):
+        extract_primitives_from_pdf_pdfium(df, yolox_auth_token="stale_token")
+
+
+def test_extract_primitives_from_pdf_nemotron_parse_rejects_yolox_auth_token():
+    """
+    Regression: extract_primitives_from_pdf_nemotron_parse no longer accepts
+    yolox_auth_token.  Python raises TypeError before the function body runs.
+    """
+    df = pd.DataFrame()
+    with pytest.raises(TypeError, match="yolox_auth_token"):
+        extract_primitives_from_pdf_nemotron_parse(df, yolox_auth_token="stale_token")
+
+
+def test_extract_primitives_from_pdf_rejects_yolox_auth_token():
+    """
+    Regression: the general extract_primitives_from_pdf no longer accepts
+    yolox_auth_token.  The unified_exception_handler re-raises the TypeError
+    produced by the decorator's inspect.Signature.bind_partial call.
+    """
+    df = pd.DataFrame()
+    with pytest.raises(TypeError):
+        extract_primitives_from_pdf(
+            df_extraction_ledger=df,
+            extract_method="pdfium",
+            yolox_auth_token="stale_token",
+        )
diff --git a/api/api_tests/internal/mutate/test_deduplicate_images.py b/api/api_tests/internal/mutate/test_deduplicate_images.py
index 3c4f2f1f6..ded0f7150 100644
--- a/api/api_tests/internal/mutate/test_deduplicate_images.py
+++ b/api/api_tests/internal/mutate/test_deduplicate_images.py
@@ -7,13 +7,19 @@
 import pandas as pd
 from typing import Dict, Union
 
-from nv_ingest_api.internal.mutate.deduplicate import _hash_content, deduplicate_images_internal
+from nv_ingest_api.internal.mutate.deduplicate import (
+    _hash_content,
+    calculate_iou,
+    deduplicate_by_bbox_internal,
+    deduplicate_images_internal,
+)
 
 
 # Dummy enumeration for testing purposes.
 class DummyContentTypeEnum:
     IMAGE = "IMAGE"
     INFO_MSG = "INFO_MSG"
+    STRUCTURED = "STRUCTURED"
 
 
 # Patch the global ContentTypeEnum in the deduplicate module.
@@ -101,3 +107,102 @@ def test_deduplicate_with_sha256():
         {"document_type": [DummyContentTypeEnum.IMAGE], "metadata": [{"content": "same content"}]}, index=[0]
     )
     pd.testing.assert_frame_equal(result.sort_index(), expected.sort_index())
+
+
+# Tests for calculate_iou
+
+
+@pytest.mark.parametrize(
+    "bbox1, bbox2, expected_iou",
+    [
+        # No overlap
+        ((0, 0, 10, 10), (20, 20, 30, 30), 0.0),
+        # Full overlap (identical boxes)
+        ((0, 0, 10, 10), (0, 0, 10, 10), 1.0),
+        # Partial overlap (50% overlap)
+        ((0, 0, 10, 10), (5, 0, 15, 10), 1 / 3),
+    ],
+)
+def test_calculate_iou(bbox1, bbox2, expected_iou):
+    result = calculate_iou(bbox1, bbox2)
+    assert abs(result - expected_iou) < 1e-6
+
+
+# Tests for deduplicate_by_bbox_internal
+
+
+def test_deduplicate_by_bbox_removes_overlapping_image():
+    """Test that overlapping images are removed when prefer_structured=True."""
+    df = pd.DataFrame(
+        {
+            "document_type": [DummyContentTypeEnum.IMAGE, DummyContentTypeEnum.STRUCTURED],
+            "metadata": [
+                {
+                    "content": "image_content",
+                    "content_metadata": {"page_number": 1},
+                    "image_metadata": {"image_location": (0, 0, 100, 100), "image_location_max_dimensions": (100, 100)},
+                },
+                {
+                    "content": "table_content",
+                    "content_metadata": {"page_number": 1, "subtype": "table"},
+                    "table_metadata": {"table_location": (0, 0, 100, 100), "table_location_max_dimensions": (100, 100)},
+                },
+            ],
+        }
+    )
+    result = deduplicate_by_bbox_internal(df, iou_threshold=0.5, prefer_structured=True)
+    # Image should be removed, only structured remains
+    assert len(result) == 1
+    assert result.iloc[0]["document_type"] == DummyContentTypeEnum.STRUCTURED
+
+
+def test_deduplicate_by_bbox_removes_overlapping_structured():
+    """Test that overlapping structured elements are removed when prefer_structured=False."""
+    df = pd.DataFrame(
+        {
+            "document_type": [DummyContentTypeEnum.IMAGE, DummyContentTypeEnum.STRUCTURED],
+            "metadata": [
+                {
+                    "content": "image_content",
+                    "content_metadata": {"page_number": 1},
+                    "image_metadata": {"image_location": (0, 0, 100, 100), "image_location_max_dimensions": (100, 100)},
+                },
+                {
+                    "content": "table_content",
+                    "content_metadata": {"page_number": 1, "subtype": "table"},
+                    "table_metadata": {"table_location": (0, 0, 100, 100), "table_location_max_dimensions": (100, 100)},
+                },
+            ],
+        }
+    )
+    result = deduplicate_by_bbox_internal(df, iou_threshold=0.5, prefer_structured=False)
+    # Structured should be removed, only image remains
+    assert len(result) == 1
+    assert result.iloc[0]["document_type"] == DummyContentTypeEnum.IMAGE
+
+
+def test_deduplicate_by_bbox_no_overlap():
+    """Test that non-overlapping elements on same page are kept."""
+    df = pd.DataFrame(
+        {
+            "document_type": [DummyContentTypeEnum.IMAGE, DummyContentTypeEnum.STRUCTURED],
+            "metadata": [
+                {
+                    "content": "image_content",
+                    "content_metadata": {"page_number": 1},
+                    "image_metadata": {"image_location": (0, 0, 50, 50), "image_location_max_dimensions": (100, 100)},
+                },
+                {
+                    "content": "table_content",
+                    "content_metadata": {"page_number": 1, "subtype": "table"},
+                    "table_metadata": {
+                        "table_location": (60, 60, 100, 100),
+                        "table_location_max_dimensions": (100, 100),
+                    },
+                },
+            ],
+        }
+    )
+    result = deduplicate_by_bbox_internal(df, iou_threshold=0.5, prefer_structured=True)
+    # Both should be kept since no overlap
+    assert len(result) == 2
diff --git a/api/api_tests/internal/primitives/nim/model_interface/test_yolox_interface_page_elements.py b/api/api_tests/internal/primitives/nim/model_interface/test_yolox_interface_page_elements.py
index 870e69b44..33b8a0402 100644
--- a/api/api_tests/internal/primitives/nim/model_interface/test_yolox_interface_page_elements.py
+++ b/api/api_tests/internal/primitives/nim/model_interface/test_yolox_interface_page_elements.py
@@ -100,9 +100,9 @@ def test_postprocess_annotations_table_filtering(self):
         try:
             result = self.model_interface.postprocess_annotations(annotations, original_image_shapes=original_shapes)
 
-            # Check that both expansion functions were called
-            self.mock_expand_table.assert_called_once_with(annotations[0])
-            self.mock_expand_chart.assert_called_once()
+            # v3 path does not call legacy v2 expansion functions.
+            self.mock_expand_table.assert_not_called()
+            self.mock_expand_chart.assert_not_called()
 
             # Check that transform_normalized_coordinates_to_original was called
             self.model_interface.transform_normalized_coordinates_to_original.assert_called_once()
@@ -139,9 +139,9 @@ def test_postprocess_annotations_chart_filtering(self):
         try:
             result = self.model_interface.postprocess_annotations(annotations, original_image_shapes=original_shapes)
 
-            # Check that both expansion functions were called
-            self.mock_expand_table.assert_called_once()
-            self.mock_expand_chart.assert_called_once()
+            # v3 path does not call legacy v2 expansion functions.
+            self.mock_expand_table.assert_not_called()
+            self.mock_expand_chart.assert_not_called()
 
             # Check the result (should have only one chart entry with confidence >= 0.4)
             self.assertEqual(len(result), 1)
@@ -239,10 +239,14 @@ def test_postprocess_annotations_multiple_images(self):
         try:
             result = self.model_interface.postprocess_annotations(annotations, original_image_shapes=original_shapes)
 
-            # Check that transform_normalized_coordinates_to_original was called with both images
-            self.model_interface.transform_normalized_coordinates_to_original.assert_called_once_with(
-                [{"table": [[0.1, 0.2, 0.3, 0.4, 0.5]]}, {"chart": [[0.1, 0.2, 0.3, 0.4, 0.5]]}], original_shapes
+            # v3 post-processing mutates annotation dicts before coordinate transform.
+            self.model_interface.transform_normalized_coordinates_to_original.assert_called_once()
+            transform_args, transform_kwargs = (
+                self.model_interface.transform_normalized_coordinates_to_original.call_args
             )
+            self.assertEqual(len(transform_args[0]), 2)
+            self.assertEqual(transform_args[1], original_shapes)
+            self.assertEqual(transform_kwargs, {})
 
             # Check the result (should match the transformed results)
             self.assertEqual(len(result), 2)
@@ -325,16 +329,9 @@ def tearDown(self):
         self.expand_chart_patcher.stop()
 
     def test_postprocess_annotations_v3_path_is_taken(self):
-        v3_annotations = [
-            {
-                "table": [],
-                "chart": [],
-                "title": [],
-                "infographic": [],
-                "paragraph": [[0.1, 0.1, 0.2, 0.2, 0.9]],
-                "header_footer": [],
-            }
-        ]
+        # Even if a page has no v3-only detections (e.g., no paragraph/header_footer),
+        # v3 post-processing must still run when the interface is configured for a v3 model.
+        v3_annotations = [{"table": [[0.1, 0.1, 0.2, 0.2, 0.9]], "chart": [], "title": [], "infographic": []}]
 
         self.model_interface.postprocess_annotations(v3_annotations)
 
@@ -343,9 +340,12 @@ def test_postprocess_annotations_v3_path_is_taken(self):
         self.mock_expand_chart.assert_not_called()
 
     def test_postprocess_annotations_v2_fallback_path_is_taken(self):
+        # A v2-configured interface should use the legacy expansion functions.
+        model_v2 = YoloxPageElementsModelInterface(version="nemoretriever-page-elements-v2")
+        model_v2.transform_normalized_coordinates_to_original = MagicMock(side_effect=lambda x, y: x)
         v2_annotations = [{"table": [[0.1, 0.1, 0.2, 0.2, 0.9]], "chart": [], "title": [], "infographic": []}]
 
-        self.model_interface.postprocess_annotations(v2_annotations)
+        model_v2.postprocess_annotations(v2_annotations)
 
         self.mock_postprocess_v3.assert_not_called()
         self.mock_expand_table.assert_called_once()
diff --git a/api/api_tests/internal/schemas/extract/test_extract_chart_schema.py b/api/api_tests/internal/schemas/extract/test_extract_chart_schema.py
index 84b1a01a9..20ee6373b 100644
--- a/api/api_tests/internal/schemas/extract/test_extract_chart_schema.py
+++ b/api/api_tests/internal/schemas/extract/test_extract_chart_schema.py
@@ -35,15 +35,15 @@ def test_both_endpoints_provided():
 
 
 def test_invalid_yolox_empty():
-    with pytest.raises(ValidationError) as excinfo:
-        ChartExtractorConfigSchema(yolox_endpoints=(None, None), ocr_endpoints=("grpc_ocr", None))
-    assert "Both gRPC and HTTP services cannot be empty for yolox_endpoints." in str(excinfo.value)
+    config = ChartExtractorConfigSchema(yolox_endpoints=(None, None), ocr_endpoints=("grpc_ocr", None))
+    assert config.yolox_endpoints == (None, None)
+    assert config.yolox_infer_protocol == "local"
 
 
 def test_invalid_ocr_empty():
-    with pytest.raises(ValidationError) as excinfo:
-        ChartExtractorConfigSchema(yolox_endpoints=("grpc_service", None), ocr_endpoints=("  ", '   "  '))
-    assert "Both gRPC and HTTP services cannot be empty for ocr_endpoints." in str(excinfo.value)
+    config = ChartExtractorConfigSchema(yolox_endpoints=("grpc_service", None), ocr_endpoints=("  ", '   "  '))
+    assert config.ocr_endpoints == (None, None)
+    assert config.ocr_infer_protocol == "local"
 
 
 def test_protocol_case_insensitive():
@@ -80,6 +80,15 @@ def test_protocol_auto_inference_from_endpoints():
     assert config.ocr_infer_protocol == "grpc"
 
 
+def test_protocol_defaults_to_local_if_endpoints_empty():
+    config = ChartExtractorConfigSchema(
+        yolox_endpoints=(None, None),
+        ocr_endpoints=(None, None),
+    )
+    assert config.yolox_infer_protocol == "local"
+    assert config.ocr_infer_protocol == "local"
+
+
 def test_extra_fields_forbidden_in_chart_extractor_config():
     with pytest.raises(ValidationError):
         ChartExtractorConfigSchema(
diff --git a/api/api_tests/internal/schemas/extract/test_extract_image_schema.py b/api/api_tests/internal/schemas/extract/test_extract_image_schema.py
index f2f147ed8..749ef31a9 100644
--- a/api/api_tests/internal/schemas/extract/test_extract_image_schema.py
+++ b/api/api_tests/internal/schemas/extract/test_extract_image_schema.py
@@ -31,15 +31,15 @@ def test_valid_yolox_both():
 
 
 def test_invalid_yolox_empty_both():
-    with pytest.raises(ValidationError) as excinfo:
-        ImageConfigSchema(yolox_endpoints=(None, None))
-    assert "Both gRPC and HTTP services cannot be empty for yolox_endpoints." in str(excinfo.value)
+    config = ImageConfigSchema(yolox_endpoints=(None, None))
+    assert config.yolox_endpoints == (None, None)
+    assert config.yolox_infer_protocol == "local"
 
 
 def test_cleaning_yolox_endpoints_spaces_and_quotes():
-    with pytest.raises(ValidationError) as excinfo:
-        ImageConfigSchema(yolox_endpoints=("  ", '  "  '))
-    assert "Both gRPC and HTTP services cannot be empty for yolox_endpoints." in str(excinfo.value)
+    config = ImageConfigSchema(yolox_endpoints=("  ", '  "  '))
+    assert config.yolox_endpoints == (None, None)
+    assert config.yolox_infer_protocol == "local"
 
 
 def test_custom_protocol_is_normalized():
diff --git a/api/api_tests/internal/schemas/extract/test_extract_infographic_schema.py b/api/api_tests/internal/schemas/extract/test_extract_infographic_schema.py
index 57ff7e49a..13b008ad9 100644
--- a/api/api_tests/internal/schemas/extract/test_extract_infographic_schema.py
+++ b/api/api_tests/internal/schemas/extract/test_extract_infographic_schema.py
@@ -30,15 +30,15 @@ def test_valid_ocr_both():
 
 
 def test_invalid_ocr_both_empty():
-    with pytest.raises(ValidationError) as excinfo:
-        InfographicExtractorConfigSchema(ocr_endpoints=(None, None))
-    assert "Both gRPC and HTTP services cannot be empty for ocr_endpoints." in str(excinfo.value)
+    config = InfographicExtractorConfigSchema(ocr_endpoints=(None, None))
+    assert config.ocr_endpoints == (None, None)
+    assert config.ocr_infer_protocol == "local"
 
 
 def test_cleaning_ocr_endpoints_spaces_and_quotes():
-    with pytest.raises(ValidationError) as excinfo:
-        InfographicExtractorConfigSchema(ocr_endpoints=("  ", '  "  '))
-    assert "Both gRPC and HTTP services cannot be empty for ocr_endpoints." in str(excinfo.value)
+    config = InfographicExtractorConfigSchema(ocr_endpoints=("  ", '  "  '))
+    assert config.ocr_endpoints == (None, None)
+    assert config.ocr_infer_protocol == "local"
 
 
 def test_extra_fields_forbidden_in_infographic_config():
diff --git a/api/api_tests/internal/schemas/extract/test_extract_pdf_schema.py b/api/api_tests/internal/schemas/extract/test_extract_pdf_schema.py
index 34d0e403b..4422064c7 100644
--- a/api/api_tests/internal/schemas/extract/test_extract_pdf_schema.py
+++ b/api/api_tests/internal/schemas/extract/test_extract_pdf_schema.py
@@ -29,14 +29,15 @@ def test_pdfium_valid_yolox_http_only():
 
 
 def test_pdfium_invalid_yolox_both_empty():
-    with pytest.raises(ValidationError) as excinfo:
-        PDFiumConfigSchema(yolox_endpoints=(None, None))
-    assert "Both gRPC and HTTP services cannot be empty for yolox_endpoints." in str(excinfo.value)
+    config = PDFiumConfigSchema(yolox_endpoints=(None, None))
+    assert config.yolox_endpoints == (None, None)
+    assert config.yolox_infer_protocol == "local"
 
 
 def test_pdfium_cleaning_yolox_endpoints_spaces_and_quotes():
-    with pytest.raises(ValidationError):
-        PDFiumConfigSchema(yolox_endpoints=("  ", '  "  '))
+    config = PDFiumConfigSchema(yolox_endpoints=("  ", '  "  '))
+    assert config.yolox_endpoints == (None, None)
+    assert config.yolox_infer_protocol == "local"
 
 
 def test_pdfium_extra_fields_forbidden():
diff --git a/api/api_tests/internal/schemas/extract/test_extract_table_schema.py b/api/api_tests/internal/schemas/extract/test_extract_table_schema.py
index 26ddc6c83..94c9bc02f 100644
--- a/api/api_tests/internal/schemas/extract/test_extract_table_schema.py
+++ b/api/api_tests/internal/schemas/extract/test_extract_table_schema.py
@@ -24,15 +24,15 @@ def test_table_valid_yolox_and_ocr_http_only():
 
 
 def test_table_invalid_yolox_both_empty():
-    with pytest.raises(ValidationError) as excinfo:
-        TableExtractorConfigSchema(yolox_endpoints=(None, None), ocr_endpoints=("grpc_ocr", None))
-    assert "Both gRPC and HTTP services cannot be empty for yolox_endpoints." in str(excinfo.value)
+    config = TableExtractorConfigSchema(yolox_endpoints=(None, None), ocr_endpoints=("grpc_ocr", None))
+    assert config.yolox_endpoints == (None, None)
+    assert config.yolox_infer_protocol == "local"
 
 
 def test_table_invalid_ocr_both_empty():
-    with pytest.raises(ValidationError) as excinfo:
-        TableExtractorConfigSchema(yolox_endpoints=("grpc_yolox", None), ocr_endpoints=("  ", '  "  '))
-    assert "Both gRPC and HTTP services cannot be empty for ocr_endpoints." in str(excinfo.value)
+    config = TableExtractorConfigSchema(yolox_endpoints=("grpc_yolox", None), ocr_endpoints=("  ", '  "  '))
+    assert config.ocr_endpoints == (None, None)
+    assert config.ocr_infer_protocol == "local"
 
 
 def test_table_extra_fields_forbidden():
diff --git a/api/api_tests/internal/schemas/transform/test_image_caption_schema.py b/api/api_tests/internal/schemas/transform/test_image_caption_schema.py
index 12f24c358..6dbfd3784 100644
--- a/api/api_tests/internal/schemas/transform/test_image_caption_schema.py
+++ b/api/api_tests/internal/schemas/transform/test_image_caption_schema.py
@@ -14,6 +14,8 @@ def test_image_caption_extraction_schema_defaults():
     assert schema.endpoint_url.startswith("https://")
     assert schema.prompt.startswith("Caption")
     assert schema.model_name.startswith("nvidia/")
+    assert schema.context_text_max_chars == 0
+    assert schema.temperature == 1.0
     assert schema.raise_on_failure is False
 
 
@@ -40,6 +42,26 @@ def test_image_caption_extraction_schema_accepts_truthy_values():
     assert schema.raise_on_failure is False
 
 
+def test_image_caption_extraction_schema_context_text_max_chars_custom():
+    schema = ImageCaptionExtractionSchema(context_text_max_chars=512)
+    assert schema.context_text_max_chars == 512
+
+
+def test_image_caption_extraction_schema_context_text_max_chars_none_coerced():
+    schema = ImageCaptionExtractionSchema(context_text_max_chars=None)
+    assert schema.context_text_max_chars == 0
+
+
+def test_image_caption_extraction_schema_temperature_custom():
+    schema = ImageCaptionExtractionSchema(temperature=0.5)
+    assert schema.temperature == 0.5
+
+
+def test_image_caption_extraction_schema_temperature_none_coerced():
+    schema = ImageCaptionExtractionSchema(temperature=None)
+    assert schema.temperature == 1.0
+
+
 def test_image_caption_extraction_schema_rejects_extra_fields():
     with pytest.raises(ValidationError) as excinfo:
         ImageCaptionExtractionSchema(extra_field="oops")
diff --git a/api/api_tests/internal/transform/test_caption_image.py b/api/api_tests/internal/transform/test_caption_image.py
index 49e014405..a3d8327f7 100644
--- a/api/api_tests/internal/transform/test_caption_image.py
+++ b/api/api_tests/internal/transform/test_caption_image.py
@@ -72,6 +72,7 @@ def test_transform_image_create_vlm_caption_internal_happy_path(
         dummy_task_config["api_key"],
         dummy_task_config["endpoint_url"],
         dummy_task_config["model_name"],
+        temperature=1.0,
     )
 
     # Assert captions updated correctly in the DataFrame
@@ -125,6 +126,7 @@ def test_transform_image_create_vlm_caption_internal_uses_fallback_config(
         dummy_transform_config.api_key,
         dummy_transform_config.endpoint_url,
         dummy_transform_config.model_name,
+        temperature=1.0,
     )
 
     # Assert captions updated correctly
@@ -236,7 +238,7 @@ def test_generate_captions_happy_path(mock_scale, mock_create_client):
 
     # Assert infer called with correct data
     expected_payload = {"base64_images": ["scaled_b64img1", "scaled_b64img2"], "prompt": "describe this"}
-    mock_client.infer.assert_called_once_with(expected_payload, model_name="test_model")
+    mock_client.infer.assert_called_once_with(expected_payload, model_name="test_model", temperature=1.0)
 
     # Result matches mock captions
     assert result == ["Caption 1", "Caption 2"]
@@ -280,6 +282,216 @@ def test_generate_captions_empty_images_returns_empty_list(mock_scale, mock_crea
         model_name="test_model",
     )
 
-    mock_client.infer.assert_called_once_with({"base64_images": [], "prompt": "describe this"}, model_name="test_model")
+    mock_client.infer.assert_called_once_with(
+        {"base64_images": [], "prompt": "describe this"}, model_name="test_model", temperature=1.0
+    )
 
     assert result == []
+
+
+# --- _gather_context_text_for_image tests ---
+
+
+def test_gather_context_text_page_match():
+    """Page text is returned when page_number matches."""
+    image_meta = {
+        "content_metadata": {
+            "type": "image",
+            "page_number": 3,
+        },
+    }
+    page_text_map = {3: ["page three text", "more text"]}
+    result = module_under_test._gather_context_text_for_image(image_meta, page_text_map, 200)
+    assert result == "page three text more text"
+
+
+def test_gather_context_text_truncation():
+    """Text is truncated to max_chars."""
+    image_meta = {
+        "content_metadata": {
+            "type": "image",
+            "page_number": 0,
+        },
+    }
+    page_text_map = {0: ["a" * 500]}
+    result = module_under_test._gather_context_text_for_image(image_meta, page_text_map, 10)
+    assert len(result) == 10
+
+
+def test_gather_context_text_safety_cap():
+    """Text is capped at _MAX_CONTEXT_TEXT_CHARS even if max_chars is larger."""
+    image_meta = {
+        "content_metadata": {
+            "type": "image",
+            "page_number": 0,
+        },
+    }
+    big_text = "x" * 10000
+    page_text_map = {0: [big_text]}
+    result = module_under_test._gather_context_text_for_image(image_meta, page_text_map, 99999)
+    assert len(result) == module_under_test._MAX_CONTEXT_TEXT_CHARS
+
+
+def test_gather_context_text_no_text():
+    """Returns empty string when no text is available."""
+    image_meta = {
+        "content_metadata": {
+            "type": "image",
+            "page_number": 5,
+        },
+    }
+    result = module_under_test._gather_context_text_for_image(image_meta, {}, 200)
+    assert result == ""
+
+
+def test_gather_context_text_wrong_page():
+    """Returns empty string when page number doesn't match any text."""
+    image_meta = {
+        "content_metadata": {
+            "type": "image",
+            "page_number": 99,
+        },
+    }
+    page_text_map = {0: ["some text"]}
+    result = module_under_test._gather_context_text_for_image(image_meta, page_text_map, 200)
+    assert result == ""
+
+
+# --- _build_prompt_with_context tests ---
+
+
+def test_build_prompt_with_context():
+    result = module_under_test._build_prompt_with_context("Caption this:", "nearby text")
+    assert result == "Text near this image:\n---\nnearby text\n---\n\nCaption this:"
+
+
+def test_build_prompt_with_empty_context():
+    result = module_under_test._build_prompt_with_context("Caption this:", "")
+    assert result == "Caption this:"
+
+
+# --- _build_page_text_map tests ---
+
+
+def test_build_page_text_map():
+    df = pd.DataFrame(
+        [
+            {
+                "metadata": {
+                    "content": "text on page 0",
+                    "content_metadata": {"type": "text", "page_number": 0},
+                }
+            },
+            {
+                "metadata": {
+                    "content": "more on page 0",
+                    "content_metadata": {"type": "text", "page_number": 0},
+                }
+            },
+            {
+                "metadata": {
+                    "content": "image content",
+                    "content_metadata": {"type": "image", "page_number": 0},
+                }
+            },
+            {
+                "metadata": {
+                    "content": "page 1 text",
+                    "content_metadata": {"type": "text", "page_number": 1},
+                }
+            },
+        ]
+    )
+    result = module_under_test._build_page_text_map(df)
+    assert result == {0: ["text on page 0", "more on page 0"], 1: ["page 1 text"]}
+
+
+# --- Context-enabled integration tests ---
+
+
+@patch(f"{MODULE_UNDER_TEST}._generate_captions")
+def test_transform_context_enabled_per_image_calls(mock_generate, dummy_transform_config):
+    """With context enabled, each image gets its own VLM call with enriched prompt."""
+    df = pd.DataFrame(
+        [
+            {
+                "metadata": {
+                    "content": "b64_img1",
+                    "content_metadata": {"type": "image", "page_number": 0},
+                    "image_metadata": {},
+                }
+            },
+            {
+                "metadata": {
+                    "content": "page zero text",
+                    "content_metadata": {"type": "text", "page_number": 0},
+                    "image_metadata": {},
+                }
+            },
+        ]
+    )
+    mock_generate.return_value = ["caption_with_context"]
+
+    task_config = {
+        "api_key": "key",
+        "prompt": "Caption this:",
+        "system_prompt": "sys",
+        "endpoint_url": "https://url",
+        "model_name": "model",
+        "context_text_max_chars": 500,
+    }
+
+    result = transform_image_create_vlm_caption_internal(df.copy(), task_config, dummy_transform_config)
+
+    # Should be called once (one image)
+    assert mock_generate.call_count == 1
+    call_args = mock_generate.call_args
+    # The prompt should be enriched with context
+    assert "Text near this image:" in call_args[0][1]
+    assert "page zero text" in call_args[0][1]
+    assert "Caption this:" in call_args[0][1]
+    # The image should be passed individually
+    assert call_args[0][0] == ["b64_img1"]
+    # Caption should be set
+    assert result.iloc[0]["metadata"]["image_metadata"]["caption"] == "caption_with_context"
+
+
+@patch(f"{MODULE_UNDER_TEST}._generate_captions")
+def test_transform_temperature_forwarded(mock_generate, dummy_df_with_images, dummy_transform_config):
+    """Temperature from task_config is forwarded to _generate_captions."""
+    mock_generate.return_value = ["c1", "c2"]
+
+    task_config = {
+        "api_key": "key",
+        "prompt": "Describe",
+        "system_prompt": "sys",
+        "endpoint_url": "https://url",
+        "model_name": "model",
+        "temperature": 0.7,
+    }
+
+    transform_image_create_vlm_caption_internal(dummy_df_with_images.copy(), task_config, dummy_transform_config)
+
+    mock_generate.assert_called_once()
+    _, kwargs = mock_generate.call_args
+    assert kwargs["temperature"] == 0.7
+
+
+@patch(f"{MODULE_UNDER_TEST}._generate_captions")
+def test_transform_context_disabled_batch_preserved(
+    mock_generate, dummy_df_with_images, dummy_task_config, dummy_transform_config
+):
+    """With context disabled (default), batch behavior is unchanged."""
+    mock_generate.return_value = ["c1", "c2"]
+
+    _ = transform_image_create_vlm_caption_internal(
+        dummy_df_with_images.copy(), dummy_task_config, dummy_transform_config
+    )
+
+    # Should be called once in batch mode
+    mock_generate.assert_called_once()
+    call_args = mock_generate.call_args
+    # All images passed at once
+    assert call_args[0][0] == ["base64_image_1", "base64_image_2"]
+    # Prompt should NOT be enriched
+    assert "Text near this image:" not in call_args[0][1]
diff --git a/api/api_tests/internal/transform/test_embed_text.py b/api/api_tests/internal/transform/test_embed_text.py
index a30adbc62..9186fe0ef 100644
--- a/api/api_tests/internal/transform/test_embed_text.py
+++ b/api/api_tests/internal/transform/test_embed_text.py
@@ -195,6 +195,27 @@ def test_transform_create_text_embeddings_internal_with_only_empty_text(mock_asy
     mock_async_runner.assert_not_called()
 
 
+@patch(f"{MODULE_UNDER_TEST}._async_runner")
+def test_transform_create_text_embeddings_internal_uses_callable_embedder_when_no_endpoint(mock_async_runner, dummy_df):
+    def _local_embedder(texts):
+        return [[0.9, 0.8]] * len(list(texts))
+
+    task_cfg = {
+        "endpoint_url": None,  # Explicitly disable remote endpoint
+        "embedder": _local_embedder,
+        "local_batch_size": 2,
+    }
+
+    result_df, _trace = module_under_test.transform_create_text_embeddings_internal(
+        dummy_df.copy(),
+        task_cfg,
+    )
+
+    mock_async_runner.assert_not_called()
+    assert result_df.iloc[0]["metadata"]["embedding"] == [0.9, 0.8]
+    assert result_df.iloc[1]["metadata"]["embedding"] == [0.9, 0.8]
+
+
 @patch(f"{MODULE_UNDER_TEST}._async_request_handler")
 def test_async_runner_happy_path(mock_handler):
     # Arrange
diff --git a/api/api_tests/internal/transform/test_split_text.py b/api/api_tests/internal/transform/test_split_text.py
index bf2a8569e..f2ec44d39 100644
--- a/api/api_tests/internal/transform/test_split_text.py
+++ b/api/api_tests/internal/transform/test_split_text.py
@@ -13,15 +13,15 @@
 MODULE_UNDER_TEST = f"{module_under_test.__name__}"
 
 
-@patch(f"{MODULE_UNDER_TEST}.AutoTokenizer")
+@patch(f"{MODULE_UNDER_TEST}._get_tokenizer")
 @patch(f"{MODULE_UNDER_TEST}.os.path.exists", return_value=False)
 @patch(f"{MODULE_UNDER_TEST}.os.environ.get", return_value="/mock/model/path")
-def test_transform_text_split_and_tokenize_internal_happy_path(mock_environ_get, mock_exists, mock_tokenizer_class):
+def test_transform_text_split_and_tokenize_internal_happy_path(mock_environ_get, mock_exists, mock_get_tokenizer):
     # Setup a mock tokenizer
     mock_tokenizer = MagicMock()
     # Produce fake offsets
-    mock_tokenizer.encode_plus.return_value = {"offset_mapping": [(0, 4), (5, 9), (10, 19)]}
-    mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
+    mock_tokenizer.return_value = {"offset_mapping": [(0, 4), (5, 9), (10, 19)]}
+    mock_get_tokenizer.return_value = mock_tokenizer
 
     # Dummy dataframe
     df = pd.DataFrame(
@@ -57,8 +57,8 @@ def test_transform_text_split_and_tokenize_internal_happy_path(mock_environ_get,
         execution_trace_log=None,
     )
 
-    # Assert tokenizer was loaded with correct identifier
-    mock_tokenizer_class.from_pretrained.assert_called_once_with("mock_tokenizer", token=None)
+    # Assert cached tokenizer was loaded with correct identifier
+    mock_get_tokenizer.assert_called_once_with("mock_tokenizer", token=None)
 
     # Assert that splitting occurred for first row only
     assert not result.empty
@@ -67,13 +67,9 @@ def test_transform_text_split_and_tokenize_internal_happy_path(mock_environ_get,
     assert any("won't" in c for c in split_contents)
 
 
-@patch(f"{MODULE_UNDER_TEST}.AutoTokenizer")
+@patch(f"{MODULE_UNDER_TEST}._get_tokenizer")
 @patch(f"{MODULE_UNDER_TEST}.os.path.exists", return_value=False)
-def test_transform_text_split_and_tokenize_internal_no_matching_source_type(mock_exists, mock_tokenizer_class):
-    # Setup mock tokenizer
-    mock_tokenizer = MagicMock()
-    mock_tokenizer_class.from_pretrained.return_value = mock_tokenizer
-
+def test_transform_text_split_and_tokenize_internal_no_matching_source_type(mock_exists, mock_get_tokenizer):
     # Dummy dataframe with unmatched source_type
     df = pd.DataFrame(
         [
@@ -94,14 +90,14 @@ def test_transform_text_split_and_tokenize_internal_no_matching_source_type(mock
         execution_trace_log=None,
     )
 
-    # Should return the same DataFrame
+    # Should return the same DataFrame without loading a tokenizer
     assert result.equals(df)
-    mock_tokenizer_class.from_pretrained.assert_not_called()
+    mock_get_tokenizer.assert_not_called()
 
 
 def test_split_into_chunks_empty_text():
     mock_tokenizer = MagicMock()
-    mock_tokenizer.encode_plus.return_value = {"offset_mapping": []}
+    mock_tokenizer.return_value = {"offset_mapping": []}
 
     chunks = module_under_test._split_into_chunks("", mock_tokenizer)
     assert chunks == []
@@ -136,7 +132,7 @@ def test_split_into_chunks_happy_path():
 
     # Mock tokenizer behavior
     mock_tokenizer = MagicMock()
-    mock_tokenizer.encode_plus.return_value = {
+    mock_tokenizer.return_value = {
         "offset_mapping": [(0, 8), (7, 16), (17, 19), (20, 27), (28, 36), (37, 45), (46, 55)]
     }
 
diff --git a/api/api_tests/util/nim/test_init.py b/api/api_tests/util/nim/test_init.py
index 3acb3bcae..a4d15e168 100644
--- a/api/api_tests/util/nim/test_init.py
+++ b/api/api_tests/util/nim/test_init.py
@@ -7,6 +7,32 @@
 import nv_ingest_api.util.nim as module_under_test
 
 
+def test_create_inference_client_defaults_to_local_when_no_endpoints():
+    mock_interface = MagicMock()
+    with patch(f"{module_under_test.__name__}.get_nim_client_manager") as mock_client:
+        result = module_under_test.create_inference_client(
+            (None, None),
+            model_interface=mock_interface,
+        )
+
+        # Local path should not touch NimClientManager.
+        mock_client.assert_not_called()
+        assert result.protocol == "local"
+
+
+def test_create_inference_client_honors_explicit_protocol_local():
+    mock_interface = MagicMock()
+    with patch(f"{module_under_test.__name__}.get_nim_client_manager") as mock_client:
+        result = module_under_test.create_inference_client(
+            ("grpc://localhost:50051", "http://localhost:8000"),
+            model_interface=mock_interface,
+            infer_protocol="local",
+        )
+
+        mock_client.assert_not_called()
+        assert result.protocol == "local"
+
+
 def test_create_inference_client_defaults_to_grpc_when_grpc_endpoint_present():
     mock_interface = MagicMock()
     with patch(f"{module_under_test.__name__}.get_nim_client_manager") as mock_client:
@@ -114,7 +140,7 @@ def test_create_inference_client_honors_explicit_protocol_http():
 
 def test_create_inference_client_raises_for_invalid_protocol():
     mock_interface = MagicMock()
-    with pytest.raises(ValueError, match="Invalid infer_protocol specified. Must be 'grpc' or 'http'."):
+    with pytest.raises(ValueError, match="Invalid infer_protocol specified. Must be 'grpc', 'http', or 'local'."):
         module_under_test.create_inference_client(
             ("grpc://localhost:50051", "http://localhost:8000"),
             model_interface=mock_interface,
diff --git a/api/api_tests/util/service_clients/redis/test_redis_pool_metrics.py b/api/api_tests/util/service_clients/redis/test_redis_pool_metrics.py
new file mode 100644
index 000000000..a5fa069ec
--- /dev/null
+++ b/api/api_tests/util/service_clients/redis/test_redis_pool_metrics.py
@@ -0,0 +1,172 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+import queue
+import threading
+from unittest.mock import MagicMock, patch
+
+import pytest
+import redis
+
+from nv_ingest_api.util.service_clients.redis.redis_pool_metrics import (
+    InstrumentedBlockingConnectionPool,
+    POOL_CONNECTIONS_IN_USE,
+    POOL_CONNECTIONS_AVAILABLE,
+    POOL_CONNECTIONS_MAX,
+    POOL_TIMEOUT_TOTAL,
+    POOL_WAIT_SECONDS,
+)
+
+POOL_NAME = "test_pool"
+
+
+@pytest.fixture(autouse=True)
+def _reset_metrics():
+    for metric in (POOL_CONNECTIONS_IN_USE, POOL_CONNECTIONS_AVAILABLE, POOL_CONNECTIONS_MAX):
+        metric.labels(pool_name=POOL_NAME).set(0)
+    POOL_TIMEOUT_TOTAL.labels(pool_name=POOL_NAME)._value.set(0)
+    POOL_WAIT_SECONDS.remove(POOL_NAME)
+    yield
+
+
+def _make_pool(max_connections=4, timeout=1):
+    def fake_init(self_inner, **kwargs):
+        self_inner.max_connections = kwargs.get("max_connections", 50)
+        self_inner.timeout = kwargs.get("timeout", 20)
+        self_inner.connection_kwargs = {}
+        self_inner._connections = []
+        self_inner.pool = queue.Queue(maxsize=self_inner.max_connections)
+        for _ in range(self_inner.max_connections):
+            self_inner.pool.put_nowait(MagicMock(name="mock_connection"))
+
+    with patch.object(redis.BlockingConnectionPool, "__init__", fake_init):
+        pool = InstrumentedBlockingConnectionPool(pool_name=POOL_NAME, max_connections=max_connections, timeout=timeout)
+    return pool
+
+
+class TestInit:
+    def test_sets_max_gauge(self):
+        pool = _make_pool(max_connections=10)
+        assert POOL_CONNECTIONS_MAX.labels(pool_name=POOL_NAME)._value.get() == 10
+        assert pool._pool_name == POOL_NAME
+
+
+class TestGetConnection:
+    def test_updates_gauges_on_acquire(self):
+        pool = _make_pool(max_connections=4)
+
+        with patch.object(redis.BlockingConnectionPool, "get_connection", side_effect=lambda *a, **kw: pool.pool.get()):
+            pool.get_connection("SET")
+
+        assert POOL_CONNECTIONS_IN_USE.labels(pool_name=POOL_NAME)._value.get() == 1
+        assert POOL_CONNECTIONS_AVAILABLE.labels(pool_name=POOL_NAME)._value.get() == 3
+
+    def test_records_wait_time(self):
+        pool = _make_pool(max_connections=4)
+
+        with patch.object(redis.BlockingConnectionPool, "get_connection", side_effect=lambda *a, **kw: pool.pool.get()):
+            pool.get_connection("SET")
+            pool.get_connection("SET")
+
+        hist = POOL_WAIT_SECONDS.labels(pool_name=POOL_NAME)
+        assert hist._sum.get() > 0
+        # First bucket (<=1ms) should hold both observations since mock returns instantly
+        assert hist._buckets[0].get() == 2
+
+    def test_timeout_increments_counter(self):
+        pool = _make_pool(max_connections=4)
+
+        with patch.object(
+            redis.BlockingConnectionPool, "get_connection", side_effect=redis.ConnectionError("pool exhausted")
+        ):
+            with pytest.raises(redis.ConnectionError):
+                pool.get_connection("SET")
+
+        assert POOL_TIMEOUT_TOTAL.labels(pool_name=POOL_NAME)._value.get() == 1
+
+    def test_multiple_acquire_release_cycle(self):
+        pool = _make_pool(max_connections=4)
+
+        conns = []
+        with patch.object(redis.BlockingConnectionPool, "get_connection", side_effect=lambda *a, **kw: pool.pool.get()):
+            for _ in range(3):
+                conns.append(pool.get_connection("SET"))
+
+        assert POOL_CONNECTIONS_IN_USE.labels(pool_name=POOL_NAME)._value.get() == 3
+        assert POOL_CONNECTIONS_AVAILABLE.labels(pool_name=POOL_NAME)._value.get() == 1
+
+        with patch.object(redis.BlockingConnectionPool, "release", side_effect=lambda conn: pool.pool.put_nowait(conn)):
+            for conn in conns:
+                pool.release(conn)
+
+        assert POOL_CONNECTIONS_IN_USE.labels(pool_name=POOL_NAME)._value.get() == 0
+        assert POOL_CONNECTIONS_AVAILABLE.labels(pool_name=POOL_NAME)._value.get() == 4
+
+
+class TestRelease:
+    def test_updates_gauges_on_release(self):
+        pool = _make_pool(max_connections=4)
+
+        with patch.object(redis.BlockingConnectionPool, "get_connection", side_effect=lambda *a, **kw: pool.pool.get()):
+            conn = pool.get_connection("SET")
+
+        assert POOL_CONNECTIONS_IN_USE.labels(pool_name=POOL_NAME)._value.get() == 1
+
+        with patch.object(redis.BlockingConnectionPool, "release", side_effect=lambda conn: pool.pool.put_nowait(conn)):
+            pool.release(conn)
+
+        assert POOL_CONNECTIONS_IN_USE.labels(pool_name=POOL_NAME)._value.get() == 0
+        assert POOL_CONNECTIONS_AVAILABLE.labels(pool_name=POOL_NAME)._value.get() == 4
+
+
+class TestGetPoolStats:
+    def test_returns_correct_stats(self):
+        pool = _make_pool(max_connections=4)
+
+        with patch.object(redis.BlockingConnectionPool, "get_connection", side_effect=lambda *a, **kw: pool.pool.get()):
+            pool.get_connection("SET")
+            pool.get_connection("SET")
+
+        stats = pool.get_pool_stats()
+        assert stats["pool_name"] == POOL_NAME
+        assert stats["in_use"] == 2
+        assert stats["available"] == 2
+        assert stats["max"] == 4
+        assert stats["utilization_pct"] == pytest.approx(50.0)
+
+    def test_empty_pool_stats(self):
+        pool = _make_pool(max_connections=4)
+        stats = pool.get_pool_stats()
+        assert stats["in_use"] == 0
+        assert stats["available"] == 4
+        assert stats["utilization_pct"] == pytest.approx(0.0)
+
+
+class TestConcurrency:
+    def test_concurrent_acquire_release(self):
+        pool = _make_pool(max_connections=8)
+
+        errors = []
+        barrier = threading.Barrier(4)
+
+        def worker():
+            try:
+                conn = pool.get_connection("SET")
+                barrier.wait(timeout=5)
+                pool.release(conn)
+            except Exception as e:
+                errors.append(e)
+
+        with patch.object(
+            redis.BlockingConnectionPool, "get_connection", side_effect=lambda *a, **kw: pool.pool.get()
+        ), patch.object(redis.BlockingConnectionPool, "release", side_effect=lambda c: pool.pool.put_nowait(c)):
+            threads = [threading.Thread(target=worker) for _ in range(4)]
+            for t in threads:
+                t.start()
+            for t in threads:
+                t.join(timeout=10)
+
+        assert not errors
+        assert pool.pool.qsize() == 8
+        assert pool.get_pool_stats()["in_use"] == 0
diff --git a/api/pyproject.toml b/api/pyproject.toml
index bc41b54de..f6072cf84 100644
--- a/api/pyproject.toml
+++ b/api/pyproject.toml
@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools", "wheel"]
+requires = ["setuptools", "wheel>=0.46.2"]
 build-backend = "setuptools.build_meta"
 
 [tool.uv]
@@ -21,7 +21,6 @@ classifiers = [
 ]
 dependencies = [
     "backoff==2.2.1",
-    "moviepy==2.2.1",
     "pandas>=2.0",
     "pydantic>2.0.0",
     "pydantic-settings>2.0.0",
@@ -30,6 +29,12 @@ dependencies = [
     "ffmpeg-python==0.2.0",
     "tritonclient",
     "glom",
+    "pypdfium2==4.30.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "moviepy==2.2.1",
 ]
 
 [project.urls]
diff --git a/api/src/nv_ingest_api/interface/extract.py b/api/src/nv_ingest_api/interface/extract.py
index a52c946f2..a7a7a16b4 100644
--- a/api/src/nv_ingest_api/interface/extract.py
+++ b/api/src/nv_ingest_api/interface/extract.py
@@ -57,11 +57,12 @@ def extract_primitives_from_pdf(
     adobe_client_secret: Optional[str] = None,
     # LLama
     llama_api_key: Optional[str] = None,
+    # Parameter shared by PDFium and Nemotron Parse:
+    auth_token: Optional[str] = None,
     # PDFium-specific parameters:
-    yolox_auth_token: Optional[str] = None,
     yolox_endpoints: Optional[Tuple[Optional[str], Optional[str]]] = None,
     yolox_infer_protocol: str = "http",
-    # Nemoretriver Parse parameters:
+    # Nemotron Parse-specific parameters:
     nemotron_parse_endpoints: Optional[Tuple[str, str]] = None,
     nemotron_parse_protocol: str = "http",
     nemotron_parse_model_name: str = None,
@@ -78,9 +79,10 @@ def extract_primitives_from_pdf(
     It processes a DataFrame containing base64-encoded PDF data and returns a new DataFrame
     with structured information about the extracted elements.
 
-    The function uses a decorator pattern to dynamically validate configuration parameters
-    and invoke the appropriate extraction pipeline. This design allows for flexible
-    engine-specific configuration while maintaining a consistent interface.
+    The function uses a decorator pattern (`extraction_interface_relay_constructor`) that
+    validates parameters against the method-specific Pydantic schema (e.g. PDFiumConfigSchema
+    for pdfium, NemotronParseConfigSchema for nemotron_parse) and passes only schema-defined
+    keys into the backend.
 
     Parameters
     ----------
@@ -137,8 +139,10 @@ def extract_primitives_from_pdf(
     llama_api_key : str, optional
         API key for LlamaParse service. Required when extract_method="llama".
 
-    yolox_auth_token : str, optional
-        Authentication token for YOLOX inference services.
+    auth_token : str, optional
+        Authentication token for method-specific services. Used for pdfium (YOLOX/page-elements
+        and related NVIDIA CV APIs) and for nemotron_parse (NVIDIA API). Required when using
+        NVIDIA-hosted endpoints (e.g. ai.api.nvidia.com, integrate.api.nvidia.com).
 
     yolox_endpoints : tuple of (str, str), optional
         A tuple containing (gRPC endpoint, HTTP endpoint) for YOLOX services.
@@ -186,16 +190,15 @@ def extract_primitives_from_pdf(
 
     Notes
     -----
-    The function uses a decorator pattern through `extraction_interface_relay_constructor`
-    which dynamically processes the parameters and validates them against the appropriate
-    configuration schema. The actual extraction work is delegated to the
-    `extract_primitives_from_pdf_internal` function.
+    The decorator validates parameters against the schema for the chosen ``extract_method`` (e.g. PDFiumConfigSchema
+    for pdfium) and passes the resulting config to `extract_primitives_from_pdf_internal`. Only parameters that exist
+    as fields on that schema are passed through.
 
     For each extraction method, specific parameters are required:
-    - pdfium: yolox_endpoints
+    - pdfium: yolox_endpoints; auth_token for NVIDIA-hosted YOLOX (e.g. page-elements)
     - adobe: adobe_client_id, adobe_client_secret
     - llama: llama_api_key
-    - nemotron_parse: nemotron_parse_endpoints
+    - nemotron_parse: nemotron_parse_endpoints; auth_token for NVIDIA API
     - unstructured_io: unstructured_io_api_key
     - tika: tika_server_url
 
@@ -239,7 +242,7 @@ def extract_primitives_from_pdf_pdfium(
     extract_charts: bool = True,
     extract_infographics: bool = True,
     text_depth: str = "page",
-    yolox_auth_token: Optional[str] = None,
+    auth_token: Optional[str] = None,
     yolox_endpoints: Optional[Tuple[Optional[str], Optional[str]]] = None,
     yolox_infer_protocol: str = "http",
 ) -> pd.DataFrame:
@@ -275,8 +278,9 @@ def extract_primitives_from_pdf_pdfium(
         Whether to extract infographics
     text_depth : str, default "page"
         Level of text granularity (page, block, paragraph, line)
-    yolox_auth_token : str, optional
-        Authentication token for YOLOX inference services
+    auth_token : str, optional
+        Authentication token for YOLOX inference services (NVIDIA CV APIs, e.g. page-elements).
+        Passed into the pdfium config schema; required for NVIDIA-hosted endpoints.
     yolox_endpoints : tuple of (str, str), optional
         Tuple containing (gRPC endpoint, HTTP endpoint) for YOLOX services
     yolox_infer_protocol : str, default "http"
@@ -296,7 +300,7 @@ def extract_primitives_from_pdf_pdfium(
         extract_charts=extract_charts,
         extract_infographics=extract_infographics,
         text_depth=text_depth,
-        yolox_auth_token=yolox_auth_token,
+        auth_token=auth_token,
         yolox_endpoints=yolox_endpoints,
         yolox_infer_protocol=yolox_infer_protocol,
     )
@@ -311,7 +315,7 @@ def extract_primitives_from_pdf_nemotron_parse(
     extract_charts: bool = True,
     extract_infographics: bool = True,
     text_depth: str = "page",
-    yolox_auth_token: Optional[str] = None,
+    auth_token: Optional[str] = None,
     yolox_endpoints: Optional[Tuple[Optional[str], Optional[str]]] = None,
     yolox_infer_protocol: str = "http",
     nemotron_parse_endpoints: Optional[Tuple[str, str]] = None,
@@ -369,9 +373,9 @@ def extract_primitives_from_pdf_nemotron_parse(
         - "paragraph" : Text extracted at paragraph level (semantic units)
         - "line" : Text extracted at line level (finest granularity)
 
-    yolox_auth_token : Optional[str], default None
-        Authentication token for YOLOX inference services used for image processing.
-        Required if the YOLOX services need authentication.
+    auth_token : Optional[str], default None
+        Authentication token used for both YOLOX inference (image processing) and Nemotron
+        Parse (NVIDIA API). Required when using NVIDIA-hosted endpoints.
 
     yolox_endpoints : Optional[Tuple[Optional[str], Optional[str]]], default None
         A tuple containing (gRPC endpoint, HTTP endpoint) for YOLOX services.
@@ -469,7 +473,7 @@ def extract_primitives_from_pdf_nemotron_parse(
         extract_infographics=extract_infographics,
         text_depth=text_depth,
         yolox_endpoints=yolox_endpoints,
-        yolox_auth_token=yolox_auth_token,
+        auth_token=auth_token,
         yolox_infer_protocol=yolox_infer_protocol,
         nemotron_parse_endpoints=nemotron_parse_endpoints,
         nemotron_parse_protocol=nemotron_parse_protocol,
diff --git a/api/src/nv_ingest_api/internal/extract/image/chart_extractor.py b/api/src/nv_ingest_api/internal/extract/image/chart_extractor.py
index 7e2fea053..82bc7be19 100644
--- a/api/src/nv_ingest_api/internal/extract/image/chart_extractor.py
+++ b/api/src/nv_ingest_api/internal/extract/image/chart_extractor.py
@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+import os
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Union
 from typing import Dict
@@ -19,7 +20,7 @@
 from nv_ingest_api.util.image_processing.table_and_chart import process_yolox_graphic_elements
 from nv_ingest_api.internal.primitives.nim.model_interface.ocr import PaddleOCRModelInterface
 from nv_ingest_api.internal.primitives.nim.model_interface.ocr import NemoRetrieverOCRModelInterface
-from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name  # noqa: F401
 from nv_ingest_api.internal.primitives.nim import NimClient
 from nv_ingest_api.internal.primitives.nim.model_interface.yolox import YoloxGraphicElementsModelInterface
 from nv_ingest_api.util.image_processing.transforms import base64_to_numpy
@@ -31,6 +32,114 @@
 logger = logging.getLogger(f"ray.{__name__}")
 
 
+def _local_nemotron_ocr_boxes_texts(
+    base64_images: List[str],
+    *,
+    merge_level: str = "paragraph",
+    trace_info: Optional[Dict] = None,
+) -> List[List[Any]]:
+    """
+    Local OCR fallback using the Nemotron OCR v1 pipeline via:
+      `nemo_retriever.model.local.nemotron_ocr_v1.NemotronOCRV1`
+
+    Returns list aligned with base64_images:
+      [bounding_boxes, text_predictions, conf_scores]
+    """
+    model_dir = (
+        os.getenv("RETRIEVER_NEMOTRON_OCR_MODEL_DIR", "").strip()
+        or os.getenv("NEMOTRON_OCR_MODEL_DIR", "").strip()
+        or os.getenv("NEMOTRON_OCR_V1_MODEL_DIR", "").strip()
+    )
+
+    # Import locally to avoid making `nv-ingest-api` hard-depend on nemo-retriever unless needed.
+    try:
+        from nemo_retriever.model.local.nemotron_ocr_v1 import NemotronOCRV1  # type: ignore
+    except Exception as e:
+        raise RuntimeError(
+            "Local chart OCR fallback requires the `nemo-retriever` package to be importable "
+            "so we can use `nemo_retriever.model.local.nemotron_ocr_v1.NemotronOCRV1`."
+        ) from e
+
+    if trace_info is not None:
+        trace_info.setdefault("ocr", {})
+        trace_info["ocr"]["backend"] = "local_nemotron_ocr_v1"
+        trace_info["ocr"]["model_dir"] = model_dir or None
+
+    ocr = NemotronOCRV1(model_dir=model_dir) if model_dir else NemotronOCRV1()
+
+    results: List[List[Any]] = []
+    for b64 in base64_images:
+        try:
+            arr = base64_to_numpy(b64)
+            h, w = int(arr.shape[0]), int(arr.shape[1])
+            preds = ocr.invoke(b64, merge_level=merge_level)
+
+            boxes: List[List[List[float]]] = []
+            texts: List[str] = []
+            confs: List[float] = []
+
+            # Common per-line dict form: left/right/upper/lower in [0,1] plus text.
+            if isinstance(preds, list):
+                for item in preds:
+                    if not isinstance(item, dict):
+                        continue
+                    txt = item.get("text")
+                    if not isinstance(txt, str) or not txt.strip() or txt.strip() == "nan":
+                        continue
+
+                    if all(k in item for k in ("left", "right", "upper", "lower")):
+                        try:
+                            x1 = float(item["left"]) * float(w)
+                            x2 = float(item["right"]) * float(w)
+                            # nemotron_ocr uses (lower, upper) y coords.
+                            y1 = float(item["lower"]) * float(h)
+                            y2 = float(item["upper"]) * float(h)
+                            quad = [[x1, y1], [x2, y1], [x2, y2], [x1, y2]]
+                        except Exception:
+                            quad = [[0.0, 0.0], [float(w), 0.0], [float(w), float(h)], [0.0, float(h)]]
+                    else:
+                        quad = [[0.0, 0.0], [float(w), 0.0], [float(w), float(h)], [0.0, float(h)]]
+
+                    texts.append(txt.strip())
+                    boxes.append(quad)
+                    confs.append(
+                        float(item.get("confidence")) if isinstance(item.get("confidence"), (int, float)) else 1.0
+                    )
+
+            # Fallback: stringify unknown output.
+            if not texts:
+                s = ""
+                try:
+                    s = str(preds).strip()
+                except Exception:
+                    s = ""
+                if s and s.lower() not in {"none", "null"}:
+                    texts = [s]
+                    boxes = [[[0.0, 0.0], [float(w), 0.0], [float(w), float(h)], [0.0, float(h)]]]
+                    confs = [1.0]
+
+            results.append([boxes, texts, confs])
+        except Exception:
+            logger.exception("Local Nemotron OCR failed for chart image.")
+            results.append([[], [], []])
+
+    return results
+
+
+class _LocalNemotronOCRClient:
+    @property
+    def protocol(self) -> str:
+        return "local"
+
+    def infer(self, data: Dict[str, Any], **kwargs: Any) -> Any:
+        base64_images = data.get("base64_images") or []
+        if not isinstance(base64_images, list):
+            raise ValueError("Expected data['base64_images'] to be a list.")
+        merge_level = kwargs.get("merge_level", "paragraph")
+        trace_info = kwargs.get("trace_info")
+        return _local_nemotron_ocr_boxes_texts(base64_images, merge_level=merge_level, trace_info=trace_info)
+
+
 def _filter_valid_chart_images(
     base64_images: List[str],
 ) -> Tuple[List[str], List[np.ndarray], List[int], List[Tuple[str, Optional[Dict]]]]:
@@ -93,21 +202,25 @@ def _run_chart_inference(
         stage_name="chart_extraction",
         trace_info=trace_info,
     )
-    if ocr_model_name == "paddle":
-        future_ocr_kwargs.update(
-            model_name="paddle",
-            max_batch_size=1 if ocr_client.protocol == "grpc" else 2,
-        )
-    elif ocr_model_name in {"scene_text_ensemble", "scene_text_wrapper", "scene_text_python"}:
-        future_ocr_kwargs.update(
-            model_name=ocr_model_name,
-            input_names=["INPUT_IMAGE_URLS", "MERGE_LEVELS"],
-            output_names=["OUTPUT"],
-            dtypes=["BYTES", "BYTES"],
-            merge_level="paragraph",
-        )
+    if str(getattr(ocr_client, "protocol", "")).lower() == "local":
+        # Local Nemotron OCR path (model_name/input_names/etc. are ignored by the local adapter).
+        future_ocr_kwargs.update(merge_level="paragraph")
     else:
-        raise ValueError(f"Unknown OCR model name: {ocr_model_name}")
+        if ocr_model_name == "paddle":
+            future_ocr_kwargs.update(
+                model_name="paddle",
+                max_batch_size=1 if ocr_client.protocol == "grpc" else 2,
+            )
+        elif ocr_model_name in {"scene_text_ensemble", "scene_text_wrapper", "scene_text_python"}:
+            future_ocr_kwargs.update(
+                model_name=ocr_model_name,
+                input_names=["INPUT_IMAGE_URLS", "MERGE_LEVELS"],
+                output_names=["OUTPUT"],
+                dtypes=["BYTES", "BYTES"],
+                merge_level="paragraph",
+            )
+        else:
+            raise ValueError(f"Unknown OCR model name: {ocr_model_name}")
 
     with ThreadPoolExecutor(max_workers=2) as executor:
         future_yolox = executor.submit(yolox_client.infer, **future_yolox_kwargs)
@@ -217,7 +330,7 @@ def _update_chart_metadata(
 
 
 def _create_yolox_client(
-    yolox_endpoints: Tuple[str, str],
+    yolox_endpoints: Tuple[Optional[str], Optional[str]],
     yolox_protocol: str,
     auth_token: str,
 ) -> NimClient:
@@ -234,7 +347,7 @@ def _create_yolox_client(
 
 
 def _create_ocr_client(
-    ocr_endpoints: Tuple[str, str],
+    ocr_endpoints: Tuple[Optional[str], Optional[str]],
     ocr_protocol: str,
     ocr_model_name: str,
     auth_token: str,
@@ -300,10 +413,6 @@ def extract_chart_data_from_image_internal(
 
     endpoint_config = extraction_config.endpoint_config
 
-    # Get the grpc endpoint to determine the model if needed
-    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]
-    ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
-
     try:
         # 1) Identify rows that meet criteria in a single pass
         #    - metadata exists
@@ -341,18 +450,35 @@ def meets_criteria(row):
             base64_images.append(meta["content"])  # guaranteed by meets_criteria
 
         # 3) Call our bulk _update_metadata to get all results.
-        yolox_client = _create_yolox_client(
-            endpoint_config.yolox_endpoints,
-            endpoint_config.yolox_infer_protocol,
-            endpoint_config.auth_token,
-        )
-
-        ocr_client = _create_ocr_client(
-            endpoint_config.ocr_endpoints,
-            endpoint_config.ocr_infer_protocol,
-            ocr_model_name,
-            endpoint_config.auth_token,
-        )
+        # Extract endpoints (may be empty/None -> local fallback).
+        yolox_endpoints: Tuple[Optional[str], Optional[str]] = (None, None)
+        yolox_protocol = "local"
+        ocr_endpoints: Tuple[Optional[str], Optional[str]] = (None, None)
+        ocr_protocol = "local"
+        auth_token = ""
+        workers = 5
+        if endpoint_config is not None:
+            yolox_endpoints = getattr(endpoint_config, "yolox_endpoints", (None, None))
+            yolox_protocol = getattr(endpoint_config, "yolox_infer_protocol", "") or "local"
+            ocr_endpoints = getattr(endpoint_config, "ocr_endpoints", (None, None))
+            ocr_protocol = getattr(endpoint_config, "ocr_infer_protocol", "") or "local"
+            auth_token = getattr(endpoint_config, "auth_token", "") or ""
+            workers = int(getattr(endpoint_config, "workers_per_progress_engine", 5) or 5)
+
+        has_ocr_endpoint = bool((ocr_endpoints[0] or ocr_endpoints[1]))
+
+        yolox_client = _create_yolox_client(yolox_endpoints, yolox_protocol, auth_token)
+
+        # If OCR endpoints are not configured (or protocol is local), use local Nemotron OCR.
+        if (not has_ocr_endpoint) or str(ocr_protocol).lower() == "local":
+            ocr_client = _LocalNemotronOCRClient()
+            ocr_model_name = "local"
+        else:
+            # Get the grpc endpoint to determine the model if needed
+            ocr_grpc_endpoint = ocr_endpoints[0]  # noqa: F841
+            # ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+            ocr_model_name = "scene_text_ensemble"
+            ocr_client = _create_ocr_client(ocr_endpoints, ocr_protocol, ocr_model_name, auth_token)
 
         bulk_results = _update_chart_metadata(
             base64_images=base64_images,
@@ -360,7 +486,7 @@ def meets_criteria(row):
             yolox_model_name=yolox_client.model_interface.model_name,
             ocr_client=ocr_client,
             ocr_model_name=ocr_model_name,
-            worker_pool_size=endpoint_config.workers_per_progress_engine,
+            worker_pool_size=workers,
             trace_info=execution_trace_log,
         )
 
diff --git a/api/src/nv_ingest_api/internal/extract/image/infographic_extractor.py b/api/src/nv_ingest_api/internal/extract/image/infographic_extractor.py
index 048ff979c..6b84803cf 100644
--- a/api/src/nv_ingest_api/internal/extract/image/infographic_extractor.py
+++ b/api/src/nv_ingest_api/internal/extract/image/infographic_extractor.py
@@ -3,6 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+import os
 from typing import Any
 from typing import Dict
 from typing import List
@@ -171,6 +172,100 @@ def _create_ocr_client(
     return ocr_client
 
 
+def _local_nemotron_ocr_text_predictions(
+    base64_images: List[str],
+    *,
+    merge_level: str = "paragraph",
+    trace_info: Optional[Dict] = None,
+) -> List[Tuple[str, Optional[Any], Optional[Any]]]:
+    """
+    Local OCR fallback using the Nemotron OCR v1 pipeline via:
+      `nemo_retriever.model.local.nemotron_ocr_v1.NemotronOCRV1`
+
+    Returns list of tuples aligned with base64_images:
+      (base64_image, bounding_boxes_or_none, text_predictions_or_none)
+
+    This mirrors the shape consumed by the caller in this module.
+    """
+    # Keep the same "skip tiny images" behavior as the NIM path.
+    valid_images, valid_indices, results = _filter_infographic_images(base64_images)
+
+    model_dir = (
+        os.getenv("RETRIEVER_NEMOTRON_OCR_MODEL_DIR", "").strip()
+        or os.getenv("NEMOTRON_OCR_MODEL_DIR", "").strip()
+        or os.getenv("NEMOTRON_OCR_V1_MODEL_DIR", "").strip()
+    )
+
+    # Import locally to avoid making `nv-ingest-api` hard-depend on nemo-retriever unless needed.
+    try:
+        from nemo_retriever.model.local.nemotron_ocr_v1 import NemotronOCRV1  # type: ignore
+    except Exception as e:
+        raise RuntimeError(
+            "Local infographic OCR fallback requires the `nemo-retriever` package to be importable "
+            "so we can use `nemo_retriever.model.local.nemotron_ocr_v1.NemotronOCRV1`."
+        ) from e
+
+    if trace_info is not None:
+        trace_info.setdefault("ocr", {})
+        trace_info["ocr"]["backend"] = "local_nemotron_ocr_v1"
+        trace_info["ocr"]["model_dir"] = model_dir or None
+
+    ocr = NemotronOCRV1(model_dir=model_dir) if model_dir else NemotronOCRV1()
+
+    for idx, b64 in enumerate(valid_images):
+        original_index = valid_indices[idx]
+        try:
+            # Pass base64 directly; NemotronOCR supports base64 bytes.
+            preds = ocr.invoke(b64, merge_level=merge_level)
+
+            # Best-effort extraction of text strings from Nemotron OCR outputs.
+            texts: List[str] = []
+            if isinstance(preds, dict):
+                if isinstance(preds.get("text"), str):
+                    texts.append(preds["text"])
+                if isinstance(preds.get("texts"), list):
+                    texts.extend([x for x in preds["texts"] if isinstance(x, str)])
+                if isinstance(preds.get("words"), list):
+                    for w in preds["words"]:
+                        if isinstance(w, dict) and isinstance(w.get("text"), str):
+                            texts.append(w["text"])
+            elif isinstance(preds, list):
+                for item in preds:
+                    if isinstance(item, str):
+                        if item.strip():
+                            texts.append(item.strip())
+                        continue
+                    if isinstance(item, dict):
+                        if isinstance(item.get("text"), str) and item["text"].strip() and item["text"].strip() != "nan":
+                            texts.append(item["text"].strip())
+                            continue
+                        if isinstance(item.get("texts"), list):
+                            texts.extend([x.strip() for x in item["texts"] if isinstance(x, str) and x.strip()])
+                            continue
+                        if isinstance(item.get("words"), list):
+                            for w in item["words"]:
+                                if isinstance(w, dict) and isinstance(w.get("text"), str) and w["text"].strip():
+                                    texts.append(w["text"].strip())
+
+            # Fallback: stringify unknown shapes.
+            if not texts:
+                try:
+                    s = str(preds).strip()
+                    if s and s.lower() not in {"none", "null"}:
+                        texts = [s]
+                except Exception:
+                    texts = []
+
+            # The rest of the pipeline expects `text_predictions` to be a list of strings.
+            text_predictions = texts if texts else None
+            results[original_index] = (base64_images[original_index], None, text_predictions)
+        except Exception:
+            logger.exception("Local Nemotron OCR failed for infographic image index=%s", original_index)
+            results[original_index] = (base64_images[original_index], None, None)
+
+    return results
+
+
 def _meets_infographic_criteria(row: pd.Series) -> bool:
     """
     Determines if a DataFrame row meets the criteria for infographic extraction.
@@ -243,10 +338,6 @@ def extract_infographic_data_from_image_internal(
 
     endpoint_config = extraction_config.endpoint_config
 
-    # Get the grpc endpoint to determine the model if needed
-    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]
-    ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
-
     try:
         # Identify rows that meet the infographic criteria.
         mask = df_extraction_ledger.apply(_meets_infographic_criteria, axis=1)
@@ -259,21 +350,44 @@ def extract_infographic_data_from_image_internal(
         # Extract base64 images from valid rows.
         base64_images = [df_extraction_ledger.at[idx, "metadata"]["content"] for idx in valid_indices]
 
-        # Call bulk update to extract infographic data.
-        ocr_client = _create_ocr_client(
-            endpoint_config.ocr_endpoints,
-            endpoint_config.ocr_infer_protocol,
-            ocr_model_name,
-            endpoint_config.auth_token,
-        )
-
-        bulk_results = _update_infographic_metadata(
-            base64_images=base64_images,
-            ocr_client=ocr_client,
-            ocr_model_name=ocr_model_name,
-            worker_pool_size=endpoint_config.workers_per_progress_engine,
-            trace_info=execution_trace_log,
-        )
+        # If endpoints are not configured, fall back to local Nemotron OCR.
+        ocr_endpoints = (None, None)
+        ocr_protocol = "local"
+        auth_token = ""
+        workers = 5
+        if endpoint_config is not None:
+            ocr_endpoints = getattr(endpoint_config, "ocr_endpoints", (None, None))
+            ocr_protocol = getattr(endpoint_config, "ocr_infer_protocol", "") or "local"
+            auth_token = getattr(endpoint_config, "auth_token", "") or ""
+            workers = int(getattr(endpoint_config, "workers_per_progress_engine", 5) or 5)
+
+        has_endpoint = bool((ocr_endpoints[0] or ocr_endpoints[1]))
+        if not has_endpoint or str(ocr_protocol).lower() == "local":
+            bulk_results = _local_nemotron_ocr_text_predictions(
+                base64_images,
+                merge_level="paragraph",
+                trace_info=execution_trace_log,
+            )
+        else:
+            # Get the grpc endpoint to determine the model if needed
+            ocr_grpc_endpoint = ocr_endpoints[0]
+            ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+
+            # Call bulk update to extract infographic data via NIM endpoints.
+            ocr_client = _create_ocr_client(
+                ocr_endpoints,
+                ocr_protocol,
+                ocr_model_name,
+                auth_token,
+            )
+
+            bulk_results = _update_infographic_metadata(
+                base64_images=base64_images,
+                ocr_client=ocr_client,
+                ocr_model_name=ocr_model_name,
+                worker_pool_size=workers,
+                trace_info=execution_trace_log,
+            )
 
         # Write the extracted results back into the DataFrame.
         for result_idx, df_idx in enumerate(valid_indices):
diff --git a/api/src/nv_ingest_api/internal/extract/image/ocr_extractor.py b/api/src/nv_ingest_api/internal/extract/image/ocr_extractor.py
index 31e69c481..68599dc06 100644
--- a/api/src/nv_ingest_api/internal/extract/image/ocr_extractor.py
+++ b/api/src/nv_ingest_api/internal/extract/image/ocr_extractor.py
@@ -15,7 +15,7 @@
 from nv_ingest_api.internal.primitives.nim import NimClient
 from nv_ingest_api.internal.primitives.nim.model_interface.ocr import PaddleOCRModelInterface
 from nv_ingest_api.internal.primitives.nim.model_interface.ocr import NemoRetrieverOCRModelInterface
-from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name  # noqa: F401
 from nv_ingest_api.internal.schemas.extract.extract_ocr_schema import OCRExtractorSchema
 from nv_ingest_api.util.image_processing.transforms import base64_to_numpy
 from nv_ingest_api.util.nim import create_inference_client
@@ -257,6 +257,11 @@ def _process_page_elements(df_to_process: pd.DataFrame, ocr_results: List[Tuple]
         return df_to_process
 
     for result_idx, df_idx in enumerate(valid_indices):
+        # Preserve the original base64 image before overwriting with OCR text.
+        # This enables text_image modality for multimodal embeddings.
+        original_image = df_to_process.loc[df_idx, "metadata"]["content"]
+        df_to_process.loc[df_idx, "metadata"]["text_metadata"]["source_image"] = original_image
+
         # Unpack result: (bounding_boxes, text_predictions, confidence_scores)
         bboxes, texts, _ = ocr_results[result_idx]
         if not bboxes or not texts:
@@ -356,8 +361,9 @@ def extract_text_data_from_image_internal(
     endpoint_config = extraction_config.endpoint_config
 
     # Get the grpc endpoint to determine the model if needed
-    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]
-    ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]  # noqa: F841
+    # ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+    ocr_model_name = "scene_text_ensemble"
 
     try:
         # Identify rows that meet the text criteria.
diff --git a/api/src/nv_ingest_api/internal/extract/image/table_extractor.py b/api/src/nv_ingest_api/internal/extract/image/table_extractor.py
index ad188de5d..d754f5a41 100644
--- a/api/src/nv_ingest_api/internal/extract/image/table_extractor.py
+++ b/api/src/nv_ingest_api/internal/extract/image/table_extractor.py
@@ -3,6 +3,8 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import logging
+import os
+from pathlib import Path
 from concurrent.futures import ThreadPoolExecutor
 from typing import Any, Union
 from typing import Dict
@@ -17,7 +19,7 @@
 from nv_ingest_api.internal.enums.common import TableFormatEnum
 from nv_ingest_api.internal.primitives.nim.model_interface.ocr import PaddleOCRModelInterface
 from nv_ingest_api.internal.primitives.nim.model_interface.ocr import NemoRetrieverOCRModelInterface
-from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name  # noqa: F401
 from nv_ingest_api.internal.primitives.nim import NimClient
 from nv_ingest_api.internal.schemas.extract.extract_table_schema import TableExtractorSchema
 from nv_ingest_api.util.image_processing.table_and_chart import join_yolox_table_structure_and_ocr_output
@@ -32,6 +34,75 @@
 PADDLE_MIN_HEIGHT = 32
 
 
+def _maybe_dump_ocr_input_images(
+    *,
+    df_extraction_ledger: pd.DataFrame,
+    df_indices: List[Any],
+    base64_images: List[str],
+    backend_tag: str,
+) -> None:
+    """
+    Best-effort debug helper to write OCR input images to disk.
+
+    Controlled via env vars set by higher-level CLIs:
+      - NV_INGEST_DUMP_OCR_INPUT_IMAGES=1
+      - NV_INGEST_DUMP_OCR_INPUT_IMAGES_DIR=/path/to/dir
+      - NV_INGEST_DUMP_OCR_INPUT_IMAGES_PREFIX=<input_filename>
+
+    Filenames:
+      <prefix>.page_<PPPP>_<IIII>.<backend_tag>.png
+    where IIII is 1-based within each page (pages can have multiple structured images).
+    """
+    if os.getenv("NV_INGEST_DUMP_OCR_INPUT_IMAGES", "").strip().lower() not in {"1", "true", "yes", "on"}:
+        return
+
+    out_dir = os.getenv("NV_INGEST_DUMP_OCR_INPUT_IMAGES_DIR", "").strip()
+    prefix = os.getenv("NV_INGEST_DUMP_OCR_INPUT_IMAGES_PREFIX", "").strip() or "input"
+    if not out_dir:
+        return
+
+    try:
+        from PIL import Image  # type: ignore
+    except Exception:
+        return
+
+    try:
+        Path(out_dir).mkdir(parents=True, exist_ok=True)
+    except Exception:
+        return
+
+    per_page_counts: Dict[int, int] = {}
+
+    for df_idx, b64 in zip(df_indices, base64_images):
+        try:
+            meta = df_extraction_ledger.at[df_idx, "metadata"]
+            page = 0
+            if isinstance(meta, dict):
+                cm = meta.get("content_metadata") if isinstance(meta.get("content_metadata"), dict) else {}
+                p = cm.get("page_number")
+                try:
+                    page = int(p) if p is not None else 0
+                except Exception:
+                    page = 0
+
+            per_page_counts[page] = per_page_counts.get(page, 0) + 1
+            within_page_i = per_page_counts[page]
+
+            arr = base64_to_numpy(b64)
+            if arr.ndim == 2:
+                arr = np.stack([arr] * 3, axis=-1)
+            if arr.shape[2] == 4:
+                arr = arr[:, :, :3]
+            if arr.dtype != np.uint8:
+                arr = (arr * 255).astype(np.uint8) if np.issubdtype(arr.dtype, np.floating) else arr.astype(np.uint8)
+
+            img = Image.fromarray(arr, mode="RGB")
+            out_path = Path(out_dir) / f"{prefix}.page_{page:04d}_{within_page_i:04d}.{backend_tag}.png"
+            img.save(out_path, format="PNG")
+        except Exception:
+            continue
+
+
 def _filter_valid_images(
     base64_images: List[str],
 ) -> Tuple[List[str], List[np.ndarray], List[int]]:
@@ -268,6 +339,329 @@ def _create_ocr_client(
     return ocr_client
 
 
+def _local_nemotron_ocr_boxes_texts(
+    base64_images: List[str],
+    *,
+    merge_level: str = "word",
+    trace_info: Optional[Dict] = None,
+) -> List[Tuple[str, Any, Any, Any]]:
+    """
+    Local OCR fallback using the Nemotron OCR v1 pipeline via:
+      `nemo_retriever.model.local.nemotron_ocr_v1.NemotronOCRV1`
+
+    Returns a list aligned with base64_images:
+      (base64_image, cell_predictions=None, bounding_boxes, text_predictions)
+
+    Where:
+      - bounding_boxes: List[List[List[float]]] (quadrilateral boxes [[x,y] * 4])
+      - text_predictions: List[str]
+    """
+    # Preserve the same "skip tiny images" behavior as the NIM path.
+    valid_images, valid_arrays, valid_indices = _filter_valid_images(base64_images)
+
+    # Initialize defaults for all images (including those skipped).
+    results: List[Tuple[str, Any, Any, Any]] = [(img, None, None, None) for img in base64_images]
+    if not valid_images:
+        return results
+
+    model_dir = (
+        os.getenv("RETRIEVER_NEMOTRON_OCR_MODEL_DIR", "").strip()
+        or os.getenv("NEMOTRON_OCR_MODEL_DIR", "").strip()
+        or os.getenv("NEMOTRON_OCR_V1_MODEL_DIR", "").strip()
+    )
+
+    # Lazy import to avoid hard dependency when running pure API package.
+    try:
+        from nemo_retriever.model.local.nemotron_ocr_v1 import NemotronOCRV1  # type: ignore
+    except Exception as e:
+        raise RuntimeError(
+            "Local table OCR fallback requires the `nemo-retriever` package to be importable "
+            "so we can use `nemo_retriever.model.local.nemotron_ocr_v1.NemotronOCRV1`."
+        ) from e
+
+    if trace_info is not None:
+        trace_info.setdefault("ocr", {})
+        trace_info["ocr"]["backend"] = "local_nemotron_ocr_v1"
+        trace_info["ocr"]["model_dir"] = model_dir or None
+
+    # Instantiate local OCR model once per call.
+    ocr = NemotronOCRV1(model_dir=model_dir) if model_dir else NemotronOCRV1()
+
+    def _xyxy_to_quad(xyxy: List[float]) -> List[List[float]]:
+        x1, y1, x2, y2 = [float(v) for v in xyxy]
+        return [[x1, y1], [x2, y1], [x2, y2], [x1, y2]]
+
+    for local_i, (b64, arr) in enumerate(zip(valid_images, valid_arrays)):
+        original_index = valid_indices[local_i]
+        try:
+            h, w = int(arr.shape[0]), int(arr.shape[1])
+
+            preds = ocr.invoke(b64, merge_level=merge_level)
+
+            boxes: List[List[List[float]]] = []
+            texts: List[str] = []
+
+            # Common "packed" form: dict with boxes/texts.
+            if isinstance(preds, dict):
+                pb = preds.get("boxes") or preds.get("bboxes") or preds.get("bounding_boxes")
+                pt = preds.get("texts") or preds.get("text_predictions") or preds.get("text")
+                if isinstance(pb, list) and isinstance(pt, list):
+                    for b, txt in zip(pb, pt):
+                        if isinstance(txt, str) and txt.strip():
+                            texts.append(txt.strip())
+                            if isinstance(b, list):
+                                # b may be [[x,y]*4] or flat len 8 or xyxy len 4
+                                if len(b) == 4 and all(isinstance(p, (list, tuple)) and len(p) == 2 for p in b):
+                                    boxes.append([[float(x), float(y)] for x, y in b])  # type: ignore[misc]
+                                elif len(b) == 8 and all(isinstance(v, (int, float)) for v in b):
+                                    pts = [float(v) for v in b]
+                                    boxes.append(
+                                        [[pts[0], pts[1]], [pts[2], pts[3]], [pts[4], pts[5]], [pts[6], pts[7]]]
+                                    )
+                                elif len(b) == 4 and all(isinstance(v, (int, float)) for v in b):
+                                    boxes.append(_xyxy_to_quad([float(v) for v in b]))
+
+            # Per-region list form: list[dict]
+            if (not texts) and isinstance(preds, list):
+                for item in preds:
+                    if isinstance(item, str):
+                        if item.strip():
+                            texts.append(item.strip())
+                            boxes.append([[0.0, 0.0], [float(w), 0.0], [float(w), float(h)], [0.0, float(h)]])
+                        continue
+                    if not isinstance(item, dict):
+                        continue
+
+                    # Nemotron OCR pipeline returns normalized coords: left/right/lower/upper in [0,1]
+                    if all(k in item for k in ("left", "right", "upper", "lower")) and isinstance(
+                        item.get("text"), str
+                    ):
+                        txt0 = str(item.get("text") or "").strip()
+                        if not txt0 or txt0 == "nan":
+                            continue
+                        try:
+                            x1 = float(item["left"]) * float(w)
+                            x2 = float(item["right"]) * float(w)
+                            y1 = float(item["lower"]) * float(h)
+                            y2 = float(item["upper"]) * float(h)
+                            quad = [[x1, y1], [x2, y1], [x2, y2], [x1, y2]]
+                        except Exception:
+                            quad = [[0.0, 0.0], [float(w), 0.0], [float(w), float(h)], [0.0, float(h)]]
+                        texts.append(txt0)
+                        boxes.append(quad)
+                        continue
+
+                    txt = (
+                        item.get("text")
+                        or item.get("ocr_text")
+                        or item.get("generated_text")
+                        or item.get("output_text")
+                    )
+                    if not isinstance(txt, str) or not txt.strip():
+                        continue
+                    txt = txt.strip()
+
+                    b = item.get("box") or item.get("bbox") or item.get("bounding_box") or item.get("bbox_points")
+                    quad: Optional[List[List[float]]] = None
+                    if isinstance(b, list):
+                        if len(b) == 4 and all(isinstance(p, (list, tuple)) and len(p) == 2 for p in b):
+                            quad = [[float(x), float(y)] for x, y in b]  # type: ignore[misc]
+                        elif len(b) == 8 and all(isinstance(v, (int, float)) for v in b):
+                            pts = [float(v) for v in b]
+                            quad = [[pts[0], pts[1]], [pts[2], pts[3]], [pts[4], pts[5]], [pts[6], pts[7]]]
+                        elif len(b) == 4 and all(isinstance(v, (int, float)) for v in b):
+                            quad = _xyxy_to_quad([float(v) for v in b])
+                    elif isinstance(b, dict):
+                        pts = b.get("points")
+                        if isinstance(pts, list) and len(pts) == 4:
+                            try:
+                                quad = [[float(p.get("x")), float(p.get("y"))] for p in pts]  # type: ignore[union-attr]
+                            except Exception:
+                                quad = None
+
+                    if quad is None:
+                        quad = [[0.0, 0.0], [float(w), 0.0], [float(w), float(h)], [0.0, float(h)]]
+
+                    texts.append(txt)
+                    boxes.append(quad)
+
+            # If we still didn't parse anything, best-effort stringify.
+            if not texts:
+                s = ""
+                try:
+                    s = str(preds).strip()
+                except Exception:
+                    s = ""
+                if s and s.lower() not in {"none", "null"}:
+                    texts = [s]
+                    boxes = [[0.0, 0.0], [float(w), 0.0], [float(w), float(h)], [0.0, float(h)]]  # type: ignore[assignment]  # noqa: E501
+
+            if texts and not boxes:
+                # Provide a dummy full-image box per text.
+                boxes = [[[0.0, 0.0], [float(w), 0.0], [float(w), float(h)], [0.0, float(h)]] for _ in texts]
+
+            results[original_index] = (base64_images[original_index], None, boxes, texts)
+        except Exception as ex:  # noqa: F841
+            logger.exception("Local Nemotron OCR failed for table image index=%s", original_index)
+            results[original_index] = (base64_images[original_index], None, None, None)
+
+    return results
+
+
+def _local_nemotron_table_structure_cell_predictions(
+    base64_images: List[str],
+    *,
+    trace_info: Optional[Dict] = None,
+) -> List[Optional[Dict[str, Any]]]:
+    """
+    Local table-structure fallback using:
+      `nemo_retriever.model.local.nemotron_table_structure_v1.NemotronTableStructureV1`
+
+    Returns a list aligned with base64_images where each element is either:
+      - None (failed / skipped), or
+      - dict with keys {"cell","row","column"} mapping to lists of [x1,y1,x2,y2,score] in **pixel** coords.
+
+    This matches what `join_yolox_table_structure_and_ocr_output()` expects (it treats boxes as Nx4/Nx5).
+    """
+    valid_images, valid_arrays, valid_indices = _filter_valid_images(base64_images)
+    out: List[Optional[Dict[str, Any]]] = [None for _ in base64_images]
+    if not valid_images:
+        return out
+
+    # Lazy import to avoid hard dependency when running pure API package.
+    try:
+        from nemo_retriever.model.local.nemotron_table_structure_v1 import NemotronTableStructureV1  # type: ignore
+    except Exception as e:
+        raise RuntimeError(
+            "Local table-structure fallback requires the `nemo-retriever` package to be importable "
+            "so we can use `nemo_retriever.model.local.nemotron_table_structure_v1.NemotronTableStructureV1`."
+        ) from e
+
+    try:
+        import torch
+    except Exception as e:
+        raise RuntimeError("Local table-structure fallback requires PyTorch to be installed.") from e
+
+    dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    if trace_info is not None:
+        trace_info.setdefault("yolox", {})
+        trace_info["yolox"]["backend"] = "local_nemotron_table_structure_v1"
+        trace_info["yolox"]["device"] = str(dev)
+
+    model = NemotronTableStructureV1(endpoint=None)
+    # Best-effort: move underlying module to device if present.
+    try:
+        if hasattr(model, "_model") and model._model is not None:
+            model._model = model._model.to(dev)  # type: ignore[attr-defined]
+    except Exception:
+        pass
+
+    def _to_list(v: Any) -> Any:
+        try:
+            import numpy as _np
+
+            if isinstance(v, torch.Tensor):
+                return v.detach().cpu().tolist()
+            if isinstance(v, _np.ndarray):
+                return v.tolist()
+        except Exception:
+            pass
+        return v
+
+    # Label mapping fallback if model emits integer ids.
+    id_to_label = {0: "cell", 1: "row", 2: "column"}
+
+    for local_i, arr in enumerate(valid_arrays):
+        idx = valid_indices[local_i]
+        try:
+            # Ensure RGB uint8.
+            if arr.ndim == 2:
+                arr = arr[:, :, None]
+            if arr.shape[-1] == 1:
+                arr = np.repeat(arr, 3, axis=-1)
+            if arr.shape[-1] == 4:
+                arr = arr[:, :, :3]
+            if arr.dtype != np.uint8:
+                arr = (arr * 255).astype(np.uint8) if np.issubdtype(arr.dtype, np.floating) else arr.astype(np.uint8)
+
+            h, w = int(arr.shape[0]), int(arr.shape[1])
+            t = torch.from_numpy(arr).permute(2, 0, 1).contiguous()
+            t = t.to(device=dev, dtype=torch.uint8, non_blocking=(dev.type == "cuda"))
+
+            x = model.preprocess(t, (h, w))
+            with torch.inference_mode():
+                with torch.autocast(device_type="cuda"):
+                    preds = model.invoke(x, (h, w))
+
+            # Normalize to (boxes, labels, scores)
+            boxes = None
+            labels = None
+            scores = None
+
+            if isinstance(preds, dict) and all(k in preds for k in ("boxes", "labels", "scores")):
+                boxes = preds.get("boxes")
+                labels = preds.get("labels")
+                scores = preds.get("scores")
+            else:
+                try:
+                    b, l, s = model.postprocess(preds)  # type: ignore[arg-type]
+                    boxes, labels, scores = b, l, s
+                except Exception:
+                    boxes = None
+
+            if boxes is None or labels is None or scores is None:
+                out[idx] = None
+                continue
+
+            boxes_l = _to_list(boxes)
+            labels_l = _to_list(labels)
+            scores_l = _to_list(scores)
+
+            # Flatten labels/scores shapes.
+            if isinstance(labels_l, list) and labels_l and isinstance(labels_l[0], list):
+                labels_l = [x[0] if isinstance(x, list) and x else x for x in labels_l]
+            if isinstance(scores_l, list) and scores_l and isinstance(scores_l[0], list):
+                scores_l = [x[0] if isinstance(x, list) and x else x for x in scores_l]
+
+            # Detect normalized coordinates.
+            mx = 0.0
+            try:
+                mx = float(max(max(b) for b in boxes_l)) if isinstance(boxes_l, list) and boxes_l else 0.0
+            except Exception:
+                mx = 0.0
+            normalized = mx <= 1.5
+
+            preds_by_label: Dict[str, List[List[float]]] = {"cell": [], "row": [], "column": []}
+            for b, lab, sc in zip(boxes_l, labels_l, scores_l):
+                if not (isinstance(b, list) and len(b) >= 4):
+                    continue
+                x1, y1, x2, y2 = [float(v) for v in b[:4]]
+                if normalized:
+                    x1, x2 = x1 * w, x2 * w
+                    y1, y2 = y1 * h, y2 * h
+                score = float(sc) if sc is not None else 0.0
+
+                label_name = None
+                if isinstance(lab, str):
+                    label_name = lab
+                else:
+                    try:
+                        label_name = id_to_label.get(int(lab))
+                    except Exception:
+                        label_name = None
+                if label_name not in preds_by_label:
+                    # Ignore unknown classes for table markdown joining.
+                    continue
+                preds_by_label[label_name].append([x1, y1, x2, y2, score])
+
+            out[idx] = preds_by_label
+        except Exception:
+            logger.exception("Local Nemotron table-structure failed for index=%s", idx)
+            out[idx] = None
+
+    return out
+
+
 def extract_table_data_from_image_internal(
     df_extraction_ledger: pd.DataFrame,
     task_config: Union[IngestTaskTableExtraction, Dict[str, Any]],
@@ -306,10 +700,6 @@ def extract_table_data_from_image_internal(
 
     endpoint_config = extraction_config.endpoint_config
 
-    # Get the grpc endpoint to determine the model if needed
-    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]
-    ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
-
     try:
         # 1) Identify rows that meet criteria (structured, subtype=table, table_metadata != None, content not empty)
         def meets_criteria(row):
@@ -346,28 +736,105 @@ def meets_criteria(row):
         )
         enable_yolox = True if table_content_format in (TableFormatEnum.MARKDOWN,) else False
 
-        yolox_client = _create_yolox_client(
-            endpoint_config.yolox_endpoints,
-            endpoint_config.yolox_infer_protocol,
-            endpoint_config.auth_token,
-        )
-        ocr_client = _create_ocr_client(
-            endpoint_config.ocr_endpoints,
-            endpoint_config.ocr_infer_protocol,
-            ocr_model_name,
-            endpoint_config.auth_token,
-        )
-
-        bulk_results = _update_table_metadata(
-            base64_images=base64_images,
-            yolox_client=yolox_client,
-            yolox_model_name=yolox_client.model_interface.model_name,
-            ocr_client=ocr_client,
-            ocr_model_name=ocr_model_name,
-            worker_pool_size=endpoint_config.workers_per_progress_engine,
-            enable_yolox=enable_yolox,
-            trace_info=execution_trace_log,
-        )
+        # Extract endpoints (may be empty/None -> local fallback).
+        yolox_endpoints = (None, None)
+        yolox_protocol = "local"
+        ocr_endpoints = (None, None)
+        ocr_protocol = "local"
+        auth_token = ""
+        workers = 5
+        if endpoint_config is not None:
+            yolox_endpoints = getattr(endpoint_config, "yolox_endpoints", (None, None))
+            yolox_protocol = getattr(endpoint_config, "yolox_infer_protocol", "") or "local"
+            ocr_endpoints = getattr(endpoint_config, "ocr_endpoints", (None, None))
+            ocr_protocol = getattr(endpoint_config, "ocr_infer_protocol", "") or "local"
+            auth_token = getattr(endpoint_config, "auth_token", "") or ""
+            workers = int(getattr(endpoint_config, "workers_per_progress_engine", 5) or 5)
+
+        has_yolox_endpoint = bool((yolox_endpoints[0] or yolox_endpoints[1]))
+        has_ocr_endpoint = bool((ocr_endpoints[0] or ocr_endpoints[1]))
+
+        # If markdown format requested but no YOLOX endpoints, use local table-structure model.
+        local_yolox_preds: Optional[List[Optional[Dict[str, Any]]]] = None
+        if enable_yolox and not has_yolox_endpoint:
+            local_yolox_preds = _local_nemotron_table_structure_cell_predictions(
+                base64_images,
+                trace_info=execution_trace_log,
+            )
+
+        # If OCR endpoints are not configured (or protocol is local), use local Nemotron OCR.
+        use_local_ocr = (not has_ocr_endpoint) or str(ocr_protocol).lower() == "local"
+        if use_local_ocr:
+            # Dump the exact images we will pass to OCR (after size filtering).
+            try:
+                valid_imgs, _valid_arrs, valid_pos = _filter_valid_images(base64_images)
+                df_idxs_for_valid = [valid_indices[p] for p in valid_pos]
+                _maybe_dump_ocr_input_images(
+                    df_extraction_ledger=df_extraction_ledger,
+                    df_indices=df_idxs_for_valid,
+                    base64_images=valid_imgs,
+                    backend_tag="hf",
+                )
+            except Exception:
+                pass
+            bulk_results = _local_nemotron_ocr_boxes_texts(
+                base64_images,
+                merge_level="paragraph",
+                trace_info=execution_trace_log,
+            )
+        else:
+            # Dump the exact images we will pass to OCR (after size filtering).
+            try:
+                valid_imgs, _valid_arrs, valid_pos = _filter_valid_images(base64_images)
+                df_idxs_for_valid = [valid_indices[p] for p in valid_pos]
+                _maybe_dump_ocr_input_images(
+                    df_extraction_ledger=df_extraction_ledger,
+                    df_indices=df_idxs_for_valid,
+                    base64_images=valid_imgs,
+                    backend_tag="nim",
+                )
+            except Exception:
+                pass
+            # Get the grpc endpoint to determine the model if needed
+            ocr_grpc_endpoint = ocr_endpoints[0]  # noqa: F841
+            # ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+            ocr_model_name = "scene_text_ensemble"
+
+            yolox_client = _create_yolox_client(
+                yolox_endpoints,
+                yolox_protocol,
+                auth_token,
+            )
+            ocr_client = _create_ocr_client(
+                ocr_endpoints,
+                ocr_protocol,
+                ocr_model_name,
+                auth_token,
+            )
+
+            bulk_results = _update_table_metadata(
+                base64_images=base64_images,
+                yolox_client=yolox_client,
+                yolox_model_name=yolox_client.model_interface.model_name,
+                ocr_client=ocr_client,
+                ocr_model_name=ocr_model_name,
+                worker_pool_size=workers,
+                enable_yolox=enable_yolox,
+                trace_info=execution_trace_log,
+            )
+
+        # If we ran local table-structure, splice its predictions into bulk_results.
+        if local_yolox_preds is not None:
+            merged: List[Tuple[str, Any, Any, Any]] = []
+            for i, rec in enumerate(bulk_results):
+                try:
+                    b64_img, _cell_preds, bbox, txts = rec
+                except Exception:
+                    merged.append(rec)
+                    continue
+                cell_preds = local_yolox_preds[i]
+                merged.append((b64_img, cell_preds, bbox, txts))
+            bulk_results = merged
 
         # 4) Write the results (bounding_boxes, text_predictions) back
         for row_id, idx in enumerate(valid_indices):
@@ -375,7 +842,7 @@ def meets_criteria(row):
             _, cell_predictions, bounding_boxes, text_predictions = bulk_results[row_id]
 
             if table_content_format == TableFormatEnum.SIMPLE:
-                table_content = " ".join(text_predictions)
+                table_content = " ".join(text_predictions) if text_predictions else ""
             elif table_content_format == TableFormatEnum.PSEUDO_MARKDOWN:
                 table_content = convert_ocr_response_to_psuedo_markdown(bounding_boxes, text_predictions)
             elif table_content_format == TableFormatEnum.MARKDOWN:
diff --git a/api/src/nv_ingest_api/internal/extract/pdf/engines/nemotron_parse.py b/api/src/nv_ingest_api/internal/extract/pdf/engines/nemotron_parse.py
index 7cf68ab6c..949a37d98 100644
--- a/api/src/nv_ingest_api/internal/extract/pdf/engines/nemotron_parse.py
+++ b/api/src/nv_ingest_api/internal/extract/pdf/engines/nemotron_parse.py
@@ -516,7 +516,10 @@ def _convert_pdfium_page_to_numpy_for_parser(
     padding_tuple: Tuple[int, int] = (NEMOTRON_PARSE_MAX_WIDTH, NEMOTRON_PARSE_MAX_HEIGHT),
 ) -> np.ndarray:
     page_images, padding_offsets = pdfium_pages_to_numpy(
-        [page], render_dpi=render_dpi, scale_tuple=scale_tuple, padding_tuple=padding_tuple
+        [page],
+        render_dpi=render_dpi,
+        scale_tuple=scale_tuple,
+        padding_tuple=padding_tuple,
     )
 
     return page_images[0], padding_offsets[0]
@@ -527,7 +530,11 @@ def _convert_pdfium_page_to_numpy_for_yolox(
     scale_tuple: Tuple[int, int] = (YOLOX_PAGE_IMAGE_PREPROC_WIDTH, YOLOX_PAGE_IMAGE_PREPROC_HEIGHT),
     padding_tuple: Tuple[int, int] = (YOLOX_PAGE_IMAGE_PREPROC_WIDTH, YOLOX_PAGE_IMAGE_PREPROC_HEIGHT),
 ) -> np.ndarray:
-    page_images, padding_offsets = pdfium_pages_to_numpy([page], scale_tuple=scale_tuple, padding_tuple=padding_tuple)
+    page_images, padding_offsets = pdfium_pages_to_numpy(
+        [page],
+        scale_tuple=scale_tuple,
+        padding_tuple=padding_tuple,
+    )
 
     return page_images[0], padding_offsets[0]
 
diff --git a/api/src/nv_ingest_api/internal/extract/pdf/engines/pdfium.py b/api/src/nv_ingest_api/internal/extract/pdf/engines/pdfium.py
index 5ddf13707..41386bb7e 100644
--- a/api/src/nv_ingest_api/internal/extract/pdf/engines/pdfium.py
+++ b/api/src/nv_ingest_api/internal/extract/pdf/engines/pdfium.py
@@ -435,6 +435,7 @@ def pdfium_extractor(
     text_extraction_method = extractor_config.get("extract_method", "pdfium")
     extract_images_method = extractor_config.get("extract_images_method", "group")
     extract_images_params = extractor_config.get("extract_images_params", {})
+    page_image_max_dimension = extractor_config.get("page_image_max_dimension", 1024)
 
     # Extract metadata_column
     metadata_column = extractor_config.get("metadata_column", "metadata")
@@ -555,7 +556,11 @@ def pdfium_extractor(
                     page_text = ""
                 else:
                     page_text = _extract_page_text(page)
-                image, _ = pdfium_pages_to_numpy([page], scale_tuple=(16384, 16384), trace_info=execution_trace_log)
+                image, _ = pdfium_pages_to_numpy(
+                    [page],
+                    scale_tuple=(page_image_max_dimension, page_image_max_dimension),
+                    trace_info=execution_trace_log,
+                )
                 base64_image = numpy_to_base64(image[0])
                 if len(base64_image) > 2**24 - 1:
                     base64_image, _ = scale_image_to_encoding_size(base64_image, max_base64_size=2**24 - 1)
@@ -572,13 +577,12 @@ def pdfium_extractor(
 
             # If we want OCR extraction, rasterize the page and store it
             if extraction_needed_for_text or extraction_needed_for_structured:
-                image, padding_offsets = pdfium_pages_to_numpy(
+                image, _ = pdfium_pages_to_numpy(
                     [page],
                     scale_tuple=(YOLOX_PAGE_IMAGE_PREPROC_WIDTH, YOLOX_PAGE_IMAGE_PREPROC_HEIGHT),
-                    padding_tuple=(YOLOX_PAGE_IMAGE_PREPROC_WIDTH, YOLOX_PAGE_IMAGE_PREPROC_HEIGHT),
                     trace_info=execution_trace_log,
                 )
-                pages_for_extractions.append((page_idx, image[0], padding_offsets[0]))
+                pages_for_extractions.append((page_idx, image[0], (0, 0)))  # No padding offset
 
                 # Whenever pages_for_extractions hits YOLOX_MAX_BATCH_SIZE, submit a job
                 if len(pages_for_extractions) >= YOLOX_MAX_BATCH_SIZE:
diff --git a/api/src/nv_ingest_api/internal/mutate/deduplicate.py b/api/src/nv_ingest_api/internal/mutate/deduplicate.py
index 444042c7d..8481b36fd 100644
--- a/api/src/nv_ingest_api/internal/mutate/deduplicate.py
+++ b/api/src/nv_ingest_api/internal/mutate/deduplicate.py
@@ -4,7 +4,8 @@
 
 import logging
 import hashlib
-from typing import Any, Dict, Optional, List
+from collections import defaultdict
+from typing import Any, Dict, Optional, List, Tuple, Set
 
 import pandas as pd
 
@@ -14,6 +15,251 @@
 logger = logging.getLogger(__name__)
 
 
+def calculate_iou(bbox1: Tuple[float, ...], bbox2: Tuple[float, ...]) -> float:
+    """
+    Calculate Intersection over Union (IoU) for two bounding boxes.
+
+    Boxes are in format (x1, y1, x2, y2) where (x1, y1) is the top-left corner
+    and (x2, y2) is the bottom-right corner.
+
+    Parameters
+    ----------
+    bbox1 : tuple
+        First bounding box as (x1, y1, x2, y2).
+    bbox2 : tuple
+        Second bounding box as (x1, y1, x2, y2).
+
+    Returns
+    -------
+    float
+        IoU value between 0.0 and 1.0.
+    """
+    x1_1, y1_1, x2_1, y2_1 = bbox1[:4]
+    x1_2, y1_2, x2_2, y2_2 = bbox2[:4]
+
+    # Calculate intersection coordinates
+    x1_inter = max(x1_1, x1_2)
+    y1_inter = max(y1_1, y1_2)
+    x2_inter = min(x2_1, x2_2)
+    y2_inter = min(y2_1, y2_2)
+
+    # Check for no intersection
+    if x2_inter <= x1_inter or y2_inter <= y1_inter:
+        return 0.0
+
+    intersection_area = (x2_inter - x1_inter) * (y2_inter - y1_inter)
+
+    # Calculate areas
+    area1 = (x2_1 - x1_1) * (y2_1 - y1_1)
+    area2 = (x2_2 - x1_2) * (y2_2 - y1_2)
+    union_area = area1 + area2 - intersection_area
+
+    if union_area <= 0:
+        return 0.0
+
+    return intersection_area / union_area
+
+
+def _normalize_bbox(bbox: Tuple[float, ...], max_dimensions: Tuple[float, float]) -> Tuple[float, float, float, float]:
+    """
+    Normalize bounding box coordinates by max dimensions.
+
+    Parameters
+    ----------
+    bbox : tuple
+        Bounding box as (x1, y1, x2, y2).
+    max_dimensions : tuple
+        Max dimensions as (max_width, max_height).
+
+    Returns
+    -------
+    tuple
+        Normalized bounding box as (x1, y1, x2, y2) with values in [0, 1].
+    """
+    x1, y1, x2, y2 = bbox[:4]
+    max_width, max_height = max_dimensions
+
+    if max_width <= 0 or max_height <= 0:
+        # Cannot normalize, return original bbox
+        return (x1, y1, x2, y2)
+
+    return (x1 / max_width, y1 / max_height, x2 / max_width, y2 / max_height)
+
+
+def _get_image_bbox_info(row: pd.Series) -> Optional[Dict[str, Any]]:
+    """
+    Extract normalized bounding box info from an IMAGE row.
+
+    Parameters
+    ----------
+    row : pd.Series
+        DataFrame row with metadata.
+
+    Returns
+    -------
+    dict or None
+        Dictionary with 'page', 'bbox' (normalized), and 'index', or None if bbox not available.
+    """
+    try:
+        metadata = row.get("metadata", {})
+        if not isinstance(metadata, dict):
+            return None
+
+        content_metadata = metadata.get("content_metadata", {})
+        image_metadata = metadata.get("image_metadata", {})
+
+        page = content_metadata.get("page_number", -1)
+        bbox = image_metadata.get("image_location")
+        max_dims = image_metadata.get("image_location_max_dimensions", (0, 0))
+
+        if bbox is None or not isinstance(bbox, (tuple, list)) or len(bbox) < 4:
+            return None
+
+        # Normalize bbox by max dimensions
+        if max_dims and len(max_dims) >= 2 and max_dims[0] > 0 and max_dims[1] > 0:
+            normalized_bbox = _normalize_bbox(tuple(bbox[:4]), tuple(max_dims[:2]))
+        else:
+            normalized_bbox = tuple(bbox[:4])
+
+        return {"page": page, "bbox": normalized_bbox, "index": row.name}
+    except Exception:
+        return None
+
+
+def _get_structured_bbox_info(row: pd.Series) -> Optional[Dict[str, Any]]:
+    """
+    Extract normalized bounding box info from a STRUCTURED row (table/chart/infographic).
+
+    Parameters
+    ----------
+    row : pd.Series
+        DataFrame row with metadata.
+
+    Returns
+    -------
+    dict or None
+        Dictionary with 'page', 'bbox' (normalized), 'index', and 'subtype', or None if bbox not available.
+    """
+    try:
+        metadata = row.get("metadata", {})
+        if not isinstance(metadata, dict):
+            return None
+
+        content_metadata = metadata.get("content_metadata", {})
+        table_metadata = metadata.get("table_metadata", {})
+
+        page = content_metadata.get("page_number", -1)
+        subtype = content_metadata.get("subtype", "")
+        bbox = table_metadata.get("table_location")
+        max_dims = table_metadata.get("table_location_max_dimensions", (0, 0))
+
+        if bbox is None or not isinstance(bbox, (tuple, list)) or len(bbox) < 4:
+            return None
+
+        # Normalize bbox by max dimensions
+        if max_dims and len(max_dims) >= 2 and max_dims[0] > 0 and max_dims[1] > 0:
+            normalized_bbox = _normalize_bbox(tuple(bbox[:4]), tuple(max_dims[:2]))
+        else:
+            normalized_bbox = tuple(bbox[:4])
+
+        return {"page": page, "bbox": normalized_bbox, "index": row.name, "subtype": subtype}
+    except Exception:
+        return None
+
+
+def deduplicate_by_bbox_internal(
+    df_ledger: pd.DataFrame,
+    iou_threshold: float = 0.45,
+    prefer_structured: bool = True,
+) -> pd.DataFrame:
+    """
+    Remove duplicate visual elements based on bounding box overlap.
+
+    When an IMAGE element's bounding box substantially overlaps with a STRUCTURED
+    element (table/chart/infographic) on the same page, one is removed based on
+    the prefer_structured flag.
+
+    Parameters
+    ----------
+    df_ledger : pd.DataFrame
+        DataFrame with document_type, metadata columns.
+    iou_threshold : float
+        Minimum IoU to consider elements as duplicates (default 0.4).
+    prefer_structured : bool
+        If True, keep structured elements and drop images when duplicates found.
+        If False, keep images and drop structured elements.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with bbox-based duplicates removed.
+    """
+    # Identify rows by type
+    image_mask = df_ledger["document_type"] == ContentTypeEnum.IMAGE
+    structured_mask = df_ledger["document_type"] == ContentTypeEnum.STRUCTURED
+
+    if not image_mask.any() or not structured_mask.any():
+        return df_ledger  # Nothing to deduplicate
+
+    # Extract bounding box info for each type
+    image_infos = []
+    for idx in df_ledger[image_mask].index:
+        info = _get_image_bbox_info(df_ledger.loc[idx])
+        if info is not None:
+            image_infos.append(info)
+
+    structured_infos = []
+    for idx in df_ledger[structured_mask].index:
+        info = _get_structured_bbox_info(df_ledger.loc[idx])
+        if info is not None:
+            structured_infos.append(info)
+
+    if not image_infos or not structured_infos:
+        return df_ledger
+
+    # Group by page for efficient comparison
+    images_by_page: Dict[int, List[Dict[str, Any]]] = defaultdict(list)
+    for info in image_infos:
+        images_by_page[info["page"]].append(info)
+
+    structured_by_page: Dict[int, List[Dict[str, Any]]] = defaultdict(list)
+    for info in structured_infos:
+        structured_by_page[info["page"]].append(info)
+
+    # Find duplicates by comparing bounding boxes on the same page
+    indices_to_drop: Set[Any] = set()
+
+    for page in images_by_page:
+        if page not in structured_by_page:
+            continue
+
+        for image_info in images_by_page[page]:
+            if image_info["index"] in indices_to_drop:
+                continue  # Already marked for removal
+
+            for struct_info in structured_by_page[page]:
+                if struct_info["index"] in indices_to_drop:
+                    continue  # Already marked for removal
+
+                iou = calculate_iou(image_info["bbox"], struct_info["bbox"])
+
+                if iou >= iou_threshold:
+                    # Found a duplicate pair
+                    if prefer_structured:
+                        indices_to_drop.add(image_info["index"])
+                    else:
+                        indices_to_drop.add(struct_info["index"])
+                    break  # One match is enough to mark as duplicate
+
+    if not indices_to_drop:
+        return df_ledger
+
+    logger.info(f"Bbox dedup: Removed {len(indices_to_drop)} duplicate elements")
+    result = df_ledger.drop(index=list(indices_to_drop))
+
+    return result
+
+
 def _hash_content(x: Any, algorithm: str = "md5") -> bytes:
     """
     Compute a hash of the content using the specified algorithm.
@@ -45,12 +291,15 @@ def deduplicate_images_internal(
     execution_trace_log: Optional[List[Any]] = None,
 ) -> pd.DataFrame:
     """
-    Deduplicate images in a DataFrame based on content hashes.
+    Deduplicate images in a DataFrame based on content hashes and/or bounding box overlap.
 
     The function processes rows where the 'document_type' is IMAGE, computes a content hash for each,
     and then either removes duplicates or marks them based on the 'filter' flag in task_config.
     A 'hash_algorithm' flag in task_config determines the algorithm used for hashing.
 
+    Additionally, if 'enable_bbox_dedup' is True, removes images that substantially overlap
+    with structured elements (tables/charts) based on IoU threshold.
+
     Parameters
     ----------
     df_ledger : pd.DataFrame
@@ -59,6 +308,9 @@ def deduplicate_images_internal(
         Configuration parameters, including:
             - "filter": bool, if True duplicate rows are removed; if False, duplicates are marked.
             - "hash_algorithm": str, the algorithm to use for hashing (default "md5").
+            - "enable_bbox_dedup": bool, if True also deduplicate by bounding box overlap.
+            - "iou_threshold": float, IoU threshold for bbox dedup (default 0.45).
+            - "bbox_dedup_prefer_structured": bool, if True keep structured elements (default True).
     mutate_config : ImageDedupSchema, optional
     execution_trace_log : Optional[List[Any]], optional
 
@@ -84,24 +336,40 @@ def deduplicate_images_internal(
             if col not in df_ledger.columns:
                 raise ValueError(f"Missing required column '{col}'.")
 
-        # Select image rows.
-        image_mask = df_ledger["document_type"] == ContentTypeEnum.IMAGE
-        if not image_mask.any():
-            return df_ledger[~image_mask]
+        result = df_ledger
+
+        # Parameters are nested inside "params" key from task_properties
+        params = task_config.get("params", {})
+
+        # Content-hash based deduplication for images
+        image_mask = result["document_type"] == ContentTypeEnum.IMAGE
+        if image_mask.any():
+            df_images = result.loc[image_mask].copy()
+            hash_algorithm = params.get("hash_algorithm", "md5")
+
+            # Compute content hash for each image.
+            df_images["_image_content_hash"] = df_images["metadata"].apply(_hash_content, args=(hash_algorithm,))
+            df_images_deduped = df_images.drop_duplicates(subset="_image_content_hash")
+            deduped_indices = df_images_deduped.index
+
+            non_image_rows = result.loc[~image_mask]
+            deduped_images = df_images.loc[deduped_indices][result.columns.difference(["_image_content_hash"])]
+
+            result = pd.concat([deduped_images, non_image_rows], axis=0)
 
-        df_images = df_ledger.loc[image_mask].copy()
-        hash_algorithm = task_config.get("hash_algorithm", "md5")
+        # Bounding box based deduplication (enabled by default)
+        enable_bbox_dedup = params.get("enable_bbox_dedup", True)
 
-        # Compute content hash for each image.
-        df_images["_image_content_hash"] = df_images["metadata"].apply(_hash_content, args=(hash_algorithm,))
-        df_images_deduped = df_images.drop_duplicates(subset="_image_content_hash")
-        deduped_indices = df_images_deduped.index
+        if enable_bbox_dedup:
+            iou_threshold = params.get("iou_threshold", 0.45)
 
-        non_image_rows = df_ledger.loc[~image_mask]
-        deduped_images = df_images.loc[deduped_indices][df_ledger.columns.difference(["_image_content_hash"])]
+            prefer_structured = params.get("bbox_dedup_prefer_structured", True)
 
-        result, execution_trace_log = pd.concat([deduped_images, non_image_rows], axis=0), {}
-        _ = execution_trace_log
+            result = deduplicate_by_bbox_internal(
+                df_ledger=result,
+                iou_threshold=iou_threshold,
+                prefer_structured=prefer_structured,
+            )
 
         return result
     except Exception as e:
diff --git a/api/src/nv_ingest_api/internal/primitives/nim/model_interface/yolox.py b/api/src/nv_ingest_api/internal/primitives/nim/model_interface/yolox.py
index 8045d470a..ecba3f8d2 100644
--- a/api/src/nv_ingest_api/internal/primitives/nim/model_interface/yolox.py
+++ b/api/src/nv_ingest_api/internal/primitives/nim/model_interface/yolox.py
@@ -5,6 +5,7 @@
 import os
 import logging
 import warnings
+import threading
 from math import log
 from typing import Any
 from typing import Dict
@@ -28,6 +29,9 @@
 
 YOLOX_PAGE_DEFAULT_VERSION = "nemoretriever-page-elements-v3"
 
+# Note: local-vs-remote selection is driven by `infer_protocol` ("local" vs "grpc"/"http")
+# at the `create_inference_client(...)` layer, not by environment variables.
+
 # yolox-page-elements-v2 and v3 common contants
 YOLOX_PAGE_CONF_THRESHOLD = 0.01
 YOLOX_PAGE_IOU_THRESHOLD = 0.5
@@ -392,11 +396,23 @@ class YoloxPageElementsModelInterface(YoloxModelInterfaceBase):
     An interface for handling inference with yolox-page-elements model, supporting both gRPC and HTTP protocols.
     """
 
-    def __init__(self, version: str = YOLOX_PAGE_DEFAULT_VERSION, endpoints: Optional[Tuple[str, str]] = None):
+    # ---- Local Nemotron singleton (lazy) ----
+    _local_nemotron_lock = threading.Lock()
+    _local_nemotron_instance = None
+    _local_nemotron_device = None
+
+    def __init__(
+        self,
+        version: str = YOLOX_PAGE_DEFAULT_VERSION,
+        endpoints: Optional[Tuple[str, str]] = None,
+        *,
+        backend: Optional[str] = None,
+    ):
         """
         Initialize the yolox-page-elements model interface.
         """
         self.version = version
+        self.backend = (backend or "nim").strip().lower()
 
         super().__init__(
             nim_max_image_size=YOLOX_PAGE_NIM_MAX_IMAGE_SIZE,
@@ -407,6 +423,200 @@ def __init__(self, version: str = YOLOX_PAGE_DEFAULT_VERSION, endpoints: Optiona
             endpoints=endpoints,
         )
 
+    @classmethod
+    def _get_local_nemotron_page_elements_v3(cls, *, device: Optional[str] = None):
+        """
+        Lazily create and return a process-wide singleton NemotronPageElementsV3 model.
+
+        Notes
+        -----
+        - Imports are deferred so the API can run without nemo-retriever/torch installed unless local backend is used.
+        - Device selection is best-effort; tensors are moved to the chosen device before invocation.
+        """
+        if cls._local_nemotron_instance is not None:
+            return cls._local_nemotron_instance, cls._local_nemotron_device
+
+        with cls._local_nemotron_lock:
+            if cls._local_nemotron_instance is not None:
+                return cls._local_nemotron_instance, cls._local_nemotron_device
+
+            try:
+                import torch  # local-only dependency
+            except Exception as e:  # pragma: no cover
+                raise RuntimeError(
+                    "Local YOLOX backend requested but 'torch' is not available. "
+                    "Install the nemo-retriever/local model dependencies or run with infer_protocol='grpc'/'http'."
+                ) from e
+
+            try:
+                # Import path used by nemo_retriever stages.
+                from nemo_retriever.model.local.nemotron_page_elements_v3 import NemotronPageElementsV3  # type: ignore
+            except Exception as e:  # pragma: no cover
+                raise RuntimeError(
+                    "Local YOLOX backend requested but 'nemo-retriever' package is not importable. "
+                    "Ensure the 'nemo-retriever' project is installed on the PYTHONPATH, or "
+                    "run with infer_protocol='grpc'/'http' and backend='local'."  # noqa: E501
+                ) from e
+
+            # Choose device (default: cuda if available else cpu).
+            dev_str = (device or "").strip()
+            if dev_str:
+                dev = torch.device(dev_str)
+            else:
+                dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+            model = NemotronPageElementsV3()
+            # Best-effort: move underlying module to device if present.
+            try:
+                if hasattr(model, "_model") and model._model is not None:
+                    model._model = model._model.to(dev)  # type: ignore[attr-defined]
+            except Exception:
+                # Some wrappers manage device internally; we'll always move tensors below.
+                pass
+
+            cls._local_nemotron_instance = model
+            cls._local_nemotron_device = dev
+            logger.info(f"Initialized local NemotronPageElementsV3 singleton on device={dev}.")
+
+            return cls._local_nemotron_instance, cls._local_nemotron_device
+
+    def infer(self, data: Dict[str, Any], **kwargs) -> List[Dict[str, Any]]:
+        """
+        Unified inference entrypoint.
+
+        - backend="nim": this interface is meant to be invoked via NimClient (existing behavior).
+        - backend="local": runs a local singleton NemotronPageElementsV3 and returns yolox-style annotations.
+        """
+        if self.backend == "local":
+            return self._infer_local_nemotron_page_elements_v3(data, **kwargs)
+
+        raise RuntimeError(
+            "YoloxPageElementsModelInterface.infer() is only supported for backend='local'. "
+            "For backend='nim', construct a NimClient and call NimClient.infer()."
+        )
+
+    def _infer_local_nemotron_page_elements_v3(self, data: Dict[str, Any], **kwargs) -> List[Dict[str, Any]]:
+        """
+        Local inference using Nemotron Page Elements v3.
+
+        Returns
+        -------
+        List[Dict[str, Any]]
+            Same structure as NimClient inference results for yolox-page-elements:
+            per image: {label: [[x1,y1,x2,y2,score], ...], ...} with coordinates in original pixel space.
+        """
+        # Validate + record original shapes.
+        data = self.prepare_data_for_inference(data)
+        images = data.get("images", [])
+        if not images:
+            return []
+
+        # Nemotron label id mapping used by nemo_retriever local stages.
+        # Nemotron emits "text" where nv-ingest yolox expects "paragraph".
+        id_to_label = {
+            0: "table",
+            1: "chart",
+            2: "title",
+            3: "infographic",
+            4: "paragraph",  # nemotron: "text"
+            5: "header_footer",
+        }
+        alias_label = {"text": "paragraph"}
+
+        model, dev = self._get_local_nemotron_page_elements_v3(device=kwargs.get("device"))
+
+        try:
+            import torch  # local-only dependency
+        except Exception as e:  # pragma: no cover
+            raise RuntimeError("Local YOLOX backend requested but 'torch' is not available.") from e
+
+        # Convert numpy HWC -> torch CHW uint8 on device; preprocess (resize/pad).
+        tensors: List["torch.Tensor"] = []
+        orig_shapes_hw: List[Tuple[int, int]] = []
+        for img in images:
+            if not isinstance(img, np.ndarray):
+                raise ValueError("All elements in data['images'] must be numpy.ndarray objects for local inference.")
+            if img.ndim != 3 or img.shape[2] not in (3, 4):
+                raise ValueError(f"Expected HWC RGB/RGBA image; got shape={getattr(img, 'shape', None)}")
+
+            # Ensure RGB uint8.
+            if img.shape[2] == 4:
+                img = img[:, :, :3]
+            if img.dtype != np.uint8:
+                img = (img * 255).astype(np.uint8) if np.issubdtype(img.dtype, np.floating) else img.astype(np.uint8)
+
+            h, w = int(img.shape[0]), int(img.shape[1])
+            orig_shapes_hw.append((h, w))
+
+            t = torch.from_numpy(img).permute(2, 0, 1).contiguous()
+            t = t.to(device=dev, dtype=torch.uint8, non_blocking=(getattr(dev, "type", "") == "cuda"))
+            tensors.append(model.preprocess(t))
+
+        # Best-effort batching (mirrors nemo_retriever local stage behavior).
+        per_image_preds: Optional[List[Any]] = None
+        with torch.inference_mode():
+            with torch.autocast(device_type="cuda"):
+                try:
+                    batch_tensor = torch.stack(tensors, dim=0)
+                    m = model.model  # may raise if remote-only
+                    try:
+                        raw = m(batch_tensor, list(orig_shapes_hw))
+                    except Exception:
+                        raw = m(batch_tensor, orig_shapes_hw[0])
+                    raw0 = raw[0] if isinstance(raw, (tuple, list)) and len(raw) > 0 else raw
+                    if isinstance(raw0, list) and len(raw0) == int(batch_tensor.shape[0]):
+                        per_image_preds = raw0
+                except Exception:
+                    per_image_preds = None
+
+                annotation_dicts: List[Dict[str, Any]] = []
+                for i in range(len(tensors)):
+                    preds = (
+                        per_image_preds[i]
+                        if per_image_preds is not None
+                        else model.invoke(tensors[i], orig_shapes_hw[i])
+                    )
+                    boxes, labels, scores = model.postprocess(preds)
+
+                ann: Dict[str, List[List[float]]] = {lab: [] for lab in YOLOX_PAGE_V3_CLASS_LABELS}
+                for box, lab, score in zip(boxes, labels, scores):
+                    # coerce label -> string
+                    if isinstance(lab, str):
+                        label_name = alias_label.get(lab, lab)
+                    else:
+                        try:
+                            lab_i = int(lab.item()) if hasattr(lab, "item") else int(lab)
+                        except Exception:
+                            continue
+                        label_name = id_to_label.get(lab_i, f"unknown_{lab_i}")
+
+                    if label_name not in ann:
+                        # Ignore unknown labels rather than polluting downstream keys.
+                        continue
+
+                    # box is xyxy normalized
+                    if hasattr(box, "detach"):
+                        box_list = box.detach().cpu().tolist()
+                    else:
+                        box_list = box.tolist() if hasattr(box, "tolist") else list(box)
+
+                    try:
+                        s = float(score.item()) if hasattr(score, "item") else float(score)
+                    except Exception:
+                        s = 0.0
+
+                    ann[label_name].append(
+                        [float(box_list[0]), float(box_list[1]), float(box_list[2]), float(box_list[3]), s]
+                    )
+
+                annotation_dicts.append(ann)
+
+        # Reuse the existing nv-ingest postprocessing + coord transform.
+        return self.postprocess_annotations(
+            annotation_dicts,
+            original_image_shapes=data.get("original_image_shapes", []),
+        )
+
     def name(
         self,
     ) -> str:
@@ -424,7 +634,16 @@ def name(
     def postprocess_annotations(self, annotation_dicts, final_score=None, **kwargs):
         original_image_shapes = kwargs.get("original_image_shapes", [])
 
-        running_v3 = annotation_dicts and set(YOLOX_PAGE_V3_CLASS_LABELS) <= annotation_dicts[0].keys()
+        # Decide v2 vs v3 post-processing.
+        #
+        # IMPORTANT: Do not infer v3 purely from output keys.
+        # It's common for model outputs (especially gRPC JSON) to omit classes that had no detections
+        # on a given page, which would incorrectly skip v3 post-processing for v3 models.
+        running_v3 = str(getattr(self, "version", "")).endswith("-v3")
+        if (not running_v3) and annotation_dicts:
+            # Back-compat / best-effort auto-detect if version string isn't v3.
+            # Treat presence of any v3-only classes as v3.
+            running_v3 = any(k in annotation_dicts[0] for k in ("paragraph", "header_footer"))
 
         if not final_score:
             if running_v3:
@@ -485,10 +704,21 @@ class YoloxGraphicElementsModelInterface(YoloxModelInterfaceBase):
     An interface for handling inference with yolox-graphic-elemenents model, supporting both gRPC and HTTP protocols.
     """
 
-    def __init__(self, endpoints: Optional[Tuple[str, str]] = None):
+    # ---- Local Nemotron singleton (lazy) ----
+    _local_nemotron_lock = threading.Lock()
+    _local_nemotron_instance = None
+    _local_nemotron_device = None
+
+    def __init__(
+        self,
+        endpoints: Optional[Tuple[str, str]] = None,
+        *,
+        backend: Optional[str] = None,
+    ):
         """
         Initialize the yolox-graphic-elements model interface.
         """
+        self.backend = (backend or "nim").strip().lower()
         super().__init__(
             nim_max_image_size=YOLOX_GRAPHIC_NIM_MAX_IMAGE_SIZE,
             conf_threshold=YOLOX_GRAPHIC_CONF_THRESHOLD,
@@ -497,6 +727,255 @@ def __init__(self, endpoints: Optional[Tuple[str, str]] = None):
             class_labels=YOLOX_GRAPHIC_CLASS_LABELS,
             endpoints=endpoints,
         )
+        # Ensure a stable model_name even when endpoints are absent (common for local backend).
+        if not hasattr(self, "model_name") or not getattr(self, "model_name", None):
+            self.model_name = "yolox-graphic-elements"
+
+    @classmethod
+    def _get_local_nemotron_graphic_elements_v1(cls, *, device: Optional[str] = None):
+        """
+        Lazily create and return a process-wide singleton Nemotron Graphic Elements v1 model.
+
+        Note
+        ----
+        This intentionally avoids importing the monorepo `nemo-retriever` package so local
+        chart extraction can work in environments where only `nv_ingest_api` + the
+        Nemotron HF packages are installed.
+        """
+        if cls._local_nemotron_instance is not None:
+            return cls._local_nemotron_instance, cls._local_nemotron_device
+
+        with cls._local_nemotron_lock:
+            if cls._local_nemotron_instance is not None:
+                return cls._local_nemotron_instance, cls._local_nemotron_device
+
+            try:
+                import torch  # local-only dependency
+            except Exception as e:  # pragma: no cover
+                raise RuntimeError(
+                    "Local YOLOX (graphic-elements) backend requested but 'torch' is not available. "
+                    "Install the nemo-retriever/local model dependencies or run with infer_protocol='grpc'/'http'."
+                ) from e
+
+            try:
+                from nemotron_graphic_elements_v1.model import (  # type: ignore
+                    define_model as define_model_graphic_elements,
+                )
+                from nemotron_graphic_elements_v1.model import (  # type: ignore
+                    resize_pad as resize_pad_graphic_elements,
+                )
+            except Exception as e:  # pragma: no cover
+                raise RuntimeError(
+                    "Local YOLOX (graphic-elements) backend requested but the "
+                    "`nemotron-graphic-elements-v1` package is not importable. "
+                    "Install it (and its deps) or run with infer_protocol='grpc'/'http'."
+                ) from e
+
+            dev_str = (device or "").strip()
+            if dev_str:
+                dev = torch.device(dev_str)
+            else:
+                dev = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+            # Create minimal wrapper matching the methods we use in local inference.
+            # Use the same model id string used by the nemo_retriever shim.
+            model_id = "Nemotron Graphic Elements v1"
+            hf_model = define_model_graphic_elements(model_id)
+            input_shape = (1024, 1024)
+
+            # Best-effort: move underlying module to device if present.
+            try:
+                if hf_model is not None and hasattr(hf_model, "to"):
+                    hf_model = hf_model.to(dev)
+            except Exception:
+                pass
+
+            class _LocalNemotronGraphicElements:
+                def __init__(self, m, shape):
+                    self._model = m
+                    self._shape = shape
+
+                @property
+                def input_shape(self):
+                    return self._shape
+
+                def preprocess(self, tensor):
+                    return resize_pad_graphic_elements(tensor, self.input_shape)
+
+                def invoke(self, input_data, orig_shape):
+                    if self._model is None:
+                        raise RuntimeError("Local Nemotron Graphic Elements v1 model was not initialized.")
+                    return self._model(input_data, orig_shape)[0]
+
+            model = _LocalNemotronGraphicElements(hf_model, input_shape)
+
+            cls._local_nemotron_instance = model
+            cls._local_nemotron_device = dev
+            logger.info(f"Initialized local NemotronGraphicElementsV1 singleton on device={dev}.")
+
+            return cls._local_nemotron_instance, cls._local_nemotron_device
+
+    def infer(self, data: Dict[str, Any], **kwargs) -> List[Dict[str, Any]]:
+        """
+        Unified inference entrypoint.
+
+        - backend="nim": this interface is meant to be invoked via NimClient (existing behavior).
+        - backend="local": runs a local NemotronGraphicElementsV1 and returns yolox-style annotations.
+        """
+        if self.backend == "local":
+            return self._infer_local_nemotron_graphic_elements_v1(data, **kwargs)
+
+        raise RuntimeError(
+            "YoloxGraphicElementsModelInterface.infer() is only supported for backend='local'. "
+            "For backend='nim', construct a NimClient and call NimClient.infer()."
+        )
+
+    def _infer_local_nemotron_graphic_elements_v1(self, data: Dict[str, Any], **kwargs) -> List[Dict[str, Any]]:
+        """
+        Local inference using Nemotron Graphic Elements v1.
+
+        Returns:
+          per image: {label: [[x1,y1,x2,y2], ...], ...} with coordinates in original pixel space.
+        """
+        data = self.prepare_data_for_inference(data)
+        images = data.get("images", [])
+        if not images:
+            return []
+
+        model, dev = self._get_local_nemotron_graphic_elements_v1(device=kwargs.get("device"))
+
+        try:
+            import torch  # local-only dependency
+        except Exception as e:  # pragma: no cover
+            raise RuntimeError("Local YOLOX backend requested but 'torch' is not available.") from e
+
+        def _to_list(v: Any) -> Any:
+            try:
+                if isinstance(v, torch.Tensor):
+                    return v.detach().cpu().tolist()
+                if isinstance(v, np.ndarray):
+                    return v.tolist()
+            except Exception:
+                pass
+            return v
+
+        def _extract_boxes_labels_scores(preds: Any) -> Tuple[Any, Any, Any]:
+            # Common shapes emitted by HF detectors: dict with keys.
+            if isinstance(preds, dict):
+                # IMPORTANT: do not use `or` directly on torch.Tensors (truthiness is ambiguous).
+                def _first_present(d: Dict[str, Any], keys: List[str]) -> Any:
+                    for k in keys:
+                        if k in d and d.get(k) is not None:
+                            return d.get(k)
+                    return None
+
+                boxes = _first_present(preds, ["boxes", "bboxes", "pred_boxes"])
+                labels = _first_present(preds, ["labels", "classes", "pred_classes"])
+                scores = _first_present(preds, ["scores", "confidences", "pred_scores"])
+                return boxes, labels, scores
+            # Sometimes wrapped as list/tuple with dict payload.
+            if isinstance(preds, (list, tuple)) and preds:
+                p0 = preds[0]
+                if isinstance(p0, dict):
+                    return _extract_boxes_labels_scores(p0)
+            return None, None, None
+
+        # Convert images to torch tensors and run per-image (best-effort batching handled by underlying model).
+        annotation_dicts: List[Dict[str, Any]] = []
+        orig_shapes = data.get("original_image_shapes", [])
+        for img, shape in zip(images, orig_shapes):
+            if not isinstance(img, np.ndarray):
+                raise ValueError("All elements in data['images'] must be numpy.ndarray objects for local inference.")
+            if img.ndim != 3 or img.shape[2] not in (3, 4):
+                raise ValueError(f"Expected HWC RGB/RGBA image; got shape={getattr(img, 'shape', None)}")
+
+            # Ensure RGB uint8.
+            if img.shape[2] == 4:
+                img = img[:, :, :3]
+            if img.dtype != np.uint8:
+                img = (img * 255).astype(np.uint8) if np.issubdtype(img.dtype, np.floating) else img.astype(np.uint8)
+
+            h, w = int(img.shape[0]), int(img.shape[1])
+            t = torch.from_numpy(img).permute(2, 0, 1).contiguous()
+            t = t.to(device=dev, dtype=torch.uint8, non_blocking=(getattr(dev, "type", "") == "cuda"))
+            x = model.preprocess(t)
+
+            with torch.inference_mode():
+                with torch.autocast(device_type="cuda"):
+                    preds = model.invoke(x, (h, w))
+
+            boxes, labels, scores = _extract_boxes_labels_scores(preds)
+            boxes_l = _to_list(boxes) if boxes is not None else []
+            labels_l = _to_list(labels) if labels is not None else []
+            scores_l = _to_list(scores) if scores is not None else []
+
+            # Normalize shapes.
+            if not isinstance(boxes_l, list):
+                boxes_l = []
+            if not isinstance(labels_l, list):
+                labels_l = []
+            if not isinstance(scores_l, list):
+                scores_l = []
+
+            n = min(len(boxes_l), len(labels_l), len(scores_l)) if scores_l else min(len(boxes_l), len(labels_l))
+            if not scores_l:
+                scores_l = [1.0 for _ in range(n)]
+
+            # If labels are tensors nested, try flatten.
+            if labels_l and isinstance(labels_l[0], list):
+                labels_l = [x[0] if isinstance(x, list) and x else x for x in labels_l]
+            if scores_l and isinstance(scores_l[0], list):
+                scores_l = [x[0] if isinstance(x, list) and x else x for x in scores_l]
+
+            # Determine if boxes are pixel coords (values > 1) vs normalized.
+            mx = 0.0
+            try:
+                mx = float(max(max(b[:4]) for b in boxes_l[:n])) if n else 0.0
+            except Exception:
+                mx = 0.0
+            is_normalized = mx <= 1.5
+
+            ann: Dict[str, List[List[float]]] = {lab: [] for lab in YOLOX_GRAPHIC_CLASS_LABELS}
+
+            for b, lab, sc in zip(boxes_l[:n], labels_l[:n], scores_l[:n]):
+                if not (isinstance(b, list) and len(b) >= 4):
+                    continue
+                x1, y1, x2, y2 = [float(v) for v in b[:4]]
+                if not is_normalized:
+                    # Convert pixels -> normalized.
+                    if w > 0 and h > 0:
+                        x1, x2 = x1 / float(w), x2 / float(w)
+                        y1, y2 = y1 / float(h), y2 / float(h)
+                # Clamp.
+                x1 = max(0.0, min(1.0, x1))
+                y1 = max(0.0, min(1.0, y1))
+                x2 = max(0.0, min(1.0, x2))
+                y2 = max(0.0, min(1.0, y2))
+
+                label_name: Optional[str] = None
+                if isinstance(lab, str):
+                    label_name = lab
+                else:
+                    try:
+                        li = int(lab.item()) if hasattr(lab, "item") else int(lab)
+                        if 0 <= li < len(YOLOX_GRAPHIC_CLASS_LABELS):
+                            label_name = YOLOX_GRAPHIC_CLASS_LABELS[li]
+                    except Exception:
+                        label_name = None
+
+                if label_name not in ann:
+                    continue
+                try:
+                    score = float(sc.item()) if hasattr(sc, "item") else float(sc)
+                except Exception:
+                    score = 0.0
+
+                ann[label_name].append([x1, y1, x2, y2, score])
+
+            annotation_dicts.append(ann)
+
+        # Reuse existing nv-ingest postprocessing + coord transform to pixel-space box dict.
+        return self.postprocess_annotations(annotation_dicts, original_image_shapes=orig_shapes)
 
     def name(
         self,
@@ -1641,23 +2120,49 @@ def postprocess_included_texts(boxes, confs, labels, classes):
 @multiprocessing_cache(max_calls=100)  # Cache results first to avoid redundant retries from backoff
 @backoff.on_predicate(backoff.expo, max_time=30)
 def get_yolox_model_name(yolox_grpc_endpoint, default_model_name="yolox"):
+    # If a gRPC endpoint isn't provided (common when using HTTP-only NIM endpoints),
+    # skip Triton repository introspection entirely.
+    if not yolox_grpc_endpoint:
+        return default_model_name
+
+    # Guard against accidentally passing an HTTP URL into the gRPC Triton client.
+    if isinstance(yolox_grpc_endpoint, str) and (
+        yolox_grpc_endpoint.startswith("http://") or yolox_grpc_endpoint.startswith("https://")
+    ):
+        return default_model_name
+
     try:
         client = grpcclient.InferenceServerClient(yolox_grpc_endpoint)
         model_index = client.get_model_repository_index(as_json=True)
-        model_names = [x["name"] for x in model_index.get("models", [])]
-        if "pipeline" in model_names:
-            yolox_model_name = "pipeline"
-        elif "yolox_ensemble" in model_names:
-            yolox_model_name = "yolox_ensemble"
-        else:
-            yolox_model_name = default_model_name
-    except Exception:
+        model_names = [x.get("name") for x in model_index.get("models", []) if isinstance(x, dict)]
+
+        # Prefer explicit known orchestrations first.
+        for preferred in (
+            "pipeline",  # BLS pipeline
+            "yolox_ensemble",
+            "yolox",
+            "yolox-page-elements",
+            "page-elements",
+            "nemoretriever-page-elements-v3",
+            "nemoretriever-page-elements-v2",
+        ):
+            if preferred in model_names:
+                return preferred
+
+        # Otherwise pick a best-effort match for newer model names.
+        candidates = [m for m in model_names if isinstance(m, str) and ("yolox" in m or "page-elements" in m)]
+        if candidates:
+            return sorted(candidates)[0]
+
+        return default_model_name
+    except Exception as e:
         logger.warning(
-            f"Failed to get yolox-page-elements version after 30 seconds. Falling back to '{default_model_name}'."
+            "Failed to inspect YOLOX model repository at '%s' (%s). Falling back to '%s'.",
+            yolox_grpc_endpoint,
+            type(e).__name__,
+            default_model_name,
         )
-        yolox_model_name = default_model_name
-
-    return yolox_model_name
+        return default_model_name
 
 
 @multiprocessing_cache(max_calls=100)  # Cache results first to avoid redundant retries from backoff
diff --git a/api/src/nv_ingest_api/internal/schemas/extract/extract_chart_schema.py b/api/src/nv_ingest_api/internal/schemas/extract/extract_chart_schema.py
index 6be0785e6..bef340829 100644
--- a/api/src/nv_ingest_api/internal/schemas/extract/extract_chart_schema.py
+++ b/api/src/nv_ingest_api/internal/schemas/extract/extract_chart_schema.py
@@ -24,21 +24,17 @@ class ChartExtractorConfigSchema(LowercaseProtocolMixin):
 
     yolox_endpoints : Tuple[Optional[str], Optional[str]], default=(None, None)
         A tuple containing the gRPC and HTTP services for the yolox endpoint.
-        Either the gRPC or HTTP service can be empty, but not both.
+        If both are empty, the chart extractor falls back to a local HuggingFace model.
 
     ocr_endpoints : Tuple[Optional[str], Optional[str]], default=(None, None)
         A tuple containing the gRPC and HTTP services for the ocr endpoint.
-        Either the gRPC or HTTP service can be empty, but not both.
+        If both are empty, the chart extractor falls back to a local OCR pipeline.
 
     Methods
     -------
     validate_endpoints(values)
-        Validates that at least one of the gRPC or HTTP services is provided for each endpoint.
-
-    Raises
-    ------
-    ValueError
-        If both gRPC and HTTP services are empty for any endpoint.
+        Cleans and normalizes endpoints and infers the infer protocol.
+        If both endpoints are empty for an entry, infer_protocol defaults to "local".
 
     Config
     ------
@@ -93,16 +89,17 @@ def clean_service(service):
             grpc_service = clean_service(grpc_service)
             http_service = clean_service(http_service)
 
-            if not grpc_service and not http_service:
-                raise ValueError(f"Both gRPC and HTTP services cannot be empty for {endpoint_name}.")
-
             values[endpoint_name] = (grpc_service, http_service)
 
             # Auto-infer protocol from endpoints if not specified
             protocol_name = endpoint_name.replace("_endpoints", "_infer_protocol")
             protocol_value = values.get(protocol_name)
             if not protocol_value:
-                protocol_value = "http" if http_service else "grpc" if grpc_service else ""
+                # If both endpoints are empty, default to local.
+                protocol_value = "http" if http_service else "grpc" if grpc_service else "local"
+            elif not grpc_service and not http_service:
+                # If protocol was explicitly set but endpoints are empty, force local.
+                protocol_value = "local"
             values[protocol_name] = protocol_value
 
         return values
diff --git a/api/src/nv_ingest_api/internal/schemas/extract/extract_image_schema.py b/api/src/nv_ingest_api/internal/schemas/extract/extract_image_schema.py
index a0d8594c5..5e36962ee 100644
--- a/api/src/nv_ingest_api/internal/schemas/extract/extract_image_schema.py
+++ b/api/src/nv_ingest_api/internal/schemas/extract/extract_image_schema.py
@@ -78,12 +78,14 @@ def clean_service(service):
 
         for model_name in ["yolox"]:
             endpoint_name = f"{model_name}_endpoints"
-            grpc_service, http_service = values.get(endpoint_name)
+            grpc_service, http_service = values.get(endpoint_name, ("", ""))
             grpc_service = clean_service(grpc_service)
             http_service = clean_service(http_service)
 
+            # If both are empty, allow local inference.
             if not grpc_service and not http_service:
-                raise ValueError(f"Both gRPC and HTTP services cannot be empty for {endpoint_name}.")
+                grpc_service = None
+                http_service = None
 
             values[endpoint_name] = (grpc_service, http_service)
 
@@ -91,7 +93,7 @@ def clean_service(service):
             protocol_name = f"{model_name}_infer_protocol"
             protocol_value = values.get(protocol_name)
             if not protocol_value:
-                protocol_value = "http" if http_service else "grpc" if grpc_service else ""
+                protocol_value = "http" if http_service else "grpc" if grpc_service else "local"
             values[protocol_name] = protocol_value
 
         return values
diff --git a/api/src/nv_ingest_api/internal/schemas/extract/extract_infographic_schema.py b/api/src/nv_ingest_api/internal/schemas/extract/extract_infographic_schema.py
index 59c007d11..3927ba7a5 100644
--- a/api/src/nv_ingest_api/internal/schemas/extract/extract_infographic_schema.py
+++ b/api/src/nv_ingest_api/internal/schemas/extract/extract_infographic_schema.py
@@ -86,16 +86,17 @@ def clean_service(service):
             grpc_service = clean_service(grpc_service)
             http_service = clean_service(http_service)
 
-            if not grpc_service and not http_service:
-                raise ValueError(f"Both gRPC and HTTP services cannot be empty for {endpoint_name}.")
-
             values[endpoint_name] = (grpc_service, http_service)
 
             # Auto-infer protocol from endpoints if not specified
             protocol_name = endpoint_name.replace("_endpoints", "_infer_protocol")
             protocol_value = values.get(protocol_name)
             if not protocol_value:
-                protocol_value = "http" if http_service else "grpc" if grpc_service else ""
+                # If both endpoints are empty, default to local.
+                protocol_value = "http" if http_service else "grpc" if grpc_service else "local"
+            elif not grpc_service and not http_service:
+                # If protocol was explicitly set but endpoints are empty, force local.
+                protocol_value = "local"
             values[protocol_name] = protocol_value
 
         return values
diff --git a/api/src/nv_ingest_api/internal/schemas/extract/extract_pdf_schema.py b/api/src/nv_ingest_api/internal/schemas/extract/extract_pdf_schema.py
index 9c7e3d532..b3be3af10 100644
--- a/api/src/nv_ingest_api/internal/schemas/extract/extract_pdf_schema.py
+++ b/api/src/nv_ingest_api/internal/schemas/extract/extract_pdf_schema.py
@@ -79,8 +79,10 @@ def validate_endpoints(cls, values):
             grpc_service = _clean_service(grpc_service)
             http_service = _clean_service(http_service)
 
+            # If both are empty, use HuggingFace models instead
             if not grpc_service and not http_service:
-                raise ValueError(f"Both gRPC and HTTP services cannot be empty for {endpoint_name}.")
+                grpc_service = None
+                http_service = None
 
             values[endpoint_name] = (grpc_service, http_service)
 
@@ -88,7 +90,7 @@ def validate_endpoints(cls, values):
             protocol_name = f"{model_name}_infer_protocol"
             protocol_value = values.get(protocol_name)
             if not protocol_value:
-                protocol_value = "http" if http_service else "grpc" if grpc_service else ""
+                protocol_value = "http" if http_service else "grpc" if grpc_service else "local"
             values[protocol_name] = protocol_value
 
         return values
diff --git a/api/src/nv_ingest_api/internal/schemas/extract/extract_table_schema.py b/api/src/nv_ingest_api/internal/schemas/extract/extract_table_schema.py
index cdc981a17..4741f42fb 100644
--- a/api/src/nv_ingest_api/internal/schemas/extract/extract_table_schema.py
+++ b/api/src/nv_ingest_api/internal/schemas/extract/extract_table_schema.py
@@ -87,16 +87,17 @@ def clean_service(service):
             grpc_service = clean_service(grpc_service)
             http_service = clean_service(http_service)
 
-            if not grpc_service and not http_service:
-                raise ValueError(f"Both gRPC and HTTP services cannot be empty for {endpoint_name}.")
-
             values[endpoint_name] = (grpc_service, http_service)
 
             # Auto-infer protocol from endpoints if not specified
             protocol_name = endpoint_name.replace("_endpoints", "_infer_protocol")
             protocol_value = values.get(protocol_name)
             if not protocol_value:
-                protocol_value = "http" if http_service else "grpc" if grpc_service else ""
+                # If both endpoints are empty, default to local.
+                protocol_value = "http" if http_service else "grpc" if grpc_service else "local"
+            elif not grpc_service and not http_service:
+                # If protocol was explicitly set but endpoints are empty, force local.
+                protocol_value = "local"
             values[protocol_name] = protocol_value
 
         return values
diff --git a/api/src/nv_ingest_api/internal/schemas/meta/ingest_job_schema.py b/api/src/nv_ingest_api/internal/schemas/meta/ingest_job_schema.py
index 7756c861c..11f470996 100644
--- a/api/src/nv_ingest_api/internal/schemas/meta/ingest_job_schema.py
+++ b/api/src/nv_ingest_api/internal/schemas/meta/ingest_job_schema.py
@@ -113,6 +113,8 @@ class IngestTaskCaptionSchema(BaseModelNoExt):
     prompt: Optional[str] = None
     system_prompt: Optional[str] = None
     model_name: Optional[str] = None
+    context_text_max_chars: Optional[int] = None
+    temperature: Optional[float] = None
 
 
 class IngestTaskFilterParamsSchema(BaseModelNoExt):
@@ -130,6 +132,9 @@ class IngestTaskFilterSchema(BaseModelNoExt):
 
 class IngestTaskDedupParams(BaseModelNoExt):
     filter: bool = False
+    enable_bbox_dedup: bool = True
+    iou_threshold: float = Field(default=0.45, ge=0.0, le=1.0)
+    bbox_dedup_prefer_structured: bool = True
 
 
 class IngestTaskDedupSchema(BaseModelNoExt):
@@ -143,8 +148,13 @@ class IngestTaskEmbedSchema(BaseModelNoExt):
     model_name: Optional[str] = None
     api_key: Optional[str] = Field(default=None, repr=False)
     filter_errors: bool = False
+    embed_text_elements: Optional[bool] = None
+    embed_structured_elements: Optional[bool] = None
+    embed_image_elements: Optional[bool] = None
+    embed_audio_elements: Optional[bool] = None
     text_elements_modality: Optional[str] = None
     image_elements_modality: Optional[str] = None
+    image_elements_aggregate_page_content: Optional[bool] = None
     structured_elements_modality: Optional[str] = None
     audio_elements_modality: Optional[str] = None
     custom_content_field: Optional[str] = None
diff --git a/api/src/nv_ingest_api/internal/schemas/transform/transform_image_caption_schema.py b/api/src/nv_ingest_api/internal/schemas/transform/transform_image_caption_schema.py
index 9bf68fe37..7717f9695 100644
--- a/api/src/nv_ingest_api/internal/schemas/transform/transform_image_caption_schema.py
+++ b/api/src/nv_ingest_api/internal/schemas/transform/transform_image_caption_schema.py
@@ -12,6 +12,8 @@ class ImageCaptionExtractionSchema(BaseModel):
     prompt: str = "Caption the content of this image:"
     system_prompt: str = "/no_think"
     model_name: str = "nvidia/nemotron-nano-12b-v2-vl"
+    context_text_max_chars: int = 0
+    temperature: float = 1.0
     raise_on_failure: bool = False
     model_config = ConfigDict(extra="forbid")
 
@@ -33,4 +35,8 @@ def _coerce_none_to_defaults(cls, values):
             values["prompt"] = cls.model_fields["prompt"].default
         if values.get("system_prompt") is None:
             values["system_prompt"] = cls.model_fields["system_prompt"].default
+        if values.get("context_text_max_chars") is None:
+            values["context_text_max_chars"] = cls.model_fields["context_text_max_chars"].default
+        if values.get("temperature") is None:
+            values["temperature"] = cls.model_fields["temperature"].default
         return values
diff --git a/api/src/nv_ingest_api/internal/schemas/transform/transform_text_embedding_schema.py b/api/src/nv_ingest_api/internal/schemas/transform/transform_text_embedding_schema.py
index d6595c579..ce7f35d3e 100644
--- a/api/src/nv_ingest_api/internal/schemas/transform/transform_text_embedding_schema.py
+++ b/api/src/nv_ingest_api/internal/schemas/transform/transform_text_embedding_schema.py
@@ -18,14 +18,21 @@ class TextEmbeddingSchema(BaseModel):
     api_key: str = Field(default="", repr=False)
     batch_size: int = Field(default=4)
     embedding_model: str = Field(default="nvidia/llama-3.2-nv-embedqa-1b-v2")
-    embedding_nim_endpoint: str = Field(default="http://embedding:8000/v1")
+    # When null/empty, callers may choose to run a local embedding backend instead of a remote endpoint.
+    # Keep the historical default so existing configs continue to work unchanged.
+    embedding_nim_endpoint: Optional[str] = Field(default="http://embedding:8000/v1")
     encoding_format: str = Field(default="float")
     httpx_log_level: LogLevel = Field(default=LogLevel.WARNING)
     input_type: str = Field(default="passage")
     raise_on_failure: bool = Field(default=False)
     truncate: str = Field(default="END")
+    embed_text_elements: bool = Field(default=True)
+    embed_structured_elements: bool = Field(default=True)
+    embed_image_elements: bool = Field(default=True)
+    embed_audio_elements: bool = Field(default=True)
     text_elements_modality: str = Field(default="text")
     image_elements_modality: str = Field(default="text")
+    image_elements_aggregate_page_content: bool = Field(default=False)
     structured_elements_modality: str = Field(default="text")
     audio_elements_modality: str = Field(default="text")
     custom_content_field: Optional[str] = None
@@ -39,6 +46,15 @@ class TextEmbeddingSchema(BaseModel):
     def _coerce_api_key_none(cls, v):
         return "" if v is None else v
 
+    @field_validator("embedding_nim_endpoint", mode="before")
+    @classmethod
+    def _coerce_empty_endpoint_to_none(cls, v):
+        if v is None:
+            return None
+        if isinstance(v, str) and not v.strip():
+            return None
+        return v
+
     @model_validator(mode="before")
     @classmethod
     def _coerce_none_to_empty(cls, values):
diff --git a/api/src/nv_ingest_api/internal/transform/caption_image.py b/api/src/nv_ingest_api/internal/transform/caption_image.py
index 936896ce8..5cfe4add7 100644
--- a/api/src/nv_ingest_api/internal/transform/caption_image.py
+++ b/api/src/nv_ingest_api/internal/transform/caption_image.py
@@ -16,6 +16,75 @@
 
 logger = logging.getLogger(__name__)
 
+_MAX_CONTEXT_TEXT_CHARS = 4096
+
+
+def _gather_context_text_for_image(
+    image_meta: Dict[str, Any],
+    page_text_map: Dict[int, List[str]],
+    max_chars: int,
+) -> str:
+    """
+    Gather surrounding OCR text for an image to provide as VLM prompt context.
+
+    Parameters
+    ----------
+    image_meta : dict
+        The full metadata dict for the image row.
+    page_text_map : dict
+        Mapping of page number -> list of text strings, precomputed from the
+        DataFrame's text rows.
+    max_chars : int
+        Maximum number of characters to return. Will be clamped to
+        ``_MAX_CONTEXT_TEXT_CHARS``.
+
+    Returns
+    -------
+    str
+        Surrounding text (possibly truncated), or empty string if none found.
+    """
+    effective_max = min(max_chars, _MAX_CONTEXT_TEXT_CHARS)
+    content_meta = image_meta.get("content_metadata", {})
+    page_num = content_meta.get("page_number", -1)
+    page_texts = page_text_map.get(page_num, [])
+    if page_texts:
+        combined = " ".join(page_texts)
+        return combined[:effective_max]
+
+    return ""
+
+
+def _build_prompt_with_context(base_prompt: str, context_text: str) -> str:
+    """
+    Prepend surrounding-text context to the base VLM prompt.
+
+    If *context_text* is empty the *base_prompt* is returned unchanged.
+    """
+    if not context_text:
+        return base_prompt
+    return f"Text near this image:\n---\n{context_text}\n---\n\n{base_prompt}"
+
+
+def _build_page_text_map(df: pd.DataFrame) -> Dict[int, List[str]]:
+    """
+    Build a mapping of page number -> list of text content strings from text
+    rows in the DataFrame.  Computed once per call to avoid O(images * rows).
+    """
+    page_text_map: Dict[int, List[str]] = {}
+    for _, row in df.iterrows():
+        meta = row.get("metadata")
+        if meta is None:
+            continue
+        cm = meta.get("content_metadata", {})
+        if cm.get("type") != "text":
+            continue
+        content = meta.get("content", "")
+        if not content:
+            continue
+        page_num = cm.get("page_number", -1)
+        page_text_map.setdefault(page_num, []).append(content)
+    return page_text_map
+
 
 def _prepare_dataframes_mod(df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.DataFrame, pd.Series]:
     """
@@ -62,6 +131,7 @@ def _generate_captions(
     api_key: str,
     endpoint_url: str,
     model_name: str,
+    temperature: float = 1.0,
 ) -> List[str]:
     """
     Generates captions for a list of base64-encoded PNG images using the VLM model API.
@@ -116,7 +186,7 @@ def _generate_captions(
         )
 
         # Perform inference to generate captions.
-        captions: List[str] = nim_client.infer(data, model_name=model_name)
+        captions: List[str] = nim_client.infer(data, model_name=model_name, temperature=temperature)
         return captions
 
     except Exception as e:
@@ -182,6 +252,14 @@ def transform_image_create_vlm_caption_internal(
     endpoint_url: str = task_config.get("endpoint_url") or transform_config.endpoint_url
     model_name: str = task_config.get("model_name") or transform_config.model_name
 
+    # Context text: task config overrides pipeline default.
+    context_text_max_chars: int = task_config.get("context_text_max_chars") or getattr(
+        transform_config, "context_text_max_chars", 0
+    )
+
+    # Temperature: task config overrides pipeline default.
+    temperature: float = task_config.get("temperature") or getattr(transform_config, "temperature", 1.0)
+
     # Create a mask for rows where the content type is "image".
     df_mask: pd.Series = df_transform_ledger["metadata"].apply(
         lambda meta: meta.get("content_metadata", {}).get("type") == "image"
@@ -191,26 +269,50 @@ def transform_image_create_vlm_caption_internal(
     if not df_mask.any():
         return df_transform_ledger
 
-    # Collect base64-encoded images from the rows where the content type is "image".
-    base64_images: List[str] = df_transform_ledger.loc[df_mask, "metadata"].apply(lambda meta: meta["content"]).tolist()
-
-    # Generate captions for the collected images.
-    captions: List[str] = _generate_captions(
-        base64_images,
-        prompt,
-        system_prompt,
-        api_key,
-        endpoint_url,
-        model_name,
-    )
+    if context_text_max_chars and context_text_max_chars > 0:
+        page_text_map = _build_page_text_map(df_transform_ledger)
+
+        for idx in df_transform_ledger.loc[df_mask].index:
+            meta: Dict[str, Any] = df_transform_ledger.at[idx, "metadata"]
+            base64_image: str = meta["content"]
+            context_text = _gather_context_text_for_image(meta, page_text_map, context_text_max_chars)
+            enriched_prompt = _build_prompt_with_context(prompt, context_text)
+
+            captions: List[str] = _generate_captions(
+                [base64_image],
+                enriched_prompt,
+                system_prompt,
+                api_key,
+                endpoint_url,
+                model_name,
+                temperature=temperature,
+            )
+
+            image_meta: Dict[str, Any] = meta.get("image_metadata", {})
+            image_meta["caption"] = captions[0] if captions else ""
+            meta["image_metadata"] = image_meta
+            df_transform_ledger.at[idx, "metadata"] = meta
+    else:
+        base64_images: List[str] = (
+            df_transform_ledger.loc[df_mask, "metadata"].apply(lambda meta: meta["content"]).tolist()
+        )
+
+        captions: List[str] = _generate_captions(
+            base64_images,
+            prompt,
+            system_prompt,
+            api_key,
+            endpoint_url,
+            model_name,
+            temperature=temperature,
+        )
 
-    # Update the DataFrame: assign each generated caption to the corresponding row.
-    for idx, caption in zip(df_transform_ledger.loc[df_mask].index, captions):
-        meta: Dict[str, Any] = df_transform_ledger.at[idx, "metadata"]
-        image_meta: Dict[str, Any] = meta.get("image_metadata", {})
-        image_meta["caption"] = caption
-        meta["image_metadata"] = image_meta
-        df_transform_ledger.at[idx, "metadata"] = meta
+        for idx, caption in zip(df_transform_ledger.loc[df_mask].index, captions):
+            meta: Dict[str, Any] = df_transform_ledger.at[idx, "metadata"]
+            image_meta: Dict[str, Any] = meta.get("image_metadata", {})
+            image_meta["caption"] = caption
+            meta["image_metadata"] = image_meta
+            df_transform_ledger.at[idx, "metadata"] = meta
 
     logger.debug("Image content captioning complete")
     result, execution_trace_log = df_transform_ledger, {}
diff --git a/api/src/nv_ingest_api/internal/transform/embed_text.py b/api/src/nv_ingest_api/internal/transform/embed_text.py
index d6ee06c4b..88147e017 100644
--- a/api/src/nv_ingest_api/internal/transform/embed_text.py
+++ b/api/src/nv_ingest_api/internal/transform/embed_text.py
@@ -5,7 +5,7 @@
 import logging
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial
-from typing import Any, Dict, Tuple, Optional, Iterable, List
+from typing import Any, Dict, Tuple, Optional, Iterable, List, Callable, Sequence
 from urllib.parse import urlparse
 
 import glom
@@ -23,7 +23,12 @@
 logging.getLogger("httpcore").setLevel(logging.ERROR)
 
 
-MULTI_MODAL_MODELS = ["llama-3.2-nemoretriever-1b-vlm-embed-v1"]
+MULTI_MODAL_MODELS = [
+    "llama-3.2-nemoretriever-1b-vlm-embed-v1",
+    "nvidia/llama-nemotron-embed-vl-1b-v2",
+]
+
+EmbeddingCallable = Callable[[Sequence[str]], Sequence[Sequence[float]]]
 
 
 # ------------------------------------------------------------------------------
@@ -244,6 +249,50 @@ def _async_runner(
     return flat_results
 
 
+# ------------------------------------------------------------------------------
+# Local embedding hook (callable)
+# ------------------------------------------------------------------------------
+
+
+def _callable_runner(
+    prompts: List[List[str]],
+    *,
+    embedder: EmbeddingCallable,
+    batch_size: int,
+) -> dict:
+    """
+    Runs embeddings via a provided callable, returning the same shape as `_async_runner`.
+
+    Parameters
+    ----------
+    prompts:
+        A list of prompt batches (List[List[str]]).
+    embedder:
+        Callable that takes a sequence of strings and returns a sequence of embedding vectors.
+    batch_size:
+        Local batch size; used to sub-batch each provided prompt batch if needed.
+    """
+    flat_embeddings: List[Optional[Sequence[float]]] = []
+    flat_info_msgs: List[Optional[dict]] = []
+
+    for prompt_batch in prompts:
+        if not prompt_batch:
+            continue
+        for i in range(0, len(prompt_batch), max(1, int(batch_size))):
+            chunk = prompt_batch[i : i + max(1, int(batch_size))]
+            vecs = embedder(chunk)
+            vecs_list = list(vecs)
+            if len(vecs_list) != len(chunk):
+                raise ValueError(
+                    "Local embedder returned a mismatched number of embeddings "
+                    f"(got={len(vecs_list)} expected={len(chunk)})"
+                )
+            flat_embeddings.extend(vecs_list)
+            flat_info_msgs.extend([None] * len(vecs_list))
+
+    return {"embeddings": flat_embeddings, "info_msgs": flat_info_msgs}
+
+
 # ------------------------------------------------------------------------------
 # Pandas UDFs for Content Extraction
 # ------------------------------------------------------------------------------
@@ -315,7 +364,9 @@ def _add_custom_embeddings(row, embeddings, result_target_field):
 def _format_image_input_string(image_b64: Optional[str]) -> str:
     if not image_b64:
         return
-    return f"data:image/png;base64,{image_b64}"
+    # Detect format from base64 magic bytes: JPEG starts with /9j/, PNG starts with iVBORw
+    mime_type = "image/jpeg" if image_b64.startswith("/9j/") else "image/png"
+    return f"data:{mime_type};base64,{image_b64}"
 
 
 def _format_text_image_pair_input_string(text: Optional[str], image_b64: Optional[str]) -> str:
@@ -326,19 +377,29 @@ def _format_text_image_pair_input_string(text: Optional[str], image_b64: Optiona
 
 def _get_pandas_text_content(row, modality="text"):
     """
-    Extracts text content from a DataFrame row.
+    Extracts text content from a DataFrame row's metadata.
 
     Parameters
     ----------
-    row : pandas.Series
-        A row containing the 'content' key.
+    row : dict
+        The metadata dictionary containing 'content' and optionally 'text_metadata.source_image'.
 
     Returns
     -------
     str
-        The text content from the row.
+        The text content, image content, or combined text+image content based on modality.
     """
-    return row["content"]
+    if modality == "text":
+        content = row.get("content")
+    elif modality == "image":
+        source_image = row.get("text_metadata", {}).get("source_image")
+        content = _format_image_input_string(source_image)
+    elif modality == "text_image":
+        text = row.get("content")
+        source_image = row.get("text_metadata", {}).get("source_image")
+        content = _format_text_image_pair_input_string(text, source_image)
+
+    return content
 
 
 def _get_pandas_table_content(row, modality="text"):
@@ -362,7 +423,10 @@ def _get_pandas_table_content(row, modality="text"):
     elif modality == "text_image":
         text = row.get("table_metadata", {}).get("table_content")
         image = row.get("content")
-        content = _format_text_image_pair_input_string(text, image)
+        if text:
+            content = _format_text_image_pair_input_string(text, image)
+        else:
+            content = _format_image_input_string(image)  # Fallback to image only if text is empty
 
     return content
 
@@ -395,7 +459,10 @@ def _get_pandas_image_content(row, modality="text"):
         else:
             text = row.get("image_metadata", {}).get("caption")
         image = row.get("content")
-        content = _format_text_image_pair_input_string(text, image)
+        if text:
+            content = _format_text_image_pair_input_string(text, image)
+        else:
+            content = _format_image_input_string(image)  # Fallback to image only if text is empty
 
     if subtype == "page_image":
         # A workaround to save memory for full page images.
@@ -425,6 +492,96 @@ def _get_pandas_custom_content(row, custom_content_field):
         return None
 
 
+def _cleanup_source_images(row):
+    """
+    Removes source_image from text_metadata to reduce metadata size.
+
+    The source_image field is used during embedding for text_image modality
+    but should be removed afterward to avoid exceeding storage limits
+    (e.g., Milvus JSON field 64KB limit).
+
+    Parameters
+    ----------
+    row : pandas.Series
+        A DataFrame row containing 'metadata'.
+
+    Returns
+    -------
+    pandas.Series
+        The row with source_image removed from text_metadata.
+    """
+    text_metadata = row.get("metadata", {}).get("text_metadata")
+    if text_metadata and "source_image" in text_metadata:
+        del text_metadata["source_image"]
+    return row
+
+
+def _aggregate_page_content(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Aggregates text content from TEXT and STRUCTURED elements into PAGE_IMAGE entries.
+
+    For each page, collects text from:
+    - TEXT elements: content field
+    - STRUCTURED elements (tables/charts): table_metadata.table_content field
+
+    The aggregated text is stored in image_metadata.text for PAGE_IMAGE entries,
+    enabling text_image modality embedding with full page context.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame containing extracted content with metadata.
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with PAGE_IMAGE entries updated to include aggregated page text.
+    """
+    # Build mapping of page_number -> list of text content
+    page_text_map: Dict[int, List[str]] = {}
+
+    for _, row in df.iterrows():
+        metadata = row.get("metadata", {})
+        content_metadata = metadata.get("content_metadata", {})
+        content_type = content_metadata.get("type")
+        page_number = content_metadata.get("page_number")
+
+        if page_number is None:
+            continue
+
+        if page_number not in page_text_map:
+            page_text_map[page_number] = []
+
+        # Collect text from TEXT elements
+        if content_type == ContentTypeEnum.TEXT.value:
+            text_content = metadata.get("content")
+            if text_content and isinstance(text_content, str) and text_content.strip():
+                page_text_map[page_number].append(text_content.strip())
+
+        # Collect text from STRUCTURED elements (tables, charts)
+        elif content_type == ContentTypeEnum.STRUCTURED.value:
+            table_content = metadata.get("table_metadata", {}).get("table_content")
+            if table_content and isinstance(table_content, str) and table_content.strip():
+                page_text_map[page_number].append(table_content.strip())
+
+    # Apply aggregated text to PAGE_IMAGE entries
+    for idx, row in df.iterrows():
+        metadata = row.get("metadata", {})
+        content_metadata = metadata.get("content_metadata", {})
+
+        if (
+            content_metadata.get("type") == ContentTypeEnum.IMAGE.value
+            and content_metadata.get("subtype") == ContentTypeEnum.PAGE_IMAGE.value
+        ):
+            page_number = content_metadata.get("page_number")
+            if page_number in page_text_map and page_text_map[page_number]:
+                aggregated_text = "\n\n".join(page_text_map[page_number])
+                image_metadata = metadata.get("image_metadata", {})
+                image_metadata["text"] = aggregated_text
+
+    return df
+
+
 # ------------------------------------------------------------------------------
 # Batch Processing Utilities
 # ------------------------------------------------------------------------------
@@ -560,11 +717,25 @@ def transform_create_text_embeddings_internal(
             - The updated DataFrame with embeddings applied.
             - A dictionary with trace information.
     """
-    api_key = task_config.get("api_key") or transform_config.api_key
-    endpoint_url = task_config.get("endpoint_url") or transform_config.embedding_nim_endpoint
-    model_name = task_config.get("model_name") or transform_config.embedding_model
-    custom_content_field = task_config.get("custom_content_field") or transform_config.custom_content_field
-    dimensions = task_config.get("dimensions") or transform_config.dimensions
+    # Allow task_config to explicitly override values with None by checking key presence.
+    api_key = task_config["api_key"] if "api_key" in task_config else transform_config.api_key
+    endpoint_url = (
+        task_config["endpoint_url"] if "endpoint_url" in task_config else transform_config.embedding_nim_endpoint
+    )
+    model_name = task_config["model_name"] if "model_name" in task_config else transform_config.embedding_model
+    custom_content_field = (
+        task_config["custom_content_field"]
+        if "custom_content_field" in task_config
+        else transform_config.custom_content_field
+    )
+    dimensions = task_config["dimensions"] if "dimensions" in task_config else transform_config.dimensions
+
+    endpoint_url = endpoint_url.strip() if isinstance(endpoint_url, str) else endpoint_url
+    if isinstance(endpoint_url, str) and not endpoint_url:
+        endpoint_url = None
+
+    embedder: Optional[EmbeddingCallable] = task_config.get("embedder")
+    local_batch_size = int(task_config.get("local_batch_size") or transform_config.batch_size or 4)
 
     if execution_trace_log is None:
         execution_trace_log = {}
@@ -573,6 +744,42 @@ def transform_create_text_embeddings_internal(
     if df_transform_ledger.empty:
         return df_transform_ledger, {"trace_info": execution_trace_log}
 
+    # Determine if page content aggregation should be enabled
+    image_elements_modality = task_config.get("image_elements_modality") or transform_config.image_elements_modality
+
+    # Check if user explicitly set the aggregation flag
+    explicit_aggregate_setting = task_config.get("image_elements_aggregate_page_content")
+    image_elements_aggregate_page_content = (
+        explicit_aggregate_setting
+        if explicit_aggregate_setting is not None
+        else transform_config.image_elements_aggregate_page_content
+    )
+
+    # Auto-enable aggregation when using text_image modality with PAGE_IMAGE entries
+    # Only auto-enable if user hasn't explicitly set the flag
+    if explicit_aggregate_setting is None and not image_elements_aggregate_page_content:
+        if image_elements_modality == "text_image":
+            # Check if PAGE_IMAGE entries exist
+            def _has_page_images(df):
+                for _, row in df.iterrows():
+                    metadata = row.get("metadata", {})
+                    content_metadata = metadata.get("content_metadata", {})
+                    if (
+                        content_metadata.get("type") == ContentTypeEnum.IMAGE.value
+                        and content_metadata.get("subtype") == ContentTypeEnum.PAGE_IMAGE.value
+                    ):
+                        return True
+                return False
+
+            if _has_page_images(df_transform_ledger):
+                image_elements_aggregate_page_content = True
+                logger.debug("Auto-enabled page content aggregation for text_image modality with PAGE_IMAGE entries")
+
+    # Aggregate text content from TEXT and STRUCTURED elements into PAGE_IMAGE entries
+    if image_elements_aggregate_page_content:
+        df_transform_ledger = _aggregate_page_content(df_transform_ledger)
+        logger.debug("Aggregated page content into PAGE_IMAGE entries for text_image embedding")
+
     embedding_dataframes = []
     content_masks = []
 
@@ -593,6 +800,33 @@ def transform_create_text_embeddings_internal(
         ContentTypeEnum.VIDEO: lambda x: None,  # Not supported yet.
     }
 
+    # Determine which content types to embed
+    # When aggregating page content, automatically skip TEXT and STRUCTURED unless explicitly set
+    def _get_embed_flag(content_type: ContentTypeEnum) -> bool:
+        flag_map = {
+            ContentTypeEnum.TEXT: task_config.get("embed_text_elements"),
+            ContentTypeEnum.STRUCTURED: task_config.get("embed_structured_elements"),
+            ContentTypeEnum.IMAGE: task_config.get("embed_image_elements"),
+            ContentTypeEnum.AUDIO: task_config.get("embed_audio_elements"),
+        }
+        default_map = {
+            ContentTypeEnum.TEXT: transform_config.embed_text_elements,
+            ContentTypeEnum.STRUCTURED: transform_config.embed_structured_elements,
+            ContentTypeEnum.IMAGE: transform_config.embed_image_elements,
+            ContentTypeEnum.AUDIO: transform_config.embed_audio_elements,
+        }
+        task_flag = flag_map.get(content_type)
+        if task_flag is not None:
+            return task_flag
+        # When aggregating page content, skip TEXT and STRUCTURED by default
+        # since their content is already included in PAGE_IMAGE entries
+        if image_elements_aggregate_page_content and content_type in (
+            ContentTypeEnum.TEXT,
+            ContentTypeEnum.STRUCTURED,
+        ):
+            return False
+        return default_map.get(content_type, True)
+
     def _content_type_getter(row):
         return row["content_metadata"]["type"]
 
@@ -601,6 +835,11 @@ def _content_type_getter(row):
             logger.warning(f"Skipping text_embedding generation for unsupported content type: {content_type}")
             continue
 
+        # Check if this content type should be embedded
+        if not _get_embed_flag(content_type):
+            logger.debug(f"Skipping embedding for content type {content_type} (disabled by configuration)")
+            continue
+
         # Get rows matching the content type
         content_mask = df_transform_ledger["metadata"].apply(_content_type_getter) == content_type.value
         if not content_mask.any():
@@ -629,18 +868,30 @@ def _content_type_getter(row):
             else:
                 modality_batches = None
 
-            content_embeddings = _async_runner(
-                filtered_content_batches,
-                api_key,
-                endpoint_url,
-                model_name,
-                transform_config.encoding_format,
-                transform_config.input_type,
-                transform_config.truncate,
-                False,
-                modalities=modality_batches,
-                dimensions=dimensions,
-            )
+            if endpoint_url:
+                content_embeddings = _async_runner(
+                    filtered_content_batches,
+                    api_key,
+                    endpoint_url,
+                    model_name,
+                    transform_config.encoding_format,
+                    transform_config.input_type,
+                    transform_config.truncate,
+                    False,
+                    modalities=modality_batches,
+                    dimensions=dimensions,
+                )
+            elif callable(embedder):
+                content_embeddings = _callable_runner(
+                    filtered_content_batches,
+                    embedder=embedder,
+                    batch_size=local_batch_size,
+                )
+            else:
+                raise ValueError(
+                    "No embedding endpoint configured (endpoint_url/embedding_nim_endpoint are empty) "
+                    "and no local embedder was provided in task_config['embedder']."
+                )
             # Build a simple row index -> embedding map
             embeddings_dict = dict(
                 zip(df_content.loc[valid_content_mask].index, content_embeddings.get("embeddings", []))
@@ -675,17 +926,29 @@ def _content_type_getter(row):
             custom_content_list = extracted_custom_content[valid_custom_content_mask].to_list()
             custom_content_batches = _generate_batches(custom_content_list, batch_size=transform_config.batch_size)
 
-            custom_content_embeddings = _async_runner(
-                custom_content_batches,
-                api_key,
-                endpoint_url,
-                model_name,
-                transform_config.encoding_format,
-                transform_config.input_type,
-                transform_config.truncate,
-                False,
-                dimensions=dimensions,
-            )
+            if endpoint_url:
+                custom_content_embeddings = _async_runner(
+                    custom_content_batches,
+                    api_key,
+                    endpoint_url,
+                    model_name,
+                    transform_config.encoding_format,
+                    transform_config.input_type,
+                    transform_config.truncate,
+                    False,
+                    dimensions=dimensions,
+                )
+            elif callable(embedder):
+                custom_content_embeddings = _callable_runner(
+                    custom_content_batches,
+                    embedder=embedder,
+                    batch_size=local_batch_size,
+                )
+            else:
+                raise ValueError(
+                    "No embedding endpoint configured (endpoint_url/embedding_nim_endpoint are empty) "
+                    "and no local embedder was provided in task_config['embedder']."
+                )
             custom_embeddings_dict = dict(
                 zip(
                     extracted_custom_content.loc[valid_custom_content_mask].index,
@@ -699,4 +962,8 @@ def _content_type_getter(row):
             _add_custom_embeddings, embeddings=custom_embeddings_dict, result_target_field=result_target_field, axis=1
         )
 
+    # Clean up source_image from text_metadata to avoid exceeding Milvus JSON field limits.
+    # The source_image is only needed during embedding and can be safely removed afterward.
+    combined_df = combined_df.apply(_cleanup_source_images, axis=1)
+
     return combined_df, {"trace_info": execution_trace_log}
diff --git a/api/src/nv_ingest_api/internal/transform/split_text.py b/api/src/nv_ingest_api/internal/transform/split_text.py
index 39e56e961..9d099ec7f 100644
--- a/api/src/nv_ingest_api/internal/transform/split_text.py
+++ b/api/src/nv_ingest_api/internal/transform/split_text.py
@@ -6,6 +6,7 @@
 import os
 import copy
 import logging
+import threading
 import uuid
 from typing import Any, Optional, Dict
 from typing import List
@@ -19,6 +20,47 @@
 
 logger = logging.getLogger(__name__)
 
+# Module-level tokenizer cache: persists tokenizer instances for the lifetime
+# of the process, keyed by (identifier, token) to avoid re-loading on every call.
+_tokenizer_cache: Dict[str, Any] = {}
+_tokenizer_cache_lock = threading.Lock()
+
+
+def _get_tokenizer(
+    tokenizer_identifier: str,
+    token: Optional[str] = None,
+):
+    """
+    Return a cached AutoTokenizer, creating it on first use.
+
+    Parameters
+    ----------
+    tokenizer_identifier : str
+        HuggingFace model identifier or local path.
+    token : str, optional
+        HuggingFace access token.
+
+    Returns
+    -------
+    transformers.PreTrainedTokenizer
+        The (possibly cached) tokenizer instance.
+    """
+    cache_key = tokenizer_identifier
+
+    # Fast path – no lock needed for a simple dict read (GIL-protected).
+    if cache_key in _tokenizer_cache:
+        return _tokenizer_cache[cache_key]
+
+    with _tokenizer_cache_lock:
+        # Double-check after acquiring the lock.
+        if cache_key in _tokenizer_cache:
+            return _tokenizer_cache[cache_key]
+
+        logger.info("Loading and caching tokenizer: %s", tokenizer_identifier)
+        tokenizer = AutoTokenizer.from_pretrained(tokenizer_identifier, token=token)
+        _tokenizer_cache[cache_key] = tokenizer
+        return tokenizer
+
 
 def _build_split_documents(row, chunks: List[str]) -> List[dict[str, Any]]:
     """Build documents from text chunks"""
@@ -47,7 +89,7 @@ def _build_split_documents(row, chunks: List[str]) -> List[dict[str, Any]]:
 
 def _split_into_chunks(text, tokenizer, chunk_size=1024, chunk_overlap=20):
     # Tokenize the text into token IDs
-    encoding = tokenizer.encode_plus(text, add_special_tokens=False, return_offsets_mapping=True)
+    encoding = tokenizer(text, add_special_tokens=False, return_offsets_mapping=True)
 
     # Get the token IDs and offsets for splitting
     offsets = encoding["offset_mapping"]
@@ -155,7 +197,7 @@ def transform_text_split_and_tokenize_internal(
     if tokenizer_identifier is None:
         tokenizer_identifier = "intfloat/e5-large-unsupervised"
 
-    tokenizer_model = AutoTokenizer.from_pretrained(tokenizer_identifier, token=hf_access_token)
+    tokenizer_model = _get_tokenizer(tokenizer_identifier, token=hf_access_token)
 
     split_docs: List[Dict[str, Any]] = []
     for _, row in df_filtered.iterrows():
diff --git a/api/src/nv_ingest_api/util/nim/__init__.py b/api/src/nv_ingest_api/util/nim/__init__.py
index 9a851e284..575c5f2f0 100644
--- a/api/src/nv_ingest_api/util/nim/__init__.py
+++ b/api/src/nv_ingest_api/util/nim/__init__.py
@@ -2,13 +2,15 @@
 # All rights reserved.
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Tuple, Optional
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Tuple, Optional
 import re
 import logging
 
 from nv_ingest_api.internal.primitives.nim import NimClient
 from nv_ingest_api.internal.primitives.nim.model_interface.text_embedding import EmbeddingModelInterface
-from nv_ingest_api.internal.primitives.nim.nim_client import NimClientManager
 from nv_ingest_api.internal.primitives.nim.nim_client import get_nim_client_manager
 from nv_ingest_api.internal.primitives.nim.nim_model_interface import ModelInterface
 
@@ -17,6 +19,36 @@
 
 __all__ = ["create_inference_client", "infer_microservice"]
 
+_VALID_INFER_PROTOCOLS = ("grpc", "http", "local")
+
+
+@dataclass(frozen=True)
+class LocalInferenceClient:
+    """
+    Small adapter that mimics NimClient's `infer()` surface, but runs locally.
+
+    It delegates to `model_interface.infer(data, **kwargs)`.
+    """
+
+    model_interface: ModelInterface
+
+    @property
+    def protocol(self) -> str:
+        return "local"
+
+    def infer(self, data: dict, model_name: Optional[str] = None, **kwargs) -> Any:
+        # `model_name` is accepted for API compatibility but may be unused by local implementations.
+        infer_fn = getattr(self.model_interface, "infer", None)
+        if not callable(infer_fn):
+            raise RuntimeError(
+                f"Local inference requested but model_interface '{self.model_interface.name()}' "
+                "does not implement infer()."
+            )
+        return infer_fn(data, **kwargs)
+
+    def close(self) -> None:
+        return None
+
 
 def create_inference_client(
     endpoints: Tuple[str, str],
@@ -26,7 +58,7 @@ def create_inference_client(
     timeout: float = 120.0,
     max_retries: int = 10,
     **kwargs,
-) -> NimClientManager:
+) -> Any:
     """
     Create a NimClientManager for interfacing with a model inference server.
 
@@ -60,13 +92,28 @@ def create_inference_client(
 
     grpc_endpoint, http_endpoint = endpoints
 
-    if (infer_protocol is None) and (grpc_endpoint and grpc_endpoint.strip()):
-        infer_protocol = "grpc"
-    elif infer_protocol is None and http_endpoint:
-        infer_protocol = "http"
-
-    if infer_protocol not in ["grpc", "http"]:
-        raise ValueError("Invalid infer_protocol specified. Must be 'grpc' or 'http'.")
+    infer_protocol = (infer_protocol or "").strip().lower() or None
+
+    # Auto-infer protocol from endpoints if not specified.
+    if infer_protocol is None:
+        if grpc_endpoint and str(grpc_endpoint).strip():
+            infer_protocol = "grpc"
+        elif http_endpoint and str(http_endpoint).strip():
+            infer_protocol = "http"
+        else:
+            infer_protocol = "local"
+
+    if infer_protocol not in _VALID_INFER_PROTOCOLS:
+        raise ValueError("Invalid infer_protocol specified. Must be 'grpc', 'http', or 'local'.")
+
+    if infer_protocol == "local":
+        # If the interface has a backend attribute, force it to local.
+        try:
+            if hasattr(model_interface, "backend"):
+                setattr(model_interface, "backend", "local")
+        except Exception:
+            pass
+        return LocalInferenceClient(model_interface=model_interface)
 
     manager = get_nim_client_manager()
     client = manager.get_client(
diff --git a/api/src/nv_ingest_api/util/pdf/pdfium.py b/api/src/nv_ingest_api/util/pdf/pdfium.py
index e7f6140cc..27b046931 100644
--- a/api/src/nv_ingest_api/util/pdf/pdfium.py
+++ b/api/src/nv_ingest_api/util/pdf/pdfium.py
@@ -7,6 +7,7 @@
 from typing import Optional
 from typing import Tuple
 
+import cv2
 import numpy as np
 import pypdfium2 as pdfium
 import pypdfium2.raw as pdfium_c
@@ -25,6 +26,46 @@
 
 logger = logging.getLogger(__name__)
 
+
+def _compute_render_scale_to_fit(
+    page: pdfium.PdfPage,
+    target_wh: Tuple[int, int],
+    rotation: int = 0,
+) -> float:
+    """
+    Compute a PDFium render scale that fits the rotated page within target pixel bounds.
+
+    Uses the standard fit-to-box formula: min(target_w/page_w, target_h/page_h)
+
+    Parameters
+    ----------
+    page : pdfium.PdfPage
+        The PDF page to compute scale for.
+    target_wh : Tuple[int, int]
+        Target (width, height) in pixels.
+    rotation : int, optional
+        Page rotation in degrees (0, 90, 180, 270). Defaults to 0.
+
+    Returns
+    -------
+    float
+        The scale factor to use for rendering.
+    """
+    target_w, target_h = target_wh
+    if target_w <= 0 or target_h <= 0:
+        return 1.0
+
+    page_w, page_h = float(page.get_width()), float(page.get_height())
+    if page_w <= 0.0 or page_h <= 0.0:
+        return 1.0
+
+    # Swap dimensions if rotated 90 or 270 degrees
+    if (rotation % 180) != 0:
+        page_w, page_h = page_h, page_w
+
+    return max(min(target_w / page_w, target_h / page_h), 1e-3)
+
+
 PDFIUM_PAGEOBJ_MAPPING = {
     pdfium_c.FPDF_PAGEOBJ_TEXT: "TEXT",
     pdfium_c.FPDF_PAGEOBJ_PATH: "PATH",
@@ -49,16 +90,16 @@ def convert_bitmap_to_corrected_numpy(bitmap: pdfium.PdfBitmap) -> np.ndarray:
     np.ndarray
         A NumPy array representing the correctly formatted image data.
     """
-    mode = bitmap.mode  # Use the mode to identify the correct format
-
-    # Convert to a NumPy array using the built-in method
     img_arr = bitmap.to_numpy().copy()
 
-    # Automatically handle channel swapping if necessary
+    # In-place SIMD-optimized BGR→RGB swap via OpenCV. This replaces pdfium's
+    # rev_byteorder flag, which triggers a non-thread-safe code path in
+    # CFX_AggDeviceDriver::GetDIBits() that SIGTRAPs under concurrent rendering.
+    mode = bitmap.mode
     if mode in {"BGRA", "BGRX"}:
-        img_arr = img_arr[..., [2, 1, 0, 3]]  # Swap BGR(A) to RGB(A)
+        cv2.cvtColor(img_arr, cv2.COLOR_BGRA2RGBA, dst=img_arr)
     elif mode == "BGR":
-        img_arr = img_arr[..., [2, 1, 0]]  # Swap BGR to RGB
+        cv2.cvtColor(img_arr, cv2.COLOR_BGR2RGB, dst=img_arr)
 
     return img_arr
 
@@ -147,7 +188,8 @@ def pdfium_pages_to_numpy(
         Defaults to None.
     padding_tuple : Optional[Tuple[int, int]], optional
         A tuple (width, height) to pad the image to. Defaults to None.
-    rotation:
+    rotation : int, optional
+        Page rotation in degrees (0, 90, 180, 270). Defaults to 0.
 
     Returns
     -------
@@ -171,15 +213,21 @@ def pdfium_pages_to_numpy(
 
     images = []
     padding_offsets = []
-    scale = render_dpi / 72  # 72 DPI is the base DPI in PDFium
+    base_scale = render_dpi / 72  # 72 DPI is the base DPI in PDFium
 
     for idx, page in enumerate(pages):
-        # Render the page as a bitmap with the specified scale and rotation
-        page_bitmap = page.render(scale=scale, rotation=rotation)
-        img_arr = convert_bitmap_to_corrected_numpy(page_bitmap)
-        # Apply scaling using the thumbnail approach if specified
+        # Render at target scale directly when scale_tuple specified to avoid large intermediate bitmaps
+        render_scale = base_scale
         if scale_tuple:
+            render_scale = min(base_scale, _compute_render_scale_to_fit(page, scale_tuple, rotation))
+
+        page_bitmap = page.render(scale=render_scale, rotation=rotation)
+        img_arr = convert_bitmap_to_corrected_numpy(page_bitmap)
+
+        # Safety fallback for rounding edge cases - only scale down if needed
+        if scale_tuple and (img_arr.shape[1] > scale_tuple[0] or img_arr.shape[0] > scale_tuple[1]):
             img_arr = scale_numpy_image(img_arr, scale_tuple)
+
         # Apply padding if specified
         if padding_tuple:
             img_arr, (pad_width, pad_height) = pad_image(
diff --git a/api/src/nv_ingest_api/util/service_clients/redis/redis_client.py b/api/src/nv_ingest_api/util/service_clients/redis/redis_client.py
index 2dae8162f..5de911d16 100644
--- a/api/src/nv_ingest_api/util/service_clients/redis/redis_client.py
+++ b/api/src/nv_ingest_api/util/service_clients/redis/redis_client.py
@@ -16,6 +16,7 @@
 
 
 from nv_ingest_api.util.service_clients.client_base import MessageBrokerClientBase, FetchMode
+from nv_ingest_api.util.service_clients.redis.redis_pool_metrics import InstrumentedBlockingConnectionPool
 
 try:
     from diskcache import Cache
@@ -49,12 +50,13 @@ def __init__(
         max_retries: int = 3,
         max_backoff: int = 32,
         connection_timeout: int = 300,
-        max_pool_size: int = 128,
+        max_pool_size: int = 50,
         use_ssl: bool = False,
         redis_allocator: Callable[..., redis.Redis] = redis.Redis,
         fetch_mode: "FetchMode" = None,  # Replace with appropriate default if FetchMode.DESTRUCTIVE is available.
         cache_config: Optional[Dict[str, Any]] = None,
         message_ttl_seconds: Optional[int] = 600,
+        pool_name: Optional[str] = None,
     ) -> None:
         """
         Initializes the Redis client with connection pooling, retry/backoff configuration,
@@ -75,7 +77,7 @@ def __init__(
         connection_timeout : int, optional
             Timeout in seconds for establishing a Redis connection. Default is 300.
         max_pool_size : int, optional
-            Maximum size of the Redis connection pool. Default is 128.
+            Maximum size of the Redis connection pool. Default is 50.
         use_ssl : bool, optional
             Whether to use SSL for the connection. Default is False.
         redis_allocator : Callable[..., redis.Redis], optional
@@ -88,6 +90,8 @@ def __init__(
         message_ttl_seconds : int, optional
             TTL (in seconds) for messages in NON_DESTRUCTIVE mode. If not provided,
             messages may persist indefinitely.
+        pool_name : str, optional
+            Name for the connection pool used in Prometheus metrics labels.
 
         Returns
         -------
@@ -111,20 +115,22 @@ def __init__(
                 "Messages fetched non-destructively may persist indefinitely in Redis."
             )
 
-        # Configure Connection Pool
         pool_kwargs: Dict[str, Any] = {
             "host": self._host,
             "port": self._port,
             "db": self._db,
             "socket_connect_timeout": self._connection_timeout,
             "max_connections": max_pool_size,
+            "timeout": 20,  # Wait up to 20s for a connection from the pool
         }
         if self._use_ssl:
             pool_kwargs["ssl"] = True
             pool_kwargs["ssl_cert_reqs"] = None  # Or specify requirements as needed.
             logger.debug("Redis connection configured with SSL.")
 
-        self._pool: redis.ConnectionPool = redis.ConnectionPool(**pool_kwargs)
+        self._pool: redis.BlockingConnectionPool = InstrumentedBlockingConnectionPool(
+            pool_name=pool_name or "default", **pool_kwargs
+        )
 
         # Allocate initial client
         self._client: Optional[redis.Redis] = self._redis_allocator(connection_pool=self._pool)
diff --git a/api/src/nv_ingest_api/util/service_clients/redis/redis_pool_metrics.py b/api/src/nv_ingest_api/util/service_clients/redis/redis_pool_metrics.py
new file mode 100644
index 000000000..fe5c70434
--- /dev/null
+++ b/api/src/nv_ingest_api/util/service_clients/redis/redis_pool_metrics.py
@@ -0,0 +1,114 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Instrumented Redis BlockingConnectionPool with Prometheus metrics."""
+
+import logging
+import time
+from typing import Any, Optional
+
+import redis
+from prometheus_client import Counter, Gauge, Histogram
+
+logger = logging.getLogger(__name__)
+
+POOL_CONNECTIONS_IN_USE = Gauge(
+    "redis_pool_connections_in_use",
+    "Number of connections currently checked out from the pool",
+    ["pool_name"],
+)
+
+POOL_CONNECTIONS_AVAILABLE = Gauge(
+    "redis_pool_connections_available",
+    "Number of connections available in the pool queue",
+    ["pool_name"],
+)
+
+POOL_CONNECTIONS_MAX = Gauge(
+    "redis_pool_connections_max",
+    "Maximum number of connections allowed in the pool",
+    ["pool_name"],
+)
+
+POOL_WAIT_SECONDS = Histogram(
+    "redis_pool_wait_seconds",
+    "Time spent waiting to acquire a connection from the pool",
+    ["pool_name"],
+    buckets=(0.001, 0.005, 0.01, 0.025, 0.05, 0.1, 0.25, 0.5, 1.0, 2.5, 5.0, 10.0, 20.0),
+)
+
+POOL_TIMEOUT_TOTAL = Counter(
+    "redis_pool_timeout_total",
+    "Total number of pool exhaustion timeout errors",
+    ["pool_name"],
+)
+
+
+class InstrumentedBlockingConnectionPool(redis.BlockingConnectionPool):
+    """
+    A BlockingConnectionPool subclass that exposes Prometheus metrics for
+    monitoring pool utilization and connection wait times.
+
+    Usage:
+        pool = InstrumentedBlockingConnectionPool(
+            pool_name="ingest",
+            host="localhost",
+            port=6379,
+            max_connections=50,
+            timeout=20,
+        )
+        client = redis.Redis(connection_pool=pool)
+    """
+
+    def __init__(self, pool_name: str = "default", **kwargs: Any) -> None:
+        super().__init__(**kwargs)
+        self._pool_name = pool_name
+        POOL_CONNECTIONS_MAX.labels(pool_name=self._pool_name).set(self.max_connections)
+
+    def _get_in_use_count(self) -> int:
+        return self.max_connections - self.pool.qsize()
+
+    def get_connection(self, command_name: Optional[str] = None, *keys: Any, **options: Any) -> Any:
+        start_time = time.perf_counter()
+
+        try:
+            connection = super().get_connection(command_name, *keys, **options)
+            wait_time = time.perf_counter() - start_time
+
+            POOL_WAIT_SECONDS.labels(pool_name=self._pool_name).observe(wait_time)
+            self._update_gauges()
+
+            return connection
+
+        except redis.ConnectionError:
+            wait_time = time.perf_counter() - start_time
+            POOL_WAIT_SECONDS.labels(pool_name=self._pool_name).observe(wait_time)
+            POOL_TIMEOUT_TOTAL.labels(pool_name=self._pool_name).inc()
+            in_use = self._get_in_use_count()
+            logger.warning(
+                f"Redis pool '{self._pool_name}' exhausted after {wait_time:.2f}s wait. "
+                f"In use: {in_use}, Max: {self.max_connections}"
+            )
+            raise
+
+    def release(self, connection: Any) -> None:
+        super().release(connection)
+        self._update_gauges()
+
+    def _update_gauges(self) -> None:
+        available = self.pool.qsize()
+        in_use = self.max_connections - available
+        POOL_CONNECTIONS_IN_USE.labels(pool_name=self._pool_name).set(in_use)
+        POOL_CONNECTIONS_AVAILABLE.labels(pool_name=self._pool_name).set(available)
+
+    def get_pool_stats(self) -> dict:
+        available = self.pool.qsize()
+        in_use = self.max_connections - available
+        return {
+            "pool_name": self._pool_name,
+            "in_use": in_use,
+            "available": available,
+            "max": self.max_connections,
+            "utilization_pct": (in_use / self.max_connections * 100) if self.max_connections > 0 else 0,
+        }
diff --git a/api/uv.lock b/api/uv.lock
index 263ea8f9f..c8d960bf6 100644
--- a/api/uv.lock
+++ b/api/uv.lock
@@ -226,27 +226,34 @@ dependencies = [
     { name = "ffmpeg-python" },
     { name = "fsspec" },
     { name = "glom" },
-    { name = "moviepy" },
     { name = "pandas" },
     { name = "pydantic" },
     { name = "pydantic-settings" },
+    { name = "pypdfium2" },
     { name = "tritonclient" },
     { name = "universal-pathlib" },
 ]
 
+[package.optional-dependencies]
+test = [
+    { name = "moviepy" },
+]
+
 [package.metadata]
 requires-dist = [
     { name = "backoff", specifier = "==2.2.1" },
     { name = "ffmpeg-python", specifier = "==0.2.0" },
     { name = "fsspec", specifier = ">=2025.5.1" },
     { name = "glom" },
-    { name = "moviepy", specifier = "==2.2.1" },
+    { name = "moviepy", marker = "extra == 'test'", specifier = "==2.2.1" },
     { name = "pandas", specifier = ">=2.0" },
     { name = "pydantic", specifier = ">2.0.0" },
     { name = "pydantic-settings", specifier = ">2.0.0" },
+    { name = "pypdfium2", specifier = ">=4.30.0" },
     { name = "tritonclient" },
     { name = "universal-pathlib", specifier = ">=0.2.6" },
 ]
+provides-extras = ["test"]
 
 [[package]]
 name = "pandas"
@@ -482,6 +489,35 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c1/60/5d4751ba3f4a40a6891f24eec885f51afd78d208498268c734e256fb13c4/pydantic_settings-2.12.0-py3-none-any.whl", hash = "sha256:fddb9fd99a5b18da837b29710391e945b1e30c135477f484084ee513adb93809", size = 51880, upload-time = "2025-11-10T14:25:45.546Z" },
 ]
 
+[[package]]
+name = "pypdfium2"
+version = "5.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fb/f6/42f5f1b9beb7e036f5532832b9c590fd107c52a78f704302c03bc6793954/pypdfium2-5.5.0.tar.gz", hash = "sha256:3283c61f54c3c546d140da201ef48a51c18b0ad54293091a010029ac13ece23a", size = 270502, upload-time = "2026-02-18T23:22:37.643Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/08/c0/cdddce35108c118cc110c1c2ed16de82d74d7646b9bcf98eae2fa440966b/pypdfium2-5.5.0-py3-none-android_23_arm64_v8a.whl", hash = "sha256:414f0b4aef7413e04df7355043fb752f2efb6f9777e04fd880d302612dacf89f", size = 2760984, upload-time = "2026-02-18T23:21:56.668Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/c7/23a6fbd6d23fd8dbe657696acd81fba858639ef221254ce05970152ad1d8/pypdfium2-5.5.0-py3-none-android_23_armeabi_v7a.whl", hash = "sha256:126ff8b131d12f16ce96b3e85b7f413e5073212be06b571f157fe11ad221c274", size = 2303146, upload-time = "2026-02-18T23:21:58.466Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/a9/379ec56c4481f39f0e37a7ce42f4844e6ddd7662571922e2b348105960ab/pypdfium2-5.5.0-py3-none-macosx_11_0_arm64.whl", hash = "sha256:0770bd3f0be5c68443fc4017e43b1b1fe8f36877481cab70fd29b68b2c362e1b", size = 2815036, upload-time = "2026-02-18T23:22:00.288Z" },
+    { url = "https://files.pythonhosted.org/packages/91/a4/b0cc01aaae1fdf1ca4e080cc55bb432f5a2234f33209a602bc498a47850d/pypdfium2-5.5.0-py3-none-macosx_11_0_x86_64.whl", hash = "sha256:5ab41a3b9953d9be44be35c36a2340f1d67c602db98a0d6f70006610871ae43a", size = 2948686, upload-time = "2026-02-18T23:22:02.213Z" },
+    { url = "https://files.pythonhosted.org/packages/26/99/25a0c71b551d100b505c618910afec0df402b230e087078c8078f8b1fcff/pypdfium2-5.5.0-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2492a22c3126a004cee2fa208ea4aa03ede2c7e205d05814934ab18f83d073e9", size = 2977311, upload-time = "2026-02-18T23:22:03.603Z" },
+    { url = "https://files.pythonhosted.org/packages/85/64/691e21539566f7a0521295948b5589d2fdfe3df5acab9c29ff410633a839/pypdfium2-5.5.0-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:83ff93e08b1fadb00040564e2eccc99147fc1a632ba5daff745126b373d78446", size = 2762449, upload-time = "2026-02-18T23:22:05.044Z" },
+    { url = "https://files.pythonhosted.org/packages/74/b1/9af288557291e2964bf5ffd460b7ed1090fcb8c54addfd6c7c5deb9ba7c7/pypdfium2-5.5.0-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b7e85de3332bedf8e5f157c248063b4eaf968660e1e490353b6e581d9f96a4c6", size = 3074851, upload-time = "2026-02-18T23:22:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/1e/c61fddbdea5ea1ba478dc7ecc9d68069d17b858e5fed04e4e071811f0858/pypdfium2-5.5.0-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e258365f34b6e334bb415e44dd9b1ee78a6e525bf854a1e74af67af7ede7555b", size = 3423003, upload-time = "2026-02-18T23:22:09.749Z" },
+    { url = "https://files.pythonhosted.org/packages/36/5f/d2eb58c54abba3a6c3bc4c297b3a11348dd4b4deb073f1aa8a872a298278/pypdfium2-5.5.0-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bec21d833404ca771f02fa5cefb0b73e2148f05cbdb3b5b9989bdd51d9b5cbac", size = 3002104, upload-time = "2026-02-18T23:22:12.035Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/33/87423eec4f5d4287d5a1726dbb9f06fb1f1aebc38ff75dcff817c492769d/pypdfium2-5.5.0-py3-none-manylinux_2_27_s390x.manylinux_2_28_s390x.whl", hash = "sha256:1dd6ccbe1b5e2e778e8b021e47f9485b4fd42eaa6c9bdda2631641724e1fcc04", size = 3097209, upload-time = "2026-02-18T23:22:13.809Z" },
+    { url = "https://files.pythonhosted.org/packages/97/0a/a3fd71f00838bba7922691107219bee67f50fbda6d12df330ef485a97848/pypdfium2-5.5.0-py3-none-manylinux_2_38_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:da3eada345570cec5e34872d1472d4ac542f0e650ccdb6c2eac08ae1a5f07c82", size = 2965027, upload-time = "2026-02-18T23:22:16.324Z" },
+    { url = "https://files.pythonhosted.org/packages/75/4a/2181260bd8a0b1b30ac50b7fd6ee3366e04f3a9f1c29351d882652da7fa7/pypdfium2-5.5.0-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:a087fb4088c7433fd3d78833dbe42cfb66df3d5ac98e3edf66110520fb33c0f0", size = 4131431, upload-time = "2026-02-18T23:22:18.469Z" },
+    { url = "https://files.pythonhosted.org/packages/15/bb/3ccf481191346eda11c0c208bd4e46f8de019ae7d9e9c1b660633f0bb3f4/pypdfium2-5.5.0-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:e6418cdc500ef85a90319f9bc7f1c54fc133460379f509429403225d8a4c157f", size = 3747468, upload-time = "2026-02-18T23:22:20.679Z" },
+    { url = "https://files.pythonhosted.org/packages/15/51/17e50ec72cf2235ac18d9cbe907859501c769d3e964818fefac6a3e10727/pypdfium2-5.5.0-py3-none-musllinux_1_2_i686.whl", hash = "sha256:8f7b66eedfac26eb2df4b00936e081b0a1c76fb8ee1c12639d85c2e73b0769ef", size = 4337579, upload-time = "2026-02-18T23:22:23.245Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/e4/f9bdf06f4d3f1e56eff9d997392a00a4b66cbc9c20f33934c4edc2a7943f/pypdfium2-5.5.0-py3-none-musllinux_1_2_ppc64le.whl", hash = "sha256:faea3246591ce2ea6218cd06679071275e3c65f11c3f5c9091eb7fb07610af6a", size = 4376104, upload-time = "2026-02-18T23:22:25.337Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/20/06baf1f5d494e035f50fc895fa1da5ed652d03ecc59aeb3aabb0daa5adfc/pypdfium2-5.5.0-py3-none-musllinux_1_2_riscv64.whl", hash = "sha256:aba26d404b51a9de3d3e80c867a95c71abf1c79552001ae22707451e59186b3d", size = 3929824, upload-time = "2026-02-18T23:22:26.889Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/01/28940e54e6936674e9a05eb58ccce7c54d8e2ac81cd84ec0b76e7d32a010/pypdfium2-5.5.0-py3-none-musllinux_1_2_s390x.whl", hash = "sha256:e0fa8f81679e6e71f26806f4db853571ee6435dc3bde7a46acdd182ef886a5b9", size = 4270200, upload-time = "2026-02-18T23:22:28.668Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/d4/1f36c505a3770aad9a88c895a46d61fd4c0535f79548f02c93b97ff89604/pypdfium2-5.5.0-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:ee22df3376d350eeb64d2002a1071e3a02c0d874c557a3cd8229a8fc572cdaac", size = 4180794, upload-time = "2026-02-18T23:22:30.11Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/38/f77e7792b4fba37f0e3d78db52fb7288d41db3c46ed28906fb940bc3e325/pypdfium2-5.5.0-py3-none-win32.whl", hash = "sha256:ec62a00223d1222d2f35c0866dd79cdc24da070738544cdf51b17d332d4a7389", size = 3001772, upload-time = "2026-02-18T23:22:32.367Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/c5/0d7ba53148262f78d8eee528a504764f78ae7bebf434a53714294b1fd973/pypdfium2-5.5.0-py3-none-win_amd64.whl", hash = "sha256:15c32fbeebb5198afa785dd03e98906ebb4eded9ef8862e10f833c37b4a18786", size = 3107710, upload-time = "2026-02-18T23:22:33.925Z" },
+    { url = "https://files.pythonhosted.org/packages/29/ad/fae449d2ed7b3088c6ab088f53fc6a9e9af26ccc9e0477d4182e373c4dd8/pypdfium2-5.5.0-py3-none-win_arm64.whl", hash = "sha256:f618af0884c16c768539c44933a255039131dbbf39d68eded020da4f14958d73", size = 2938315, upload-time = "2026-02-18T23:22:35.907Z" },
+]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
diff --git a/ci/scripts/nightly_build_publish.py b/ci/scripts/nightly_build_publish.py
new file mode 100644
index 000000000..a53a0bf94
--- /dev/null
+++ b/ci/scripts/nightly_build_publish.py
@@ -0,0 +1,364 @@
+#!/usr/bin/env python3
+"""
+Nightly builder/publisher for Hugging Face-hosted NVIDIA OSS repos.
+
+Behavior:
+- Clones a HF git repo with Git LFS smudge disabled (so large weights are not downloaded).
+- Attempts to append a PEP 440 dev version suffix (YYYYMMDD) to pyproject.toml or setup.cfg.
+- Builds sdist + wheel via `python -m build`.
+- Optionally uploads to (Test)PyPI via twine.
+
+This is intentionally best-effort across heterogeneous upstream projects.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime as _dt
+import os
+import re
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+def _run(cmd: list[str], *, cwd: Path | None = None, env: dict[str, str] | None = None) -> None:
+    print(f"+ {' '.join(cmd)}", flush=True)
+    subprocess.run(cmd, cwd=str(cwd) if cwd else None, env=env, check=True)
+
+
+def _read_text(path: Path) -> str:
+    return path.read_text(encoding="utf-8")
+
+
+def _write_text(path: Path, text: str) -> None:
+    path.write_text(text, encoding="utf-8")
+
+
+def _nightly_suffix_yyyymmdd() -> str:
+    # Allow overriding for reproducibility.
+    forced = os.environ.get("NIGHTLY_DATE_YYYYMMDD")
+    if forced:
+        return forced
+    return _dt.datetime.now(_dt.UTC).strftime("%Y%m%d")
+
+
+def _venv_python(venv_dir: Path) -> Path:
+    if os.name == "nt":
+        return venv_dir / "Scripts" / "python.exe"
+    return venv_dir / "bin" / "python"
+
+
+def _ensure_venv(venv_dir: Path, *, system_site_packages: bool) -> Path:
+    """
+    Ensure a local venv exists and return its python path.
+
+    We intentionally do all pip/build/twine operations inside this venv to avoid
+    system-Python restrictions (e.g. PEP 668 externally-managed environments).
+    """
+    marker = venv_dir / ".orch-system-site-packages"
+    py = _venv_python(venv_dir)
+    if py.exists():
+        # If caller changes system_site_packages setting, recreate the venv to ensure
+        # the correct site-packages visibility.
+        has_marker = marker.exists()
+        if has_marker == system_site_packages:
+            return py
+        shutil.rmtree(venv_dir)
+
+    venv_dir.parent.mkdir(parents=True, exist_ok=True)
+    cmd = [sys.executable, "-m", "venv"]
+    if system_site_packages:
+        cmd.append("--system-site-packages")
+    cmd.append(str(venv_dir))
+    _run(cmd)
+    py = _venv_python(venv_dir)
+    _run([str(py), "-m", "pip", "install", "--upgrade", "pip"])
+    if system_site_packages:
+        marker.write_text("1", encoding="utf-8")
+    return py
+
+
+def _pep440_nightly(base_version: str, yyyymmdd: str) -> str:
+    """
+    Convert a base version to a nightly dev version.
+    Examples:
+      1.2.3 -> 1.2.3.dev20260127
+      1.2.3+local -> 1.2.3.dev20260127
+    """
+    base = base_version.split("+", 1)[0].strip()
+    # If already has a .dev segment, replace it to keep it monotonic daily.
+    base = re.sub(r"\.dev\d+$", "", base)
+    return f"{base}.dev{yyyymmdd}"
+
+
+def _patch_pyproject_version(repo_dir: Path) -> bool:
+    pyproject = repo_dir / "pyproject.toml"
+    if not pyproject.exists():
+        return False
+
+    text = _read_text(pyproject)
+    # Match: version = "x.y.z" under [project] (best-effort, not a full TOML parser)
+    m = re.search(r'(?ms)^\[project\]\s.*?^\s*version\s*=\s*"([^"]+)"\s*$', text)
+    if not m:
+        return False
+
+    old_version = m.group(1)
+    new_version = _pep440_nightly(old_version, _nightly_suffix_yyyymmdd())
+    if new_version == old_version:
+        return False
+
+    text2 = text[: m.start(1)] + new_version + text[m.end(1) :]
+    _write_text(pyproject, text2)
+    print(f"Patched pyproject.toml version: {old_version} -> {new_version}")
+    return True
+
+
+def _patch_setup_cfg_version(repo_dir: Path) -> bool:
+    setup_cfg = repo_dir / "setup.cfg"
+    if not setup_cfg.exists():
+        return False
+
+    text = _read_text(setup_cfg)
+    # Match in [metadata]: version = x.y.z
+    m = re.search(r"(?ms)^\[metadata\]\s.*?^\s*version\s*=\s*([^\s#]+)\s*$", text)
+    if not m:
+        return False
+
+    old_version = m.group(1).strip().strip('"').strip("'")
+    new_version = _pep440_nightly(old_version, _nightly_suffix_yyyymmdd())
+    if new_version == old_version:
+        return False
+
+    text2 = text[: m.start(1)] + new_version + text[m.end(1) :]
+    _write_text(setup_cfg, text2)
+    print(f"Patched setup.cfg version: {old_version} -> {new_version}")
+    return True
+
+
+def _ensure_clean_dir(path: Path) -> None:
+    if path.exists():
+        shutil.rmtree(path)
+    path.mkdir(parents=True, exist_ok=True)
+
+
+def _clone_repo(repo_url: str, dest: Path) -> None:
+    env = os.environ.copy()
+    # Do not download large LFS objects.
+    env["GIT_LFS_SKIP_SMUDGE"] = "1"
+    _run(["git", "clone", "--depth", "1", repo_url, str(dest)], env=env)
+
+
+def _looks_like_python_project(project_dir: Path) -> bool:
+    return (project_dir / "pyproject.toml").exists() or (project_dir / "setup.cfg").exists()
+
+
+def _auto_project_subdir(repo_dir: Path, repo_id: str) -> str:
+    """
+    Best-effort detection for repos that keep the Python project in a nested
+    same-named directory (e.g. repo 'llama-nemotron-embed-1b-v2' containing
+    'llama-nemotron-embed-1b-v2/pyproject.toml').
+    """
+    if _looks_like_python_project(repo_dir):
+        return ""
+    candidate = repo_dir / repo_id
+    if candidate.is_dir() and _looks_like_python_project(candidate):
+        return repo_id
+    return ""
+
+
+def _apply_build_env_overrides(env: dict[str, str], build_env: list[str]) -> dict[str, str]:
+    """
+    Apply KEY=VALUE overrides to the environment dict.
+    """
+    for item in build_env:
+        if "=" not in item:
+            raise ValueError(f"--build-env must be KEY=VALUE, got: {item!r}")
+        k, v = item.split("=", 1)
+        k = k.strip()
+        if not k:
+            raise ValueError(f"--build-env must have a key, got: {item!r}")
+        env[k] = v
+    return env
+
+
+def _ensure_tmpdir(env: dict[str, str]) -> dict[str, str]:
+    """
+    Ensure temp files (including `python -m build` isolated envs) land on a
+    writable filesystem with enough space.
+
+    In some CI/container setups, `/tmp` can be a small tmpfs, which breaks builds
+    for projects that need large build dependencies (e.g. PyTorch wheels).
+    """
+    tmpdir = env.get("TMPDIR") or os.environ.get("TMPDIR")
+    if not tmpdir:
+        tmpdir = str(Path.cwd() / ".orch-tmp")
+        env["TMPDIR"] = tmpdir
+    Path(tmpdir).mkdir(parents=True, exist_ok=True)
+    return env
+
+
+def _pip_install(py: Path, packages: list[str], *, cwd: Path, env: dict[str, str]) -> None:
+    if not packages:
+        return
+    _run([str(py), "-m", "pip", "install", "--upgrade", *packages], cwd=cwd, env=env)
+
+
+def _build(
+    project_dir: Path,
+    out_dir: Path,
+    *,
+    build_env: list[str],
+    no_isolation: bool,
+    venv_system_site_packages: bool,
+    venv_pip_install: list[str],
+) -> None:
+    venv_dir = Path(os.environ.get("ORCH_VENV_DIR", ".venv-build"))
+    py = _ensure_venv(venv_dir, system_site_packages=venv_system_site_packages)
+
+    env = os.environ.copy()
+    env["PIP_DISABLE_PIP_VERSION_CHECK"] = "1"
+    env["PYTHONUNBUFFERED"] = "1"
+    env = _apply_build_env_overrides(env, build_env)
+    env = _ensure_tmpdir(env)
+
+    # Clean build outputs
+    for p in (project_dir / "dist", project_dir / "build"):
+        if p.exists():
+            shutil.rmtree(p)
+
+    _pip_install(py, ["build"], cwd=project_dir, env=env)
+    _pip_install(py, venv_pip_install, cwd=project_dir, env=env)
+
+    cmd = [str(py), "-m", "build", "--sdist", "--wheel"]
+    if no_isolation:
+        cmd.append("--no-isolation")
+    _run(cmd, cwd=project_dir, env=env)
+
+    dist_dir = project_dir / "dist"
+    if not dist_dir.exists():
+        raise RuntimeError("Build succeeded but dist/ not found")
+    out_dir.mkdir(parents=True, exist_ok=True)
+    for artifact in dist_dir.iterdir():
+        shutil.copy2(artifact, out_dir / artifact.name)
+
+
+def _twine_upload(dist_dir: Path, repository_url: str, token: str, *, skip_existing: bool) -> None:
+    venv_dir = Path(os.environ.get("ORCH_VENV_DIR", ".venv-build"))
+    # Twine doesn't need system site packages; keep it off by default.
+    py = _ensure_venv(venv_dir, system_site_packages=False)
+
+    env = os.environ.copy()
+    env["TWINE_USERNAME"] = "__token__"
+    env["TWINE_PASSWORD"] = token
+    env = _ensure_tmpdir(env)
+    _run([str(py), "-m", "pip", "install", "--upgrade", "twine"], env=env)
+    cmd = [
+        str(py),
+        "-m",
+        "twine",
+        "upload",
+        "--non-interactive",
+        "--repository-url",
+        repository_url,
+    ]
+    if skip_existing:
+        cmd.append("--skip-existing")
+    cmd.append(str(dist_dir / "*"))
+    _run(cmd, env=env)
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--repo-id", required=True, help="Short identifier for logs/paths")
+    ap.add_argument("--repo-url", required=True, help="HF git repo URL, e.g. https://huggingface.co/nvidia/xxx")
+    ap.add_argument("--work-dir", default=".work", help="Workspace temp dir")
+    ap.add_argument("--dist-dir", default="dist-out", help="Where to collect artifacts")
+    ap.add_argument(
+        "--project-subdir",
+        default="",
+        help="If the Python project lives in a subdirectory, build from there (e.g. 'nemotron-ocr')",
+    )
+    ap.add_argument(
+        "--build-env",
+        action="append",
+        default=[],
+        help="Extra env vars for the build backend, as KEY=VALUE (repeatable)",
+    )
+    ap.add_argument(
+        "--build-no-isolation",
+        action="store_true",
+        help="Pass --no-isolation to `python -m build` (useful to reuse preinstalled deps in CI images)",
+    )
+    ap.add_argument(
+        "--venv-dir",
+        default=".venv-build",
+        help="Local venv used for build/twine (default: .venv-build)",
+    )
+    ap.add_argument(
+        "--venv-system-site-packages",
+        action="store_true",
+        help="Create the build venv with --system-site-packages (to reuse system-installed packages like torch)",
+    )
+    ap.add_argument(
+        "--venv-pip-install",
+        action="append",
+        default=[],
+        help="Extra packages to pip install into the build venv before building (repeatable)",
+    )
+    ap.add_argument("--upload", action="store_true", help="Upload built dists via twine")
+    ap.add_argument("--repository-url", default="https://test.pypi.org/legacy/", help="Twine repository URL")
+    ap.add_argument("--token-env", default="TEST_PYPI_API_TOKEN", help="Env var containing API token")
+    ap.add_argument("--skip-existing", action="store_true", help="Pass --skip-existing to twine")
+    args = ap.parse_args()
+
+    root = Path.cwd()
+    work_root = root / args.work_dir
+    dist_root = root / args.dist_dir
+    os.environ["ORCH_VENV_DIR"] = str(root / args.venv_dir)
+
+    repo_dir = work_root / args.repo_id
+    _ensure_clean_dir(work_root)
+    if repo_dir.exists():
+        shutil.rmtree(repo_dir)
+
+    print(f"=== Cloning {args.repo_url} -> {repo_dir} ===")
+    _clone_repo(args.repo_url, repo_dir)
+
+    print("=== Attempting nightly version patch ===")
+    if not args.project_subdir:
+        detected = _auto_project_subdir(repo_dir, args.repo_id)
+        if detected:
+            args.project_subdir = detected
+            print(f"Auto-detected project subdir: {args.project_subdir}")
+    project_dir = repo_dir / args.project_subdir if args.project_subdir else repo_dir
+    patched = _patch_pyproject_version(project_dir) or _patch_setup_cfg_version(project_dir)
+    if not patched:
+        print("No static version field found to patch (continuing).")
+
+    print("=== Building sdist + wheel ===")
+    out_dir = dist_root / args.repo_id
+    _ensure_clean_dir(out_dir)
+    _build(
+        project_dir,
+        out_dir,
+        build_env=args.build_env,
+        no_isolation=args.build_no_isolation,
+        venv_system_site_packages=args.venv_system_site_packages,
+        venv_pip_install=args.venv_pip_install,
+    )
+    print(f"Artifacts in: {out_dir}")
+
+    if args.upload:
+        token = os.environ.get(args.token_env)
+        if not token:
+            raise RuntimeError(f"Missing required env var: {args.token_env}")
+        print(f"=== Uploading to {args.repository_url} ===")
+        _twine_upload(out_dir, args.repository_url, token, skip_existing=args.skip_existing)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/ci/scripts/validate_deployment_configs.py b/ci/scripts/validate_deployment_configs.py
new file mode 100755
index 000000000..b7cf37733
--- /dev/null
+++ b/ci/scripts/validate_deployment_configs.py
@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""
+Validate consistency between Docker Compose and Helm deployment configurations.
+
+This script compares image versions and environment variables for all services
+defined in both docker-compose.yaml and helm/values.yaml, reporting any
+discrepancies found.
+"""
+
+import re
+import sys
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import yaml
+
+
+@dataclass
+class ServiceConfig:
+    """Configuration for a deployable service."""
+
+    name: str
+    image_repo: Optional[str] = None
+    image_tag: Optional[str] = None
+    environment: Dict[str, str] = field(default_factory=dict)
+
+
+@dataclass
+class ConfigDiff:
+    """Represents a configuration difference between deployments."""
+
+    service_name: str
+    field: str
+    helm_value: Optional[str]
+    compose_value: Optional[str]
+
+    def __str__(self) -> str:
+        return (
+            f"  {self.service_name}.{self.field}:\n"
+            f"    Helm:    {self.helm_value or '(not set)'}\n"
+            f"    Compose: {self.compose_value or '(not set)'}"
+        )
+
+
+# Mapping between Docker Compose service names and Helm service names
+# Most services are under nimOperator, but nv-ingest-ms-runtime is at the top level
+SERVICE_MAPPING = {
+    "page-elements": "page_elements",
+    "graphic-elements": "graphic_elements",
+    "table-structure": "table_structure",
+    "ocr": "nemoretriever_ocr_v1",
+    "embedding": "embedqa",
+    "reranker": "llama_3_2_nv_rerankqa_1b_v2",
+    "nemotron-parse": "nemotron_parse",
+    "vlm": "nemotron_nano_12b_v2_vl",
+    "audio": "audio",
+    "nv-ingest-ms-runtime": "__MAIN__",  # Special marker for top-level config
+}
+
+# Environment variables to ignore in comparison (deployment-specific)
+IGNORED_ENV_VARS = {
+    "NGC_API_KEY",
+    "NIM_NGC_API_KEY",
+    "NVIDIA_API_KEY",
+    "CUDA_VISIBLE_DEVICES",
+    "NIM_ENABLE_OTEL",  # Often differs between deployments
+    "NIM_OTEL_EXPORTER_OTLP_ENDPOINT",  # Endpoint URLs may differ
+    "TRITON_OTEL_URL",  # Endpoint URLs may differ
+    "OTEL_EXPORTER_OTLP_ENDPOINT",  # Main service OTEL endpoint
+    "MINIO_ACCESS_KEY",  # Credentials
+    "MINIO_SECRET_KEY",  # Credentials
+    "MINIO_INTERNAL_ADDRESS",  # Deployment-specific DNS names
+    "MINIO_PUBLIC_ADDRESS",  # Deployment-specific URLs
+    "MESSAGE_CLIENT_HOST",  # DNS names differ (redis vs nv-ingest-redis-master)
+    "EMBEDDING_NIM_ENDPOINT",  # DNS names differ (embedding:8000 vs llama-32-nv-embedqa-1b-v2:8000)
+    "VLM_CAPTION_ENDPOINT",  # Conditionally set in Helm, may use external API
+    "INGEST_RAY_LOG_LEVEL",  # May differ between dev/prod
+    "RAY_num_server_call_thread",  # Ray config may differ
+    "RAY_worker_num_grpc_internal_threads",  # Ray config may differ
+    "PDF_SPLIT_PAGE_COUNT",  # Tuning parameter that may differ
+    "REDIS_INGEST_TASK_QUEUE",  # Queue names may be deployment-specific
+    "MILVUS_ENDPOINT",  # DNS names differ between deployments
+    "IMAGE_STORAGE_PUBLIC_BASE_URL",  # Optional, may be empty
+    "INGEST_EDGE_BUFFER_SIZE",  # May not be explicitly set in compose (uses default)
+    # Service endpoint DNS names differ between Helm (full names) and Compose (short names)
+    "YOLOX_GRPC_ENDPOINT",
+    "YOLOX_HTTP_ENDPOINT",
+    "YOLOX_GRAPHIC_ELEMENTS_GRPC_ENDPOINT",
+    "YOLOX_GRAPHIC_ELEMENTS_HTTP_ENDPOINT",
+    "YOLOX_TABLE_STRUCTURE_GRPC_ENDPOINT",
+    "YOLOX_TABLE_STRUCTURE_HTTP_ENDPOINT",
+    "OCR_GRPC_ENDPOINT",
+    "OCR_HTTP_ENDPOINT",
+}
+
+
+def load_yaml(filepath: Path) -> dict:
+    """Load and parse a YAML file."""
+    with open(filepath) as f:
+        return yaml.safe_load(f)
+
+
+def parse_compose_image(image_str: str) -> tuple[Optional[str], Optional[str]]:
+    """
+    Parse Docker Compose image string into repository and tag.
+
+    Examples:
+        'nvcr.io/nim/nvidia/nemoretriever-ocr-v1:1.2.1'
+            -> ('nvcr.io/nim/nvidia/nemoretriever-ocr-v1', '1.2.1')
+        '${OCR_IMAGE:-nvcr.io/nim/nvidia/nemoretriever-ocr-v1}:${OCR_TAG:-1.2.1}'
+            -> ('nvcr.io/nim/nvidia/nemoretriever-ocr-v1', '1.2.1')
+    """
+    # Handle environment variable substitution patterns
+    # Extract default values from ${VAR:-default} patterns
+    image_str = re.sub(r"\$\{[^}]*:-([^}]+)\}", r"\1", image_str)
+    image_str = re.sub(r"\$\{[^}]+\}", "", image_str)
+
+    if ":" in image_str:
+        parts = image_str.rsplit(":", 1)
+        return parts[0].strip(), parts[1].strip()
+    return image_str.strip(), None
+
+
+def parse_compose_env(env_list: List) -> Dict[str, str]:
+    """Parse Docker Compose environment variables."""
+    env_dict = {}
+    if not env_list:
+        return env_dict
+
+    for item in env_list:
+        if isinstance(item, str):
+            if "=" in item:
+                key, value = item.split("=", 1)
+                # Extract default values from ${VAR:-default} patterns
+                value = re.sub(r"\$\{[^}]*:-([^}]+)\}", r"\1", value)
+                value = re.sub(r"\$\{([^}]+)\}", r"${\1}", value)  # Keep unresolved vars
+                env_dict[key.strip()] = value.strip()
+        elif isinstance(item, dict):
+            env_dict.update(item)
+
+    return env_dict
+
+
+def extract_compose_services(compose_config: dict) -> Dict[str, ServiceConfig]:
+    """Extract service configurations from Docker Compose."""
+    services = {}
+
+    for service_name, service_def in compose_config.get("services", {}).items():
+        if service_name not in SERVICE_MAPPING:
+            continue  # Skip services not in our mapping
+
+        image = service_def.get("image", "")
+        repo, tag = parse_compose_image(image)
+
+        environment = parse_compose_env(service_def.get("environment", []))
+
+        services[service_name] = ServiceConfig(
+            name=service_name,
+            image_repo=repo,
+            image_tag=tag,
+            environment=environment,
+        )
+
+    return services
+
+
+def parse_helm_env(env_list: List) -> Dict[str, str]:
+    """Parse Helm environment variables."""
+    env_dict = {}
+    if not env_list:
+        return env_dict
+
+    for item in env_list:
+        if isinstance(item, dict):
+            name = item.get("name")
+            value = item.get("value")
+            if name:
+                env_dict[name] = str(value) if value is not None else ""
+
+    return env_dict
+
+
+def extract_helm_services(helm_config: dict) -> Dict[str, ServiceConfig]:
+    """Extract service configurations from Helm values."""
+    services = {}
+
+    # Handle main nv-ingest service (top-level configuration)
+    main_image = helm_config.get("image", {})
+    main_env_vars = helm_config.get("envVars", {})
+
+    # Convert envVars dict to environment dict
+    main_environment = {k: str(v) if v is not None else "" for k, v in main_env_vars.items()}
+
+    services["nv-ingest-ms-runtime"] = ServiceConfig(
+        name="nv-ingest-ms-runtime",
+        image_repo=main_image.get("repository"),
+        image_tag=str(main_image.get("tag")) if main_image.get("tag") else None,
+        environment=main_environment,
+    )
+
+    # Handle NIM services under nimOperator
+    nim_operator = helm_config.get("nimOperator", {})
+
+    for helm_service_name, service_def in nim_operator.items():
+        if helm_service_name in ["nimCache", "nimService"]:
+            continue  # Skip configuration sections
+
+        # Find corresponding compose service name
+        compose_name = None
+        for compose_key, helm_key in SERVICE_MAPPING.items():
+            if helm_key == helm_service_name:
+                compose_name = compose_key
+                break
+
+        if not compose_name:
+            continue
+
+        image_def = service_def.get("image", {})
+        repo = image_def.get("repository")
+        tag = image_def.get("tag")
+
+        environment = parse_helm_env(service_def.get("env", []))
+
+        services[compose_name] = ServiceConfig(
+            name=compose_name,
+            image_repo=repo,
+            image_tag=str(tag) if tag else None,
+            environment=environment,
+        )
+
+    return services
+
+
+def normalize_value(value: Optional[str]) -> Optional[str]:
+    """
+    Normalize values for comparison.
+
+    Handles:
+    - Boolean normalization (true/True, false/False)
+    - Numeric precision (0.8 vs 0.80)
+    - Environment variable placeholders (${VAR:-})
+    """
+    if value is None or value == "":
+        return None
+
+    value = str(value).strip()
+
+    # Handle empty environment variable defaults like ${VAR:-}
+    if value.startswith("${") and value.endswith(":-}"):
+        return None
+
+    # Normalize booleans
+    if value.lower() in ("true", "false"):
+        return value.lower()
+
+    # Try to normalize numeric values
+    try:
+        # Handle integers
+        if "." not in value:
+            int_val = int(value)
+            return str(int_val)
+        # Handle floats
+        else:
+            float_val = float(value)
+            # Normalize to consistent precision
+            return str(float_val)
+    except (ValueError, TypeError):
+        pass
+
+    return value
+
+
+def compare_services(
+    compose_services: Dict[str, ServiceConfig], helm_services: Dict[str, ServiceConfig]
+) -> List[ConfigDiff]:
+    """Compare service configurations and return list of differences."""
+    diffs = []
+
+    # Get all service names from both configs
+    all_services = set(compose_services.keys()) | set(helm_services.keys())
+
+    for service_name in sorted(all_services):
+        compose_svc = compose_services.get(service_name)
+        helm_svc = helm_services.get(service_name)
+
+        if not compose_svc or not helm_svc:
+            # Service exists in only one config - this might be intentional (profiles)
+            continue
+
+        # Compare image repository
+        if compose_svc.image_repo and helm_svc.image_repo:
+            if compose_svc.image_repo != helm_svc.image_repo:
+                diffs.append(
+                    ConfigDiff(
+                        service_name=service_name,
+                        field="image_repository",
+                        helm_value=helm_svc.image_repo,
+                        compose_value=compose_svc.image_repo,
+                    )
+                )
+
+        # Compare image tag
+        if compose_svc.image_tag and helm_svc.image_tag:
+            if compose_svc.image_tag != helm_svc.image_tag:
+                diffs.append(
+                    ConfigDiff(
+                        service_name=service_name,
+                        field="image_tag",
+                        helm_value=helm_svc.image_tag,
+                        compose_value=compose_svc.image_tag,
+                    )
+                )
+
+        # Compare environment variables
+        all_env_keys = set(compose_svc.environment.keys()) | set(helm_svc.environment.keys())
+
+        for env_key in sorted(all_env_keys):
+            if env_key in IGNORED_ENV_VARS:
+                continue
+
+            compose_val = compose_svc.environment.get(env_key)
+            helm_val = helm_svc.environment.get(env_key)
+
+            # Normalize values for comparison
+            compose_val_normalized = normalize_value(compose_val)
+            helm_val_normalized = normalize_value(helm_val)
+
+            # Skip if both are unset or empty after normalization
+            if not compose_val_normalized and not helm_val_normalized:
+                continue
+
+            # Check for differences
+            if compose_val_normalized != helm_val_normalized:
+                diffs.append(
+                    ConfigDiff(
+                        service_name=service_name,
+                        field=f"env.{env_key}",
+                        helm_value=helm_val,
+                        compose_value=compose_val,
+                    )
+                )
+
+    return diffs
+
+
+def main() -> int:
+    """Main validation logic."""
+    # Determine repository root (script is in ci/scripts/)
+    script_dir = Path(__file__).parent
+    repo_root = script_dir.parent.parent
+
+    compose_path = repo_root / "docker-compose.yaml"
+    helm_path = repo_root / "helm" / "values.yaml"
+
+    # Load configurations
+    print("Loading configuration files...")
+    print(f"  Docker Compose: {compose_path}")
+    print(f"  Helm values:    {helm_path}")
+    print()
+
+    try:
+        compose_config = load_yaml(compose_path)
+        helm_config = load_yaml(helm_path)
+    except Exception as e:
+        print(f"❌ Error loading configuration files: {e}", file=sys.stderr)
+        return 1
+
+    # Extract service configurations
+    compose_services = extract_compose_services(compose_config)
+    helm_services = extract_helm_services(helm_config)
+
+    print(f"Found {len(compose_services)} Docker Compose services")
+    print(f"Found {len(helm_services)} Helm services")
+    print()
+
+    # Compare configurations
+    diffs = compare_services(compose_services, helm_services)
+
+    if not diffs:
+        print("✅ All service configurations are consistent!")
+        return 0
+
+    # Report differences
+    print(f"❌ Found {len(diffs)} configuration discrepancies:\n")
+
+    # Group diffs by service
+    diffs_by_service: Dict[str, List[ConfigDiff]] = {}
+    for diff in diffs:
+        if diff.service_name not in diffs_by_service:
+            diffs_by_service[diff.service_name] = []
+        diffs_by_service[diff.service_name].append(diff)
+
+    # Print grouped by service
+    for service_name in sorted(diffs_by_service.keys()):
+        service_diffs = diffs_by_service[service_name]
+        print(f"Service: {service_name}")
+        for diff in service_diffs:
+            print(diff)
+        print()
+
+    print(f"Total discrepancies: {len(diffs)}")
+    print("\nPlease update the configurations to ensure consistency between deployments.")
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/client/client_tests/primitives/tasks/test_caption.py b/client/client_tests/primitives/tasks/test_caption.py
index dd20be95c..34a47d31b 100644
--- a/client/client_tests/primitives/tasks/test_caption.py
+++ b/client/client_tests/primitives/tasks/test_caption.py
@@ -113,6 +113,110 @@ def test_caption_task_to_dict_empty_fields():
     assert task_dict == {"type": "caption", "task_properties": {}}
 
 
+def test_caption_task_temperature_init():
+    """Test initializing CaptionTask with temperature."""
+    task = CaptionTask(temperature=0.7)
+    assert task._temperature == 0.7
+
+
+def test_caption_task_temperature_default():
+    """Test that temperature defaults to None."""
+    task = CaptionTask()
+    assert task._temperature is None
+
+
+def test_caption_task_temperature_to_dict():
+    """Test to_dict includes temperature when set."""
+    task = CaptionTask(temperature=0.5)
+    task_dict = task.to_dict()
+    assert task_dict["task_properties"]["temperature"] == 0.5
+
+
+def test_caption_task_temperature_to_dict_unset():
+    """Test to_dict excludes temperature when not set."""
+    task = CaptionTask()
+    task_dict = task.to_dict()
+    assert "temperature" not in task_dict["task_properties"]
+
+
+def test_caption_task_temperature_str():
+    """Test __str__ includes temperature when set."""
+    task = CaptionTask(temperature=0.3)
+    task_str = str(task)
+    assert "temperature: 0.3" in task_str
+
+
+def test_caption_task_temperature_str_unset():
+    """Test __str__ omits temperature when not set."""
+    task = CaptionTask()
+    task_str = str(task)
+    assert "temperature" not in task_str
+
+
+def test_caption_task_context_text_max_chars_init():
+    """Test initializing CaptionTask with context_text_max_chars."""
+    task = CaptionTask(context_text_max_chars=512)
+    assert task._context_text_max_chars == 512
+
+
+def test_caption_task_context_text_max_chars_default():
+    """Test that context_text_max_chars defaults to None."""
+    task = CaptionTask()
+    assert task._context_text_max_chars is None
+
+
+def test_caption_task_context_text_max_chars_to_dict():
+    """Test to_dict includes context_text_max_chars when set."""
+    task = CaptionTask(context_text_max_chars=256)
+    task_dict = task.to_dict()
+    assert task_dict["task_properties"]["context_text_max_chars"] == 256
+
+
+def test_caption_task_context_text_max_chars_to_dict_unset():
+    """Test to_dict excludes context_text_max_chars when not set."""
+    task = CaptionTask()
+    task_dict = task.to_dict()
+    assert "context_text_max_chars" not in task_dict["task_properties"]
+
+
+def test_caption_task_context_text_max_chars_str():
+    """Test __str__ includes context_text_max_chars when set."""
+    task = CaptionTask(context_text_max_chars=1024)
+    task_str = str(task)
+    assert "context_text_max_chars: 1024" in task_str
+
+
+def test_caption_task_context_text_max_chars_str_unset():
+    """Test __str__ omits context_text_max_chars when not set."""
+    task = CaptionTask()
+    task_str = str(task)
+    assert "context_text_max_chars" not in task_str
+
+
+def test_caption_task_schema_context_text_max_chars():
+    """Test IngestTaskCaptionSchema accepts context_text_max_chars."""
+    schema = IngestTaskCaptionSchema(context_text_max_chars=100)
+    assert schema.context_text_max_chars == 100
+
+
+def test_caption_task_schema_context_text_max_chars_default():
+    """Test IngestTaskCaptionSchema context_text_max_chars defaults to None."""
+    schema = IngestTaskCaptionSchema()
+    assert schema.context_text_max_chars is None
+
+
+def test_caption_task_schema_temperature():
+    """Test IngestTaskCaptionSchema accepts temperature."""
+    schema = IngestTaskCaptionSchema(temperature=0.5)
+    assert schema.temperature == 0.5
+
+
+def test_caption_task_schema_temperature_default():
+    """Test IngestTaskCaptionSchema temperature defaults to None."""
+    schema = IngestTaskCaptionSchema()
+    assert schema.temperature is None
+
+
 # Execute tests
 if __name__ == "__main__":
     test_caption_task_schema_valid_all_fields()
@@ -127,4 +231,12 @@ def test_caption_task_to_dict_empty_fields():
     test_caption_task_to_dict_all_fields()
     test_caption_task_to_dict_partial_fields()
     test_caption_task_to_dict_empty_fields()
+    test_caption_task_context_text_max_chars_init()
+    test_caption_task_context_text_max_chars_default()
+    test_caption_task_context_text_max_chars_to_dict()
+    test_caption_task_context_text_max_chars_to_dict_unset()
+    test_caption_task_context_text_max_chars_str()
+    test_caption_task_context_text_max_chars_str_unset()
+    test_caption_task_schema_context_text_max_chars()
+    test_caption_task_schema_context_text_max_chars_default()
     print("All tests passed.")
diff --git a/client/client_tests/primitives/tasks/test_dedup.py b/client/client_tests/primitives/tasks/test_dedup.py
index 6e2741ddc..8a4edc05c 100644
--- a/client/client_tests/primitives/tasks/test_dedup.py
+++ b/client/client_tests/primitives/tasks/test_dedup.py
@@ -28,7 +28,14 @@ def test_dedup_task_default_initialization():
 
 def test_dedup_task_str_representation():
     task = DedupTask(content_type="image", filter=True)
-    expected_str = "Dedup Task:\n" "  content_type: image\n" "  filter: True\n"
+    expected_str = (
+        "Dedup Task:\n"
+        "  content_type: image\n"
+        "  filter: True\n"
+        "  enable_bbox_dedup: True\n"
+        "  iou_threshold: 0.45\n"
+        "  prefer_structured: True\n"
+    )
     assert str(task) == expected_str
 
 
@@ -57,7 +64,12 @@ def test_dedup_task_to_dict(content_type, filter_val, expected_content_type):
         "type": "dedup",
         "task_properties": {
             "content_type": expected_content_type,
-            "params": {"filter": filter_val},
+            "params": {
+                "filter": filter_val,
+                "enable_bbox_dedup": True,
+                "iou_threshold": 0.45,
+                "bbox_dedup_prefer_structured": True,
+            },
         },
     }
 
@@ -79,7 +91,12 @@ def test_dedup_task_default_params():
         "type": "dedup",
         "task_properties": {
             "content_type": "image",
-            "params": {"filter": False},
+            "params": {
+                "filter": False,
+                "enable_bbox_dedup": True,
+                "iou_threshold": 0.45,
+                "bbox_dedup_prefer_structured": True,
+            },
         },
     }
     assert task_dict == expected_dict
diff --git a/client/client_tests/util/test_lancedb_util.py b/client/client_tests/util/test_lancedb_util.py
index 4f92f6db4..30af72b67 100644
--- a/client/client_tests/util/test_lancedb_util.py
+++ b/client/client_tests/util/test_lancedb_util.py
@@ -5,53 +5,60 @@
 
 
 def make_sample_results():
-    # two record-sets, each with two items
+    """
+    Create sample NV-Ingest pipeline results for testing.
+
+    Returns records in the format produced by the extraction pipeline,
+    including document_type which is required for text extraction routing.
+    """
     return [
         [
             {
+                "document_type": "text",
                 "metadata": {
                     "embedding": [0.1, 0.2],
-                    "content": "a",
+                    "content": "text content a",
                     "content_metadata": {"page_number": 1},
                     "source_metadata": {"source_id": "s1"},
-                }
+                },
             },
             {
+                "document_type": "text",
                 "metadata": {
-                    "embedding": None,
-                    "content": "skip",
+                    "embedding": None,  # Should be skipped - no embedding
+                    "content": "skip me",
                     "content_metadata": {"page_number": 2},
                     "source_metadata": {"source_id": "s1"},
-                }
+                },
             },
         ],
         [
             {
+                "document_type": "text",
                 "metadata": {
                     "embedding": [0.3, 0.4],
-                    "content": "b",
+                    "content": "text content b",
                     "content_metadata": {"page_number": 3},
                     "source_metadata": {"source_id": "s2"},
-                }
+                },
             },
         ],
     ]
 
 
 def test_create_lancedb_results_filters_and_transforms():
+    """Test that create_lancedb_results correctly filters and transforms records."""
     results = make_sample_results()
     out = lancedb_mod.create_lancedb_results(results)
-    # Should skip the entry with None embedding and produce 2 entries
     assert isinstance(out, list)
     assert len(out) == 2
     assert out[0]["vector"] == [0.1, 0.2]
-    assert out[0]["text"] == "a"
-    assert out[0]["metadata"] == 1
-    assert out[0]["source"] == "s1"
+    assert out[0]["text"] == "text content a"
+    assert out[0]["metadata"] == '{"page_number":1}'
+    assert out[0]["source"] == '{"source_id":"s1"}'
 
 
 def test_create_index_uses_lancedb_and_pa_schema(monkeypatch):
-    # Mock lancedb.connect and pa.schema so we don't need real packages
     fake_db = Mock()
     fake_table = Mock()
     fake_db.create_table = Mock(return_value=fake_table)
@@ -60,16 +67,13 @@ def test_create_index_uses_lancedb_and_pa_schema(monkeypatch):
     monkeypatch.setattr(lancedb_mod, "pa", Mock(schema=Mock(return_value="schema")))
 
     sample = make_sample_results()
-    # call create_index with the same nested input shape the function expects
     table = lancedb_mod.LanceDB().create_index(records=sample)
 
-    # Ensure create_table was called and returned the fake table
     fake_db.create_table.assert_called()
     assert table is fake_table
 
 
 def test_write_to_index_creates_index_and_waits(monkeypatch):
-    # Create a fake table object with expected methods
     fake_table = Mock()
     fake_table.list_indices = Mock(
         return_value=[types.SimpleNamespace(name="idx1"), types.SimpleNamespace(name="idx2")]
@@ -78,24 +82,19 @@ def test_write_to_index_creates_index_and_waits(monkeypatch):
     fake_table.wait_for_index = Mock()
 
     ldb = lancedb_mod.LanceDB()
-    # write_to_index uses table.create_index then waits for indices
     ldb.write_to_index(records=None, table=fake_table)
 
     fake_table.create_index.assert_called()
     fake_table.list_indices.assert_called()
-    # Ensure wait_for_index was called with list of names
     fake_table.wait_for_index.assert_called()
 
 
 def test_retrieval_calls_embed_and_search(monkeypatch):
-    # Prepare a fake infer_microservice that returns one embedding per query
     def fake_infer_microservice(queries, **kwargs):
-        # return a list of embeddings (one per query)
         return [[0.1, 0.2, 0.3] for _ in queries]
 
     monkeypatch.setattr(lancedb_mod, "infer_microservice", fake_infer_microservice)
 
-    # Build a fake table.search chain: search(...).select(...).limit(...).to_list()
     class FakeSearchResult:
         def __init__(self, items):
             self._items = items
@@ -116,22 +115,19 @@ def to_list(self):
             return self._items
 
     fake_table = Mock()
-    # Return two hits for each search to verify wrapping
     fake_table.search = Mock(return_value=FakeSearchResult([{"text": "hit1", "metadata": 1, "source": "s"}]))
 
     ldb = lancedb_mod.LanceDB()
     queries = ["hello", "world"]
     results = ldb.retrieval(queries, table=fake_table)
 
-    # Should return a list with an entry per query
     assert isinstance(results, list)
     assert len(results) == len(queries)
-    # Each entry should be the list returned by FakeSearchResult.to_list()
     assert results[0][0]["entity"]["text"] == "hit1"
 
 
 def test_run_calls_create_and_write(monkeypatch):
-    ldb = lancedb_mod.LanceDB()
+    ldb = lancedb_mod.LanceDB(hybrid=True, fts_language="Spanish")
     monkeypatch.setattr(ldb, "create_index", Mock(return_value="table_obj"))
     monkeypatch.setattr(ldb, "write_to_index", Mock())
 
@@ -146,19 +142,28 @@ def test_run_calls_create_and_write(monkeypatch):
         metric=ldb.metric,
         num_partitions=ldb.num_partitions,
         num_sub_vectors=ldb.num_sub_vectors,
+        hybrid=True,
+        fts_language="Spanish",
     )
     assert records == out
 
 
-# ============ Additional Tests for Untested Areas ============
+def test_write_to_index_creates_fts_index_when_hybrid(monkeypatch):
+    fake_table = Mock()
+    fake_table.list_indices = Mock(
+        return_value=[
+            types.SimpleNamespace(name="vector_idx"),
+            types.SimpleNamespace(name="text_idx"),
+        ]
+    )
+    fake_table.create_index = Mock()
+    fake_table.create_fts_index = Mock()
+    fake_table.wait_for_index = Mock()
 
+    ldb = lancedb_mod.LanceDB(hybrid=True)
+    ldb.write_to_index(records=None, table=fake_table, hybrid=True)
 
-def test_init_with_uri_and_overwrite():
-    """Test LanceDB initialization with custom uri and overwrite settings."""
-    ldb = lancedb_mod.LanceDB(uri="custom_uri", overwrite=False, extra_key="value")
-    assert ldb.uri == "custom_uri"
-    assert ldb.overwrite is False
-    assert ldb.extra_key == "value"  # Verify kwargs are stored
+    fake_table.create_fts_index.assert_called_once_with("text", language=ldb.fts_language)
 
 
 def test_init_default_uri_and_overwrite():
@@ -180,12 +185,13 @@ def test_create_lancedb_results_all_none_embeddings():
     results = [
         [
             {
+                "document_type": "text",
                 "metadata": {
                     "embedding": None,
                     "content": "a",
                     "content_metadata": {"page_number": 1},
                     "source_metadata": {"source_id": "s1"},
-                }
+                },
             },
         ]
     ]
@@ -198,28 +204,31 @@ def test_create_lancedb_results_mixed_embeddings():
     results = [
         [
             {
+                "document_type": "text",
                 "metadata": {
                     "embedding": [0.1],
                     "content": "keep",
                     "content_metadata": {"page_number": 1},
                     "source_metadata": {"source_id": "s1"},
-                }
+                },
             },
             {
+                "document_type": "text",
                 "metadata": {
                     "embedding": None,
                     "content": "skip",
                     "content_metadata": {"page_number": 2},
                     "source_metadata": {"source_id": "s1"},
-                }
+                },
             },
             {
+                "document_type": "text",
                 "metadata": {
                     "embedding": [0.2, 0.3],
                     "content": "keep2",
                     "content_metadata": {"page_number": 3},
                     "source_metadata": {"source_id": "s2"},
-                }
+                },
             },
         ]
     ]
@@ -295,67 +304,103 @@ def test_write_to_index_respects_kwargs(monkeypatch):
     fake_table = Mock()
     fake_table.list_indices = Mock(return_value=[types.SimpleNamespace(name="idx1")])
     fake_table.create_index = Mock()
+    fake_table.create_fts_index = Mock()
     fake_table.wait_for_index = Mock()
 
-    ldb = lancedb_mod.LanceDB()
-    custom_kwargs = {
-        "index_type": "custom_index",
-        "metric": "cosine",
-        "num_partitions": 32,
-        "num_sub_vectors": 512,
-    }
-    ldb.write_to_index(records=None, table=fake_table, **custom_kwargs)
+    ldb = lancedb_mod.LanceDB(hybrid=True, fts_language="English")
+    ldb.write_to_index(records=None, table=fake_table)
 
-    # Verify custom_kwargs were passed to create_index
-    call_kwargs = fake_table.create_index.call_args[1]
-    assert call_kwargs["index_type"] == "custom_index"
-    assert call_kwargs["metric"] == "cosine"
-    assert call_kwargs["num_partitions"] == 32
-    assert call_kwargs["num_sub_vectors"] == 512
+    fake_table.create_index.assert_called_once()
+    fake_table.create_fts_index.assert_called_once_with("text", language="English")
 
 
-def test_retrieval_with_custom_embedding_params(monkeypatch):
-    """Test retrieval with custom embedding endpoint and model."""
+def test_retrieval_dispatches_to_hybrid(monkeypatch):
+    mock_hybrid_retrieval = Mock(return_value=[["hybrid_result"]])
+    mock_regular_retrieval = Mock(return_value=[["regular_result"]])
 
+    monkeypatch.setattr(lancedb_mod, "lancedb_hybrid_retrieval", mock_hybrid_retrieval)
+    monkeypatch.setattr(lancedb_mod, "lancedb_retrieval", mock_regular_retrieval)
+
+    ldb = lancedb_mod.LanceDB(hybrid=True)
+    results = ldb.retrieval(["test query"])
+
+    mock_hybrid_retrieval.assert_called_once()
+    mock_regular_retrieval.assert_not_called()
+    assert results == [["hybrid_result"]]
+
+
+def test_hybrid_retrieval_search_chain(monkeypatch):
     def fake_infer_microservice(queries, **kwargs):
-        # Capture kwargs and return embeddings
         fake_infer_microservice.captured_kwargs = kwargs
-        return [[0.1, 0.2] for _ in queries]
+        return [[0.1, 0.2, 0.3] for _ in queries]
 
     monkeypatch.setattr(lancedb_mod, "infer_microservice", fake_infer_microservice)
 
-    class FakeSearchResult:
+    custom_endpoint = "http://custom-embed:8012/v1"
+    custom_model = "custom/embedding-model"
+    custom_key = "custom-key"
+
+    captured_calls = {}
+
+    class FakeHybridSearchResult:
+        def vector(self, vec):
+            captured_calls["vector"] = vec
+            return self
+
+        def text(self, txt):
+            captured_calls["text"] = txt
+            return self
+
         def select(self, cols):
             return self
 
         def limit(self, n):
+            captured_calls["limit"] = n
             return self
 
         def refine_factor(self, n):
+            captured_calls["refine_factor"] = n
             return self
 
         def nprobes(self, n):
+            captured_calls["nprobes"] = n
+            return self
+
+        def rerank(self, reranker):
+            captured_calls["reranker"] = reranker
             return self
 
         def to_list(self):
-            return [{"text": "result", "metadata": 1, "source": "s"}]
+            return [{"text": "hybrid_hit", "metadata": "1", "source": "s1"}]
 
-    fake_table = Mock()
-    fake_table.search = Mock(return_value=FakeSearchResult())
+    def fake_search(query_type=None):
+        captured_calls["query_type"] = query_type
+        return FakeHybridSearchResult()
 
-    ldb = lancedb_mod.LanceDB()
-    custom_endpoint = "http://custom-endpoint:9000/v1"
-    custom_model = "my/custom-model"
-    custom_key = "my-api-key"
+    fake_table = Mock()
+    fake_table.search = Mock(side_effect=fake_search)
 
-    ldb.retrieval(
-        ["test query"],
+    results = lancedb_mod.lancedb_hybrid_retrieval(
+        queries=["test query"],
         table=fake_table,
+        top_k=5,
+        refine_factor=25,
+        n_probe=32,
         embedding_endpoint=custom_endpoint,
         model_name=custom_model,
         nvidia_api_key=custom_key,
     )
 
+    assert captured_calls["query_type"] == "hybrid"
+    assert captured_calls["vector"] == [0.1, 0.2, 0.3]
+    assert captured_calls["text"] == "test query"
+    assert captured_calls["limit"] == 5
+    assert captured_calls["refine_factor"] == 25
+    assert captured_calls["nprobes"] == 32
+    assert captured_calls["reranker"] is not None
+    assert isinstance(captured_calls["reranker"], lancedb_mod.RRFReranker)
+    assert len(results) == 1
+    assert results[0][0]["entity"]["text"] == "hybrid_hit"
     # Verify custom params were passed to infer_microservice
     assert fake_infer_microservice.captured_kwargs["embedding_endpoint"] == custom_endpoint
     assert fake_infer_microservice.captured_kwargs["model_name"] == custom_model
@@ -484,25 +529,26 @@ def to_list(self):
     assert captured_limit[0] == 10
 
 
-def test_create_lancedb_results_missing_field_raises_keyerror():
-    """Test that missing required fields raise KeyError."""
+def test_create_lancedb_results_missing_content_metadata_graceful():
+    """Test that missing content_metadata is handled gracefully (empty dict default)."""
     results = [
         [
             {
+                "document_type": "text",
                 "metadata": {
                     "embedding": [0.1],
-                    "content": "a",
-                    # Missing content_metadata
+                    "content": "text with missing content_metadata",
+                    # Missing content_metadata - should use empty dict default
                     "source_metadata": {"source_id": "s1"},
-                }
+                },
             }
         ]
     ]
-    try:
-        lancedb_mod.create_lancedb_results(results)
-        assert False, "Expected KeyError for missing content_metadata"
-    except KeyError:
-        pass  # Expected
+    out = lancedb_mod.create_lancedb_results(results)
+    # Should still produce output with JSON-serialized empty metadata.
+    assert len(out) == 1
+    assert out[0]["metadata"] == "{}"
+    assert out[0]["text"] == "text with missing content_metadata"
 
 
 def test_retrieval_multiple_queries(monkeypatch):
@@ -551,3 +597,120 @@ def make_search_result(query_vec, **kwargs):
     assert results[0][0]["entity"]["text"] == "result_0"
     assert results[1][0]["entity"]["text"] == "result_1"
     assert results[2][0]["entity"]["text"] == "result_2"
+
+
+# ============ Tests for _get_text_for_element() ============
+
+
+def test_get_text_for_element_text_type():
+    """Test text extraction for document_type='text'."""
+    element = {
+        "document_type": "text",
+        "metadata": {
+            "content": "This is plain text content",
+        },
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result == "This is plain text content"
+
+
+def test_get_text_for_element_structured_table():
+    """Test text extraction for structured tables."""
+    element = {
+        "document_type": "structured",
+        "metadata": {
+            "content_metadata": {"subtype": "table"},
+            "table_metadata": {"table_content": "| Col1 | Col2 |\n| A | B |"},
+        },
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result == "| Col1 | Col2 |\n| A | B |"
+
+
+def test_get_text_for_element_structured_chart():
+    """Test text extraction for structured charts."""
+    element = {
+        "document_type": "structured",
+        "metadata": {
+            "content_metadata": {"subtype": "chart"},
+            "table_metadata": {"table_content": "Chart showing revenue trends"},
+        },
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result == "Chart showing revenue trends"
+
+
+def test_get_text_for_element_structured_infographic():
+    """Test text extraction for infographics."""
+    element = {
+        "document_type": "structured",
+        "metadata": {
+            "content_metadata": {"subtype": "infographic"},
+            "table_metadata": {"table_content": "Infographic content description"},
+        },
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result == "Infographic content description"
+
+
+def test_get_text_for_element_image_caption():
+    """Test text extraction for images uses caption (not base64 data)."""
+    element = {
+        "document_type": "image",
+        "metadata": {
+            "content_metadata": {"subtype": "image"},
+            "image_metadata": {"caption": "A photo of a dog playing"},
+        },
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result == "A photo of a dog playing"
+
+
+def test_get_text_for_element_page_image_uses_text():
+    """Test that page_image subtype uses 'text' field (OCR) instead of caption."""
+    element = {
+        "document_type": "image",
+        "metadata": {
+            "content_metadata": {"subtype": "page_image"},
+            "image_metadata": {
+                "text": "OCR extracted text from page",
+                "caption": "Should not use this",
+            },
+        },
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result == "OCR extracted text from page"
+
+
+def test_get_text_for_element_audio():
+    """Test text extraction for audio uses transcript."""
+    element = {
+        "document_type": "audio",
+        "metadata": {
+            "audio_metadata": {"audio_transcript": "Hello, this is the audio transcript"},
+        },
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result == "Hello, this is the audio transcript"
+
+
+def test_get_text_for_element_unknown_type_fallback():
+    """Test that unknown document types fall back to metadata.content."""
+    element = {
+        "document_type": "unknown_type",
+        "metadata": {
+            "content": "Fallback content",
+        },
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result == "Fallback content"
+
+
+def test_get_text_for_element_missing_metadata():
+    """Test graceful handling of missing metadata fields."""
+    element = {
+        "document_type": "text",
+        "metadata": {},  # No content field
+    }
+    result = lancedb_mod._get_text_for_element(element)
+    assert result is None
diff --git a/client/pyproject.toml b/client/pyproject.toml
index 9409ecac6..8966d888c 100644
--- a/client/pyproject.toml
+++ b/client/pyproject.toml
@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools", "wheel"]
+requires = ["setuptools", "wheel>=0.46.2"]
 build-backend = "setuptools.build_meta"
 
 [tool.uv]
diff --git a/client/src/nv_ingest_client/client/interface.py b/client/src/nv_ingest_client/client/interface.py
index f3263237e..c991eb8b5 100644
--- a/client/src/nv_ingest_client/client/interface.py
+++ b/client/src/nv_ingest_client/client/interface.py
@@ -249,6 +249,12 @@ def __init__(
         self._output_config = None
         self._created_temp_output_dir = None
 
+        # Track extraction settings for auto-dedup
+        self._has_structured_extraction = False
+        self._has_image_extraction = False
+        self._has_dedup = False
+        self._auto_dedup = True  # Can be disabled via extract(auto_dedup=False)
+
     def __enter__(self):
         return self
 
@@ -940,10 +946,18 @@ def _prepare_ingest_run(self):
 
         If no tasks are specified in `_job_specs`, this method invokes `all_tasks()` to add
         a default set of tasks to the job specification.
+
+        Auto-enables bbox deduplication when structured extraction (tables/charts/infographics)
+        and captioning are both enabled, even if `.dedup()` was not explicitly called.
         """
         if (not self._job_specs.tasks) or all(not tasks for tasks in self._job_specs.tasks.values()):
             self.all_tasks()
 
+        # Auto-enable bbox dedup when both structured and image extraction are enabled
+        if self._auto_dedup and self._has_structured_extraction and self._has_image_extraction and not self._has_dedup:
+            logger.info("Auto-enabling bbox deduplication (structured + image extraction detected)")
+            self.dedup()
+
     def all_tasks(self) -> "Ingestor":
         """
         Adds a default set of tasks to the batch job specification.
@@ -975,7 +989,12 @@ def dedup(self, **kwargs: Any) -> "Ingestor":
         Parameters
         ----------
         kwargs : dict
-            Parameters specific to the DedupTask.
+            Parameters specific to the DedupTask:
+            - content_type: str, content type to deduplicate (default "text")
+            - filter: bool, legacy filter parameter (default False)
+            - enable_bbox_dedup: bool, enable bounding box deduplication (default True)
+            - iou_threshold: float, IoU threshold for bbox dedup (default 0.45)
+            - prefer_structured: bool, keep structured elements over images (default True)
 
         Returns
         -------
@@ -997,10 +1016,16 @@ def dedup(self, **kwargs: Any) -> "Ingestor":
         dedup_params = {
             "content_type": task_options.content_type,
             "filter": task_options.params.filter,
+            "enable_bbox_dedup": task_options.params.enable_bbox_dedup,
+            "iou_threshold": task_options.params.iou_threshold,
+            "prefer_structured": task_options.params.bbox_dedup_prefer_structured,
         }
         dedup_task = DedupTask(**dedup_params)
         self._job_specs.add_task(dedup_task)
 
+        # Track that dedup was explicitly added
+        self._has_dedup = True
+
         return self
 
     @ensure_job_specs
@@ -1038,7 +1063,16 @@ def extract(self, **kwargs: Any) -> "Ingestor":
         Parameters
         ----------
         kwargs : dict
-            Parameters specific to the ExtractTask.
+            Parameters specific to the ExtractTask:
+            - extract_text: bool, extract text content (default True)
+            - extract_images: bool, extract images (default True)
+            - extract_tables: bool, extract tables (default True)
+            - extract_charts: bool, extract charts (default True)
+            - extract_infographics: bool, extract infographics (default False)
+            - extract_page_as_image: bool, extract full page as image (default False)
+            - table_output_format: str, format for table output (default "markdown")
+            - auto_dedup: bool, auto-enable bbox deduplication when extracting both
+              structured elements and images (default True). Set to False to disable.
 
         Returns
         -------
@@ -1056,6 +1090,17 @@ def extract(self, **kwargs: Any) -> "Ingestor":
         # Users have to set to True if infographic extraction is required.
         extract_infographics = kwargs.pop("extract_infographics", False)
 
+        # Auto-dedup: enabled by default when extracting both structured elements and images
+        # Users can disable with auto_dedup=False
+        auto_dedup = kwargs.pop("auto_dedup", True)
+        self._auto_dedup = auto_dedup
+
+        # Track extraction settings for auto-dedup
+        if extract_tables or extract_charts or extract_infographics:
+            self._has_structured_extraction = True
+        if extract_images:
+            self._has_image_extraction = True
+
         for file_type in self._job_specs.file_types:
             # Let user override document_type if user explicitly sets document_type.
             if "document_type" in kwargs:
@@ -1479,6 +1524,8 @@ def caption(self, **kwargs: Any) -> "Ingestor":
             "prompt": task_options.prompt,
             "system_prompt": task_options.system_prompt,
             "model_name": task_options.model_name,
+            "context_text_max_chars": task_options.context_text_max_chars,
+            "temperature": task_options.temperature,
         }
         caption_task = CaptionTask(**caption_params)
         self._job_specs.add_task(caption_task)
diff --git a/client/src/nv_ingest_client/primitives/tasks/caption.py b/client/src/nv_ingest_client/primitives/tasks/caption.py
index 93c08a2b4..5d10a5056 100644
--- a/client/src/nv_ingest_client/primitives/tasks/caption.py
+++ b/client/src/nv_ingest_client/primitives/tasks/caption.py
@@ -24,6 +24,8 @@ def __init__(
         prompt: str = None,
         system_prompt: str = None,
         model_name: str = None,
+        context_text_max_chars: int = None,
+        temperature: float = None,
     ) -> None:
         super().__init__()
 
@@ -34,6 +36,8 @@ def __init__(
             prompt=prompt,
             system_prompt=system_prompt,
             model_name=model_name,
+            context_text_max_chars=context_text_max_chars,
+            temperature=temperature,
         )
 
         self._api_key = validated_data.api_key
@@ -41,6 +45,8 @@ def __init__(
         self._prompt = validated_data.prompt
         self._system_prompt = validated_data.system_prompt
         self._model_name = validated_data.model_name
+        self._context_text_max_chars = validated_data.context_text_max_chars
+        self._temperature = validated_data.temperature
 
     def __str__(self) -> str:
         """
@@ -59,6 +65,10 @@ def __str__(self) -> str:
             info += f"  system_prompt: {self._system_prompt}\n"
         if self._model_name:
             info += f"  model_name: {self._model_name}\n"
+        if self._context_text_max_chars:
+            info += f"  context_text_max_chars: {self._context_text_max_chars}\n"
+        if self._temperature is not None:
+            info += f"  temperature: {self._temperature}\n"
 
         return info
 
@@ -83,4 +93,10 @@ def to_dict(self) -> Dict:
         if self._model_name:
             task_properties["model_name"] = self._model_name
 
+        if self._context_text_max_chars:
+            task_properties["context_text_max_chars"] = self._context_text_max_chars
+
+        if self._temperature is not None:
+            task_properties["temperature"] = self._temperature
+
         return {"type": "caption", "task_properties": task_properties}
diff --git a/client/src/nv_ingest_client/primitives/tasks/dedup.py b/client/src/nv_ingest_client/primitives/tasks/dedup.py
index 721cfc943..90057207f 100644
--- a/client/src/nv_ingest_client/primitives/tasks/dedup.py
+++ b/client/src/nv_ingest_client/primitives/tasks/dedup.py
@@ -28,20 +28,52 @@ def __init__(
         self,
         content_type: _TypeContentType = "image",
         filter: bool = False,
+        enable_bbox_dedup: bool = True,
+        iou_threshold: float = 0.45,
+        prefer_structured: bool = True,
     ) -> None:
         """
         Setup Dedup Task Config
+
+        Parameters
+        ----------
+        content_type : str
+            Content type to deduplicate (currently only "image" supported).
+        filter : bool
+            Legacy filter parameter.
+        enable_bbox_dedup : bool
+            Enable bounding box overlap deduplication. When True, images that
+            substantially overlap with structured elements (tables/charts) on
+            the same page are removed.
+        iou_threshold : float
+            IoU (Intersection over Union) threshold for bbox dedup (0.0-1.0).
+            Elements with IoU >= threshold are considered duplicates.
+        prefer_structured : bool
+            When True, keep tables/charts and drop overlapping images.
+            When False, keep images and drop overlapping structured elements.
         """
         super().__init__()
 
+        # Validate iou_threshold
+        if not 0.0 <= iou_threshold <= 1.0:
+            raise ValueError("iou_threshold must be between 0.0 and 1.0")
+
         # Use the API schema for validation
         validated_data = IngestTaskDedupSchema(
             content_type=content_type,
-            params={"filter": filter},
+            params={
+                "filter": filter,
+                "enable_bbox_dedup": enable_bbox_dedup,
+                "iou_threshold": iou_threshold,
+                "bbox_dedup_prefer_structured": prefer_structured,
+            },
         )
 
         self._content_type = validated_data.content_type
         self._filter = validated_data.params.filter
+        self._enable_bbox_dedup = validated_data.params.enable_bbox_dedup
+        self._iou_threshold = validated_data.params.iou_threshold
+        self._prefer_structured = validated_data.params.bbox_dedup_prefer_structured
 
     def __str__(self) -> str:
         """
@@ -51,13 +83,22 @@ def __str__(self) -> str:
         info += "Dedup Task:\n"
         info += f"  content_type: {self._content_type.value}\n"
         info += f"  filter: {self._filter}\n"
+        info += f"  enable_bbox_dedup: {self._enable_bbox_dedup}\n"
+        if self._enable_bbox_dedup:
+            info += f"  iou_threshold: {self._iou_threshold}\n"
+            info += f"  prefer_structured: {self._prefer_structured}\n"
         return info
 
     def to_dict(self) -> Dict:
         """
         Convert to a dict for submission to redis
         """
-        dedup_params = {"filter": self._filter}
+        dedup_params = {
+            "filter": self._filter,
+            "enable_bbox_dedup": self._enable_bbox_dedup,
+            "iou_threshold": self._iou_threshold,
+            "bbox_dedup_prefer_structured": self._prefer_structured,
+        }
 
         task_properties = {
             "content_type": self._content_type.value,
diff --git a/client/src/nv_ingest_client/primitives/tasks/embed.py b/client/src/nv_ingest_client/primitives/tasks/embed.py
index edc403fdf..40fa1ba70 100644
--- a/client/src/nv_ingest_client/primitives/tasks/embed.py
+++ b/client/src/nv_ingest_client/primitives/tasks/embed.py
@@ -32,8 +32,13 @@ def __init__(
         text: Optional[bool] = None,
         tables: Optional[bool] = None,
         filter_errors: bool = False,
+        embed_text_elements: Optional[bool] = None,
+        embed_structured_elements: Optional[bool] = None,
+        embed_image_elements: Optional[bool] = None,
+        embed_audio_elements: Optional[bool] = None,
         text_elements_modality: Optional[str] = None,
         image_elements_modality: Optional[str] = None,
+        image_elements_aggregate_page_content: Optional[bool] = None,
         structured_elements_modality: Optional[str] = None,
         audio_elements_modality: Optional[str] = None,
         custom_content_field: Optional[str] = None,
@@ -75,8 +80,13 @@ def __init__(
             model_name=model_name,
             api_key=api_key,
             filter_errors=filter_errors,
+            embed_text_elements=embed_text_elements,
+            embed_structured_elements=embed_structured_elements,
+            embed_image_elements=embed_image_elements,
+            embed_audio_elements=embed_audio_elements,
             text_elements_modality=text_elements_modality,
             image_elements_modality=image_elements_modality,
+            image_elements_aggregate_page_content=image_elements_aggregate_page_content,
             structured_elements_modality=structured_elements_modality,
             audio_elements_modality=audio_elements_modality,
             custom_content_field=custom_content_field,
@@ -88,8 +98,13 @@ def __init__(
         self._model_name = validated_data.model_name
         self._api_key = validated_data.api_key
         self._filter_errors = validated_data.filter_errors
+        self._embed_text_elements = validated_data.embed_text_elements
+        self._embed_structured_elements = validated_data.embed_structured_elements
+        self._embed_image_elements = validated_data.embed_image_elements
+        self._embed_audio_elements = validated_data.embed_audio_elements
         self._text_elements_modality = validated_data.text_elements_modality
         self._image_elements_modality = validated_data.image_elements_modality
+        self._image_elements_aggregate_page_content = validated_data.image_elements_aggregate_page_content
         self._structured_elements_modality = validated_data.structured_elements_modality
         self._audio_elements_modality = validated_data.audio_elements_modality
         self._custom_content_field = validated_data.custom_content_field
@@ -115,10 +130,20 @@ def __str__(self) -> str:
         if self._api_key:
             info += "  api_key: [redacted]\n"
         info += f"  filter_errors: {self._filter_errors}\n"
+        if self._embed_text_elements is not None:
+            info += f"  embed_text_elements: {self._embed_text_elements}\n"
+        if self._embed_structured_elements is not None:
+            info += f"  embed_structured_elements: {self._embed_structured_elements}\n"
+        if self._embed_image_elements is not None:
+            info += f"  embed_image_elements: {self._embed_image_elements}\n"
+        if self._embed_audio_elements is not None:
+            info += f"  embed_audio_elements: {self._embed_audio_elements}\n"
         if self._text_elements_modality:
             info += f"  text_elements_modality: {self._text_elements_modality}\n"
         if self._image_elements_modality:
             info += f"  image_elements_modality: {self._image_elements_modality}\n"
+        if self._image_elements_aggregate_page_content:
+            info += f"  image_elements_aggregate_page_content: {self._image_elements_aggregate_page_content}\n"
         if self._structured_elements_modality:
             info += f"  structured_elements_modality: {self._structured_elements_modality}\n"
         if self._audio_elements_modality:
@@ -152,12 +177,27 @@ def to_dict(self) -> Dict[str, Any]:
         if self._api_key:
             task_properties["api_key"] = self._api_key
 
+        if self._embed_text_elements is not None:
+            task_properties["embed_text_elements"] = self._embed_text_elements
+
+        if self._embed_structured_elements is not None:
+            task_properties["embed_structured_elements"] = self._embed_structured_elements
+
+        if self._embed_image_elements is not None:
+            task_properties["embed_image_elements"] = self._embed_image_elements
+
+        if self._embed_audio_elements is not None:
+            task_properties["embed_audio_elements"] = self._embed_audio_elements
+
         if self._text_elements_modality:
             task_properties["text_elements_modality"] = self._text_elements_modality
 
         if self._image_elements_modality:
             task_properties["image_elements_modality"] = self._image_elements_modality
 
+        if self._image_elements_aggregate_page_content:
+            task_properties["image_elements_aggregate_page_content"] = self._image_elements_aggregate_page_content
+
         if self._structured_elements_modality:
             task_properties["structured_elements_modality"] = self._structured_elements_modality
 
diff --git a/client/src/nv_ingest_client/primitives/tasks/extract.py b/client/src/nv_ingest_client/primitives/tasks/extract.py
index e5a2563ee..7c1101ada 100644
--- a/client/src/nv_ingest_client/primitives/tasks/extract.py
+++ b/client/src/nv_ingest_client/primitives/tasks/extract.py
@@ -99,6 +99,7 @@ def __init__(
         extract_tables_method: _Type_Extract_Tables_Method_PDF = "yolox",
         extract_infographics: bool = False,
         extract_page_as_image: bool = False,
+        page_image_max_dimension: int = 1024,
         text_depth: str = "document",
         paddle_output_format: str = "pseudo_markdown",
         table_output_format: str = "markdown",
@@ -143,6 +144,7 @@ def __init__(
             "extract_charts": extract_charts,
             "extract_infographics": extract_infographics,
             "extract_page_as_image": extract_page_as_image,
+            "page_image_max_dimension": page_image_max_dimension,
             "text_depth": text_depth,
             "table_output_format": table_output_format,
         }
@@ -172,6 +174,7 @@ def __init__(
         self._extract_charts = extract_charts
         self._extract_infographics = extract_infographics
         self._extract_page_as_image = extract_page_as_image
+        self._page_image_max_dimension = page_image_max_dimension
         self._extract_text = extract_text
         self._text_depth = text_depth
         self._paddle_output_format = paddle_output_format
@@ -191,6 +194,7 @@ def __str__(self) -> str:
         info += f"  extract_charts: {self._extract_charts}\n"
         info += f"  extract_infographics: {self._extract_infographics}\n"
         info += f"  extract_page_as_image: {self._extract_page_as_image}\n"
+        info += f"  page_image_max_dimension: {self._page_image_max_dimension}\n"
         info += f"  text_depth: {self._text_depth}\n"
         info += f"  table_output_format: {self._table_output_format}\n"
         return info
diff --git a/client/src/nv_ingest_client/util/vdb/lancedb.py b/client/src/nv_ingest_client/util/vdb/lancedb.py
index 8e65dfa25..fe1452492 100644
--- a/client/src/nv_ingest_client/util/vdb/lancedb.py
+++ b/client/src/nv_ingest_client/util/vdb/lancedb.py
@@ -1,4 +1,7 @@
+import json
 import logging
+import os
+import time
 
 from datetime import timedelta
 from functools import partial
@@ -6,6 +9,7 @@
 
 import lancedb
 import pyarrow as pa
+from lancedb.rerankers import RRFReranker
 
 from nv_ingest_client.util.transport import infer_microservice
 from nv_ingest_client.util.vdb.adt_vdb import VDB
@@ -14,21 +18,136 @@
 logger = logging.getLogger(__name__)
 
 
+def _json_str(value) -> str:
+    """
+    Convert Python objects (dict/list/etc.) to a compact JSON string.
+
+    LanceDB table schema stores `metadata` and `source` as strings, so we must
+    serialize nested structures before ingestion.
+    """
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    try:
+        return json.dumps(value, ensure_ascii=False, separators=(",", ":"), default=str)
+    except Exception:
+        return str(value)
+
+
+def _maybe_parse_json(value):
+    """Best-effort parse for JSON-serialized string columns."""
+    if value is None:
+        return None
+    if isinstance(value, (dict, list)):
+        return value
+    if not isinstance(value, str):
+        return value
+    s = value.strip()
+    if not s:
+        return {}
+    # Avoid accidental parsing of plain strings that are not JSON objects/arrays.
+    if not (s.startswith("{") or s.startswith("[")):
+        return value
+    try:
+        return json.loads(s)
+    except Exception:
+        return value
+
+
+def _record_timing(event: str, duration_s: float, extra: dict | None = None):
+    timing_path = os.getenv("NV_INGEST_LANCEDB_TIMING_PATH")
+    if not timing_path:
+        return
+    payload = {
+        "event": event,
+        "duration_s": duration_s,
+        "timestamp_s": time.time(),
+    }
+    if extra:
+        payload.update(extra)
+    os.makedirs(os.path.dirname(timing_path), exist_ok=True)
+    with open(timing_path, "a") as f:
+        f.write(json.dumps(payload) + "\n")
+
+
+def _get_text_for_element(element):
+    """
+    Extract searchable text from an element based on document_type.
+
+    Matches Milvus behavior: for images, use caption/OCR text instead of raw content.
+    This prevents base64-encoded images from being stored in the text field.
+    """
+    doc_type = element.get("document_type")
+    metadata = element.get("metadata", {})
+
+    if doc_type == "text":
+        return metadata.get("content")
+    elif doc_type == "structured":
+        # Tables, charts, infographics
+        table_meta = metadata.get("table_metadata", {})
+        return table_meta.get("table_content")
+    elif doc_type == "image":
+        # Use caption/OCR text, not raw base64 image data
+        image_meta = metadata.get("image_metadata", {})
+        content_meta = metadata.get("content_metadata", {})
+        if content_meta.get("subtype") == "page_image":
+            return image_meta.get("text")
+        else:
+            return image_meta.get("caption")
+    elif doc_type == "audio":
+        audio_meta = metadata.get("audio_metadata", {})
+        return audio_meta.get("audio_transcript")
+    else:
+        # Fallback for unknown types
+        return metadata.get("content")
+
+
 def create_lancedb_results(results):
-    """Transform NV-Ingest pipeline results into LanceDB ingestible rows."""
-    old_results = [res["metadata"] for result in results for res in result]
+    """
+    Transform NV-Ingest pipeline results into LanceDB ingestible rows.
+
+    Extracts appropriate text based on document_type rather than storing
+    raw content (which may include base64 images).
+
+    Parameters
+    ----------
+    results : list
+        Pipeline output results.
+    """
     lancedb_rows = []
-    for result in old_results:
-        if result["embedding"] is None:
-            continue
-        lancedb_rows.append(
-            {
-                "vector": result["embedding"],
-                "text": result["content"],
-                "metadata": result["content_metadata"]["page_number"],
-                "source": result["source_metadata"]["source_id"],
-            }
-        )
+
+    for result in results:
+        for element in result:
+            metadata = element.get("metadata", {})
+            doc_type = element.get("document_type")
+
+            # Check if embedding exists
+            embedding = metadata.get("embedding")
+            if embedding is None:
+                continue
+
+            content_meta = metadata.get("content_metadata", {})
+
+            # Extract appropriate text based on document type
+            text = _get_text_for_element(element)
+
+            if not text:
+                source_name = metadata.get("source_metadata", {}).get("source_name", "unknown")
+                pg_num = content_meta.get("page_number")
+                logger.debug(f"No text found for entity: {source_name} page: {pg_num} type: {doc_type}")
+                continue
+
+            lancedb_rows.append(
+                {
+                    "vector": embedding,
+                    "text": text,
+                    # Stored as strings in LanceDB; serialize nested structures.
+                    "metadata": _json_str(content_meta),
+                    "source": _json_str(metadata.get("source_metadata", {})),
+                }
+            )
+
     return lancedb_rows
 
 
@@ -44,6 +163,8 @@ def __init__(
         metric="l2",
         num_partitions=16,
         num_sub_vectors=256,
+        hybrid: bool = False,
+        fts_language: str = "English",
         **kwargs,
     ):
         self.uri = uri or "lancedb"
@@ -53,11 +174,15 @@ def __init__(
         self.metric = metric
         self.num_partitions = num_partitions
         self.num_sub_vectors = num_sub_vectors
+        self.hybrid = hybrid
+        self.fts_language = fts_language
         super().__init__(**kwargs)
 
     def create_index(self, records=None, table_name="nv-ingest", **kwargs):
         """Create a LanceDB table and populate it with transformed records."""
+        connect_start = time.perf_counter()
         db = lancedb.connect(uri=self.uri)
+        _record_timing("lancedb.connect", time.perf_counter() - connect_start)
         results = create_lancedb_results(records)
         schema = pa.schema(
             [
@@ -67,9 +192,15 @@ def create_index(self, records=None, table_name="nv-ingest", **kwargs):
                 pa.field("source", pa.string()),
             ]
         )
+        create_start = time.perf_counter()
         table = db.create_table(
             table_name, data=results, schema=schema, mode="overwrite" if self.overwrite else "append"
         )
+        _record_timing(
+            "lancedb.create_table",
+            time.perf_counter() - create_start,
+            {"rows": len(results)},
+        )
         return table
 
     def write_to_index(
@@ -80,9 +211,15 @@ def write_to_index(
         metric="l2",
         num_partitions=16,
         num_sub_vectors=256,
+        hybrid: bool = None,
+        fts_language: str = None,
         **kwargs,
     ):
-        """Create an index on the LanceDB table and wait for it to become ready."""
+        """Create vector and optionally FTS indexes on the LanceDB table."""
+        hybrid = hybrid if hybrid is not None else self.hybrid
+        fts_language = fts_language or self.fts_language
+
+        vector_index_start = time.perf_counter()
         table.create_index(
             index_type=index_type,
             metric=metric,
@@ -92,6 +229,15 @@ def write_to_index(
         )
         for index_stub in table.list_indices():
             table.wait_for_index([index_stub.name], timeout=timedelta(seconds=600))
+        _record_timing("lancedb.vector_index_ready", time.perf_counter() - vector_index_start)
+
+        if hybrid:
+            fts_index_start = time.perf_counter()
+            table.create_fts_index("text", language=fts_language)
+            for index_stub in table.list_indices():
+                if "text" in index_stub.name.lower() or "fts" in index_stub.name.lower():
+                    table.wait_for_index([index_stub.name], timeout=timedelta(seconds=600))
+            _record_timing("lancedb.fts_index_ready", time.perf_counter() - fts_index_start)
 
     def run(self, records):
         """Orchestrate index creation and data ingestion."""
@@ -103,86 +249,319 @@ def run(self, records):
             metric=self.metric,
             num_partitions=self.num_partitions,
             num_sub_vectors=self.num_sub_vectors,
+            hybrid=self.hybrid,
+            fts_language=self.fts_language,
         )
         return records
 
-    def retrieval(
-        self,
-        queries,
-        table=None,
-        table_path=None,
-        table_name=None,
-        embedding_endpoint: str = "http://localhost:8012/v1",
-        nvidia_api_key: str = None,
-        model_name: str = "nvidia/llama-3.2-nv-embedqa-1b-v2",
-        top_k: int = 10,
-        refine_factor: int = 50,
-        n_probe: int = 64,
-        nv_ranker: bool = False,
-        nv_ranker_endpoint: str = None,
-        nv_ranker_model_name: str = None,
-        nv_ranker_top_k: int = 100,
-        result_fields=None,
-        **kwargs,
-    ):
-        """Run LanceDB retrieval and return results in Milvus-style format."""
-        table_path = table_path or self.uri
-        table_name = table_name or self.table_name
-        if result_fields is None:
-            result_fields = ["text", "metadata", "source", "_distance"]
-
-        if table is None:
-            db = lancedb.connect(uri=table_path)
-            table = db.open_table(table_name)
-
-        embed_model = partial(
-            infer_microservice,
-            model_name=model_name,
-            embedding_endpoint=embedding_endpoint,
-            nvidia_api_key=nvidia_api_key,
-            input_type="query",
-            output_names=["embeddings"],
-            grpc=not ("http" in urlparse(embedding_endpoint).scheme),
-        )
+    def retrieval(self, queries, **kwargs):
+        """Run LanceDB retrieval, using hybrid search if enabled."""
+        hybrid = kwargs.pop("hybrid", self.hybrid)
+        table_path = kwargs.pop("table_path", self.uri)
+        table_name = kwargs.pop("table_name", self.table_name)
 
-        search_top_k = nv_ranker_top_k if nv_ranker else top_k
-
-        results = []
-        query_embeddings = embed_model(queries)
-        for query_embed in query_embeddings:
-            search_results = (
-                table.search([query_embed], vector_column_name="vector")
-                .select(result_fields)
-                .limit(search_top_k)
-                .refine_factor(refine_factor)
-                .nprobes(n_probe)
-                .to_list()
+        if hybrid:
+            return lancedb_hybrid_retrieval(
+                queries,
+                table_path=table_path,
+                table_name=table_name,
+                **kwargs,
             )
-            formatted = []
-            for r in search_results:
-                formatted.append(
-                    {
-                        "entity": {
-                            "source": {"source_id": r.get("source")},
-                            "content_metadata": {"page_number": r.get("metadata")},
-                            "text": r.get("text"),
-                        }
+        return lancedb_retrieval(
+            queries,
+            table_path=table_path,
+            table_name=table_name,
+            **kwargs,
+        )
+
+
+def lancedb_retrieval(
+    queries,
+    table_path: str = None,
+    table_name: str = "nv-ingest",
+    table=None,
+    embedding_endpoint: str = "http://localhost:8012/v1",
+    nvidia_api_key: str = None,
+    model_name: str = "nvidia/llama-3.2-nv-embedqa-1b-v2",
+    top_k: int = 10,
+    refine_factor: int = 50,
+    n_probe: int = 64,
+    nv_ranker: bool = False,
+    nv_ranker_endpoint: str = None,
+    nv_ranker_model_name: str = None,
+    nv_ranker_top_k: int = 50,
+    result_fields=None,
+    **kwargs,
+):
+    """
+    Standalone LanceDB retrieval function.
+
+    This is the primary interface for LanceDB vector search. It embeds queries using the
+    specified embedding model and performs vector similarity search against
+    a LanceDB table.
+
+    Parameters
+    ----------
+    queries : list[str]
+        Text queries to search for.
+    table_path : str, optional
+        Path to the LanceDB database directory (the `uri` used during ingestion).
+        Required if `table` is not provided.
+    table_name : str, optional
+        Name of the table within the LanceDB database (default: "nv-ingest").
+    table : object, optional
+        Pre-opened LanceDB table object. If provided, table_path and table_name
+        are ignored. Useful for reusing connections or testing.
+    embedding_endpoint : str, optional
+        URL of the embedding microservice (default: "http://localhost:8012/v1").
+    nvidia_api_key : str, optional
+        NVIDIA API key for authentication. If None, no auth is used.
+    model_name : str, optional
+        Name of the embedding model (default: "nvidia/llama-3.2-nv-embedqa-1b-v2").
+    top_k : int, optional
+        Number of results to return per query (default: 10).
+    refine_factor : int, optional
+        LanceDB search refine factor for accuracy (default: 50).
+    n_probe : int, optional
+        Number of partitions to probe during search (default: 64).
+    nv_ranker : bool, optional
+        Whether to apply NV reranker after retrieval (default: False).
+    nv_ranker_endpoint : str, optional
+        URL of the reranker microservice.
+    nv_ranker_model_name : str, optional
+        Name of the reranker model.
+    nv_ranker_top_k : int, optional
+        Number of candidates to fetch before reranking (default: 50).
+    result_fields : list, optional
+        List of field names to retrieve from each hit document (default:
+        ["text", "metadata", "source"]).
+    **kwargs
+        Additional keyword arguments (ignored, for API compatibility).
+
+    Returns
+    -------
+    list[list[dict]]
+        For each query, a list of result dicts formatted to match Milvus output
+        structure for recall scoring compatibility.
+    """
+    if table is None:
+        if table_path is None:
+            raise ValueError("Either table or table_path must be provided")
+        db = lancedb.connect(uri=table_path)
+        table = db.open_table(table_name)
+
+    if result_fields is None:
+        result_fields = ["text", "metadata", "source"]
+
+    embed_start = time.perf_counter()
+    embed_model = partial(
+        infer_microservice,
+        model_name=model_name,
+        embedding_endpoint=embedding_endpoint,
+        nvidia_api_key=nvidia_api_key,
+        input_type="query",
+        output_names=["embeddings"],
+        grpc=not ("http" in urlparse(embedding_endpoint).scheme),
+    )
+    query_embeddings = embed_model(queries)
+    _record_timing(
+        "lancedb.embed_queries",
+        time.perf_counter() - embed_start,
+        {"query_count": len(queries)},
+    )
+
+    search_top_k = nv_ranker_top_k if nv_ranker else top_k
+
+    results = []
+    search_durations = []
+    for query_embed in query_embeddings:
+        search_start = time.perf_counter()
+        search_results = (
+            table.search([query_embed], vector_column_name="vector")
+            .select(result_fields)
+            .limit(search_top_k)
+            .refine_factor(refine_factor)
+            .nprobes(n_probe)
+            .to_list()
+        )
+        search_durations.append(time.perf_counter() - search_start)
+        formatted = []
+        for r in search_results:
+            source = _maybe_parse_json(r.get("source"))
+            content_meta = _maybe_parse_json(r.get("metadata"))
+
+            if not isinstance(source, dict):
+                source = {"source_id": "" if source is None else str(source)}
+            if not isinstance(content_meta, dict):
+                # Back-compat: previously this code used `metadata` as `page_number`.
+                try:
+                    page_number = int(content_meta)  # type: ignore[arg-type]
+                except Exception:
+                    page_number = -1
+                content_meta = {"page_number": page_number}
+
+            formatted.append(
+                {
+                    "entity": {
+                        "source": source,
+                        "content_metadata": content_meta,
+                        "text": r.get("text"),
                     }
+                }
+            )
+        results.append(formatted)
+    if search_durations:
+        total_search = sum(search_durations)
+        _record_timing(
+            "lancedb.vector_search",
+            total_search,
+            {
+                "query_count": len(search_durations),
+                "avg_query_s": total_search / len(search_durations),
+                "max_query_s": max(search_durations),
+            },
+        )
+
+    if nv_ranker:
+        rerank_start = time.perf_counter()
+        rerank_results = []
+        num_queries = len(queries)
+        for idx, (query, candidates) in enumerate(zip(queries, results), 1):
+            if num_queries > 1:
+                logger.info(f"Reranking query {idx}/{num_queries}")
+            rerank_results.append(
+                nv_rerank(
+                    query,
+                    candidates,
+                    reranker_endpoint=nv_ranker_endpoint,
+                    model_name=nv_ranker_model_name,
+                    topk=top_k,
                 )
-            results.append(formatted)
-
-        if nv_ranker:
-            rerank_results = []
-            for query, candidates in zip(queries, results):
-                rerank_results.append(
-                    nv_rerank(
-                        query,
-                        candidates,
-                        reranker_endpoint=nv_ranker_endpoint,
-                        model_name=nv_ranker_model_name,
-                        topk=top_k,
-                    )
+            )
+        results = rerank_results
+        _record_timing(
+            "lancedb.nv_rerank",
+            time.perf_counter() - rerank_start,
+            {"query_count": num_queries},
+        )
+
+    return results
+
+
+def lancedb_hybrid_retrieval(
+    queries,
+    table_path: str = None,
+    table_name: str = "nv-ingest",
+    table=None,
+    embedding_endpoint: str = "http://localhost:8012/v1",
+    nvidia_api_key: str = None,
+    model_name: str = "nvidia/llama-3.2-nv-embedqa-1b-v2",
+    top_k: int = 10,
+    refine_factor: int = 50,
+    n_probe: int = 64,
+    nv_ranker: bool = False,
+    nv_ranker_endpoint: str = None,
+    nv_ranker_model_name: str = None,
+    nv_ranker_top_k: int = 50,
+    result_fields=None,
+    **kwargs,
+):
+    """
+    LanceDB hybrid retrieval combining vector similarity with BM25 full-text search.
+
+    Uses RRF reranking to merge dense and sparse results. Requires an FTS index
+    on the text column (set hybrid=True during ingestion).
+    """
+    if table is None:
+        if table_path is None:
+            raise ValueError("Either table or table_path must be provided")
+        db = lancedb.connect(uri=table_path)
+        table = db.open_table(table_name)
+
+    if result_fields is None:
+        result_fields = ["text", "metadata", "source"]
+
+    embed_start = time.perf_counter()
+    embed_model = partial(
+        infer_microservice,
+        model_name=model_name,
+        embedding_endpoint=embedding_endpoint,
+        nvidia_api_key=nvidia_api_key,
+        input_type="query",
+        output_names=["embeddings"],
+        grpc=not ("http" in urlparse(embedding_endpoint).scheme),
+    )
+    query_embeddings = embed_model(queries)
+    _record_timing(
+        "lancedb.embed_queries",
+        time.perf_counter() - embed_start,
+        {"query_count": len(queries)},
+    )
+
+    search_top_k = nv_ranker_top_k if nv_ranker else top_k
+    reranker = RRFReranker()
+
+    results = []
+    search_durations = []
+    for query_text, query_embed in zip(queries, query_embeddings):
+        search_start = time.perf_counter()
+        search_results = (
+            table.search(query_type="hybrid")
+            .vector(query_embed)
+            .text(query_text)
+            .select(result_fields)
+            .limit(search_top_k)
+            .refine_factor(refine_factor)
+            .nprobes(n_probe)
+            .rerank(reranker)
+            .to_list()
+        )
+        search_durations.append(time.perf_counter() - search_start)
+        formatted = []
+        for r in search_results:
+            formatted.append(
+                {
+                    "entity": {
+                        "source": {"source_id": r.get("source")},
+                        "content_metadata": {"page_number": r.get("metadata")},
+                        "text": r.get("text"),
+                    }
+                }
+            )
+        results.append(formatted)
+    if search_durations:
+        total_search = sum(search_durations)
+        _record_timing(
+            "lancedb.hybrid_search",
+            total_search,
+            {
+                "query_count": len(search_durations),
+                "avg_query_s": total_search / len(search_durations),
+                "max_query_s": max(search_durations),
+            },
+        )
+
+    if nv_ranker:
+        rerank_start = time.perf_counter()
+        rerank_results = []
+        num_queries = len(queries)
+        for idx, (query, candidates) in enumerate(zip(queries, results), 1):
+            if num_queries > 1:
+                logger.info(f"Reranking query {idx}/{num_queries}")
+            rerank_results.append(
+                nv_rerank(
+                    query,
+                    candidates,
+                    reranker_endpoint=nv_ranker_endpoint,
+                    model_name=nv_ranker_model_name,
+                    topk=top_k,
                 )
-            results = rerank_results
+            )
+        results = rerank_results
+        _record_timing(
+            "lancedb.nv_rerank",
+            time.perf_counter() - rerank_start,
+            {"query_count": num_queries},
+        )
 
-        return results
+    return results
diff --git a/conda/build_conda_packages.sh b/conda/build_conda_packages.sh
deleted file mode 100755
index dfa1141f3..000000000
--- a/conda/build_conda_packages.sh
+++ /dev/null
@@ -1,134 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
-# All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-# Fail on errors (-e) and undefined variables (-u)
-set -eux
-
-##############################
-# Source Validation Script
-##############################
-BUILD_SCRIPT_BASE="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
-source "${BUILD_SCRIPT_BASE}/scripts/helper_functions.sh"
-
-# Validate environment
-validate_conda_build_environment
-
-##############################
-# Determine Git Root
-##############################
-GIT_ROOT=$(determine_git_root)
-
-##############################
-# Input Arguments
-##############################
-OUTPUT_DIR=${1:-"${BUILD_SCRIPT_BASE}/output_conda_channel"}
-CONDA_CHANNEL=${2:-""}
-BUILD_NV_INGEST=${BUILD_NV_INGEST:-1} # 1 = build by default, 0 = skip
-BUILD_NV_INGEST_API=${BUILD_NV_INGEST_API:-1} # 1 = build by default, 0 = skip
-BUILD_NV_INGEST_CLIENT=${BUILD_NV_INGEST_CLIENT:-1} # 1 = build by default, 0 = skip
-RELEASE_VERSION=${RELEASE_VERSION:-} # Version to override output name for release
-
-echo "RELEASE_VERSION: ${RELEASE_VERSION}"
-
-##############################
-# Package Directories"
-##############################
-NV_INGEST_DIR="${BUILD_SCRIPT_BASE}/packages/nv_ingest"
-NV_INGEST_API_DIR="${BUILD_SCRIPT_BASE}/packages/nv_ingest_api"
-NV_INGEST_CLIENT_DIR="${BUILD_SCRIPT_BASE}/packages/nv_ingest_client"
-
-##############################
-# Setup Output Dir
-##############################
-echo "Using OUTPUT_DIR: $OUTPUT_DIR"
-mkdir -p "${OUTPUT_DIR}/linux-64"
-
-GIT_SHA=$(git rev-parse --short HEAD)
-
-##############################
-# Build Packages
-##############################
-if [[ "${BUILD_NV_INGEST_API}" -eq 1 ]]; then
-    echo "Building nv_ingest_api..."
-    SCRIPT_PATH="$GIT_ROOT/api/src/version.py"
-    echo "SCRIPT_PATH: $SCRIPT_PATH"
-
-    # Generate the version if not specified
-    if [ -z "$RELEASE_VERSION" ]; then
-        NV_INGEST_API_VERSION=$(python3 -c "import sys, importlib.util; spec = importlib.util.spec_from_file_location('version', '$SCRIPT_PATH'); version = importlib.util.module_from_spec(spec); spec.loader.exec_module(version); print(version.get_version())")
-    else
-        NV_INGEST_API_VERSION=$RELEASE_VERSION
-    fi
-
-    echo "NV_INGEST_API_VERSION: $NV_INGEST_API_VERSION"
-    NV_INGEST_API_VERSION="${NV_INGEST_API_VERSION}" GIT_ROOT="${GIT_ROOT}/api" GIT_SHA="${GIT_SHA}" conda build "${NV_INGEST_API_DIR}" \
-        -c nvidia/label/dev -c rapidsai -c nvidia -c conda-forge \
-        --output-folder "${OUTPUT_DIR}" --no-anaconda-upload
-else
-    echo "Skipping nv_ingest_api build."
-fi
-
-if [[ "${BUILD_NV_INGEST}" -eq 1 ]]; then
-    echo "Building nv_ingest..."
-    SCRIPT_PATH="$GIT_ROOT/src/nv_ingest/version.py"
-    echo "SCRIPT_PATH: $SCRIPT_PATH"
-
-    # Generate the version if not specified
-    if [ -z "$RELEASE_VERSION" ]; then
-        NV_INGEST_SERVICE_VERSION=$(python3 -c "import sys, importlib.util; spec = importlib.util.spec_from_file_location('version', '$SCRIPT_PATH'); version = importlib.util.module_from_spec(spec); spec.loader.exec_module(version); print(version.get_version())")
-    else
-        NV_INGEST_SERVICE_VERSION=$RELEASE_VERSION
-    fi
-
-    echo "NV_INGEST_SERVICE_VERSION: $NV_INGEST_SERVICE_VERSION"
-    NV_INGEST_SERVICE_VERSION="${NV_INGEST_SERVICE_VERSION}" GIT_ROOT="${GIT_ROOT}/src" GIT_SHA="${GIT_SHA}" conda build "${NV_INGEST_DIR}" \
-        -c nvidia/label/dev -c rapidsai -c nvidia -c conda-forge \
-        --output-folder "${OUTPUT_DIR}" --no-anaconda-upload
-else
-    echo "Skipping nv_ingest build."
-fi
-
-if [[ "${BUILD_NV_INGEST_CLIENT}" -eq 1 ]]; then
-    echo "Building nv_ingest_client..."
-    SCRIPT_PATH="$GIT_ROOT/client/src/version.py"
-    echo "SCRIPT_PATH: $SCRIPT_PATH"
-
-    # Generate the version if not specified
-    if [ -z "$RELEASE_VERSION" ]; then
-        NV_INGEST_CLIENT_VERSION=$(python3 -c "import sys, importlib.util; spec = importlib.util.spec_from_file_location('version', '$SCRIPT_PATH'); version = importlib.util.module_from_spec(spec); spec.loader.exec_module(version); print(version.get_version())")
-    else
-        NV_INGEST_CLIENT_VERSION=$RELEASE_VERSION
-    fi
-
-    echo "NV_INGEST_CLIENT_VERSION: $NV_INGEST_CLIENT_VERSION"
-    NV_INGEST_CLIENT_VERSION="${NV_INGEST_CLIENT_VERSION}" GIT_ROOT="${GIT_ROOT}/client" GIT_SHA="${GIT_SHA}" conda build "${NV_INGEST_CLIENT_DIR}" \
-        -c nvidia/label/dev -c rapidsai -c nvidia -c conda-forge \
-        --output-folder "${OUTPUT_DIR}" --no-anaconda-upload
-else
-    echo "Skipping nv_ingest_client build."
-fi
-
-##############################
-# Index the Conda Channel
-##############################
-echo "Indexing conda channel at ${OUTPUT_DIR}..."
-conda index "${OUTPUT_DIR}"
-
-##############################
-# Publish to User-Specified Conda Channel
-##############################
-publish_to_conda_channel() {
-    local channel_path=$1
-    echo "Publishing to Conda channel at ${channel_path} (stubbed function)"
-    # TODO(Devin): Implement publishing logic (e.g., upload to Anaconda Cloud or other server)
-}
-
-if [[ -n "${CONDA_CHANNEL}" ]]; then
-    publish_to_conda_channel "${CONDA_CHANNEL}"
-else
-    echo "No Conda channel specified. Skipping publishing step."
-fi
-
-echo "Artifacts successfully built and placed in ${OUTPUT_DIR}"
diff --git a/conda/environments/nv_ingest_api_environment.yml b/conda/environments/nv_ingest_api_environment.yml
deleted file mode 100644
index f8d184fec..000000000
--- a/conda/environments/nv_ingest_api_environment.yml
+++ /dev/null
@@ -1,19 +0,0 @@
-name: nv_ingest_api
-channels:
-  - nvidia/label/dev
-  - rapidsai
-  - nvidia
-  - conda-forge
-dependencies:
-  - diskcache>=5.6.3
-  - pydantic>2.0.0
-  - pydantic-settings>2.0.0
-  - pytest>=8.0.2
-  - pytest-mock>=3.14.0
-  - pytest-cov>=6.0.0
-  - python>=3.12
-  - python-build>=1.2.2
-  - setuptools>=58.2.0
-  - s3fs>=2024.10.0
-  - universal-pathlib
-  - pip
diff --git a/conda/environments/nv_ingest_client_environment.yml b/conda/environments/nv_ingest_client_environment.yml
deleted file mode 100644
index 9a2dbd2f9..000000000
--- a/conda/environments/nv_ingest_client_environment.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-name: nv_ingest_client
-channels:
-  - nvidia/label/dev
-  - rapidsai
-  - nvidia
-  - conda-forge
-dependencies:
-  - click>=8.1.7
-  - diskcache>=5.6.3
-  - fsspec>=2024.10.0
-  - s3fs>=2024.10.0
-  - httpx>=0.28.1
-  - pydantic>=2.10.3
-  - pypdfium2>=4.30.0
-  - pytest>=8.0.2
-  - pytest-mock>=3.14.0
-  - pytest-cov>=6.0.0
-  - python>=3.12
-  - python-build>=1.2.2
-  - python-docx>=1.1.2
-  - python-pptx>=1.0.2
-  - requests>=2.28.2
-  - setuptools>=58.2.0
-  - tqdm>=4.67.1
-  - pip
diff --git a/conda/environments/nv_ingest_environment.base.yml b/conda/environments/nv_ingest_environment.base.yml
deleted file mode 100644
index 70c74aea2..000000000
--- a/conda/environments/nv_ingest_environment.base.yml
+++ /dev/null
@@ -1,56 +0,0 @@
-name: nv_ingest_runtime
-channels:
-  - nvidia/label/dev
-  - rapidsai
-  - nvidia
-  - conda-forge
-dependencies:
-  - azure-core>=1.32.0
-  - click>=8.1.7
-  - diskcache>=5.6.3
-  - fastapi>=0.115.6
-  - fastparquet>=2024.11.0
-  - fsspec>=2024.10.0
-  - s3fs>=2024.10.0
-  - gunicorn
-  - h11>=0.16.0 # Must pin at or above 0.16.0 for CVE mitigation
-  - httpx>=0.28.1
-  - isodate>=0.7.2
-  - langdetect>=1.0.9
-  - minio>=7.2.12
-  - opentelemetry-api>=1.27.0
-  - opentelemetry-exporter-otlp>=1.27.0
-  - opentelemetry-sdk>=1.27.0
-  - protobuf>=5.29.3
-  - psutil=7.1.0
-  - pydantic>2.0.0
-  - pydantic-settings>2.0.0
-  - pytest>=8.0.2
-  - pytest-mock>=3.14.0
-  - pytest-cov>=6.0.0
-  - python>=3.12.11,<3.13
-  - python-build>=1.2.2
-  - python-docx>=1.1.2
-  - python-dotenv>=1.0.1
-  - python-pptx>=1.0.2
-  - redis-py>=5.2.1
-  - requests>=2.28.2
-  - scikit-learn>=1.6.0
-  - scipy>=1.15.1
-  - setuptools>=58.2.0
-  - tabulate>=0.9.0
-  - transformers>=4.57.3 # CVE Fix
-  - tqdm>=4.67.1
-  - uvicorn
-  - universal_pathlib
-  - pip
-  - pip:
-      - milvus-lite==2.4.12
-      - opencv-python # For some reason conda cant solve our req set with py-opencv so we need to use pip
-      - prometheus-client
-      - pymilvus>=2.5.0
-      - pymilvus[bulk_writer, model]
-      - tritonclient
-      - nvidia-riva-client==2.20.0
-      - unstructured-client
-      - markitdown
diff --git a/conda/environments/nv_ingest_environment.linux_64.yml b/conda/environments/nv_ingest_environment.linux_64.yml
deleted file mode 100644
index 355cc7cfa..000000000
--- a/conda/environments/nv_ingest_environment.linux_64.yml
+++ /dev/null
@@ -1,9 +0,0 @@
-name: nv_ingest_runtime
-channels:
-  - nvidia/label/dev
-  - rapidsai
-  - nvidia
-  - conda-forge
-dependencies:
-  - pypdfium2>=4.30.0
-  - ray-all>=2.52.0
diff --git a/conda/environments/nv_ingest_environment.linux_aarch64.yml b/conda/environments/nv_ingest_environment.linux_aarch64.yml
deleted file mode 100644
index 448236a29..000000000
--- a/conda/environments/nv_ingest_environment.linux_aarch64.yml
+++ /dev/null
@@ -1,10 +0,0 @@
-name: nv_ingest_runtime
-channels:
-  - nvidia/label/dev
-  - rapidsai
-  - nvidia
-  - conda-forge
-dependencies:
-  - pip:
-      - pypdfium2>=4.30.0
-      - ray[all]>=2.52.0
diff --git a/conda/packages/nv_ingest/meta.yaml b/conda/packages/nv_ingest/meta.yaml
deleted file mode 100644
index 285d1721b..000000000
--- a/conda/packages/nv_ingest/meta.yaml
+++ /dev/null
@@ -1,84 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
-# All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-{% set py_version = environ['CONDA_PY'] %}
-{% set GIT_SHA = environ['GIT_SHA'] %}
-
-# Determine Git root, falling back to default path ../../.. if Git is not available or the directory is not a Git repo
-{% set git_root = environ.get('GIT_ROOT', '../../../src') %}
-
-package:
-  name: nv_ingest
-  version: {{ environ.get('NV_INGEST_SERVICE_VERSION', 'Unknown') }}
-
-source:
-  path: {{ git_root }}
-
-build:
-  number: 0
-  string: py{{ py_version }}_{{ GIT_SHA }}
-  script:
-    - {{ PYTHON }} -m pip install . --no-deps -vv
-
-requirements:
-  build:
-    - pip
-    - python=3.12.11
-    - setuptools>=78.1.1
-  run:
-    - azure-core>=1.32.0
-    - click>=8.1.7
-    - fastapi>=0.115.6
-    - fastparquet>=2024.11.0
-    - fsspec>=2024.10.0
-    - httpx>=0.28.1
-    - isodate>=0.7.2
-    - langdetect>=1.0.9
-    - minio>=7.2.12
-    - opentelemetry-api>=1.27.0
-    - opentelemetry-exporter-otlp>=1.27.0
-    - opentelemetry-sdk>=1.27.0
-    - protobuf>=5.29.3
-    - pydantic>=2.0.0
-    - pypdfium2>=4.30.0
-    - pytest>=8.0.2
-    - pytest-mock>=3.14.0
-    - python>=3.12.11
-    - python-docx>=1.1.2
-    - python-dotenv>=1.0.1
-    - python-magic>=0.4.27
-    - python-pptx>=1.0.2
-    - ray-all>=2.52.0
-    - redis-py>=5.2.1
-    - requests>=2.28.2
-    - scipy>=1.15.1
-    - setuptools>=78.1.1
-    - tabulate>=0.9.0
-    - tqdm>=4.67.1
-    - transformers>=4.57.3
-    # - unstructured-client>=0.25.9
-    - uvicorn
-    - universal_pathlib
-  pip:
-    - nvidia-riva-client==2.20.0
-    - markitdown
-
-  test:
-    commands:
-      - pytest ./tests
-
-about:
-  home: "https://github.com/NVIDIA/nv-ingest"
-  license: "Apache-2.0"
-  summary: "Python module supporting document ingestion."
-  description: "Python module supporting document ingestion."
-
-extra:
-  recipe-maintainers:
-    - drobison@nvidia.com
-
-channels:
-  - rapidsai
-  - nvidia
-  - conda-forge
diff --git a/conda/packages/nv_ingest_api/meta.yaml b/conda/packages/nv_ingest_api/meta.yaml
deleted file mode 100644
index ea51cb87c..000000000
--- a/conda/packages/nv_ingest_api/meta.yaml
+++ /dev/null
@@ -1,70 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
-# All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-{% set py_version = environ['CONDA_PY'] %}
-{% set GIT_SHA = environ['GIT_SHA'] %}
-
-# Determine Git root, falling back to default path ../../.. if Git is not available or the directory is not a Git repo
-{% set git_root = environ.get('GIT_ROOT', '../../../api') %}
-
-package:
-  name: nv_ingest_api
-  version: {{ environ.get('NV_INGEST_API_VERSION', 'Unknown') }}
-
-source:
-  path: {{ git_root }}
-
-build:
-  number: 0
-  string: py{{ py_version }}_{{ GIT_SHA }}
-  script:
-    - {{ PYTHON }} -m pip install . --no-deps -vv
-
-requirements:
-  build:
-    - pip
-    - python=3.12.11
-    - setuptools>=78.1.1
-  run:
-    - azure-core>=1.32.0
-    - fastparquet>=2024.11.0
-    - fsspec>=2024.10.0
-    - httpx>=0.28.1
-    - isodate>=0.7.2
-    - langdetect>=1.0.9
-    - protobuf=5.29.3
-    - pydantic>=2.0.0
-    - pypdfium2>=4.30.0
-    - pytest>=8.0.2
-    - pytest-mock>=3.14.0
-    - python>=3.12.11
-    - python-docx>=1.1.2
-    - python-dotenv>=1.0.1
-    - python-magic>=0.4.27
-    - python-pptx>=1.0.2
-    - requests>=2.28.2
-    - setuptools>=78.1.1
-    - tabulate>=0.9.0
-    - transformers>=4.57.3
-    - universal-pathlib
-    # - unstructured-client>=0.25.9
-
-  test:
-    commands:
-      - pytest ./tests
-
-about:
-  home: "https://github.com/NVIDIA/nv-ingest"
-  license: "Apache-2.0"
-  summary: "Python module with core document ingestion functions."
-  description: "Python module with core document ingestion functions."
-
-extra:
-  recipe-maintainers:
-    - jdyer@nvidia.com
-
-channels:
-  - rapidsai
-  - nvidia
-  - conda-forge
diff --git a/conda/packages/nv_ingest_client/meta.yaml b/conda/packages/nv_ingest_client/meta.yaml
deleted file mode 100644
index fd78c4f50..000000000
--- a/conda/packages/nv_ingest_client/meta.yaml
+++ /dev/null
@@ -1,59 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
-# All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-{% set py_version = environ['CONDA_PY'] %}
-{% set GIT_SHA = environ['GIT_SHA'] %}
-
-# Determine Git root, falling back to default path ../../.. if Git is not available or the directory is not a Git repo
-{% set git_root = environ.get('GIT_ROOT', '../../../client') %}
-
-package:
-  name: nv_ingest_client
-  version: {{ environ.get('NV_INGEST_CLIENT_VERSION', 'Unknown') }}
-
-source:
-  path: {{ git_root }}
-
-build:
-  number: 0
-  string: py{{ py_version }}_{{ GIT_SHA }}
-  script:
-    - {{ PYTHON }} -m pip install . --no-deps -vv
-
-requirements:
-  build:
-    - pip
-    - python=3.12.11
-    - setuptools>=78.1.1
-  run:
-    - click>=8.1.7
-    - fsspec>=2024.10.0
-    - httpx>=0.28.1
-    - pydantic>=2.0.0
-    - pypdfium2>=4.30.0
-    - python>=3.12
-    - python-docx>=1.1.2
-    - python-pptx>=1.0.2
-    - requests>=2.28.2
-    - setuptools>=78.1.1
-    - tqdm>=4.67.1
-
-  test:
-    commands:
-      - pytest ./tests
-
-about:
-  home: "https://github.com/NVIDIA/nv-ingest"
-  license: "Apache-2.0"
-  summary: "Python module supporting document ingestion."
-  description: "Python module supporting document ingestion."
-
-extra:
-  recipe-maintainers:
-    - drobison@nvidia.com
-
-channels:
-  - rapidsai
-  - nvidia
-  - conda-forge
diff --git a/conda/scripts/helper_functions.sh b/conda/scripts/helper_functions.sh
deleted file mode 100644
index 75c8da338..000000000
--- a/conda/scripts/helper_functions.sh
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env bash
-# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
-# All rights reserved.
-# SPDX-License-Identifier: Apache-2.0
-
-# Fail on errors and undefined variables
-set -euo pipefail
-
-validate_conda_build_environment() {
-    ##############################
-    # Validate Dependencies
-    ##############################
-
-    # Ensure conda is installed
-    if ! command -v conda &> /dev/null; then
-        echo "Error: conda not found in PATH. Please ensure Conda is installed and available."
-        exit 1
-    fi
-
-    # Ensure conda-build is installed
-    if ! command -v conda-build &> /dev/null; then
-        echo "Error: conda-build not found in PATH. Install it via: conda install conda-build"
-        exit 1
-    fi
-
-    # Ensure git is installed
-    if ! command -v git &> /dev/null; then
-        echo "Error: git not found in PATH. Please ensure Git is installed and available."
-        exit 1
-    fi
-}
-
-determine_git_root() {
-    ##############################
-    # Determine Git Root
-    ##############################
-
-    if git rev-parse --is-inside-work-tree &> /dev/null; then
-        echo "$(git rev-parse --show-toplevel)"
-    else
-        echo "Error: Not inside a Git repository. Unable to determine the Git root."
-        exit 1
-    fi
-}
diff --git a/deploy/pdf-blueprint.ipynb b/deploy/pdf-blueprint.ipynb
index 4b1eb06e1..1c8b47db8 100644
--- a/deploy/pdf-blueprint.ipynb
+++ b/deploy/pdf-blueprint.ipynb
@@ -30,8 +30,8 @@
   },
   {
    "attachments": {
-    "b947a5fe-b01b-4f18-82e7-fda0c3a19c1a.png": {
-     "image/png": "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"
+    "754d0879-53f3-45e9-84f1-307ef35d2a4b.png": {
+     "image/png": "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"
     }
    },
    "cell_type": "markdown",
@@ -45,7 +45,7 @@
     "\n",
     "This blueprint is comprised of multiple pieces that come together to form a powerful multi-modal RAG solution\n",
     "\n",
-    "![arch](attachment:b947a5fe-b01b-4f18-82e7-fda0c3a19c1a.png)"
+    "![arch](attachment:754d0879-53f3-45e9-84f1-307ef35d2a4b.png)"
    ]
   },
   {
@@ -1239,7 +1239,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.11"
+   "version": "3.13.12"
   }
  },
  "nbformat": 4,
diff --git a/docker-compose.a100-40gb.yaml b/docker-compose.a100-40gb.yaml
index b1562bc32..a717d7a3a 100644
--- a/docker-compose.a100-40gb.yaml
+++ b/docker-compose.a100-40gb.yaml
@@ -19,10 +19,6 @@ services:
     environment:
       - NIM_TRITON_MAX_BATCH_SIZE=1
 
-  embedding:
-    environment:
-      - NIM_TRITON_MAX_SEQ_LENGTH=128
-
   reranker:
     environment:
       - NIM_TRITON_MAX_BATCH_SIZE=1
diff --git a/docker-compose.a10g.yaml b/docker-compose.a10g.yaml
index b1562bc32..a717d7a3a 100644
--- a/docker-compose.a10g.yaml
+++ b/docker-compose.a10g.yaml
@@ -19,10 +19,6 @@ services:
     environment:
       - NIM_TRITON_MAX_BATCH_SIZE=1
 
-  embedding:
-    environment:
-      - NIM_TRITON_MAX_SEQ_LENGTH=128
-
   reranker:
     environment:
       - NIM_TRITON_MAX_BATCH_SIZE=1
diff --git a/docker-compose.l40s.yaml b/docker-compose.l40s.yaml
index b1562bc32..a717d7a3a 100644
--- a/docker-compose.l40s.yaml
+++ b/docker-compose.l40s.yaml
@@ -19,10 +19,6 @@ services:
     environment:
       - NIM_TRITON_MAX_BATCH_SIZE=1
 
-  embedding:
-    environment:
-      - NIM_TRITON_MAX_SEQ_LENGTH=128
-
   reranker:
     environment:
       - NIM_TRITON_MAX_BATCH_SIZE=1
diff --git a/docker-compose.yaml b/docker-compose.yaml
index 45b19368e..84a9aae1a 100644
--- a/docker-compose.yaml
+++ b/docker-compose.yaml
@@ -12,17 +12,18 @@ services:
     image: ${YOLOX_IMAGE:-nvcr.io/nim/nvidia/nemoretriever-page-elements-v3}:${YOLOX_TAG:-1.7.0}
     shm_size: 16gb
     ports:
-      - "8000:8000"
-      - "8001:8001"
-      - "8002:8002"
+      - "${PAGE_ELEMENTS_HTTP_PORT:-8000}:8000"
+      - "${PAGE_ELEMENTS_GRPC_PORT:-8001}:8001"
+      - "${PAGE_ELEMENTS_METRICS_PORT:-8002}:8002"
+    expose:
+      - "8000"
+      - "8001"
+      - "8002"
     environment:
       - NIM_HTTP_API_PORT=8000
       - NIM_TRITON_LOG_VERBOSE=1
-      - NIM_TRITON_RATE_LIMIT=3
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - CUDA_VISIBLE_DEVICES=0
       - NIM_TRITON_MAX_BATCH_SIZE=${PAGE_ELEMENTS_BATCH_SIZE:-32}
-      - NIM_TRITON_CUDA_MEMORY_POOL_MB=${PAGE_ELEMENTS_CUDA_MEMORY_POOL_MB:-2048}
       - NIM_TRITON_CPU_THREADS_PRE_PROCESSOR=${PAGE_ELEMENTS_CPU_THREADS_PRE_PROCESSOR:-2}
       - NIM_TRITON_CPU_THREADS_POST_PROCESSOR=${PAGE_ELEMENTS_CPU_THREADS_POST_PROCESSOR:-1}
       - OMP_NUM_THREADS=2
@@ -41,23 +42,22 @@ services:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
 
   graphic-elements:
     image: ${YOLOX_GRAPHIC_ELEMENTS_IMAGE:-nvcr.io/nim/nvidia/nemoretriever-graphic-elements-v1}:${YOLOX_GRAPHIC_ELEMENTS_TAG:-1.6.0}
     shm_size: 16gb
-    ports:
-      - "8003:8000"
-      - "8004:8001"
-      - "8005:8002"
+    expose:
+      - "8000"
+      - "8001"
+      - "8002"
     environment:
       - NIM_HTTP_API_PORT=8000
       - NIM_TRITON_LOG_VERBOSE=1
       - NIM_TRITON_RATE_LIMIT=3
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - CUDA_VISIBLE_DEVICES=0
       - NIM_TRITON_MAX_BATCH_SIZE=${GRAPHIC_ELEMENTS_BATCH_SIZE:-32}
       - NIM_TRITON_CUDA_MEMORY_POOL_MB=${GRAPHIC_ELEMENTS_CUDA_MEMORY_POOL_MB:-2048}
       - OMP_NUM_THREADS=1
@@ -66,23 +66,22 @@ services:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
 
   table-structure:
     image: ${YOLOX_TABLE_STRUCTURE_IMAGE:-nvcr.io/nim/nvidia/nemoretriever-table-structure-v1}:${YOLOX_TABLE_STRUCTURE_TAG:-1.6.0}
     shm_size: 16gb
-    ports:
-      - "8006:8000"
-      - "8007:8001"
-      - "8008:8002"
+    expose:
+      - "8000"
+      - "8001"
+      - "8002"
     environment:
       - NIM_HTTP_API_PORT=8000
       - NIM_TRITON_LOG_VERBOSE=1
       - NIM_TRITON_RATE_LIMIT=3
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - CUDA_VISIBLE_DEVICES=0
       - NIM_TRITON_MAX_BATCH_SIZE=${TABLE_STRUCTURE_BATCH_SIZE:-32}
       - NIM_TRITON_CUDA_MEMORY_POOL_MB=${TABLE_STRUCTURE_CUDA_MEMORY_POOL_MB:-2048}
       - OMP_NUM_THREADS=1
@@ -91,7 +90,7 @@ services:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
 
@@ -99,23 +98,25 @@ services:
     image: ${OCR_IMAGE:-nvcr.io/nim/nvidia/nemoretriever-ocr-v1}:${OCR_TAG:-1.2.1}
     shm_size: 16gb
     ports:
-      - "8009:8000"
-      - "8010:8001"
-      - "8011:8002"
+      - "${OCR_HTTP_PORT:-8019}:8000"
+      - "${OCR_GRPC_PORT:-8010}:8001"
+      - "${OCR_METRICS_PORT:-8011}:8002"
+    expose:
+      - "8000"
+      - "8001"
+      - "8002"
     environment:
       - OMP_NUM_THREADS=${OCR_OMP_NUM_THREADS:-8}
       - NIM_HTTP_API_PORT=8000
       - NIM_TRITON_LOG_VERBOSE=1
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - CUDA_VISIBLE_DEVICES=0
       - NIM_TRITON_MAX_BATCH_SIZE=${OCR_BATCH_SIZE:-32}
-      - NIM_TRITON_ENABLE_MODEL_CONTROL=1
     deploy:
       resources:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
 
@@ -123,12 +124,11 @@ services:
     # NIM ON
     image: ${EMBEDDING_IMAGE:-nvcr.io/nim/nvidia/llama-3.2-nv-embedqa-1b-v2}:${EMBEDDING_TAG:-1.10.1}
     shm_size: 16gb
-    ports:
-      - "8012:8000"
-      - "8013:8001"
-      - "8014:8002"
+    expose:
+      - "8000"
+      - "8001"
+      - "8002"
     environment:
-      - CUDA_VISIBLE_DEVICES=0
       - NIM_HTTP_API_PORT=8000
       - NIM_TRITON_LOG_VERBOSE=1
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
@@ -140,7 +140,7 @@ services:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
 
@@ -148,19 +148,18 @@ services:
     # NIM ON
     image: ${RERANKER_IMAGE:-nvcr.io/nim/nvidia/llama-3.2-nv-rerankqa-1b-v2}:${RERANKER_TAG:-1.8.0}
     shm_size: 16gb
-    ports:
-      - "8020:8000"
+    expose:
+      - "8000"
     environment:
       - NIM_HTTP_API_PORT=8000
       - NIM_TRITON_LOG_VERBOSE=1
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - CUDA_VISIBLE_DEVICES=0
     deploy:
       resources:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
     profiles:
@@ -169,21 +168,20 @@ services:
   nemotron-parse:
     image: ${NEMOTRON_PARSE_IMAGE:-nvcr.io/nim/nvidia/nemotron-parse}:${NEMOTRON_PARSE_TAG:-1.5.0}
     shm_size: 16gb
-    ports:
-      - "8015:8000"
-      - "8016:8001"
-      - "8017:8002"
+    expose:
+      - "8000"
+      - "8001"
+      - "8002"
     environment:
       - NIM_HTTP_API_PORT=8000
       - NIM_TRITON_LOG_VERBOSE=1
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - CUDA_VISIBLE_DEVICES=0
     deploy:
       resources:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
     profiles:
@@ -192,13 +190,12 @@ services:
   vlm:
     image: ${VLM_IMAGE:-nvcr.io/nim/nvidia/nemotron-nano-12b-v2-vl}:${VLM_TAG:-1.5.0}
     shm_size: 16gb
-    ports:
-      - "8018:8000"
+    expose:
+      - "8000"
     environment:
       - NIM_HTTP_API_PORT=8000
       - NIM_TRITON_LOG_VERBOSE=1
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - CUDA_VISIBLE_DEVICES=0
       # VLM will use all available VRAM on device
       # For more info
       # https://docs.nvidia.com/nim/vision-language-models/latest/configuration.html
@@ -208,7 +205,7 @@ services:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
     profiles:
@@ -217,29 +214,28 @@ services:
   audio:
     image: ${AUDIO_IMAGE:-nvcr.io/nim/nvidia/parakeet-1-1b-ctc-en-us}:${AUDIO_TAG:-1.4.0}
     shm_size: 2gb
-    ports:
-      - "8021:50051"  # grpc
-      - "8022:9000"  # http
+    expose:
+      - "50051" # grpc
+      - "9000"  # http
     ulimits:
       nofile: 2048
     environment:
       - NIM_TAGS_SELECTOR=name=parakeet-1-1b-ctc-en-us,mode=ofl
       - NIM_TRITON_LOG_VERBOSE=1
       - NGC_API_KEY=${NIM_NGC_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - CUDA_VISIBLE_DEVICES=0
     deploy:
       resources:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     runtime: nvidia
     profiles:
       - audio
 
   nv-ingest-ms-runtime:
-    image: nvcr.io/nvidia/nemo-microservices/nv-ingest:latest
+    image: nvcr.io/nvidia/nemo-microservices/nv-ingest:26.1.2
     shm_size: 40gb # Should be at minimum 30% of assigned memory per Ray documentation
     build:
       context: ${NV_INGEST_ROOT:-.}
@@ -270,13 +266,13 @@ services:
       - CUDA_VISIBLE_DEVICES=-1
       # Optional: Load custom pipeline YAML (uncomment and mount ./config volume above)
       #- INGEST_CONFIG_PATH=/workspace/config/custom_summarization_pipeline.yaml
-      - MAX_INGEST_PROCESS_WORKERS=${MAX_INGEST_PROCESS_WORKERS:-16}
+      - MAX_INGEST_PROCESS_WORKERS=${MAX_INGEST_PROCESS_WORKERS:-32}
       - EMBEDDING_NIM_ENDPOINT=${EMBEDDING_NIM_ENDPOINT:-http://embedding:8000/v1}
       - EMBEDDING_NIM_MODEL_NAME=${EMBEDDING_NIM_MODEL_NAME:-nvidia/llama-3.2-nv-embedqa-1b-v2}
       - INGEST_LOG_LEVEL=DEFAULT
       - INGEST_RAY_LOG_LEVEL=DEVELOPMENT
       - INGEST_DYNAMIC_MEMORY_THRESHOLD=0.80
-      - INGEST_DISABLE_DYNAMIC_SCALING=${INGEST_DISABLE_DYNAMIC_SCALING:-false}
+      - INGEST_DISABLE_DYNAMIC_SCALING=${INGEST_DISABLE_DYNAMIC_SCALING:-true}
       # Ray internals configuration
       - RAY_num_grpc_threads=1
       - RAY_num_server_call_thread=1
@@ -308,7 +304,7 @@ services:
       - NEMOTRON_PARSE_MODEL_NAME=nvidia/nemotron-parse
       - NGC_API_KEY=${NGC_API_KEY:-ngcapikey}
       - NVIDIA_API_KEY=${NVIDIA_API_KEY:-${NGC_API_KEY:-ngcapikey}}
-      - NV_INGEST_MAX_UTIL=${NV_INGEST_MAX_UTIL:-48}
+      - NV_INGEST_MAX_UTIL=${NV_INGEST_MAX_UTIL:-32}
       - OTEL_EXPORTER_OTLP_ENDPOINT=http://otel-collector:4317
       # Self-hosted ocr endpoints.
       - OCR_GRPC_ENDPOINT=ocr:8001
@@ -451,7 +447,6 @@ services:
   milvus:
     # Turn on to leverage the `vdb_upload` task
     restart: always
-    container_name: milvus-standalone
     image: milvusdb/milvus:v2.5.3-gpu
     command: [ "bash", "-c", "sed -i 's/bucketName: a-bucket/bucketName: ${MINIO_BUCKET:-nv-ingest}/' /milvus/configs/milvus.yaml && milvus run standalone" ]
     hostname: milvus
@@ -468,15 +463,15 @@ services:
       start_period: 90s
       timeout: 20s
       retries: 3
-    ports:
-      - "19530:19530"
-      - "9091:9091"
+    expose:
+      - "19530"
+      - "9091"
     deploy:
       resources:
         reservations:
           devices:
             - driver: nvidia
-              device_ids: ["0"]
+              device_ids: ["${GPU_ID:-0}"]
               capabilities: [gpu]
     depends_on:
       - "etcd"
diff --git a/docker/scripts/entrypoint.sh b/docker/scripts/entrypoint.sh
index abb8a389d..96e64c6a0 100755
--- a/docker/scripts/entrypoint.sh
+++ b/docker/scripts/entrypoint.sh
@@ -15,13 +15,7 @@
 # limitations under the License.
 
 
-#!/bin/bash
-
-# Activate the `nv_ingest_runtime` conda environment
-
 set -e
-. /opt/conda/etc/profile.d/conda.sh
-conda activate nv_ingest_runtime
 
 # Source "source" file if it exists
 SRC_FILE="/opt/docker/bin/entrypoint_source"
diff --git a/docker/scripts/entrypoint_devcontainer.sh b/docker/scripts/entrypoint_devcontainer.sh
index 7625bd44a..fd891447e 100755
--- a/docker/scripts/entrypoint_devcontainer.sh
+++ b/docker/scripts/entrypoint_devcontainer.sh
@@ -15,12 +15,6 @@
 # limitations under the License.
 
 
-#!/bin/bash
-
-# Activate the `nv_ingest_runtime` conda environment
-. /opt/conda/etc/profile.d/conda.sh
-conda activate nv_ingest_runtime
-
 # Source "source" file if it exists
 SRC_FILE="/opt/docker/bin/entrypoint_source"
 [ -f "${SRC_FILE}" ] && source "${SRC_FILE}"
diff --git a/docker/scripts/entrypoint_source_ext.sh b/docker/scripts/entrypoint_source_ext.sh
index dd4d62ec2..479e76188 100755
--- a/docker/scripts/entrypoint_source_ext.sh
+++ b/docker/scripts/entrypoint_source_ext.sh
@@ -19,12 +19,12 @@ fi
 
 # Install audio dependencies
 if ! python -c "import pkg_resources; pkg_resources.require('librosa')" 2>/dev/null; then
-  echo "Installing librosa using conda..."
-  mamba install -y -c conda-forge librosa
+  echo "Installing librosa with uv..."
+  uv pip install librosa
 fi
 
-# If MEM_TRACE is set in the environment, use mamba to install memray
+# If MEM_TRACE is set in the environment, install memray
 if [ -n "$MEM_TRACE" ]; then
-  echo "MEM_TRACE is set. Installing memray via mamba..."
-  mamba install -y conda-forge::memray
+  echo "MEM_TRACE is set. Installing memray with uv..."
+  uv pip install memray
 fi
diff --git a/docs/docs/extraction/audio.md b/docs/docs/extraction/audio.md
index ec2e26370..021ee74b6 100644
--- a/docs/docs/extraction/audio.md
+++ b/docs/docs/extraction/audio.md
@@ -1,6 +1,6 @@
-# Extract Speech with NeMo Retriever Extraction
+# Extract Speech with NeMo Retriever Library
 
-This documentation describes two methods to run [NeMo Retriever extraction](overview.md) 
+This documentation describes two methods to run [NeMo Retriever Library](overview.md) 
 with the [RIVA ASR NIM microservice](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/index.html) 
 to extract speech from audio files.
 
@@ -9,7 +9,7 @@ to extract speech from audio files.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 Currently, you can extract speech from the following file types:
 
@@ -20,7 +20,7 @@ Currently, you can extract speech from the following file types:
 
 ## Overview
 
-[NeMo Retriever extraction](overview.md) supports extracting speech from audio files for Retrieval Augmented Generation (RAG) applications. 
+[NeMo Retriever Library](overview.md) supports extracting speech from audio files for Retrieval Augmented Generation (RAG) applications. 
 Similar to how the multimodal document extraction pipeline leverages object detection and image OCR microservices, 
 NeMo Retriever leverages the [RIVA ASR NIM microservice](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/index.html) 
 to transcribe speech to text, which is then embedded by using the NeMo Retriever embedding NIM. 
@@ -62,17 +62,17 @@ Use the following procedure to run the NIM locally.
     NGC_API_KEY=<your-ngc-key>
     ```
 
-3. Start the nv-ingest services with the `audio` profile. This profile includes the necessary components for audio processing. Use the following command. The `--profile audio` flag ensures that speech-specific services are launched. For more information, refer to [Profile Information](quickstart-guide.md#profile-information).
+3. Start the retriever services with the `audio` profile. This profile includes the necessary components for audio processing. Use the following command. The `--profile audio` flag ensures that speech-specific services are launched. For more information, refer to [Profile Information](quickstart-guide.md#profile-information).
 
     ```shell
     docker compose --profile retrieval --profile audio up
     ```
 
-4. After the services are running, you can interact with nv-ingest by using Python.
+4. After the services are running, you can interact with the pipeline by using Python.
 
     - The `Ingestor` object initializes the ingestion process.
     - The `files` method specifies the input files to process.
-    - The `extract` method tells nv-ingest to extract information from WAV audio files.
+    - The `extract` method tells the pipeline to extract information from WAV audio files.
     - The `document_type` parameter is optional, because `Ingestor` should detect the file type automatically.
 
     ```python
@@ -94,7 +94,7 @@ Use the following procedure to run the NIM locally.
 
 ## Use NVCF Endpoints for Cloud-Based Inference
 
-Instead of running NV-Ingest locally, you can use NVCF to perform inference by using remote endpoints.
+Instead of running the pipeline locally, you can use NVCF to perform inference by using remote endpoints.
 
 1. NVCF requires an authentication token and a function ID for access. Ensure you have these credentials ready before making API calls.
 
@@ -102,7 +102,7 @@ Instead of running NV-Ingest locally, you can use NVCF to perform inference by u
 
     - The `Ingestor` object initializes the ingestion process.
     - The `files` method specifies the input files to process.
-    - The `extract` method tells nv-ingest to extract information from WAV audio files.
+    - The `extract` method tells the pipeline to extract information from WAV audio files.
     - The `document_type` parameter is optional, because `Ingestor` should detect the file type automatically.
 
     ```python
@@ -132,4 +132,4 @@ Instead of running NV-Ingest locally, you can use NVCF to perform inference by u
 
 - [Support Matrix](support-matrix.md)
 - [Troubleshoot Nemo Retriever Extraction](troubleshoot.md)
-- [Use the NV-Ingest Python API](nv-ingest-python-api.md)
+- [Use the Python API](nv-ingest-python-api.md)
diff --git a/docs/docs/extraction/benchmarking.md b/docs/docs/extraction/benchmarking.md
index 5d6b02599..0f8cd81d9 100644
--- a/docs/docs/extraction/benchmarking.md
+++ b/docs/docs/extraction/benchmarking.md
@@ -2,12 +2,35 @@
 
 A configurable, dataset-agnostic testing framework for end-to-end validation of nv-ingest pipelines. This framework uses structured YAML configuration for type safety, validation, and parameter management.
 
+## Dataset Prerequisites
+
+    
+Before you run any benchmarking or evaluation tests, you must first download the benchmark datasets. The three primary datasets used in nv-ingest benchmarking and evaluations are the following:
+    
+- **Bo20** - 20 PDFs for quick testing
+- **Bo767** - 767 PDFs for comprehensive benchmarking
+- **Bo10k** - 10,000 PDFs for large-scale evaluations
+    
+### How to Download the Datasets
+    
+Use the [Digital Corpora Download Notebook](https://github.com/NVIDIA/nv-ingest/blob/main/evaluation/digital_corpora_download.ipynb) to download these datasets from the public Digital Corpora source. This notebook provides automated download functions that do the following:
+    
+- Download PDFs directly from Digital Corpora's public repository.
+- Support all three dataset sizes (Bo20, Bo767, Bo10k).
+- Handle the extraction and organization of files automatically.
+    
+!!! Important
+
+    These datasets are prerequisites for all benchmarking operations described in this guide. Complete the dataset download before proceeding with any test scenarios below.
 ## Quick Start
 
 ### Prerequisites
-- Docker and Docker Compose running
-- Python environment with nv-ingest-client
-- Access to test datasets
+
+Before you use this documentation, you need the following:
+
+- Docker and Docker Compose are running
+- A Python environment with nv-ingest-client installed
+- The [benchmark datasets are downloaded](#dataset-prerequisites)
 
 ### Run Your First Test
 
diff --git a/docs/docs/extraction/chunking.md b/docs/docs/extraction/chunking.md
index 0bddfa4a2..540b147ca 100644
--- a/docs/docs/extraction/chunking.md
+++ b/docs/docs/extraction/chunking.md
@@ -12,7 +12,7 @@ There are two ways that NV Ingest chunks text:
 
 !!! warning
 
-    NeMo Retriever extraction is designed to process language and language-length strings. If you submit a document that contains extremely long, or non-language text strings, such as a DNA sequence, errors or unexpected results occur.
+    NeMo Retriever Library is designed to process language and language-length strings. If you submit a document that contains extremely long, or non-language text strings, such as a DNA sequence, errors or unexpected results occur.
 
 
 
@@ -107,5 +107,5 @@ If you are building the container yourself and want to pre-download this model,
 ## Related Topics
 
 - [Use the Python API](nv-ingest-python-api.md)
-- [NeMo Retriever Extraction V2 API Guide](v2-api-guide.md)
+- [NeMo Retriever Library V2 API Guide](v2-api-guide.md)
 - [Environment Variables](environment-variables.md)
diff --git a/docs/docs/extraction/content-metadata.md b/docs/docs/extraction/content-metadata.md
index 617181d91..e7d8bb050 100644
--- a/docs/docs/extraction/content-metadata.md
+++ b/docs/docs/extraction/content-metadata.md
@@ -1,6 +1,6 @@
-# Metadata Reference for NeMo Retriever Extraction
+# Metadata Reference for NeMo Retriever Library
 
-This documentation contains the reference for the metadata used in [NeMo Retriever extraction](overview.md). 
+This documentation contains the reference for the metadata used in [NeMo Retriever Library](overview.md). 
 The definitions used in this documentation are the following:
 
 - **Source** — The file that is ingested, and from which content and metadata is extracted.
@@ -10,7 +10,7 @@ Metadata can be extracted from a source or content, or generated by using models
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 
@@ -43,7 +43,7 @@ These fields apply to all content types including text, images, and tables.
 | Subtype | The type of the content for structured data types, such as table or chart. | — |
 | Content | Content extracted from the source.  | Extracted |
 | Description | A text description of the content object. | Generated |
-| Page \# | The page \# of the content in the source. Prior to 26.1.1, this field was 0-indexed. Beginning with 26.1.1, this field is 1-indexed. | Extracted |
+| Page \# | The page \# of the content in the source. Prior to 26.1.2, this field was 0-indexed. Beginning with 26.1.2, this field is 1-indexed. | Extracted |
 | Hierarchy | The location or order of the content within the source.  | Extracted |
 
 
diff --git a/docs/docs/extraction/custom-metadata.md b/docs/docs/extraction/custom-metadata.md
index 57e917ff8..805aef628 100644
--- a/docs/docs/extraction/custom-metadata.md
+++ b/docs/docs/extraction/custom-metadata.md
@@ -6,7 +6,7 @@ and use it for filtering results during retrieval operations.
 For example, you can add author metadata to your documents, and filter by author when you retrieve results. 
 To create filters, you use [Milvus Filtering Expressions](https://milvus.io/docs/boolean.md).
 
-Use this documentation to use custom metadata to filter search results when you work with [NeMo Retriever extraction](overview.md).
+Use this documentation to use custom metadata to filter search results when you work with [NeMo Retriever Library](overview.md).
 
 
 ## Limitations
@@ -56,7 +56,7 @@ meta_df.to_csv(file_path)
 ### Example: Add Custom Metadata During Ingestion
 
 The following example adds custom metadata during ingestion. 
-For more information about the `Ingestor` class, see [Use the NV-Ingest Python API](nv-ingest-python-api.md).
+For more information about the `Ingestor` class, see [Use the Python API](nv-ingest-python-api.md).
 For more information about the `vdb_upload` method, see [Upload Data](data-store.md).
 
 ```python
diff --git a/docs/docs/extraction/data-store.md b/docs/docs/extraction/data-store.md
index f0fb07482..580a1dfc7 100644
--- a/docs/docs/extraction/data-store.md
+++ b/docs/docs/extraction/data-store.md
@@ -1,47 +1,142 @@
-# Data Upload for NeMo Retriever Extraction
+# Data Upload for NeMo Retriever Library
 
-Use this documentation to learn how [NeMo Retriever extraction](overview.md) handles and uploads data.
+Use this documentation to learn how [NeMo Retriever Library](overview.md) handles and uploads data.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 ## Overview
 
-NeMo Retriever extraction supports extracting text representations of various forms of content, 
-and ingesting to the [Milvus vector database](https://milvus.io/). 
-The data upload task (`vdb_upload`) pulls extraction results to the Python client, 
-and then pushes them to Milvus by using its underlying MinIO object store service.
+NeMo Retriever Library supports extracting text representations of various forms of content,
+and ingesting to a vector database. **[LanceDB](https://lancedb.com/) is the default vector database backend** for storing and retrieving extracted embeddings. [Milvus](https://milvus.io/) remains fully supported as an alternative.
 
-The vector database stores only the extracted text representations of ingested data. 
+The data upload task (`vdb_upload`) pulls extraction results to the Python client,
+and then pushes them to the configured vector database (LanceDB or Milvus). When using Milvus, data is pushed by using its underlying MinIO object store service.
+
+The vector database stores only the extracted text representations of ingested data.
 It does not store the embeddings for images.
 
 !!! tip "Storing Extracted Images"
 
     To persist extracted images, tables, and chart renderings to disk or object storage, use the `store` task in addition to `vdb_upload`. The `store` task supports any fsspec-compatible backend (local filesystem, S3, GCS, etc.). For details, refer to [Store Extracted Images](nv-ingest-python-api.md#store-extracted-images).
 
-NeMo Retriever extraction supports uploading data by using the [Ingestor.vdb_upload API](nv-ingest-python-api.md). 
-Currently, data upload is not supported through the [NV Ingest CLI](nv-ingest_cli.md).
+NeMo Retriever Library supports uploading data by using the [Ingestor.vdb_upload API](nv-ingest-python-api.md).
+Currently, data upload is not supported through the [CLI](nv-ingest_cli.md).
+
+
+
+## Why LanceDB?
+
+LanceDB delivers measurably lower retrieval latency through three architectural advantages over the previous Milvus default:
+
+- **Lance columnar format** — Data is stored in Lance files, an Arrow/Parquet-style analytics layout optimized for fast local scans and indexed retrieval. This eliminates the serialization overhead of client-server protocols.
+- **IVF_HNSW_SQ index** — Vectors are scalar-quantized (SQ) within an IVF-HNSW index, compressing them for faster search with lower memory bandwidth cost.
+- **Embedded runtime** — LanceDB runs in-process, removing the multi-service dependency chain required by Milvus (Milvus server + etcd + MinIO). No external containers to start, configure, or maintain.
+
+This combination of file format, index strategy, and simpler runtime path produces the latency improvements observed in benchmarks.
+
+
+
+## Upload to LanceDB (default)
+
+LanceDB uses the `LanceDB` operator class from the client library. You can configure it via the Python API or via the test harness.
+
+### Programmatic API (Python)
+
+```python
+from nv_ingest_client.util.vdb.lancedb import LanceDB
+
+vdb = LanceDB(
+    uri="lancedb",           # Path to LanceDB database directory
+    table_name="nv-ingest",  # Table name
+    index_type="IVF_HNSW_SQ",  # Index type (default)
+    hybrid=False,            # Enable hybrid search (BM25 FTS + vector)
+)
+
+# Ingest
+vdb.run(results)
+
+# Retrieve
+docs = vdb.retrieval(queries, top_k=10)
+```
+
+When using the `Ingestor` with `vdb_upload`, the backend defaults to LanceDB unless you configure Milvus (see [Upload to Milvus](#upload-to-milvus)).
+
+### Test harness configuration
+
+In `tools/harness/test_configs.yaml`:
+
+```yaml
+active:
+  vdb_backend: lancedb   # Options: "lancedb" (default) or "milvus"
+  hybrid: false          # LanceDB only: enable hybrid retrieval (FTS + vector)
+  sparse: false          # Milvus only: enable BM42 sparse embeddings
+```
+
+Or via environment variables:
+
+```bash
+# Switch to Milvus
+VDB_BACKEND=milvus uv run nv-ingest-harness-run --case=e2e --dataset=bo767
+
+# Enable LanceDB hybrid search
+HYBRID=true uv run nv-ingest-harness-run --case=e2e --dataset=bo767
+```
+
+
+
+## Hybrid search (LanceDB)
+
+LanceDB supports **hybrid retrieval**, combining dense vector similarity with BM25 full-text search. Results are fused using Reciprocal Rank Fusion (RRF) reranking.
+
+Hybrid search improves recall by approximately +0.5% to +3.5% over vector-only retrieval with negligible latency impact:
+
+| Dataset            | Vector-Only Recall@5 | Hybrid Recall@5 | Delta  |
+|--------------------|----------------------|-----------------|--------|
+| bo767 (76K rows)   | 84.5%                | 85.0%           | +0.5%  |
+| bo767 (reranked)   | 90.7%                | 91.8%           | +1.1%  |
+| earnings (19K rows)| 61.5%                | 65.0%           | +3.5%  |
+| earnings (reranked)| 74.5%                | 76.4%           | +1.9%  |
+
+Hybrid search latency is typically 28–57 ms/query (vs. 31–37 ms/query for vector-only). The one-time FTS index build adds approximately 6.5 seconds for a 76K-row dataset.
+
+Enable hybrid search by setting `hybrid=True` when creating the LanceDB operator or via the harness/config (e.g. `HYBRID=true`).
+
+
+
+## Infrastructure: LanceDB vs Milvus
+
+| Aspect              | LanceDB (default)       | Milvus                    |
+|---------------------|-------------------------|---------------------------|
+| Runtime model       | Embedded (in-process)   | Client-server             |
+| External services   | None                    | Milvus + etcd + MinIO     |
+| Docker Compose profile | Not needed           | `--profile retrieval`     |
+| Index type          | IVF_HNSW_SQ             | HNSW, GPU_CAGRA, etc.     |
+| Hybrid search       | BM25 FTS + vector (RRF) | BM42 sparse embeddings    |
+| Persistence         | Lance files on disk     | Milvus server + MinIO     |
 
 
 
 ## Upload to Milvus
 
-The `vdb_upload` method uses GPU Cagra accelerated bulk indexing support to load chunks into Milvus. 
-To enable hybrid retrieval, nv-ingest supports both dense (llama-embedder embeddings) and sparse (bm25) embeddings. 
+You can continue using Milvus with no code changes — set `vdb_backend: milvus` in the harness config or use the existing Milvus API calls (`vdb_upload(milvus_uri=...)`, `nvingest_retrieval(...)`).
+
+The `vdb_upload` method uses GPU Cagra accelerated bulk indexing support to load chunks into Milvus.
+To enable hybrid retrieval with Milvus, the library supports both dense (llama-embedder embeddings) and sparse (BM42) embeddings.
 
-Bulk indexing is high throughput, but has a built-in overhead of around one minute. 
-If the number of ingested documents is 10 or fewer, nv-ingest uses faster streaming inserts instead. 
-You can control this by setting `stream=True`. 
+Bulk indexing is high throughput, but has a built-in overhead of around one minute.
+If the number of ingested documents is 10 or fewer, the library uses faster streaming inserts instead.
+You can control this by setting `stream=True`.
 
-If you set `recreate=True`, nv-ingest drops and recreates the collection given as *collection_name*. 
-The Milvus service persists data to disk by using a Docker volume defined in docker-compose.yaml. 
-You can delete all collections by deleting that volume, and then restarting the nv-ingest service.
+If you set `recreate=True`, the pipeline drops and recreates the collection given as *collection_name*.
+The Milvus service persists data to disk by using a Docker volume defined in docker-compose.yaml.
+You can delete all collections by deleting that volume, and then restarting the Milvus service.
 
 !!! warning
 
-    When you use the `vdb_upload` task with Milvus, you must expose the ports for the Milvus and MinIO containers to the nv-ingest client. This ensures that the nv-ingest client can connect to both services and perform the `vdb_upload` action.
+    When you use the `vdb_upload` task with Milvus, you must expose the ports for the Milvus and MinIO containers to the client. This ensures that the client can connect to both services and perform the `vdb_upload` action.
 
 !!! tip
 
@@ -70,9 +165,9 @@ Ingestor(client=client)
 
 ## Upload to a Custom Data Store
 
-You can ingest to other data stores by using the `Ingestor.vdb_upload` method; 
-however, you must configure other data stores and connections yourself. 
-NeMo Retriever extraction does not provide connections to other data sources. 
+You can ingest to other data stores by using the `Ingestor.vdb_upload` method;
+however, you must configure other data stores and connections yourself.
+NeMo Retriever Library does not provide connections to other data sources.
 
 !!! important
 
@@ -84,7 +179,7 @@ For more information, refer to [Build a Custom Vector Database Operator](https:/
 
 ## Related Topics
 
-- [Use the NeMo Retriever Extraction Python API](nv-ingest-python-api.md)
+- [Use the NeMo Retriever Library Python API](nv-ingest-python-api.md)
 - [Store Extracted Images](nv-ingest-python-api.md#store-extracted-images)
 - [Environment Variables](environment-config.md)
 - [Troubleshoot Nemo Retriever Extraction](troubleshoot.md)
diff --git a/docs/docs/extraction/environment-config.md b/docs/docs/extraction/environment-config.md
index 6843d9b9c..b411ea5b6 100644
--- a/docs/docs/extraction/environment-config.md
+++ b/docs/docs/extraction/environment-config.md
@@ -1,11 +1,11 @@
-# Environment Variables for NeMo Retriever Extraction
+# Environment Variables for NeMo Retriever Library
 
-The following are the environment variables that you can use to configure [NeMo Retriever extraction](overview.md).
+The following are the environment variables that you can use to configure [NeMo Retriever Library](overview.md).
 You can specify these in your .env file or directly in your environment.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 ## General Environment Variables
@@ -22,13 +22,24 @@ You can specify these in your .env file or directly in your environment.
 | `NIM_NGC_API_KEY`                | —                                                          | The key that NIM microservices inside docker containers use to access NGC resources. This is necessary only in some cases when it is different from `NGC_API_KEY`. If this is not specified, `NGC_API_KEY` is used to access NGC resources. |
 | `OTEL_EXPORTER_OTLP_ENDPOINT`    | `http://otel-collector:4317` <br/>                       | The endpoint for the OpenTelemetry exporter, used for sending telemetry data. |
 | `REDIS_INGEST_TASK_QUEUE`        | `ingest_task_queue` <br/>                              | The name of the task queue in Redis where tasks are stored and processed. |
+| `REDIS_POOL_SIZE`                | - `50` (default) <br/> - `100` <br/> - `200` <br/>     | Maximum Redis connection pool size. Increase for high-concurrency workloads processing many documents in parallel. Default of 50 works well for most deployments. |
 | `IMAGE_STORAGE_URI`              | `s3://nv-ingest/artifacts/store/images` <br/>          | Default fsspec-compatible URI for the `store` task. Supports `s3://`, `file://`, `gs://`, etc. See [Store Extracted Images](nv-ingest-python-api.md#store-extracted-images). |
 | `IMAGE_STORAGE_PUBLIC_BASE_URL`  | `https://assets.example.com/images` <br/>              | Optional HTTP(S) base URL for serving stored images. |
 
 
+## Vector Database (Retrieval) Environment Variables
+
+These variables apply when using the test harness or when configuring the vector database backend.
+
+| Name                             | Example                        | Description                                                           |
+|----------------------------------|--------------------------------|-----------------------------------------------------------------------|
+| `VDB_BACKEND`                    | `lancedb` (default) <br/> `milvus` <br/> | Vector database backend. Use `lancedb` for embedded, in-process storage (default), or `milvus` for client-server. |
+| `HYBRID`                         | `true` <br/> `false` (default) <br/> | LanceDB only: enable hybrid retrieval (BM25 FTS + vector, RRF). |
+
+
 ## Library Mode Environment Variables
 
-These environment variables apply specifically when running NV-Ingest in library mode.
+These environment variables apply specifically when running the library in library mode.
 
 | Name                              | Example                                                 | Description |
 |-----------------------------------|---------------------------------------------------------|-------------|
diff --git a/docs/docs/extraction/faq.md b/docs/docs/extraction/faq.md
index 5729845c9..7bbb33d5f 100644
--- a/docs/docs/extraction/faq.md
+++ b/docs/docs/extraction/faq.md
@@ -1,28 +1,28 @@
-# Frequently Asked Questions for NeMo Retriever Extraction
+# Frequently Asked Questions for NeMo Retriever Library
 
-This documentation contains the Frequently Asked Questions (FAQ) for [NeMo Retriever extraction](overview.md).
+This documentation contains the Frequently Asked Questions (FAQ) for [NeMo Retriever Library](overview.md).
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 
-## What if I already have a retrieval pipeline? Can I just use NeMo Retriever extraction? 
+## What if I already have a retrieval pipeline? Can I just use NeMo Retriever Library? 
 
-You can use the nv-ingest-cli or Python APIs to perform extraction only, and then consume the results.
+You can use the CLI or Python APIs to perform extraction only, and then consume the results.
 Using the Python API, `results` is a list object with one entry.
 For code examples, see the Jupyter notebooks [Multimodal RAG with LlamaIndex](https://github.com/NVIDIA/nv-ingest/blob/main/examples/llama_index_multimodal_rag.ipynb) 
 and [Multimodal RAG with LangChain](https://github.com/NVIDIA/nv-ingest/blob/main/examples/langchain_multimodal_rag.ipynb).
 
 
 
-## Where does NeMo Retriever extraction (nv-ingest) ingest to?
+## Where does NeMo Retriever Library ingest to?
 
-NeMo Retriever extraction supports extracting text representations of various forms of content, 
-and ingesting to the [Milvus vector database](https://milvus.io/). 
-NeMo Retriever extraction does not store data on disk except through Milvus and its underlying Minio object store. 
-You can ingest to other data stores; however, you must configure other data stores yourself. 
+NeMo Retriever Library supports extracting text representations of various forms of content,
+and ingesting to a vector database. **[LanceDB](https://lancedb.com/) is the default**; [Milvus](https://milvus.io/) is also fully supported.
+NeMo Retriever Library does not store data on disk except through the vector database (LanceDB uses local Lance files; Milvus uses its server and MinIO).
+You can ingest to other data stores; however, you must configure other data stores yourself.
 For more information, refer to [Data Upload](data-store.md).
 
 
diff --git a/docs/docs/extraction/helm.md b/docs/docs/extraction/helm.md
index 5172885c1..1a6e885a3 100644
--- a/docs/docs/extraction/helm.md
+++ b/docs/docs/extraction/helm.md
@@ -1,6 +1,6 @@
-# Deploy With Helm for NeMo Retriever Extraction
+# Deploy With Helm for NeMo Retriever Library
 
-<!-- Use this documentation to deploy [NeMo Retriever extraction](overview.md) by using Helm. -->
+<!-- Use this documentation to deploy [NeMo Retriever Library](overview.md) by using Helm. -->
 
-To deploy [NeMo Retriever extraction](overview.md) by using Helm, 
-refer to [NV-Ingest Helm Charts](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.0/helm/README.md).
+To deploy [NeMo Retriever Library](overview.md) by using Helm, 
+refer to [NV-Ingest Helm Charts](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.2/helm/README.md).
diff --git a/docs/docs/extraction/images/audio.png b/docs/docs/extraction/images/audio.png
index 986a808a8..31f71f214 100644
Binary files a/docs/docs/extraction/images/audio.png and b/docs/docs/extraction/images/audio.png differ
diff --git a/docs/docs/extraction/images/overview-extraction.png b/docs/docs/extraction/images/overview-extraction.png
index 7d43f46fa..31f71f214 100644
Binary files a/docs/docs/extraction/images/overview-extraction.png and b/docs/docs/extraction/images/overview-extraction.png differ
diff --git a/docs/docs/extraction/nemoretriever-parse.md b/docs/docs/extraction/nemoretriever-parse.md
index 1b187f31a..3da84cdce 100644
--- a/docs/docs/extraction/nemoretriever-parse.md
+++ b/docs/docs/extraction/nemoretriever-parse.md
@@ -1,23 +1,23 @@
-# Advanced Visual Parsing in NeMo Retriever Extraction
+# Advanced Visual Parsing with Nemotron Parse
 
 For scanned documents, or documents with complex layouts, 
 we recommend that you use [nemotron-parse](https://build.nvidia.com/nvidia/nemotron-parse). 
 Nemotron parse provides higher-accuracy text extraction. 
 
 This documentation describes the following two methods 
-to run [NeMo Retriever extraction](overview.md) with nemotron-parse.
+to run [NeMo Retriever Library](overview.md) with nemotron-parse.
 
 - Run the NIM locally by using Docker Compose
 - Use NVIDIA Cloud Functions (NVCF) endpoints for cloud-based inference
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 ## Limitations
 
-Currently, the limitations to using `nemotron-parse` with NeMo Retriever Extraction are the following:
+Currently, the limitations to using `nemotron-parse` with NeMo Retriever Library are the following:
 
 - Extraction with `nemotron-parse` only supports PDFs, not image files. For more information, refer to [Troubleshoot Nemo Retriever Extraction](troubleshoot.md).
 - `nemotron-parse` is not supported on RTX Pro 6000, B200, or H200 NVL. For more information, refer to the [Nemotron Parse Support Matrix](https://docs.nvidia.com/nim/vision-language-models/latest/support-matrix.html#nemotron-parse).
@@ -32,7 +32,7 @@ Use the following procedure to run the NIM locally.
     Due to limitations in available VRAM controls in the current release of nemotron-parse, it must run on a [dedicated additional GPU](support-matrix.md). Edit docker-compose.yaml to set nemotron-parse's device_id to a dedicated GPU: device_ids: ["1"] or higher.
 
 
-1. Start the nv-ingest services with the `nemotron-parse` profile. This profile includes the necessary components for extracting text and metadata from images. Use the following command.
+1. Start the retriever services with the `nemotron-parse` profile. This profile includes the necessary components for extracting text and metadata from images. Use the following command.
 
     - The --profile nemotron-parse flag ensures that vision-language retrieval services are launched.  For more information, refer to [Profile Information](quickstart-guide.md#profile-information).
 
@@ -40,11 +40,11 @@ Use the following procedure to run the NIM locally.
     docker compose --profile nemotron-parse up
     ```
 
-2. After the services are running, you can interact with nv-ingest by using Python.
+2. After the services are running, you can interact with the pipeline by using Python.
 
     - The `Ingestor` object initializes the ingestion process.
     - The `files` method specifies the input files to process.
-    - The `extract` method tells nv-ingest to use `nemotron-parse` for extracting text and metadata from images.
+    - The `extract` method tells the pipeline to use `nemotron-parse` for extracting text and metadata from images.
     - The `document_type` parameter is optional, because `Ingestor` should detect the file type automatically.
 
     ```python
@@ -65,7 +65,7 @@ Use the following procedure to run the NIM locally.
 
 ## Using NVCF Endpoints for Cloud-Based Inference
 
-Instead of running NV-Ingest locally, you can use NVCF to perform inference by using remote endpoints.
+Instead of running the pipeline locally, you can use NVCF to perform inference by using remote endpoints.
 
 1. Set the authentication token in the `.env` file.
 
@@ -85,7 +85,7 @@ Instead of running NV-Ingest locally, you can use NVCF to perform inference by u
 
     - The `Ingestor` object initializes the ingestion process.
     - The `files` method specifies the input files to process.
-    - The `extract` method tells nv-ingest to use `nemotron-parse` for extracting text and metadata from images.
+    - The `extract` method tells the pipeline to use `nemotron-parse` for extracting text and metadata from images.
     - The `document_type` parameter is optional, because `Ingestor` should detect the file type automatically.
 
     ```python
@@ -109,4 +109,4 @@ Instead of running NV-Ingest locally, you can use NVCF to perform inference by u
 
 - [Support Matrix](support-matrix.md)
 - [Troubleshoot Nemo Retriever Extraction](troubleshoot.md)
-- [Use the NV-Ingest Python API](nv-ingest-python-api.md)
+- [Use the Python API](nv-ingest-python-api.md)
diff --git a/docs/docs/extraction/nimclient.md b/docs/docs/extraction/nimclient.md
index 6ef9ae4f5..fae98c068 100644
--- a/docs/docs/extraction/nimclient.md
+++ b/docs/docs/extraction/nimclient.md
@@ -1,11 +1,11 @@
-# NimClient Usage Guide for NeMo Retriever Extraction
+# NimClient Usage Guide for NeMo Retriever Library
 
 The `NimClient` class provides a unified interface for connecting to and interacting with NVIDIA NIM Microservices. 
-This documentation demonstrates how to create custom NIM integrations for use in [NeMo Retriever extraction](overview.md) pipelines and User Defined Functions (UDFs).
+This documentation demonstrates how to create custom NIM integrations for use in [NeMo Retriever Library](overview.md) pipelines and User Defined Functions (UDFs).
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 The NimClient architecture consists of two main components:
 
@@ -552,11 +552,17 @@ def robust_nim_udf(control_message: IngestControlMessage) -> IngestControlMessag
 
 ### Common Issues
 
-1. **Connection Errors**: Verify NIM service is running and endpoints are correct
-2. **Authentication Failures**: Check NGC_API_KEY is valid and properly set
-3. **Timeout Errors**: Increase timeout values or check NIM service performance
-4. **Format Errors**: Ensure your ModelInterface formats data correctly for your NIM
-5. **Memory Issues**: Use appropriate batch sizes to avoid memory exhaustion
+* **Connection Errors** – Verify NIM service is running and endpoints are correct
+* **Authentication Failures** – Check NGC_API_KEY is valid and properly set
+* **Timeout Errors** – Increase timeout values or check NIM service performance
+* **Format Errors** – Ensure your ModelInterface formats data correctly for your NIM
+* **Memory Issues** – Use appropriate batch sizes to avoid memory exhaustion
+
+### NIM Triton Limit Memory
+
+If you encounter memory issues, try increasing the `NIM_TRITON_CUDA_MEMORY_POOL_MB` parameter. This adjustment typically does not affect performance.
+
+If memory issues persist, you can reduce the `NIM_TRITON_RATE_LIMIT` value — even down to 1. However, lowering this parameter affects performance.
 
 ### Debugging Tips
 
@@ -581,5 +587,5 @@ print(f"Formatted input: {formatted}")
 
 ## Related Topics
 
-- [User-Defined Functions for NeMo Retriever Extraction](user-defined-functions.md)
-- [User-Defined Stages for NeMo Retriever Extraction](user-defined-stages.md)
+- [User-Defined Functions for NeMo Retriever Library](user-defined-functions.md)
+- [User-Defined Stages for NeMo Retriever Library](user-defined-stages.md)
diff --git a/docs/docs/extraction/notebooks.md b/docs/docs/extraction/notebooks.md
index 5132085da..4bf6fe7b4 100644
--- a/docs/docs/extraction/notebooks.md
+++ b/docs/docs/extraction/notebooks.md
@@ -1,12 +1,18 @@
-# Notebooks for NeMo Retriever Extraction
+# Notebooks for NeMo Retriever Library
 
-To get started using [NeMo Retriever extraction](overview.md), you can try one of the ready-made notebooks that are available.
+To get started using [NeMo Retriever Library](overview.md), you can try one of the ready-made notebooks that are available.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
+## Dataset Downloads for Benchmarking
+
+If you plan to run benchmarking or evaluation tests, you must download the [Benchmark Datasets (Bo20, Bo767, Bo10k)](https://github.com/NVIDIA/nv-ingest/blob/main/evaluation/digital_corpora_download.ipynb) from Digital Corpora. This is a prerequisite for all benchmarking operations.
+
+## Getting Started
+
 To get started with the basics, try one of the following notebooks:
 
 - [NV-Ingest: CLI Client Quick Start Guide](https://github.com/NVIDIA/nv-ingest/blob/main/client/client_examples/examples/cli_client_usage.ipynb)
@@ -18,7 +24,7 @@ To get started with the basics, try one of the following notebooks:
 For more advanced scenarios, try one of the following notebooks:
 
 - [Build a Custom Vector Database Operator](https://github.com/NVIDIA/nv-ingest/blob/main/examples/building_vdb_operator.ipynb)
-- [Try out the NVIDIA Multimodal PDF Data Extraction Blueprint](https://github.com/NVIDIA/nv-ingest/blob/main/deploy/pdf-blueprint.ipynb)
+- [Try Enterprise RAG Blueprint](https://github.com/NVIDIA/nv-ingest/blob/main/deploy/pdf-blueprint.ipynb)
 - [Evaluate bo767 retrieval recall accuracy with NV-Ingest and Milvus](https://github.com/NVIDIA/nv-ingest/blob/main/evaluation/bo767_recall.ipynb)
 - [Multimodal RAG with LangChain](https://github.com/NVIDIA/nv-ingest/blob/main/examples/langchain_multimodal_rag.ipynb)
 - [Multimodal RAG with LlamaIndex](https://github.com/NVIDIA/nv-ingest/blob/main/examples/llama_index_multimodal_rag.ipynb)
diff --git a/docs/docs/extraction/nv-ingest-python-api.md b/docs/docs/extraction/nv-ingest-python-api.md
index d7c18a26f..d4c29f2b5 100644
--- a/docs/docs/extraction/nv-ingest-python-api.md
+++ b/docs/docs/extraction/nv-ingest-python-api.md
@@ -1,10 +1,10 @@
-# Use the NeMo Retriever Extraction Python API
+# Use the NeMo Retriever Library Python API
 
-The [NeMo Retriever extraction](overview.md) Python API provides a simple and flexible interface for processing and extracting information from various document types, including PDFs.
+The [NeMo Retriever Library](overview.md) Python API provides a simple and flexible interface for processing and extracting information from various document types, including PDFs.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 !!! tip
 
@@ -13,7 +13,7 @@ The [NeMo Retriever extraction](overview.md) Python API provides a simple and fl
 
 ## Summary of Key Methods
 
-The main class in the nv-ingest API is `Ingestor`. 
+The main class in the Python API is `Ingestor`. 
 The `Ingestor` class provides an interface for building, managing, and running data ingestion jobs, enabling for chainable task additions and job state tracking. 
 
 ### Ingestor Methods
@@ -31,7 +31,7 @@ The following table describes methods of the `Ingestor` class.
 | `save_to_disk` | Save ingestion results to disk instead of memory. |
 | `store`        | Persist extracted images/structured renderings to an fsspec-compatible backend. |
 | `split`        | Split documents into smaller sections for processing. For more information, refer to [Split Documents](chunking.md). |
-| `vdb_upload`   | Push extraction results to Milvus vector database. For more information, refer to [Data Upload](data-store.md). |
+| `vdb_upload`   | Push extraction results to the vector database (LanceDB by default, or Milvus). For more information, refer to [Data Upload](data-store.md). |
 
 
 ### Extract Method Options
@@ -55,7 +55,7 @@ The following table describes the `extract_method` options.
 
 ### Caption images and control reasoning
 
-The caption task can call a VLM with optional prompt and reasoning controls:
+The caption task can call a vision-language model (VLM) with the following optional controls:
 
 - `prompt` (string): User prompt for captioning. Defaults to `"Caption the content of this image:"`.
 - `reasoning` (boolean): Enable reasoning mode. `True` enables reasoning, `False` disables it. Defaults to `None` (service default, typically disabled).
@@ -117,7 +117,7 @@ The behavior of the upload depends on the following values of `return_failures`:
 - **True** – If any jobs succeed, the results from those jobs are uploaded, and no errors are raised (partial data upload). The `ingest` method returns a failures object that contains the details for any jobs that failed. You can inspect the failures object and selectively retry or remediate the failed jobs.
 
 
-The following example uploads data to Milvus and returns any failures.
+The following example uploads data to the vector database (LanceDB by default; use `milvus_uri` for Milvus) and returns any failures.
 
 ```python
 ingestor = (
@@ -221,7 +221,7 @@ ingestor = ingestor.extract(document_type="pdf")
 
 ### Extract Office Documents (DOCX and PPTX)
 
-NeMo Retriever extraction offers the following two extraction methods for Microsoft Office documents (.docx and .pptx), to balance performance and layout fidelity:
+NeMo Retriever Library offers the following two extraction methods for Microsoft Office documents (.docx and .pptx), to balance performance and layout fidelity:
 
 - Native extraction
 - Render as PDF
@@ -257,7 +257,7 @@ ingestor = ingestor.extract(
 
 ### PDF Extraction Strategies
 
-NeMo Retriever extraction offers specialized strategies for PDF processing to handle various document qualities.
+NeMo Retriever Library offers specialized strategies for PDF processing to handle various document qualities.
 You can select the strategy by using the following `extract_method` parameter values. 
 For the full list of `extract_method` options, refer to [Extract Method Options](#extract-method-options).
 
@@ -280,7 +280,7 @@ results = ingestor.ingest()
 
 ## Work with Large Datasets: Save to Disk
 
-By default, NeMo Retriever extraction stores the results from every document in system memory (RAM). 
+By default, NeMo Retriever Library stores the results from every document in system memory (RAM). 
 When you process a very large dataset with thousands of documents, you might encounter an Out-of-Memory (OOM) error. 
 The `save_to_disk` method configures the extraction pipeline to write the output for each document to a separate JSONL file on disk.
 
@@ -310,8 +310,8 @@ print("Ingestion results saved in ./my_ingest_results")
 
 ### Managing Disk Space with Automatic Cleanup
 
-When you use `save_to_disk`, NeMo Retriever extraction creates intermediate files. 
-For workflows where these files are temporary, NeMo Retriever extraction provides two automatic cleanup mechanisms.
+When you use `save_to_disk`, NeMo Retriever Library creates intermediate files. 
+For workflows where these files are temporary, NeMo Retriever Library provides two automatic cleanup mechanisms.
 
 - **Directory Cleanup with Context Manager** — While not required for general use, the Ingestor can be used as a context manager (`with` statement). This enables the automatic cleanup of the entire output directory when `save_to_disk(cleanup=True)` is set (which is the default).
 
@@ -367,12 +367,18 @@ with (
 
 ## Extract Captions from Images
 
-The `caption` method generates image captions by using a vision-language model. 
-This can be used to describe images extracted from documents.
+The `caption` method generates image captions by using a VLM. 
+You can use this to generate descriptions of unstructured images, infographics, and other visual content extracted from documents.
 
 !!! note
 
-    The default model used by `caption` is `nvidia/llama-3.1-nemotron-nano-vl-8b-v1`.
+    To use the `caption` option, enable the `vlm` profile when you start the NeMo Retriever Library services. The default model used by `caption` is `nvidia/llama-3.1-nemotron-nano-vl-8b-v1`. For more information, refer to [Profile Information in the Quickstart Guide](quickstart-guide.md#profile-information).
+
+### Basic Usage
+
+!!! tip
+
+    You can configure and use other vision language models for image captioning by specifying a different `model_name` and `endpoint_url` in the `caption` method. Choose a VLM that best fits your specific use case requirements.
 
 ```python
 ingestor = ingestor.caption()
@@ -388,6 +394,36 @@ ingestor = ingestor.caption(
 )
 ```
 
+### Captioning Infographics
+
+Infographics are complex visual elements that combine text, charts, diagrams, and images to convey information.
+VLMs are particularly effective at generating descriptive captions for infographics because they can understand and summarize the visual content.
+
+The following example extracts and captions infographics from a document:
+
+```python
+ingestor = (
+    Ingestor()
+    .files("document_with_infographics.pdf")
+    .extract(
+        extract_text=True,
+        extract_tables=True,
+        extract_charts=True,
+        extract_infographics=True,  # Extract infographics for captioning
+        extract_images=False,
+    )
+    .caption(
+        prompt="Describe the content and key information in this infographic:",
+        reasoning=True,  # Enable reasoning for more detailed captions
+    )
+)
+results = ingestor.ingest()
+```
+
+!!! tip
+
+    For more information about working with infographics and multimodal content, refer to [Use Multimodal Embedding](vlm-embed.md).
+
 ### Caption Images and Control Reasoning
 
 The caption task can call a VLM with optional prompt and system prompt overrides:
@@ -415,7 +451,7 @@ ingestor = (
 
 ## Extract Embeddings
 
-The `embed` method in NV-Ingest generates text embeddings for document content.
+The `embed` method in the library generates text embeddings for document content.
 
 ```python
 ingestor = ingestor.embed()
@@ -471,13 +507,13 @@ The `store` task uses [fsspec](https://filesystem-spec.readthedocs.io/) for stor
 
 !!! tip
 
-    `storage_uri` defaults to the server-side `IMAGE_STORAGE_URI` environment variable (commonly `s3://nv-ingest/...`). If you change that variable—for example to a host-mounted `file://` path—restart the nv-ingest runtime so the container picks up the new value.
+    `storage_uri` defaults to the server-side `IMAGE_STORAGE_URI` environment variable (commonly `s3://nv-ingest/...`). If you change that variable—for example to a host-mounted `file://` path—restart the runtime so the container picks up the new value.
 
 When `public_base_url` is provided, the metadata returned from `ingest()` surfaces that HTTP(S) link while still recording the underlying storage URI. Leave it unset when the storage endpoint itself is already publicly reachable.
 
 ### Docker Volume Mounts for Local Storage
 
-When running nv-ingest via Docker and using `file://` storage URIs, the path must be within a mounted volume for files to persist on the host machine.
+When running the pipeline via Docker and using `file://` storage URIs, the path must be within a mounted volume for files to persist on the host machine.
 
 By default, the `docker-compose.yaml` mounts a single volume:
 
@@ -560,5 +596,5 @@ results = ingestor.ingest()
 - [Split Documents](chunking.md)
 - [Troubleshoot Nemo Retriever Extraction](troubleshoot.md)
 - [Advanced Visual Parsing](nemoretriever-parse.md)
-- [Use NeMo Retriever Extraction with Riva for Audio Processing](audio.md)
+- [Use NeMo Retriever Library with Riva for Audio Processing](audio.md)
 - [Use Multimodal Embedding](vlm-embed.md)
diff --git a/docs/docs/extraction/nv-ingest_cli.md b/docs/docs/extraction/nv-ingest_cli.md
index c87cf6cf1..718e656c2 100644
--- a/docs/docs/extraction/nv-ingest_cli.md
+++ b/docs/docs/extraction/nv-ingest_cli.md
@@ -117,6 +117,10 @@ nv-ingest-cli \
 - `reasoning` (boolean): Set to `true` to enable reasoning, `false` to disable it. Defaults to service default (typically disabled).
 - Ensure the VLM caption profile/service is running or pointing to the public build endpoint; otherwise the caption task will be skipped.
 
+!!! tip
+
+  The caption service uses a default VLM which you can override by selecting other vision-language models to better match your image captioning needs. For more information, refer to [Extract Captions from Images](nv-ingest-python-api.md#extract-captions-from-images).
+
 Alternatively, you can use an environment variable to set the API version:
 
 ```bash
diff --git a/docs/docs/extraction/overview.md b/docs/docs/extraction/overview.md
index e04e83398..8891d57e6 100644
--- a/docs/docs/extraction/overview.md
+++ b/docs/docs/extraction/overview.md
@@ -1,37 +1,37 @@
-# What is NeMo Retriever Extraction?
+# What is NeMo Retriever Library?
 
-NeMo Retriever extraction is a scalable, performance-oriented document content and metadata extraction microservice. 
-NeMo Retriever extraction uses specialized NVIDIA NIM microservices 
+NeMo Retriever Library is a scalable, performance-oriented document content and metadata extraction microservice. 
+NeMo Retriever Library uses specialized NVIDIA NIM microservices 
 to find, contextualize, and extract text, tables, charts and infographics that you can use in downstream generative applications.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
-NeMo Retriever extraction enables parallelization of splitting documents into pages where artifacts are classified (such as text, tables, charts, and infographics), extracted, and further contextualized through optical character recognition (OCR) into a well defined JSON schema. 
-From there, NeMo Retriever extraction can optionally manage computation of embeddings for the extracted content, 
-and optionally manage storing into a vector database [Milvus](https://milvus.io/).
+NeMo Retriever Library enables parallelization of splitting documents into pages where artifacts are classified (such as text, tables, charts, and infographics), extracted, and further contextualized through optical character recognition (OCR) into a well defined JSON schema. 
+From there, NeMo Retriever Library can optionally manage computation of embeddings for the extracted content, 
+and optionally manage storing into a vector database ([LanceDB](https://lancedb.com/) by default, or [Milvus](https://milvus.io/)).
 
 !!! note
 
-    Cached and Deplot are deprecated. Instead, NeMo Retriever extraction now uses the yolox-graphic-elements NIM. With this change, you should now be able to run NeMo Retriever extraction on a single 24GB A10G or better GPU. If you want to use the old pipeline, with Cached and Deplot, use the [NeMo Retriever extraction 24.12.1 release](https://github.com/NVIDIA/nv-ingest/tree/24.12.1).
+    Cached and Deplot are deprecated. Instead, NeMo Retriever Library now uses the yolox-graphic-elements NIM. With this change, you should now be able to run NeMo Retriever Library on a single 24GB A10G or better GPU. If you want to use the old pipeline, with Cached and Deplot, use the [NeMo Retriever Library 24.12.1 release](https://github.com/NVIDIA/nv-ingest/tree/24.12.1).
 
 
 
-## What NeMo Retriever Extraction Is ✔️
+## What NeMo Retriever Library Is ✔️
 
-The following diagram shows the Nemo Retriever extraction pipeline.
+The following diagram shows the retriever pipeline.
 
 ![Overview diagram](images/overview-extraction.png)
 
-NeMo Retriever extraction is a microservice service that does the following:
+NeMo Retriever Library is a microservice service that does the following:
 
 - Accept a JSON job description, containing a document payload, and a set of ingestion tasks to perform on that payload.
 - Allow the results of a job to be retrieved. The result is a JSON dictionary that contains a list of metadata describing objects extracted from the base document, and processing annotations and timing/trace data.
 - Support multiple methods of extraction for each document type to balance trade-offs between throughput and accuracy. For example, for .pdf documents, extraction is performed by using pdfium, [nemotron-parse](https://build.nvidia.com/nvidia/nemotron-parse), Unstructured.io, and Adobe Content Extraction Services.
 - Support various types of pre- and post- processing operations, including text splitting and chunking, transform and filtering, embedding generation, and image offloading to storage.
 
-NeMo Retriever extraction supports the following file types:
+NeMo Retriever Library supports the following file types:
 
 - `avi` (early access)
 - `bmp`
@@ -53,9 +53,9 @@ NeMo Retriever extraction supports the following file types:
 - `wav`
 
 
-## What NeMo Retriever Extraction Isn't ✖️
+## What NeMo Retriever Library Isn't ✖️
 
-NeMo Retriever extraction does not do the following:
+NeMo Retriever Library does not do the following:
 
 - Run a static pipeline or fixed set of operations on every submitted document.
 - Act as a wrapper for any specific document parsing library.
@@ -69,4 +69,4 @@ NeMo Retriever extraction does not do the following:
 - [Deploy With Docker Compose (Self-Hosted)](quickstart-guide.md)
 - [Deploy With Helm](helm.md)
 - [Notebooks](notebooks.md)
-- [Multimodal PDF Data Extraction](https://build.nvidia.com/nvidia/multimodal-pdf-data-extraction-for-enterprise-rag)
+- [Enterprise RAG Blueprint](https://build.nvidia.com/nvidia/multimodal-pdf-data-extraction-for-enterprise-rag)
diff --git a/docs/docs/extraction/prerequisites.md b/docs/docs/extraction/prerequisites.md
index e745cce97..a5e0512e1 100644
--- a/docs/docs/extraction/prerequisites.md
+++ b/docs/docs/extraction/prerequisites.md
@@ -1,10 +1,10 @@
-# Prerequisites for NeMo Retriever Extraction
+# Prerequisites for NeMo Retriever Library
 
-Before you begin using [NeMo Retriever extraction](overview.md), ensure the following software and hardware prerequisites are met.
+Before you begin using [NeMo Retriever Library](overview.md), ensure the following software and hardware prerequisites are met.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 
@@ -16,7 +16,7 @@ Before you begin using [NeMo Retriever extraction](overview.md), ensure the foll
 - [Docker Buildx](https://docs.docker.com/build/concepts/overview/#buildx) `>= 0.17` (Compose 2.40+ enforces this)
 - [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) (NVIDIA Driver >= `535`, CUDA >= `12.2`)
 - [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
-- [Conda Python environment and package manager](https://github.com/conda-forge/miniforge)
+- [UV Python package and environment manager](https://docs.astral.sh/uv/getting-started/installation/)
 
 
 !!! note
diff --git a/docs/docs/extraction/quickstart-guide.md b/docs/docs/extraction/quickstart-guide.md
index acc80cb91..6f7ab7194 100644
--- a/docs/docs/extraction/quickstart-guide.md
+++ b/docs/docs/extraction/quickstart-guide.md
@@ -1,28 +1,28 @@
-# Deploy With Docker Compose (Self-Hosted) for NeMo Retriever Extraction
+# Deploy With Docker Compose (Self-Hosted) for NeMo Retriever Library
 
-Use this documentation to get started using [NeMo Retriever extraction](overview.md) in self-hosted mode.
+This guide helps you get started using [NeMo Retriever Library](overview.md) in self-hosted mode.
 
 
-## Step 1: Starting Containers
+## Step 1: Start Containers
 
-This example demonstrates how to use the provided [docker-compose.yaml](https://github.com/NVIDIA/nv-ingest/blob/main/docker-compose.yaml) to start all needed services with a few commands.
+Use the provided [docker-compose.yaml](https://github.com/NVIDIA/nv-ingest/blob/main/docker-compose.yaml) to start all needed services with a few commands.
 
 !!! warning
 
     NIM containers on their first startup can take 10-15 minutes to pull and fully load models.
 
 
-If you prefer, you can run on Kubernetes by using [our Helm chart](https://github.com/NVIDIA/nv-ingest/blob/main/helm/README.md). Also, there are [additional environment variables](environment-config.md) you might want to configure.
+If you prefer, you can run on Kubernetes by using [our Helm chart](https://github.com/NVIDIA/nv-ingest/blob/main/helm/README.md). Also, there are [additional environment variables](environment-config.md) you can configure.
 
-1. Git clone the repo:
+a. Git clone the repo:
 
     `git clone https://github.com/nvidia/nv-ingest`
 
-2. Change the directory to the cloned repo
+b. Change the directory to the cloned repo by running the following code.
    
     `cd nv-ingest`.
 
-3. [Generate API keys](ngc-api-key.md) and authenticate with NGC with the `docker login` command:
+c. [Generate API keys](ngc-api-key.md) and authenticate with NGC with the `docker login` command.
 
     ```shell
     # This is required to access pre-built containers and NIM microservices
@@ -31,7 +31,7 @@ If you prefer, you can run on Kubernetes by using [our Helm chart](https://githu
     Password: <Your Key>
     ```
    
-4. Create a .env file that contains your NVIDIA Build API key.
+d. Create a .env file that contains your NVIDIA Build API key.
 
     !!! note
 
@@ -44,34 +44,27 @@ If you prefer, you can run on Kubernetes by using [our Helm chart](https://githu
     NIM_NGC_API_KEY=<key to download model files after containers start>
     ```
    
-5. Make sure NVIDIA is set as your default container runtime before running the docker compose command with the command:
+e. Make sure that NVIDIA is set as your default container runtime before you run the docker compose command by running the following code.
 
     `sudo nvidia-ctk runtime configure --runtime=docker --set-as-default`
 
-6. Start core services. This example uses the retrieval profile.  For more information about other profiles, see [Profile Information](#profile-information).
+f. Start core services. By default, the pipeline uses **LanceDB** as the vector database (embedded, in-process); no extra Docker profile is required. If you want to use **Milvus** instead, start with the retrieval profile. This example uses the retrieval profile to run Milvus. For more information about other profiles, see [Profile Information](#profile-information).
 
     `docker compose --profile retrieval up`
 
+    !!! tip "LanceDB (default)"
+
+        To use the default LanceDB backend, you can run `docker compose up` without `--profile retrieval`. LanceDB runs in-process and does not require Milvus, etcd, or MinIO. For details, see [Data Upload](data-store.md).
+
     !!! tip
 
         By default, we have [configured log levels to be verbose](https://github.com/NVIDIA/nv-ingest/blob/main/docker-compose.yaml). It's possible to observe service startup proceeding. You will notice a lot of log messages. Disable verbose logging by configuring `NIM_TRITON_LOG_VERBOSE=0` for each NIM in [docker-compose.yaml](https://github.com/NVIDIA/nv-ingest/blob/main/docker-compose.yaml).
 
     !!! tip
 
-        The default configuration may not fit on a single GPU for some hardware targets. If you are running on any of the following GPUs, use a `docker compose` override file to reduce VRAM usage:
-        - A100-SXM4-40GB
-        - A10G
-        Override files typically lower per-service memory allocation, batch sizes, or concurrency. This trades peak throughput for making the full pipeline runnable on the available GPU. To use an override file, include it in your `docker compose up` command by using a second `-f` flag after the base `docker-compose.yaml` file. The settings in the second file override the values that are set in the first file.
-
-    The following example uses an override file that contains settings that are optimized for an NVIDIA A100 GPU with 40GB of VRAM.
-    ```shell
-    docker compose \
-      -f docker-compose.yaml \
-      -f docker-compose.a100-40gb.yaml \
-      --profile retrieval up
-    ```
+        The default configuration might not fit on a single GPU for some hardware targets. Use a [docker compose override file](#docker-compose-override-files) to reduce VRAM usage. Override files typically lower per-service memory allocation, batch sizes, or concurrency, trading peak throughput for making the full pipeline runnable on the available GPU.
 
-7. When core services have fully started, `nvidia-smi` should show processes like the following:
+g. When core services have fully started, `nvidia-smi` should show processes like the following:
 
     ```
     # If it's taking > 1m for `nvidia-smi` to return, the bus will likely be busy setting up the models.
@@ -89,11 +82,11 @@ If you prefer, you can run on Kubernetes by using [our Helm chart](https://githu
     +---------------------------------------------------------------------------------------+
     ```
 
-8. Run the command `docker ps`. You should see output similar to the following. Confirm that the status of the containers is `Up`.
+h. Run the command `docker ps`. You should see output similar to the following. Confirm that the status of the containers is `Up`.
 
     ```
     CONTAINER ID  IMAGE                                            COMMAND                 CREATED         STATUS                  PORTS            NAMES
-    1b885f37c991  nvcr.io/nvidia/nemo-microservices/nv-ingest:...  "/opt/conda/envs/nv_…"  7 minutes ago   Up 7 minutes (healthy)  0.0.0.0:7670...  nv-ingest-nv-ingest-ms-runtime-1
+    1b885f37c991  nvcr.io/nvidia/nemo-microservices/nv-ingest:...  "/usr/bin/tini -- /w…"  7 minutes ago   Up 7 minutes (healthy)  0.0.0.0:7670...  nv-ingest-nv-ingest-ms-runtime-1
     14ef31ed7f49  milvusdb/milvus:v2.5.3-gpu                       "/tini -- bash -c 's…"  7 minutes ago   Up 7 minutes (healthy)  0.0.0.0:9091...  milvus-standalone
     dceaf36cc5df  otel/opentelemetry-collector-contrib:...         "/otelcol-contrib --…"  7 minutes ago   Up 7 minutes            0.0.0.0:4317...  nv-ingest-otel-collector-1
     5bd0b48eb71b  nvcr.io/nim/nvidia/nemoretriever-graphic-ele...  "/opt/nvidia/nvidia_…"  7 minutes ago   Up 7 minutes            0.0.0.0:8003...  nv-ingest-graphic-elements-1
@@ -111,33 +104,44 @@ If you prefer, you can run on Kubernetes by using [our Helm chart](https://githu
 
 ## Step 2: Install Python Dependencies
 
-You can interact with the NV-Ingest service from the host, or by using `docker exec` to run commands in the NV-Ingest container.
+You can interact with the service from the host, or by using `docker exec` to run commands in the runtime container.
 
-To interact from the host, you'll need a Python environment and install the client dependencies:
+To interact from the host, you'll need a Python environment that has the client dependencies installed.
 
 ```
-# conda not required but makes it easy to create a fresh Python environment
-conda create --name nv-ingest-dev python=3.12.11
-conda activate nv-ingest-dev
-pip install nv-ingest==25.9.0 nv-ingest-api==25.9.0 nv-ingest-client==25.9.0
+uv venv --python 3.12 nv-ingest-dev
+source nv-ingest-dev/bin/activate
+uv pip install nv-ingest==26.1.2 nv-ingest-api==26.1.2 nv-ingest-client==26.1.2
 ```
 
 !!! tip
 
-    To confirm that you have activated your Conda environment, run `which pip` and `which python`, and confirm that you see `nvingest` in the result. You can do this before any pip or python command that you run.
+    To confirm that you have activated your virtual environment, run `which pip` and `which python`, and confirm that you see `nvingest` in the result. You can do this before any pip or python command that you run.
 
 
 !!! note
 
-    Interacting from the host depends on the appropriate port being exposed from the nv-ingest container to the host as defined in [docker-compose.yaml](https://github.com/NVIDIA/nv-ingest/blob/main/docker-compose.yaml#L265). If you prefer, you can disable exposing that port and interact with the NV-Ingest service directly from within its container. To interact within the container run `docker exec -it nv-ingest-nv-ingest-ms-runtime-1 bash`. You'll be in the `/workspace` directory with `DATASET_ROOT` from the .env file mounted at `./data`. The pre-activated `nv_ingest_runtime` conda environment has all the Python client libraries pre-installed and you should see `(nv_ingest_runtime) root@aba77e2a4bde:/workspace#`. From the bash prompt above, you can run the [nv-ingest-cli](#ingest_cli_example) and [Python](#ingest_python_example) examples described below.
-    Because various service URIs default to `localhost`, running within the NV-Ingest container will also require URIs to be manually specified in order for services to be accessed between containers on the internal Docker network. See the [code below](#ingest_python_example) for an example specifying `milvus_uri`.
+Interaction from the host requires the appropriate port to be exposed from the runtime container, as defined in the `docker-compose.yaml` file. If you prefer, you can disable this port and interact directly with the service from within its container.
 
+To work inside the container, run the following code.
 
-## Step 3: Ingesting Documents
+```bash
+docker exec -it nv-ingest-nv-ingest-ms-runtime-1 bash
+```
+This command opens a shell in the `/workspace` directory, where the `DATASET_ROOT` from your `.env` file is mounted at `./data`. The pre-created `nv_ingest_runtime` virtual environment includes all necessary Python client libraries. You should see a prompt similar to the following.
 
-You can submit jobs programmatically in Python or using the [NV-Ingest CLI](nv-ingest_cli.md).
+```bash
+(nv_ingest_runtime) root@your-computer-name:/workspace#
+```
+From this prompt, you can run the CLI and Python examples.
+
+Because many service URIs default to localhost, running inside the runtime container also requires that you specify URIs manually so that services can communicate across containers on the internal Docker network. When using Milvus, see the example following for how to set the `milvus_uri`. With the default LanceDB backend, no extra URI configuration is needed.
+
+## Step 3: Ingest Documents
 
-In the following examples, we do text, chart, table, and image extraction.
+You can submit jobs programmatically in Python or using the [CLI](nv-ingest_cli.md).
+
+The following examples demonstrate how to extract text, charts, tables, and images:
 
 - **extract_text** — Uses [PDFium](https://github.com/pypdfium2-team/pypdfium2/) to find and extract text from pages.
 - **extract_images** — Uses [PDFium](https://github.com/pypdfium2-team/pypdfium2/) to extract images.
@@ -409,7 +413,7 @@ python src/util/image_viewer.py --file_path ./processed_docs/image/multimodal_te
 
 !!! tip
 
-    Beyond inspecting the results, you can read them into things like [llama-index](https://github.com/NVIDIA/nv-ingest/blob/main/examples/llama_index_multimodal_rag.ipynb) or [langchain](https://github.com/NVIDIA/nv-ingest/blob/main/examples/langchain_multimodal_rag.ipynb) retrieval pipelines. Also, checkout our [demo using a retrieval pipeline on build.nvidia.com](https://build.nvidia.com/nvidia/multimodal-pdf-data-extraction-for-enterprise-rag) to query over document content pre-extracted with NV-Ingest.
+    Beyond inspecting the results, you can read them into things like [llama-index](https://github.com/NVIDIA/nv-ingest/blob/main/examples/llama_index_multimodal_rag.ipynb) or [langchain](https://github.com/NVIDIA/nv-ingest/blob/main/examples/langchain_multimodal_rag.ipynb) retrieval pipelines. Also, checkout our [Enterprise RAG Blueprint on build.nvidia.com](https://build.nvidia.com/nvidia/multimodal-pdf-data-extraction-for-enterprise-rag) to query over document content pre-extracted with the retriever pipeline.
 
 
 
@@ -420,17 +424,96 @@ You can specify multiple `--profile` options.
 
 | Profile               | Type     | Description                                                       | 
 |-----------------------|----------|-------------------------------------------------------------------| 
-| `retrieval`           | Core     | Enables the embedding NIM and (GPU accelerated) Milvus.           | 
+| `retrieval`           | Core     | Enables the embedding NIM and (optional) GPU-accelerated Milvus. Omit this profile to use the default LanceDB backend.           | 
 | `audio`               | Advanced | Use [Riva](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/index.html) for processing audio files. For more information, refer to [Audio Processing](audio.md). | 
 | `nemotron-parse`      | Advanced | Use [nemotron-parse](https://build.nvidia.com/nvidia/nemotron-parse), which adds state-of-the-art text and table extraction. For more information, refer to [Advanced Visual Parsing](nemoretriever-parse.md). | 
-| `vlm`                 | Advanced | Use [llama 3.1 Nemotron 8B Vision](https://build.nvidia.com/nvidia/llama-3.1-nemotron-nano-vl-8b-v1/modelcard) for experimental image captioning of unstructured images. | 
+| `vlm`                 | Advanced | Use [llama 3.1 Nemotron 8B Vision](https://build.nvidia.com/nvidia/llama-3.1-nemotron-nano-vl-8b-v1/modelcard) for image captioning of unstructured images and infographics. This profile enables the `caption` method in the Python API to generate text descriptions of visual content. For more information, refer to [Use Multimodal Embedding](vlm-embed.md) and [Extract Captions from Images](nv-ingest-python-api.md#extract-captions-from-images). | 
 
 
-!!! important
+## Docker Compose override files
 
-    Advanced features require additional GPU support and disk space. For more information, refer to [Support Matrix](support-matrix.md).
+The default [docker-compose.yaml](https://github.com/NVIDIA/nv-ingest/blob/main/docker-compose.yaml) might exceed VRAM on a single GPU for some hardware. Override files reduce per-service memory, batch sizes, or concurrency so the full pipeline can run on the available GPU. To use an override, pass a second `-f` file after the base compose file; Docker Compose merges them and the override takes precedence.
+
+| Override file | GPU target |
+|---------------|------------|
+| `docker-compose.a10g.yaml` | NVIDIA A10G |
+| `docker-compose.a100-40gb.yaml` | NVIDIA A100-SXM4-40GB |
+| `docker-compose.l40s.yaml` | NVIDIA L40S |
+
+For RTX Pro 6000 Server Edition and other GPUs with limited VRAM, use the override that best matches your GPU memory (for example, `docker-compose.l40s.yaml` or `docker-compose.a10g.yaml`).
+
+### Example: Using the VLM Profile for Infographic Captioning
+
+Infographics often combine text, charts, and diagrams into complex visuals. Vision-language model (VLM) captioning generates natural language descriptions that capture this complexity, making the content searchable and more accessible for downstream applications.
 
+To use VLM captioning for infographics, start NeMo Retriever Library with both the `retrieval` and `vlm` profiles by running the following code.
+```shell
+docker compose \
+  -f docker-compose.yaml \
+  --profile retrieval \
+  --profile vlm up
+```
+
+### Example with A100 40GB
 
+The following example uses an override file for an A100 40GB GPU.
+
+```shell
+docker compose \
+  -f docker-compose.yaml \
+  -f docker-compose.a100-40gb.yaml \
+  --profile retrieval up
+```
+
+### Example with A10G
+
+```shell
+docker compose \
+  -f docker-compose.yaml \
+  -f docker-compose.a10g.yaml \
+  --profile retrieval up
+```
+
+### Example with L40S
+
+```shell
+docker compose \
+  -f docker-compose.yaml \
+  -f docker-compose.l40s.yaml \
+  --profile retrieval up
+```
+
+
+## Specify MIG slices for NIM models
+
+When you deploy the pipeline with NIM models on MIG‑enabled GPUs, MIG device slices are requested and scheduled through the `values.yaml` file for the corresponding NIM microservice. For IBM Content-Aware Storage (CAS) deployments, this allows NIM pods to land only on nodes that expose the desired MIG profiles [raw.githubusercontent](https://raw.githubusercontent.com/NVIDIA/nv-ingest/main/helm/README.md%E2%80%8B).​
+
+To target a specific MIG profile—for example, a 3g.20gb slice on an A100, which is a hardware-partitioned virtual GPU instance that gives your workload a fixed mid-sized share of the A100’s compute plus 20 GB of dedicated GPU memory and behaves like a smaller independent GPU—for a given NIM, configure the `resources` and `nodeSelector` under that NIM’s values path in `values.yaml`.
+
+The following example shows the pattern. Paths vary by NIM, such as `nvingest.nvidiaNim.nemoretrieverPageElements` instead of the generic `nvingest.nim` placeholder. For details refer to [catalog.ngc.nvidia](https://catalog.ngc.nvidia.com/orgs/nvidia/teams/nemo-microservices/helm-charts/nv-ingest)​.
+Set `resources.requests` and `resources.limits` to the name of the MIG resource that you want (for example, `nvidia.com/mig-3g.20gb`).
+```shell
+nvingest:
+  nvidiaNim:
+    nemoretrieverPageElements:
+      modelName: "meta/llama3-8b-instruct"        # Example NIM model
+      resources:
+        limits:
+          nvidia.com/mig-3g.20gb: 1               # MIG profile resource
+        requests:
+          nvidia.com/mig-3g.20gb: 1
+      nodeSelector:
+        nvidia.com/gpu.product: A100-SXM4-40GB-MIG-3g.20gb
+```
+Key points:
+* Use the appropriate NIM‑specific values path (for example, `nvingest.nvidiaNim.nemoretrieverPageElements.resources`) rather than the generic `nvingest.nim` placeholder.
+* Set `resources.requests` and `resources.limits` to the desired MIG resource name (for example, `nvidia.com/mig-3g.20gb`).
+* Use `nodeSelector` (or tolerations/affinity, if you prefer) to target nodes labeled with the corresponding MIG‑enabled GPU product (for example, `nvidia.com/gpu.product: A100-SXM4-40GB-MIG-3g.20gb`).
+This syntax and structure can be repeated for each NIM model used by CAS, ensuring that each NV-Ingest NIM pod is mapped to the correct MIG slice type and scheduled onto compatible nodes.
+
+!!! important
+
+    Advanced features require additional GPU support and disk space. For more information, refer to [Support Matrix](support-matrix.md).
 
 ## Related Topics
 
@@ -440,4 +523,4 @@ You can specify multiple `--profile` options.
 - [Deploy Without Containers (Library Mode)](quickstart-library-mode.md)
 - [Deploy With Helm](helm.md)
 - [Notebooks](notebooks.md)
-- [Multimodal PDF Data Extraction](https://build.nvidia.com/nvidia/multimodal-pdf-data-extraction-for-enterprise-rag)
+- [Enterprise RAG Blueprint](https://build.nvidia.com/nvidia/multimodal-pdf-data-extraction-for-enterprise-rag)
diff --git a/docs/docs/extraction/quickstart-library-mode.md b/docs/docs/extraction/quickstart-library-mode.md
index b3c0a2ea7..c027e6a0d 100644
--- a/docs/docs/extraction/quickstart-library-mode.md
+++ b/docs/docs/extraction/quickstart-library-mode.md
@@ -1,10 +1,10 @@
-# Deploy Without Containers (Library Mode) for NeMo Retriever Extraction
+# Deploy Without Containers (Library Mode) for NeMo Retriever Library
 
-[NeMo Retriever extraction](overview.md) is typically deployed as a cluster of containers for robust, scalable production use. 
+[NeMo Retriever Library](overview.md) is typically deployed as a cluster of containers for robust, scalable production use. 
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 In addition, you can use library mode, which is intended for the following cases:
 
@@ -21,7 +21,7 @@ To get started using library mode, you need the following:
 
 - Linux operating systems (Ubuntu 22.04 or later recommended) or MacOS
 - Python 3.12
-- We strongly advise using an isolated Python virtual env, such as provided by [uv](https://docs.astral.sh/uv/getting-started/installation/) or [conda](https://github.com/conda-forge/miniforge)
+- We strongly advise using an isolated Python virtual env with [uv](https://docs.astral.sh/uv/getting-started/installation/).
 
 
 
@@ -29,17 +29,19 @@ To get started using library mode, you need the following:
 
 Use the following procedure to prepare your environment.
 
-1. Run the following code to create your NV Ingest Conda environment.
+1. Run the following code to create your NV Ingest Python environment.
 
     ```
        uv venv --python 3.12 nvingest && \
          source nvingest/bin/activate && \
-         uv pip install nv-ingest==25.9.0 nv-ingest-api==25.9.0 nv-ingest-client==25.9.0 milvus-lite==2.4.12
+         uv pip install nv-ingest==26.1.2 nv-ingest-api==26.1.2 nv-ingest-client==26.1.2
     ```
 
+    By default, the pipeline uses **LanceDB** as the vector database (no extra package required). To use **Milvus** (e.g. milvus-lite) instead, also install `milvus-lite==2.4.12` and pass `milvus_uri="milvus.db"` in `vdb_upload`. For details, see [Data Upload](data-store.md).
+
     !!! tip
 
-        To confirm that you have activated your Conda environment, run `which python` and confirm that you see `nvingest` in the result. You can do this before any python command that you run.
+        To confirm that you have activated your virtual environment, run `which python` and confirm that you see `nvingest` in the result. You can do this before any python command that you run.
 
 2. Set or create a .env file that contains your NVIDIA Build API key and other environment variables.
 
@@ -96,9 +98,9 @@ def main():
         message_client_hostname="localhost",
     )
 
-    # gpu_cagra accelerated indexing is not available in milvus-lite
-    # Provide a filename for milvus_uri to use milvus-lite
-    milvus_uri = "milvus.db"
+    # Optional: use Milvus (e.g. milvus-lite) by providing milvus_uri and installing milvus-lite.
+    # By default, LanceDB is used and no milvus_uri is needed.
+    # milvus_uri = "milvus.db"
     collection_name = "test"
     sparse = False
 
@@ -119,7 +121,7 @@ def main():
         .embed()
         .vdb_upload(
             collection_name=collection_name,
-            milvus_uri=milvus_uri,
+            # milvus_uri=milvus_uri,  # Uncomment to use Milvus instead of LanceDB
             sparse=sparse,
             # for llama-3.2 embedder, use 1024 for e5-v5
             dense_dim=2048,
@@ -185,16 +187,17 @@ This chart shows some gadgets, and some very fictitious costs.
 
 ## Step 3: Query Ingested Content
 
-To query for relevant snippets of the ingested content, and use them with an LLM to generate answers, use the following code.
+To query for relevant snippets of the ingested content, and use them with an LLM to generate answers, use the following code. With the default LanceDB backend, use the LanceDB retrieval API (see [Data Upload](data-store.md)). The example below shows retrieval when using Milvus (e.g. milvus-lite).
 
 ```python
 import os
 from openai import OpenAI
 from nv_ingest_client.util.milvus import nvingest_retrieval
 
+# Only needed when using Milvus (e.g. milvus-lite) instead of LanceDB
 milvus_uri = "milvus.db"
 collection_name = "test"
-sparse=False
+sparse = False
 
 queries = ["Which animal is responsible for the typos?"]
 
@@ -481,4 +484,4 @@ The `run_pipeline` throws the following errors:
 - [Deploy With Docker Compose (Self-Hosted)](quickstart-guide.md)
 - [Deploy With Helm](helm.md)
 - [Notebooks](notebooks.md)
-- [Multimodal PDF Data Extraction](https://build.nvidia.com/nvidia/multimodal-pdf-data-extraction-for-enterprise-rag)
+- [Enterprise RAG Blueprint](https://build.nvidia.com/nvidia/multimodal-pdf-data-extraction-for-enterprise-rag)
diff --git a/docs/docs/extraction/ray-logging.md b/docs/docs/extraction/ray-logging.md
index bf8431809..524674bae 100644
--- a/docs/docs/extraction/ray-logging.md
+++ b/docs/docs/extraction/ray-logging.md
@@ -1,8 +1,8 @@
 # Configure Ray Logging
 
-[NeMo Retriever extraction](overview.md) uses [Ray](https://docs.ray.io/en/latest/index.html) for logging. 
+[NeMo Retriever Library](overview.md) uses [Ray](https://docs.ray.io/en/latest/index.html) for logging. 
 You can use environment variables for fine-grained control over [Ray's logging behavior](https://docs.ray.io/en/latest/ray-observability/user-guides/configure-logging.html). 
-In addition, NeMo Retriever extraction provides preset configurations that you can use to quickly update Ray logging behavior.
+In addition, NeMo Retriever Library provides preset configurations that you can use to quickly update Ray logging behavior.
 
 
 !!! important
@@ -13,7 +13,7 @@ In addition, NeMo Retriever extraction provides preset configurations that you c
 
 ## Quick Start - Use Preset Configurations
 
-To get started quickly, use one of the NeMo Retriever extraction package-level preset variables. 
+To get started quickly, use one of the NeMo Retriever Library package-level preset variables. 
 Run the code below that corresponds to your use case; production, development, or debugging. 
 The log levels are explained following.
 
@@ -96,7 +96,7 @@ If you specify an invalid value, the variable reverts to the default value with
 
 | Variable                          | Type                             | Description | Valid Values | Default | 
 |-----------------------------------|----------------------------------|-------------|--------------|---------| 
-| `INGEST_RAY_LOG_LEVEL`            | NeMo Retriever extraction preset | Set multiple Ray logging variables to optimize for specific use cases. | `PRODUCTION`, `DEVELOPMENT`, `DEBUG` | `DEVELOPMENT` | 
+| `INGEST_RAY_LOG_LEVEL`            | NeMo Retriever Library preset | Set multiple Ray logging variables to optimize for specific use cases. | `PRODUCTION`, `DEVELOPMENT`, `DEBUG` | `DEVELOPMENT` | 
 | `RAY_DEDUP_LOGS`                  | Log flow control                 | Specify whether to log multiple instances of repeated events or to combine into a single entry. 1 to combine repeated messages (for example, `[repeated 5x]`). | `0`, `1` | `1` | 
 | `RAY_DISABLE_IMPORT_WARNING`      | Ray internal logging             | `1` to suppresses `Ray X.Y.Z started` message and other warnings during initialization. | `0`, `1` | `0` | 
 | `RAY_LOG_TO_DRIVER`               | Log flow control                 | `true`to log worker messages in the main process. `false` to log worker messages in worker log files. | `true`, `false` | `true` | 
diff --git a/docs/docs/extraction/releasenotes-nv-ingest.md b/docs/docs/extraction/releasenotes-nv-ingest.md
index 1f2fde700..fb4b847f8 100644
--- a/docs/docs/extraction/releasenotes-nv-ingest.md
+++ b/docs/docs/extraction/releasenotes-nv-ingest.md
@@ -1,18 +1,18 @@
-# Release Notes for NeMo Retriever Extraction
+# Release Notes for NeMo Retriever Library
 
-This documentation contains the release notes for [NeMo Retriever extraction](overview.md).
+This documentation contains the release notes for [NeMo Retriever Library](overview.md).
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 
-## Release 26.01 (26.1.1)
+## Release 26.01 (26.1.2)
 
-The NeMo Retriever extraction 26.01 release adds new hardware and software support, and other improvements.
+The NeMo Retriever Library 26.01 release adds new hardware and software support, and other improvements.
 
-To upgrade the Helm Charts for this version, refer to [NV-Ingest Helm Charts](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.1/helm/README.md).
+To upgrade the Helm Charts for this version, refer to [NV-Ingest Helm Charts](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.2/helm/README.md).
 
 
 ### Highlights 
@@ -20,7 +20,7 @@ To upgrade the Helm Charts for this version, refer to [NV-Ingest Helm Charts](ht
 This release contains the following key changes:
 
 - Added functional support for [H200 NVL](https://www.nvidia.com/en-us/data-center/h200/). For details, refer to [Support Matrix](support-matrix.md).
-- All Helm deployments for Kubernetes now use [NVIDIA NIM Operator](https://docs.nvidia.com/nim-operator/latest/index.html). For details, refer to [NV-Ingest Helm Charts](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.0/helm/README.md). 
+- All Helm deployments for Kubernetes now use [NVIDIA NIM Operator](https://docs.nvidia.com/nim-operator/latest/index.html). For details, refer to [NV-Ingest Helm Charts](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.2/helm/README.md). 
 - Updated RIVA NIM to version 1.4.0. For details, refer to [Extract Speech](audio.md).
 - Updated VLM NIM to [nemotron-nano-12b-v2-vl](https://build.nvidia.com/nvidia/nemotron-nano-12b-v2-vl/modelcard). For details, refer to [Extract Captions from Images](nv-ingest-python-api.md#extract-captions-from-images).
 - Added VLM caption prompt customization parameters, including reasoning control. For details, refer to [Caption Images and Control Reasoning](nv-ingest-python-api.md#caption-images-and-control-reasoning).
@@ -28,12 +28,12 @@ This release contains the following key changes:
 - Support is now deprecated for [paddleocr](https://build.nvidia.com/baidu/paddleocr/modelcard).
 - The `meta-llama/Llama-3.2-1B` tokenizer is now pre-downloaded so that you can run token-based splitting without making a network request. For details, refer to [Split Documents](chunking.md).
 - For scanned PDFs, added specialized extraction strategies. For details, refer to [PDF Extraction Strategies](nv-ingest-python-api.md#pdf-extraction-strategies).
-- Added support for [LanceDB](https://lancedb.com/). For details, refer to [Upload to a Custom Data Store](data-store.md).
+- [LanceDB](https://lancedb.com/) is now the default vector database backend; Milvus remains fully supported. For details, refer to [Data Upload](data-store.md).
 - The V2 API is now available and is the default processing pipeline. The response format remains backwards-compatible. You can enable the v2 API by using `message_client_kwargs={"api_version": "v2"}`.For details, refer to [API Reference](api-docs).
 - Large PDFs are now automatically split into chunks and processed in parallel, delivering faster ingestion for long documents. For details, refer to [PDF Pre-Splitting](v2-api-guide.md).
 - Issues maintaining extraction quality while processing very large files are now resolved with the V2 API. For details, refer to [V2 API Guide](v2-api-guide.md).
 - Updated the embedding task to support embedding on custom content fields like the results of summarization functions. For details, refer to [Use the Python API](nv-ingest-python-api.md).
-- User-defined function summarization is now using `nemotron-mini-4b-instruct` which provides significant speed improvements. For details, refer to [User-defined Functions](user-defined-functions.md) and [NV-Ingest UDF Examples](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.0/examples/udfs/README.md).
+- User-defined function summarization is now using `nemotron-mini-4b-instruct` which provides significant speed improvements. For details, refer to [User-defined Functions](user-defined-functions.md) and [NV-Ingest UDF Examples](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.2/examples/udfs/README.md).
 - In the `Ingestor.extract` method, the defaults for `extract_text` and `extract_images` are now set to `true` for consistency with `extract_tables` and `extract_charts`. For details, refer to [Use the Python API](nv-ingest-python-api.md).
 - The `table-structure` profile is no longer available. The table-structure profile is now part of the default profile. For details, refer to [Profile Information](quickstart-guide.md#profile-information).
 - New documentation [Why Throughput Is Dataset-Dependent](throughput-is-dataset-dependent.md).
@@ -49,8 +49,8 @@ This release contains the following key changes:
 
 The following are the known issues that are fixed in this version:
 
-- A10G support is restored. To use A10G hardware, use release 26.1.1 or later. For details, refer to [Support Matrix](support-matrix.md).
-- L40S support is restored. To use L40S hardware, use release 26.1.1 or later. For details, refer to [Support Matrix](support-matrix.md).
+- A10G support is restored. To use A10G hardware, use release 26.1.2 or later. For details, refer to [Support Matrix](support-matrix.md).
+- L40S support is restored. To use L40S hardware, use release 26.1.2 or later. For details, refer to [Support Matrix](support-matrix.md).
 - The page number field in the content metadata now starts at 1 instead of 0 so each page number is no longer off by one from what you would expect. For details, refer to [Content Metadata](content-metadata.md).
 - Support for batches that include individual files greater than approximately 400MB is restored. This includes audio files and pdfs.
 
@@ -58,14 +58,15 @@ The following are the known issues that are fixed in this version:
 
 ## All Known Issues
 
-The following are the known issues for NeMo Retriever extraction:
+The following are the known issues for NeMo Retriever Library:
 
 - Advanced visual parsing is not supported on RTX Pro 6000, B200, or H200 NVL. For details, refer to [Advanced Visual Parsing](advanced-visual-parsing.md) and [Support Matrix](support-matrix.md).
-
+- The Page Elements NIM (`nemoretriever-page-elements-v3:1.7.0`) may intermittently fail during inference under high-concurrency workloads. This happens when Triton’s dynamic batching combines requests that exceed the model’s maximum batch size, a situation more commonly seen in multi-GPU setups or large ingestion runs. In these cases, extraction fails for the impacted documents. A correction is planned for `nemoretriever-page-elements-v3:1.7.1`.
 
 
 ## Release Notes for Previous Versions
 
+| [26.1.1](https://docs.nvidia.com/nemo/retriever/26.1.1/extraction/releasenotes-nv-ingest/)
 | [25.9.0](https://docs.nvidia.com/nemo/retriever/25.9.0/extraction/releasenotes-nv-ingest/) 
 | [25.6.3](https://docs.nvidia.com/nemo/retriever/25.6.3/extraction/releasenotes-nv-ingest/) 
 | [25.6.2](https://docs.nvidia.com/nemo/retriever/25.6.2/extraction/releasenotes-nv-ingest/) 
diff --git a/docs/docs/extraction/scaling-modes.md b/docs/docs/extraction/scaling-modes.md
index fd09df0ce..5c57b33ac 100644
--- a/docs/docs/extraction/scaling-modes.md
+++ b/docs/docs/extraction/scaling-modes.md
@@ -1,13 +1,13 @@
-# Resource Scaling Modes for NeMo Retriever Extraction
+# Resource Scaling Modes for NeMo Retriever Library
 
-This guide covers how resource scaling modes work across stages in [NeMo Retriever extraction](overview.md), and how to configure it with docker-compose.
+This guide covers how resource scaling modes work across stages in [NeMo Retriever Library](overview.md), and how to configure it with docker-compose.
 
 - **Static scaling**: Each pipeline stage runs a fixed number of replicas based on heuristics (memory-aware). Good for consistent latency; higher steady-state memory usage.
 - **Dynamic scaling**: Only the source stage is fixed; other stages scale up/down based on observed resource pressure. Better memory efficiency; may briefly pause to spin replicas back up after idle periods.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 
diff --git a/docs/docs/extraction/support-matrix.md b/docs/docs/extraction/support-matrix.md
index e240e7f9d..5dbc49508 100644
--- a/docs/docs/extraction/support-matrix.md
+++ b/docs/docs/extraction/support-matrix.md
@@ -1,10 +1,10 @@
-# Support Matrix for NeMo Retriever Extraction
+# Support Matrix for NeMo Retriever Library
 
-Before you begin using [NeMo Retriever extraction](overview.md), ensure that you have the hardware for your use case.
+Before you begin using [NeMo Retriever Library](overview.md), ensure that you have the hardware for your use case.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 ## Core and Advanced Pipeline Features
@@ -17,21 +17,26 @@ The core pipeline features include the following:
 - nemoretriever-table-structure-v1 — Detects rows, columns, and cells within a table to preserve table structure and convert to Markdown format. 
 - nemoretriever-graphic-elements-v1 — Detects graphic elements within chart images such as titles, legends, axes, and numerical values. 
 - nemoretriever-ocr-v1 — Image OCR model to detect and extract text from images.
-- retrieval — Enables embedding and indexing into Milvus.
+- retrieval — Enables embedding and indexing into LanceDB (default) or Milvus.
 
 Advanced features require additional GPU support and disk space. 
 This includes the following:
 
 - Audio extraction — Use [Riva](https://docs.nvidia.com/deeplearning/riva/user-guide/docs/index.html) for processing audio files. For more information, refer to [Audio Processing](audio.md).
 - Advanced visual parsing — Use [nemotron-parse](https://docs.nvidia.com/nim/vision-language-models/latest/examples/nemotron-parse/overview.html), which adds state-of-the-art text and table extraction. For more information, refer to [Advanced Visual Parsing ](nemoretriever-parse.md).
-- VLM image captioning — Use [nemotron-nano-12b-v2-vl](https://build.nvidia.com/nvidia/nemotron-nano-12b-v2-vl/modelcard) for experimental image captioning of unstructured images. For more information, refer to [Extract Captions from Images](nv-ingest-python-api.md#extract-captions-from-images).
+- git — Use [nemotron-nano-12b-v2-vl](https://build.nvidia.com/nvidia/nemotron-nano-12b-v2-vl/modelcard) for experimental image captioning of unstructured images. 
+    
+    !!! note
+    
+        While nemotron-nano-12b-v2-vl is the default VLM, you can configure and use other vision language models for image captioning based on your specific use case requirements. For more information, refer to [Extract Captions from Images](nv-ingest-python-api.md#extract-captions-from-images).
+
 - Reranker — Use [llama-3.2-nv-rerankqa-1b-v2](https://build.nvidia.com/nvidia/llama-3.2-nv-rerankqa-1b-v2) for improved retrieval accuracy.
 
 
 
 ## Hardware Requirements
 
-NeMo Retriever extraction supports the following GPU hardware.
+NeMo Retriever Library supports the following GPU hardware.
 
 - [RTX Pro 6000 Blackwell Server Edition](https://www.nvidia.com/en-us/data-center/rtx-pro-6000-blackwell-server-edition/)
 - [DGX B200](https://www.nvidia.com/en-us/data-center/dgx-b200/)
@@ -42,7 +47,7 @@ NeMo Retriever extraction supports the following GPU hardware.
 - [L40S](https://www.nvidia.com/en-us/data-center/l40s/)
 
 
-The following are the hardware requirements to run NeMo Retriever extraction.
+The following are the hardware requirements to run NeMo Retriever Library.
 
 |Feature         | GPU Option                | RTX Pro 6000  | B200          | H200 NVL      | H100        | A100 80GB   | A100 40GB     | A10G          | L40S   |
 |----------------|---------------------------|---------------|---------------|---------------|-------------|-------------|---------------|---------------|--------|
diff --git a/docs/docs/extraction/telemetry.md b/docs/docs/extraction/telemetry.md
index ca38844e8..9d34aaa92 100644
--- a/docs/docs/extraction/telemetry.md
+++ b/docs/docs/extraction/telemetry.md
@@ -1,10 +1,10 @@
-# Telemetry with NeMo Retriever Extraction
+# Telemetry with NeMo Retriever Library
 
-You can view telemetry data for [NeMo Retriever extraction](overview.md).
+You can view telemetry data for [NeMo Retriever Library](overview.md).
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 ## OpenTelemetry
diff --git a/docs/docs/extraction/troubleshoot.md b/docs/docs/extraction/troubleshoot.md
index 74646d10a..1b130952b 100644
--- a/docs/docs/extraction/troubleshoot.md
+++ b/docs/docs/extraction/troubleshoot.md
@@ -1,15 +1,15 @@
-# Troubleshoot NeMo Retriever Extraction
+# Troubleshoot NeMo Retriever Library
 
-Use this documentation to troubleshoot issues that arise when you use [NeMo Retriever extraction](overview.md).
+Use this documentation to troubleshoot issues that arise when you use [NeMo Retriever Library](overview.md).
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 ## Can't process long, non-language text strings
 
-NeMo Retriever extraction is designed to process language and language-length strings. 
+NeMo Retriever Library is designed to process language and language-length strings. 
 If you submit a document that contains extremely long, or non-language text strings, 
 such as a DNA sequence, errors or unexpected results occur.
 
@@ -48,7 +48,7 @@ ulimit -u 10,000
 ## Out-of-Memory (OOM) Error when Processing Large Datasets
 
 When you process a very large dataset with thousands of documents, you might encounter an Out-of-Memory (OOM) error. 
-This happens because, by default, NeMo Retriever extraction stores the results from every document in system memory (RAM). 
+This happens because, by default, NeMo Retriever Library stores the results from every document in system memory (RAM). 
 If the total size of the results exceeds the available memory, the process fails.
 
 To resolve this issue, use the `save_to_disk` method. 
diff --git a/docs/docs/extraction/user-defined-functions.md b/docs/docs/extraction/user-defined-functions.md
index 70402f010..74a710698 100644
--- a/docs/docs/extraction/user-defined-functions.md
+++ b/docs/docs/extraction/user-defined-functions.md
@@ -1,11 +1,11 @@
-# Add User-Defined Functions to NeMo Retriever Extraction
+# Add User-Defined Functions to NeMo Retriever Library
 
-User-Defined Functions (UDFs) allow you to inject custom processing logic into the [NeMo Retriever extraction](overview.md) pipeline at specific stages. 
+User-Defined Functions (UDFs) allow you to inject custom processing logic into the [NeMo Retriever Library](overview.md) pipeline at specific stages. 
 This guide covers how to write, validate, and submit UDFs using both the CLI and the Python client interface.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 
@@ -121,7 +121,7 @@ results = ingestor.files("/path/to/document.pdf") \
 
 ### Understanding IngestControlMessage (ICM)
 
-The `IngestControlMessage` is the primary data structure that flows through the NV-Ingest pipeline. Your UDF receives an ICM and must return a (potentially modified) ICM.
+The `IngestControlMessage` is the primary data structure that flows through the pipeline. Your UDF receives an ICM and must return a (potentially modified) ICM.
 
 #### Key ICM Methods
 
@@ -379,7 +379,7 @@ def my_udf(control_message: IngestControlMessage) -> IngestControlMessage:
 
 ### UDF Function Specification Formats
 
-NV-Ingest supports four different formats for specifying UDF functions:
+The library supports four different formats for specifying UDF functions:
 
 ### 1. Inline Function String
 Define your function directly as a string:
@@ -456,7 +456,7 @@ ingestor.udf(udf_function="my_package.processors.text_utils:enhance_metadata")
 
 ## Integrating with NVIDIA NIMs
 
-NVIDIA Inference Microservices (NIMs) provide powerful AI capabilities that can be seamlessly integrated into your UDFs. The `NimClient` class offers a unified interface for connecting to and using NIMs within the NV-Ingest pipeline.
+NVIDIA Inference Microservices (NIMs) provide powerful AI capabilities that can be seamlessly integrated into your UDFs. The `NimClient` class offers a unified interface for connecting to and using NIMs within the pipeline.
 
 ### Quick NIM Integration
 
@@ -521,7 +521,7 @@ export NGC_API_KEY="your-ngc-api-key"
 
 ### Available NIM Interfaces
 
-NV-Ingest provides several pre-built model interfaces:
+The library provides several pre-built model interfaces:
 
 - **VLMModelInterface**: Vision-Language Models for image analysis and captioning
 - **EmbeddingModelInterface**: Text embedding generation
@@ -542,7 +542,7 @@ See the comprehensive [**NimClient Usage Guide**](nimclient_usage.md).
 
 ### Error Handling
 
-The NV-Ingest system automatically catches all exceptions that occur within UDF execution. If your UDF fails for any reason, the system will:
+The system automatically catches all exceptions that occur within UDF execution. If your UDF fails for any reason, the system will:
 
 1. Annotate the job with appropriate error information
 2. Mark the job as failed
@@ -553,7 +553,7 @@ You do not need to implement extensive error handling within your UDF - focus on
 
 ### Performance Considerations
 
-UDFs execute within the NV-Ingest pipeline and can significantly impact overall system performance and stability. Understanding these considerations is crucial for maintaining optimal pipeline throughput and reliability.
+UDFs execute within the pipeline and can significantly impact overall system performance and stability. Understanding these considerations is crucial for maintaining optimal pipeline throughput and reliability.
 
 #### Pipeline Impact
 
@@ -941,6 +941,6 @@ def debug_udf(control_message: IngestControlMessage) -> IngestControlMessage:
 
 ## Related Topics
 
-- [NV-Ingest UDF Examples](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.0/examples/udfs/README.md)
-- [User-Defined Stages for NeMo Retriever Extraction](user-defined-stages.md)
+- [NV-Ingest UDF Examples](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.2/examples/udfs/README.md)
+- [User-Defined Stages for NeMo Retriever Library](user-defined-stages.md)
 - [NimClient Usage](nimclient.md)
diff --git a/docs/docs/extraction/user-defined-stages.md b/docs/docs/extraction/user-defined-stages.md
index 8d622795a..57f68179f 100644
--- a/docs/docs/extraction/user-defined-stages.md
+++ b/docs/docs/extraction/user-defined-stages.md
@@ -1,6 +1,6 @@
-# Add User-defined Stages to Your NeMo Retriever Extraction Pipeline
+# Add User-defined Stages to Your NeMo Retriever Library Pipeline
 
-This documentation demonstrates how to add user-defined stages to your [NeMo Retriever extraction](overview.md) pipeline.
+This documentation demonstrates how to add user-defined stages to your [NeMo Retriever Library](overview.md) pipeline.
 You can directly import a function, or use a string module path, and include robust signature validation. 
 By following these steps, 
 your Lambda stages are robust, signature-validated, plug-and-play for your RayPipeline, 
@@ -8,7 +8,7 @@ and operate on a well-defined DataFrame payload and metadata structure.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 To add user-defined stages to your pipeline, you need the following:
@@ -21,7 +21,7 @@ To add user-defined stages to your pipeline, you need the following:
 
 - **A DataFrame payload** — The `control_message.payload` field must be a [pandas.DataFrame](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html). For more information, refer to [Create a DataFrame Payload](#create-a-dataframe-payload).
 
-- **Valid metadata** — The `metadata` field must conform to the [nv-ingest metadata schema](content-metadata.md). For more information, refer to [Update and Validate Metadata](#update-and-validate-metadata).
+- **Valid metadata** — The `metadata` field must conform to the [content metadata schema](content-metadata.md). For more information, refer to [Update and Validate Metadata](#update-and-validate-metadata).
 
 
 
@@ -160,7 +160,7 @@ When the pipeline runs it does the following:
 ## Update and Validate Metadata
 
 The `metadata` column in each row is a dictionary (JSON object), 
-and must conform to the [nv-ingest metadata schema](content-metadata.md). 
+and must conform to the [content metadata schema](content-metadata.md). 
 
 After you change any metadata, you can validate it by using the `validate_metadata` function 
 as demonstrated in the following code example.
@@ -228,7 +228,7 @@ Use the following best practices to avoid validation failures.
 
 ## Minimal Complete Example
 
-The  following example adds user-defined stages to your NeMo Retriever extraction pipeline. 
+The  following example adds user-defined stages to your NeMo Retriever Library pipeline. 
 
 1. The following code creates a function for a user-defined stage.
 
@@ -292,5 +292,5 @@ The  following example adds user-defined stages to your NeMo Retriever extractio
 
 ## Related Topics
 
-- [User-Defined Functions for NeMo Retriever Extraction](user-defined-functions.md)
+- [User-Defined Functions for NeMo Retriever Library](user-defined-functions.md)
 - [NimClient Usage](nimclient.md)
diff --git a/docs/docs/extraction/v2-api-guide.md b/docs/docs/extraction/v2-api-guide.md
index 6a0f72d0d..5aa87f1f6 100644
--- a/docs/docs/extraction/v2-api-guide.md
+++ b/docs/docs/extraction/v2-api-guide.md
@@ -1,4 +1,4 @@
-# NeMo Retriever Extraction V2 API Guide: PDF Pre Splitting
+# NeMo Retriever Library V2 API Guide: PDF Pre Splitting
 
 > **TL;DR:** V2 API automatically splits large PDFs into chunks for faster parallel processing.
 > 
diff --git a/docs/docs/extraction/vlm-embed.md b/docs/docs/extraction/vlm-embed.md
index eb7d364af..3ffe2b7c0 100644
--- a/docs/docs/extraction/vlm-embed.md
+++ b/docs/docs/extraction/vlm-embed.md
@@ -1,6 +1,6 @@
-# Use Multimodal Embedding with NeMo Retriever Extraction
+# Use Multimodal Embedding with NeMo Retriever Library
 
-This documentation describes how to use [NeMo Retriever extraction](overview.md) 
+This documentation describes how to use [NeMo Retriever Library](overview.md) 
 with the multimodal embedding model [Llama 3.2 NeMo Retriever Multimodal Embedding 1B](https://build.nvidia.com/nvidia/llama-3_2-nemoretriever-1b-vlm-embed-v1).
 
 The `Llama 3.2 NeMo Retriever Multimodal Embedding 1B` model is optimized for multimodal question-answering retrieval. 
@@ -10,14 +10,14 @@ The model supports images that contain text, tables, charts, and infographics.
 
 !!! note
 
-    NeMo Retriever extraction is also known as NVIDIA Ingest and nv-ingest.
+    NeMo Retriever Library is also known as NVIDIA Ingest.
 
 
 ## Configure and Run the Multimodal NIM
 
 Use the following procedure to configure and run the multimodal embedding NIM locally.
 
-1. Set the embedding model in your .env file. This tells NeMo Retriever extraction to use the Llama 3.2 Multimodal model instead of the default text-only embedding model.
+1. Set the embedding model in your .env file. This tells NeMo Retriever Library to use the Llama 3.2 Multimodal model instead of the default text-only embedding model.
 
     ```
     EMBEDDING_IMAGE=nvcr.io/nvidia/nemo-microservices/llama-3.2-nemoretriever-1b-vlm-embed-v1
@@ -25,7 +25,7 @@ Use the following procedure to configure and run the multimodal embedding NIM lo
     EMBEDDING_NIM_MODEL_NAME=nvidia/llama-3.2-nemoretriever-1b-vlm-embed-v1
     ```
 
-2. Start the NeMo Retriever extraction services. The multimodal embedding service is included by default.
+2. Start the NeMo Retriever Library services. The multimodal embedding service is included by default.
 
     ```
     docker compose --profile retrieval up
@@ -90,7 +90,7 @@ results = ingestor.ingest()
 ## Example with Embedding Entire PDF Pages as Images
 
 For documents where the entire page layout is important (such as infographics, complex diagrams, or forms), 
-you can configure NeMo Retriever extraction to treat every page as a single image.
+you can configure NeMo Retriever Library to treat every page as a single image.
 The following example extracts and embeds each page as an image.
 
 !!! note
@@ -118,10 +118,9 @@ ingestor = (
 results = ingestor.ingest()
 ```
 
-
-
 ## Related Topics
 
 - [Support Matrix](support-matrix.md)
 - [Troubleshoot Nemo Retriever Extraction](troubleshoot.md)
-- [Use the NV-Ingest Python API](nv-ingest-python-api.md)
+- [Use the Python API](nv-ingest-python-api.md)
+- [Extract Captions from Images](nv-ingest-python-api.md#extract-captions-from-images)
diff --git a/docs/docs/index.md b/docs/docs/index.md
index 8b3feb4c8..32d7b1acd 100644
--- a/docs/docs/index.md
+++ b/docs/docs/index.md
@@ -10,7 +10,7 @@ empowering secure, enterprise-grade retrieval.
 NeMo Retriever provides the following:
 
 - **Multimodal Data Extraction** — Quickly extract documents at scale that include text, tables, charts, and infographics.
-- **Embedding + Indexing** — Embed all extracted text from text chunks and images, and then insert into Milvus - accelerated with NVIDIA cuVS.
+- **Embedding + Indexing** — Embed all extracted text from text chunks and images, and then insert into LanceDB (default) or Milvus — accelerated with NVIDIA cuVS.
 - **Retrieval** — Leverage semantic + hybrid search for high accuracy retrieval with the embedding + reranking NIM microservice.
 
 
diff --git a/examples/building_vdb_operator.ipynb b/examples/building_vdb_operator.ipynb
index ca9983585..11e7a6759 100644
--- a/examples/building_vdb_operator.ipynb
+++ b/examples/building_vdb_operator.ipynb
@@ -486,7 +486,7 @@
     "    self.write_to_index(records)\n",
     "```\n",
     "\n",
-    "This method is called by the NV-Ingest Ingestor class during the ingestion pipeline. For more information on how operators are integrated into NV-Ingest, refer to the [interface implementation](https://github.com/NVIDIA/nv-ingest/blob/release/25.6.2/client/src/nv_ingest_client/client/interface.py#L324).\n",
+    "This method is called by the NV-Ingest Ingestor class during the ingestion pipeline. For more information on how operators are integrated into NV-Ingest, refer to the [interface implementation](https://github.com/NVIDIA/nv-ingest/blob/release/26.1.2/client/src/nv_ingest_client/client/interface.py#L324).\n",
     "\n",
     "The simplicity of this method belies its importance - it ensures that indexes are properly configured before data ingestion begins."
    ]
diff --git a/examples/lancedb_vdb_operator.ipynb b/examples/lancedb_vdb_operator.ipynb
new file mode 100644
index 000000000..3888cf652
--- /dev/null
+++ b/examples/lancedb_vdb_operator.ipynb
@@ -0,0 +1,144 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Build a LanceDB VDB Operator\n",
+        "\n",
+        "This tutorial mirrors the VDB operator walkthrough but uses LanceDB instead of Milvus/OpenSearch. You will ingest NV-Ingest extraction results into a local LanceDB table and run vector search against it.\n",
+        "\n",
+        "**Important:** NVIDIA makes no claim about accuracy, performance, or functionality of any vector database except Milvus. If you use a different vector database, it's your responsibility to test and maintain it."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Prerequisites\n",
+        "\n",
+        "- NV-Ingest microservices running (see `docker-compose.yaml` and repo quickstart).\n",
+        "- NV-Ingest Python client installed.\n",
+        "- LanceDB and PyArrow available in your environment.\n",
+        "\n",
+        "If you are running this from the repo, ensure the services are up before continuing."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# Optional: install LanceDB dependencies if needed\n",
+        "# %pip install -qU lancedb pyarrow"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## VDB Interface Overview\n",
+        "\n",
+        "NV-Ingest defines a lightweight `VDB` abstract class at `client/src/nv_ingest_client/util/vdb/adt_vdb.py`. The LanceDB operator in `client/src/nv_ingest_client/util/vdb/lancedb.py` implements this interface with methods for:\n",
+        "\n",
+        "- `create_index(...)`: create the LanceDB table\n",
+        "- `write_to_index(...)`: build the vector index\n",
+        "- `run(...)`: orchestration entry point for ingestion\n",
+        "\n",
+        "For retrieval, use the standalone `lancedb_retrieval` function which provides search with optional reranking support."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Step 1: Ingest NV-Ingest Results into LanceDB\n",
+        "\n",
+        "We instantiate the `LanceDB` operator, point it at a local database path, and then use the NV-Ingest `Ingestor` to extract, embed, and upload results into LanceDB."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from nv_ingest_client.client import Ingestor\n",
+        "from nv_ingest_client.util.vdb.lancedb import LanceDB\n",
+        "\n",
+        "lancedb_uri = \"./lancedb\"\n",
+        "table_name = \"nv-ingest\"\n",
+        "\n",
+        "vdb = LanceDB(\n",
+        "    uri=lancedb_uri,\n",
+        "    table_name=table_name,\n",
+        "    overwrite=True,\n",
+        ")\n",
+        "\n",
+        "ingestor = (\n",
+        "    Ingestor(message_client_hostname=\"localhost\")\n",
+        "    .files(\"../data/multimodal_test.pdf\")\n",
+        "    .extract(\n",
+        "        extract_text=True,\n",
+        "        extract_tables=True,\n",
+        "        extract_images=False,\n",
+        "    )\n",
+        "    .embed()\n",
+        "    .vdb_upload(vdb_op=vdb)\n",
+        ")\n",
+        "\n",
+        "results = ingestor.ingest()\n",
+        "results"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "The LanceDB database is created at `./lancedb`, and the table name is `nv-ingest`. If you rerun the cell with `overwrite=True`, it will recreate the table."
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Step 2: Search the LanceDB Table\n",
+        "\n",
+        "Use the `lancedb_retrieval` function to embed queries and run vector search against the table."
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from nv_ingest_client.util.vdb.lancedb import lancedb_retrieval\n",
+        "\n",
+        "queries = [\n",
+        "    \"What is shown in the charts?\",\n",
+        "    \"Summarize the table contents.\",\n",
+        "]\n",
+        "\n",
+        "search_results = lancedb_retrieval(\n",
+        "    queries,\n",
+        "    table_path=lancedb_uri,\n",
+        "    table_name=table_name,\n",
+        "    embedding_endpoint=\"http://localhost:8012/v1\",\n",
+        "    model_name=\"nvidia/llama-3.2-nv-embedqa-1b-v2\",\n",
+        "    top_k=5,\n",
+        ")\n",
+        "\n",
+        "search_results[0][:3]"
+      ]
+    }
+  ],
+  "metadata": {
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 2
+}
diff --git a/examples/metadata_and_filtered_search.ipynb b/examples/metadata_and_filtered_search.ipynb
index b89adfa86..afcd9b127 100644
--- a/examples/metadata_and_filtered_search.ipynb
+++ b/examples/metadata_and_filtered_search.ipynb
@@ -21,7 +21,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/opt/conda/envs/nv_ingest_runtime/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "/opt/nv_ingest_runtime/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
       "  from .autonotebook import tqdm as notebook_tqdm\n"
      ]
     }
@@ -147,7 +147,7 @@
      "output_type": "stream",
      "text": [
       "[nltk_data] Downloading package punkt_tab to\n",
-      "[nltk_data]     /opt/conda/envs/nv_ingest_runtime/lib/python3.12/site-\n",
+      "[nltk_data]     /opt/nv_ingest_runtime/lib/python3.12/site-\n",
       "[nltk_data]     packages/llama_index/core/_static/nltk_cache...\n",
       "[nltk_data]   Package punkt_tab is already up-to-date!\n"
      ]
diff --git a/helm/Chart.yaml b/helm/Chart.yaml
index c8bb9fb71..12f044ec9 100644
--- a/helm/Chart.yaml
+++ b/helm/Chart.yaml
@@ -2,7 +2,7 @@ apiVersion: v2
 name: nv-ingest
 description: NV-Ingest Microservice
 type: application
-version: 25.9.0
+version: 26.1.2
 maintainers:
   - name: NVIDIA Corporation
     url: https://www.nvidia.com/
diff --git a/helm/README.md b/helm/README.md
index b1280130a..253f10659 100644
--- a/helm/README.md
+++ b/helm/README.md
@@ -9,20 +9,8 @@ This documentation contains documentation for the NV-Ingest Helm charts.
 
 Before you install the Helm charts, be sure you meet the hardware and software prerequisites. Refer to the [supported configurations](https://github.com/NVIDIA/nv-ingest?tab=readme-ov-file#hardware).
 
-> Starting with version 26.1.0, the [NVIDIA NIM Operator](https://docs.nvidia.com/nim-operator/latest/install.html) is required. All NIM services are now deployed by using NIM Operator CRDs (NIMCache and NIMService), not Helm subcharts.
->
-> **Upgrading from 25.9.0:**
-> 1. Install NIM Operator before upgrading
-> 2. Update your values file with the new configuration keys:
->
-> | 25.9.0 | 26.x |
-> |--------|------|
-> | `nim-vlm-image-captioning.deployed=true` | `nimOperator.nemotron_nano_12b_v2_vl.enabled=true` |
-> | `paddleocr-nim.deployed=true` | `nimOperator.nemoretriever_ocr_v1.enabled=true` |
-> | `riva-nim.deployed=true` | `nimOperator.audio.enabled=true` |
-> | `nim-vlm-text-extraction.deployed=true` | `nimOperator.nemotron_parse.enabled=true` |
-
-The [Nvidia GPU Operator](https://docs.nvidia.com/datacenter/cloud-native/gpu-operator/latest/getting-started.html) must also be installed and configured in your cluster.
+The [Nvidia nim-operator](https://docs.nvidia.com/nim-operator/latest/install.html) must also be installed and configured in your cluster to ensure that
+the Nvidia NIMs are properly deployed.
 
 ## Initial Environment Setup
 
@@ -57,7 +45,7 @@ To install or upgrade the Helm chart, run the following code.
 helm upgrade \
     --install \
     nv-ingest \
-    https://helm.ngc.nvidia.com/nvidia/nemo-microservices/charts/nv-ingest-25.9.0.tgz \
+    https://helm.ngc.nvidia.com/nvidia/nemo-microservices/charts/nv-ingest-26.1.2.tgz \
     -n ${NAMESPACE} \
     --username '$oauthtoken' \
     --password "${NGC_API_KEY}" \
@@ -66,7 +54,7 @@ helm upgrade \
     --set ngcApiSecret.create=true \
     --set ngcApiSecret.password="${NGC_API_KEY}" \
     --set image.repository="nvcr.io/nvidia/nemo-microservices/nv-ingest" \
-    --set image.tag="25.9.0"
+    --set image.tag="26.1.2"
 ```
 
 Optionally you can create your own versions of the `Secrets` if you do not want to use the creation via the helm chart.
@@ -117,7 +105,7 @@ For more information, refer to [NV-Ingest-Client](https://github.com/NVIDIA/nv-i
 # Just to be cautious we remove any existing installation
 pip uninstall nv-ingest-client
 
-pip install nv-ingest-client==25.9.0
+pip install nv-ingest-client==26.1.2
 ```
 
 #### Rest Endpoint Ingress
@@ -359,7 +347,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | fullnameOverride | string | `""` |  |
 | image.pullPolicy | string | `"IfNotPresent"` |  |
 | image.repository | string | `"nvcr.io/nvidia/nemo-microservices/nv-ingest"` |  |
-| image.tag | string | `"25.9.0"` |  |
+| image.tag | string | `"26.1.2"` |  |
 | imagePullSecrets[0].name | string | `"ngc-api"` |  |
 | imagePullSecrets[1].name | string | `"ngc-secret"` |  |
 | ingress.annotations | object | `{}` |  |
@@ -428,7 +416,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.audio.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.audio.storage.pvc.create | bool | `true` |  |
 | nimOperator.audio.storage.pvc.size | string | `"25Gi"` |  |
-| nimOperator.audio.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.audio.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.embedqa.authSecret | string | `"ngc-api"` |  |
 | nimOperator.embedqa.enabled | bool | `true` |  |
 | nimOperator.embedqa.env[0].name | string | `"NIM_HTTP_API_PORT"` |  |
@@ -445,12 +433,12 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.embedqa.image.pullPolicy | string | `"IfNotPresent"` |  |
 | nimOperator.embedqa.image.pullSecrets[0] | string | `"ngc-secret"` |  |
 | nimOperator.embedqa.image.repository | string | `"nvcr.io/nim/nvidia/llama-3.2-nv-embedqa-1b-v2"` |  |
-| nimOperator.embedqa.image.tag | string | `"1.10.0"` |  |
+| nimOperator.embedqa.image.tag | string | `"1.10.1"` |  |
 | nimOperator.embedqa.replicas | int | `1` |  |
 | nimOperator.embedqa.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.embedqa.storage.pvc.create | bool | `true` |  |
 | nimOperator.embedqa.storage.pvc.size | string | `"50Gi"` |  |
-| nimOperator.embedqa.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.embedqa.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.graphic_elements.authSecret | string | `"ngc-api"` |  |
 | nimOperator.graphic_elements.enabled | bool | `true` |  |
 | nimOperator.graphic_elements.env[0].name | string | `"NIM_HTTP_API_PORT"` |  |
@@ -476,7 +464,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.graphic_elements.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.graphic_elements.storage.pvc.create | bool | `true` |  |
 | nimOperator.graphic_elements.storage.pvc.size | string | `"25Gi"` |  |
-| nimOperator.graphic_elements.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.graphic_elements.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.llama_3_2_nv_rerankqa_1b_v2.authSecret | string | `"ngc-api"` |  |
 | nimOperator.llama_3_2_nv_rerankqa_1b_v2.enabled | bool | `false` |  |
 | nimOperator.llama_3_2_nv_rerankqa_1b_v2.env | list | `[]` |  |
@@ -491,7 +479,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.llama_3_2_nv_rerankqa_1b_v2.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.llama_3_2_nv_rerankqa_1b_v2.storage.pvc.create | bool | `true` |  |
 | nimOperator.llama_3_2_nv_rerankqa_1b_v2.storage.pvc.size | string | `"50Gi"` |  |
-| nimOperator.llama_3_2_nv_rerankqa_1b_v2.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.llama_3_2_nv_rerankqa_1b_v2.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.nemoretriever_ocr_v1.authSecret | string | `"ngc-api"` |  |
 | nimOperator.nemoretriever_ocr_v1.enabled | bool | `true` |  |
 | nimOperator.nemoretriever_ocr_v1.env[0].name | string | `"OMP_NUM_THREADS"` |  |
@@ -519,7 +507,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.nemoretriever_ocr_v1.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.nemoretriever_ocr_v1.storage.pvc.create | bool | `true` |  |
 | nimOperator.nemoretriever_ocr_v1.storage.pvc.size | string | `"25Gi"` |  |
-| nimOperator.nemoretriever_ocr_v1.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.nemoretriever_ocr_v1.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.nemotron_nano_12b_v2_vl.authSecret | string | `"ngc-api"` |  |
 | nimOperator.nemotron_nano_12b_v2_vl.enabled | bool | `false` |  |
 | nimOperator.nemotron_nano_12b_v2_vl.expose.service.grpcPort | int | `8001` |  |
@@ -533,7 +521,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.nemotron_nano_12b_v2_vl.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.nemotron_nano_12b_v2_vl.storage.pvc.create | bool | `true` |  |
 | nimOperator.nemotron_nano_12b_v2_vl.storage.pvc.size | string | `"300Gi"` |  |
-| nimOperator.nemotron_nano_12b_v2_vl.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.nemotron_nano_12b_v2_vl.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.nemotron_parse.authSecret | string | `"ngc-api"` |  |
 | nimOperator.nemotron_parse.enabled | bool | `false` |  |
 | nimOperator.nemotron_parse.env[0].name | string | `"NIM_HTTP_API_PORT"` |  |
@@ -551,11 +539,11 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.nemotron_parse.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.nemotron_parse.storage.pvc.create | bool | `true` |  |
 | nimOperator.nemotron_parse.storage.pvc.size | string | `"100Gi"` |  |
-| nimOperator.nemotron_parse.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.nemotron_parse.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.nimCache.pvc.create | bool | `true` |  |
 | nimOperator.nimCache.pvc.size | string | `"25Gi"` |  |
 | nimOperator.nimCache.pvc.storageClass | string | `"default"` |  |
-| nimOperator.nimCache.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.nimCache.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.nimService.namespaces | list | `[]` |  |
 | nimOperator.nimService.resources | object | `{}` |  |
 | nimOperator.page_elements.authSecret | string | `"ngc-api"` |  |
@@ -603,7 +591,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.page_elements.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.page_elements.storage.pvc.create | bool | `true` |  |
 | nimOperator.page_elements.storage.pvc.size | string | `"25Gi"` |  |
-| nimOperator.page_elements.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.page_elements.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nimOperator.table_structure.authSecret | string | `"ngc-api"` |  |
 | nimOperator.table_structure.enabled | bool | `true` |  |
 | nimOperator.table_structure.env[0].name | string | `"NIM_HTTP_API_PORT"` |  |
@@ -629,7 +617,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | nimOperator.table_structure.resources.limits."nvidia.com/gpu" | int | `1` |  |
 | nimOperator.table_structure.storage.pvc.create | bool | `true` |  |
 | nimOperator.table_structure.storage.pvc.size | string | `"25Gi"` |  |
-| nimOperator.table_structure.storage.pvc.volumeAccessMode | string | `"ReadWriteMany"` |  |
+| nimOperator.table_structure.storage.pvc.volumeAccessMode | string | `"ReadWriteOnce"` |  |
 | nodeSelector | object | `{}` |  |
 | opentelemetry-collector.config.exporters.debug.verbosity | string | `"detailed"` |  |
 | opentelemetry-collector.config.exporters.zipkin.endpoint | string | `"http://nv-ingest-zipkin:9411/api/v2/spans"` |  |
@@ -682,7 +670,7 @@ You can also use NV-Ingest's Python client API to interact with the service runn
 | prometheus.alertmanager.enabled | bool | `false` |  |
 | prometheus.enabled | bool | `false` |  |
 | prometheus.server.enabled | bool | `false` |  |
-| readinessProbe.enabled | bool | `false` |  |
+| readinessProbe.enabled | bool | `true` |  |
 | readinessProbe.failureThreshold | int | `220` |  |
 | readinessProbe.httpGet.path | string | `"/v1/health/ready"` |  |
 | readinessProbe.httpGet.port | string | `"http"` |  |
diff --git a/helm/README.md.gotmpl b/helm/README.md.gotmpl
index 48e79c6b4..6080e6d71 100644
--- a/helm/README.md.gotmpl
+++ b/helm/README.md.gotmpl
@@ -46,7 +46,7 @@ To install or upgrade the Helm chart, run the following code.
 helm upgrade \
     --install \
     nv-ingest \
-    https://helm.ngc.nvidia.com/nvidia/nemo-microservices/charts/nv-ingest-25.9.0.tgz \
+    https://helm.ngc.nvidia.com/nvidia/nemo-microservices/charts/nv-ingest-26.1.2.tgz \
     -n ${NAMESPACE} \
     --username '$oauthtoken' \
     --password "${NGC_API_KEY}" \
@@ -55,7 +55,7 @@ helm upgrade \
     --set ngcApiSecret.create=true \
     --set ngcApiSecret.password="${NGC_API_KEY}" \
     --set image.repository="nvcr.io/nvidia/nemo-microservices/nv-ingest" \
-    --set image.tag="25.9.0"
+    --set image.tag="26.1.2"
 ```
 
 Optionally you can create your own versions of the `Secrets` if you do not want to use the creation via the helm chart.
@@ -107,7 +107,7 @@ For more information, refer to [NV-Ingest-Client](https://github.com/NVIDIA/nv-i
 # Just to be cautious we remove any existing installation
 pip uninstall nv-ingest-client
 
-pip install nv-ingest-client==25.9.0
+pip install nv-ingest-client==26.1.2
 ```
 
 #### Rest Endpoint Ingress
diff --git a/helm/overrides/values-a100-40gb.yaml b/helm/overrides/values-a100-40gb.yaml
new file mode 100644
index 000000000..003c234ba
--- /dev/null
+++ b/helm/overrides/values-a100-40gb.yaml
@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# GPU-specific overrides for A100 40GB (loaded by harness when --deployment-type helm --sku a100-40gb).
+# Sets NIM_TRITON_MAX_BATCH_SIZE=1 per NIM to match docker-compose.a100-40gb.yaml.
+
+nimOperator:
+  page_elements:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CPU_THREADS_PRE_PROCESSOR
+        value: "2"
+      - name: OMP_NUM_THREADS
+        value: "2"
+      - name: NIM_TRITON_CPU_THREADS_POST_PROCESSOR
+        value: "1"
+      - name: NIM_ENABLE_OTEL
+        value: "true"
+      - name: NIM_OTEL_SERVICE_NAME
+        value: "page-elements"
+      - name: NIM_OTEL_TRACES_EXPORTER
+        value: "otlp"
+      - name: NIM_OTEL_METRICS_EXPORTER
+        value: "console"
+      - name: NIM_OTEL_EXPORTER_OTLP_ENDPOINT
+        value: "http://otel-collector:4318"
+      - name: TRITON_OTEL_URL
+        value: "http://otel-collector:4318/v1/traces"
+      - name: TRITON_OTEL_RATE
+        value: "1"
+
+  graphic_elements:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_RATE_LIMIT
+        value: "3"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
+        value: "2048"
+      - name: OMP_NUM_THREADS
+        value: "1"
+
+  table_structure:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_RATE_LIMIT
+        value: "3"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
+        value: "2048"
+      - name: OMP_NUM_THREADS
+        value: "1"
+
+  nemoretriever_ocr_v1:
+    env:
+      - name: OMP_NUM_THREADS
+        value: "8"
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+
+  llama_3_2_nv_rerankqa_1b_v2:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
diff --git a/helm/overrides/values-a10g.yaml b/helm/overrides/values-a10g.yaml
new file mode 100644
index 000000000..2c78459f2
--- /dev/null
+++ b/helm/overrides/values-a10g.yaml
@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# GPU-specific overrides for A10G (loaded by harness when --deployment-type helm --sku a10g).
+# Sets NIM_TRITON_MAX_BATCH_SIZE=1 per NIM to match docker-compose.a10g.yaml.
+
+nimOperator:
+  page_elements:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CPU_THREADS_PRE_PROCESSOR
+        value: "2"
+      - name: OMP_NUM_THREADS
+        value: "2"
+      - name: NIM_TRITON_CPU_THREADS_POST_PROCESSOR
+        value: "1"
+      - name: NIM_ENABLE_OTEL
+        value: "true"
+      - name: NIM_OTEL_SERVICE_NAME
+        value: "page-elements"
+      - name: NIM_OTEL_TRACES_EXPORTER
+        value: "otlp"
+      - name: NIM_OTEL_METRICS_EXPORTER
+        value: "console"
+      - name: NIM_OTEL_EXPORTER_OTLP_ENDPOINT
+        value: "http://otel-collector:4318"
+      - name: TRITON_OTEL_URL
+        value: "http://otel-collector:4318/v1/traces"
+      - name: TRITON_OTEL_RATE
+        value: "1"
+
+  graphic_elements:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_RATE_LIMIT
+        value: "3"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
+        value: "2048"
+      - name: OMP_NUM_THREADS
+        value: "1"
+
+  table_structure:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_RATE_LIMIT
+        value: "3"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
+        value: "2048"
+      - name: OMP_NUM_THREADS
+        value: "1"
+
+  nemoretriever_ocr_v1:
+    env:
+      - name: OMP_NUM_THREADS
+        value: "8"
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+
+  llama_3_2_nv_rerankqa_1b_v2:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
diff --git a/helm/overrides/values-l40s.yaml b/helm/overrides/values-l40s.yaml
new file mode 100644
index 000000000..dc17c93aa
--- /dev/null
+++ b/helm/overrides/values-l40s.yaml
@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# GPU-specific overrides for L40S (loaded by harness when --deployment-type helm --sku l40s).
+# Sets NIM_TRITON_MAX_BATCH_SIZE=1 per NIM to match docker-compose.l40s.yaml.
+
+nimOperator:
+  page_elements:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CPU_THREADS_PRE_PROCESSOR
+        value: "2"
+      - name: OMP_NUM_THREADS
+        value: "2"
+      - name: NIM_TRITON_CPU_THREADS_POST_PROCESSOR
+        value: "1"
+      - name: NIM_ENABLE_OTEL
+        value: "true"
+      - name: NIM_OTEL_SERVICE_NAME
+        value: "page-elements"
+      - name: NIM_OTEL_TRACES_EXPORTER
+        value: "otlp"
+      - name: NIM_OTEL_METRICS_EXPORTER
+        value: "console"
+      - name: NIM_OTEL_EXPORTER_OTLP_ENDPOINT
+        value: "http://otel-collector:4318"
+      - name: TRITON_OTEL_URL
+        value: "http://otel-collector:4318/v1/traces"
+      - name: TRITON_OTEL_RATE
+        value: "1"
+
+  graphic_elements:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_RATE_LIMIT
+        value: "3"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
+        value: "2048"
+      - name: OMP_NUM_THREADS
+        value: "1"
+
+  table_structure:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_RATE_LIMIT
+        value: "3"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+      - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
+        value: "2048"
+      - name: OMP_NUM_THREADS
+        value: "1"
+
+  nemoretriever_ocr_v1:
+    env:
+      - name: OMP_NUM_THREADS
+        value: "8"
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
+
+  llama_3_2_nv_rerankqa_1b_v2:
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
+      - name: NIM_TRITON_MAX_BATCH_SIZE
+        value: "1"
diff --git a/helm/values.yaml b/helm/values.yaml
index f69c83fe6..7bf32dea3 100644
--- a/helm/values.yaml
+++ b/helm/values.yaml
@@ -28,7 +28,7 @@ nameOverride: ""
 image:
   pullPolicy: IfNotPresent
   repository: "nvcr.io/nvidia/nemo-microservices/nv-ingest"
-  tag: "25.9.0"
+  tag: "26.1.2"
 
 ## @section Pod Configuration
 ## @param podAnnotations [object] Sets additional annotations on the main deployment pods
@@ -69,9 +69,7 @@ replicaCount: 1
 ## @param resources.requests.memory [default: 24Gi] Specify request for memory
 ## @param resources.requests.cpu [default: "24000m"] Specify request for CPU
 resources:
-  limits:
-    memory: 200Gi
-    cpu: "48000m"
+  limits: {}
   requests:
     memory: 24Gi
     cpu: "24000m"
@@ -105,13 +103,14 @@ tmpDirSize: 50Gi
 ## @param envVars.INGEST_LOG_LEVEL [default: "DEFAULT"] Log level for the ingest service
 ## @param envVars.INGEST_EDGE_BUFFER_SIZE [default: "64"] Size of the edge buffer for ingestion
 ## @param envVars.INGEST_DYNAMIC_MEMORY_THRESHOLD [default: "0.80"] Dynamic memory threshold for ingestion
-## @param envVars.MAX_INGEST_PROCESS_WORKERS [default: "16"] Maximum Ingestion worker processes
+## @param envVars.MAX_INGEST_PROCESS_WORKERS [default: "32"] Maximum Ingestion worker processes
 ## @param envVars.MESSAGE_CLIENT_HOST [default: "nv-ingest-redis-master"] Override this value to specify a differing REST endpoint host
 ## @param envVars.MESSAGE_CLIENT_PORT [default: "6379"] Override this value to specify a differing REST endpoint port
 ## @param envVars.MESSAGE_CLIENT_TYPE [default: "redis"] Type of message client to use
 ## @param envVars.REDIS_INGEST_TASK_QUEUE [default: "ingest_task_queue"] Name of the Redis queue for ingest tasks
+## @param envVars.REDIS_POOL_SIZE [default: "50"] Maximum Redis connection pool size. Increase for high-concurrency workloads (e.g., 100-200 for large batch jobs)
 ## @param envVars.NV_INGEST_DEFAULT_TIMEOUT_MS [default: "1234"] Override the Timeout of the NVIngest requests
-## @param envVars.NV_INGEST_MAX_UTIL [default: "48"] Maximum number of CPU cores to utilize for processing. Defaults to number of available CPU cores if not set
+## @param envVars.NV_INGEST_MAX_UTIL [default: "32"] Maximum number of CPU cores to utilize for processing. Defaults to number of available CPU cores if not set
 ## @param envVars.MINIO_INTERNAL_ADDRESS [default: "nv-ingest-minio:9000"] Override this to the cluster local DNS name of minio
 ## @param envVars.MINIO_PUBLIC_ADDRESS [default: "http://localhost:9000"] Override this to publicly routable minio address, default assumes port-forwarding
 ## @param envVars.MINIO_BUCKET [default: "nv-ingest"] Override this for specific minio bucket to upload extracted images to
@@ -148,9 +147,11 @@ envVars:
   ARROW_DEFAULT_MEMORY_POOL: "system"
   OMP_NUM_THREADS: 1
   RAY_num_grpc_threads: 1
+  RAY_num_server_call_thread: 1
+  RAY_worker_num_grpc_internal_threads: 1
 
-  MAX_INGEST_PROCESS_WORKERS: 16
-  NV_INGEST_MAX_UTIL: 48
+  MAX_INGEST_PROCESS_WORKERS: 32
+  NV_INGEST_MAX_UTIL: 32
   INGEST_DYNAMIC_MEMORY_THRESHOLD: 0.80
   INGEST_EDGE_BUFFER_SIZE: 64
   INGEST_DISABLE_DYNAMIC_SCALING: true
@@ -206,8 +207,6 @@ envVars:
   # To use the NGC hosted NIM (Build API), manually set this value to "https://integrate.api.nvidia.com/v1/chat/completions".
   # VLM_CAPTION_ENDPOINT: "DO_NOT_USE_HERE_FOR_REFERENCE_ONLY"
   VLM_CAPTION_MODEL_NAME: "nvidia/nemotron-nano-12b-v2-vl"
-  VLM_CAPTION_PROMPT: "Caption the content of this image:"
-  VLM_CAPTION_SYSTEM_PROMPT: "/no_think"
 
 
   # "ready" check configuration.
@@ -669,12 +668,8 @@ nimOperator:
         value: "8000"
       - name: NIM_TRITON_LOG_VERBOSE
         value: "1"
-      - name: NIM_TRITON_RATE_LIMIT
-        value: "3"
       - name: NIM_TRITON_MAX_BATCH_SIZE
         value: "32"
-      - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
-        value: "2048"
       - name: NIM_TRITON_CPU_THREADS_PRE_PROCESSOR
         value: "2"
       - name: OMP_NUM_THREADS
@@ -787,9 +782,9 @@ nimOperator:
       - name: NIM_TRITON_MAX_BATCH_SIZE
         value: "32"
       - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
-        value: "3072"
+        value: "2048"
       - name: OMP_NUM_THREADS
-        value: "8"
+        value: "1"
 
   ## @param embedqa [object] Configuration for EmbedQA NIM
   ## @param embedqa.enabled [bool] Enable the EmbedQA service
@@ -845,8 +840,8 @@ nimOperator:
   nemoretriever_ocr_v1:
     enabled: true
     image:
-      repository: nvcr.io/nvidia/nemo-microservices/nemoretriever-ocr-v1
-      tag: 1.1.0
+      repository: nvcr.io/nim/nvidia/nemoretriever-ocr-v1
+      tag: 1.2.1
       pullPolicy: IfNotPresent
       pullSecrets:
         - ngc-secret
@@ -872,14 +867,8 @@ nimOperator:
         value: "8000"
       - name: NIM_TRITON_LOG_VERBOSE
         value: "1"
-      - name: NIM_TRITON_RATE_LIMIT
-        value: "3"
-      - name: NIM_TRITON_CUDA_MEMORY_POOL_MB
-        value: "8192"
       - name: NIM_TRITON_MAX_BATCH_SIZE
         value: "32"
-      - name: NIM_TRITON_ENABLE_MODEL_CONTROL
-        value: "1"
 
   ## @param llama_3_2_nv_rerankqa_1b_v2 [object] Configuration for LLaMA-3.2 NV RerankQA 1B v2 NIM
   ## @param llama_3_2_nv_rerankqa_1b_v2.enabled [bool] Enable this NIM
@@ -913,7 +902,11 @@ nimOperator:
         type: ClusterIP
         port: 8000
         grpcPort: 8001
-    env: []
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
 
   ## @param nemotron_nano_12b_v2_vl [object] Configuration for Nemotron Nano 12B v2 VL NIM
   ## @param nemotron_nano_12b_v2_vl.enabled [bool] Enable this NIM
@@ -953,6 +946,11 @@ nimOperator:
         type: ClusterIP
         port: 8000
         grpcPort: 8001
+    env:
+      - name: NIM_HTTP_API_PORT
+        value: "8000"
+      - name: NIM_TRITON_LOG_VERBOSE
+        value: "1"
 
   ## @param nemotron_parse [object] Configuration for Nemotron Parse NIM
   ## @param nemotron_parse.enabled [bool] Enable or disable the Nemotron Parse NIM deployment.
diff --git a/nemo_retriever/Dockerfile b/nemo_retriever/Dockerfile
new file mode 100644
index 000000000..e73077559
--- /dev/null
+++ b/nemo_retriever/Dockerfile
@@ -0,0 +1,104 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# syntax=docker/dockerfile:1.3
+#
+# Build from nv-ingest root: docker build -f nemo_retriever/Dockerfile -t retriever .
+# Run: docker run retriever  (help) or docker run -v /host/docs:/data retriever /data
+
+ARG BASE_IMG=nvcr.io/nvidia/base/ubuntu
+ARG BASE_IMG_TAG=jammy-20250619
+
+FROM $BASE_IMG:$BASE_IMG_TAG AS base
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+      bzip2 \
+      ca-certificates \
+      curl \
+      libgl1-mesa-glx \
+      libglib2.0-0 \
+      wget \
+    && apt-get clean
+
+# ffmpeg/ffprobe for audio extraction (run before LibreOffice so apt state is consistent)
+COPY docker/scripts/install_ffmpeg.sh /tmp/install_ffmpeg.sh
+RUN bash /tmp/install_ffmpeg.sh && rm /tmp/install_ffmpeg.sh
+
+# LibreOffice (headless) for docx/pptx -> PDF. GPL source handling per nv-ingest Dockerfile.
+ARG GPL_LIBS="\
+    libltdl7 \
+    libhunspell-1.7-0 \
+    libhyphen0 \
+    libdbus-1-3 \
+"
+# Keep libfreetype6 so LibreOffice (soffice.bin) can load; omit from force-remove.
+ARG FORCE_REMOVE_PKGS="\
+    ucf \
+    liblangtag-common \
+    libjbig0 \
+    pinentry-curses \
+    gpg-agent \
+    gnupg-utils \
+    gpgsm \
+    gpg-wks-server \
+    gpg-wks-client \
+    gpgconf \
+    gnupg \
+    readline-common \
+    libreadline8 \
+    dirmngr \
+    libjpeg8 \
+"
+RUN sed -i 's/# deb-src/deb-src/' /etc/apt/sources.list \
+    && apt-get update \
+    && apt-get install -y --no-install-recommends \
+      dpkg-dev \
+      libreoffice \
+      $GPL_LIBS \
+    && apt-get source $GPL_LIBS \
+    && for pkg in $FORCE_REMOVE_PKGS; do \
+         dpkg --remove --force-depends "$pkg" || true; \
+       done \
+    && apt-get clean
+
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
+
+ENV PATH=/root/.local/bin:$PATH
+ENV UV_LINK_MODE=copy
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv python install 3.12 \
+    && uv venv --python 3.12 /opt/retriever_runtime
+
+ENV VIRTUAL_ENV=/opt/retriever_runtime
+ENV PATH=/opt/retriever_runtime/bin:/root/.local/bin:$PATH
+ENV LD_LIBRARY_PATH=/opt/retriever_runtime/lib:${LD_LIBRARY_PATH}
+
+# ---------------------------------------------------------------------------
+# Install retriever and siblings (build context = nv-ingest root)
+# ---------------------------------------------------------------------------
+FROM base AS install
+
+WORKDIR /workspace
+
+# Unbuffered stdout/stderr so CLI output appears when run without a TTY (e.g. docker run without -it)
+ENV PYTHONUNBUFFERED=1
+
+COPY retriever retriever
+COPY src src
+COPY api api
+COPY client client
+
+# Use conda env's uv; create venv and install retriever in editable mode (path deps: ../src, ../api, ../client)
+SHELL ["/bin/bash", "-c"]
+RUN --mount=type=cache,target=/root/.cache/pip \
+    --mount=type=cache,target=/root/.cache/uv \
+    source /opt/conda/etc/profile.d/conda.sh \
+    && conda activate retriever_libcudart \
+    && uv venv .retriever \
+    && . .retriever/bin/activate \
+    && uv pip install -e ./retriever
+
+# Default: run in-process pipeline (help if no args)
+ENTRYPOINT ["/workspace/.retriever/bin/python", "-m", "retriever.examples.inprocess_pipeline"]
+CMD ["--help"]
diff --git a/nemo_retriever/RAY_BALANCING.md b/nemo_retriever/RAY_BALANCING.md
new file mode 100644
index 000000000..ec71d3142
--- /dev/null
+++ b/nemo_retriever/RAY_BALANCING.md
@@ -0,0 +1,162 @@
+# Ray Balancing Strategy
+
+This document describes the default Ray Data balancing strategy used by
+`nemo_retriever/src/nemo_retriever/ray_balance_dag.py`, why each test family exists, and
+what to try next.
+
+## Goal
+
+Keep the default experiment set broad enough to find bottlenecks, but small
+enough to run repeatedly across multiple machines. The default matrix is now
+designed to stay under 1,000 variants.
+
+## Design Approach
+
+The default matrix uses a practical DOE-style approach:
+
+1. **Baseline run**  
+   A stable reference point used for quick comparisons.
+2. **One-factor-at-a-time (OFAT) sweeps**  
+   Change one knob while keeping others at baseline to isolate sensitivity.
+3. **Targeted interaction sweeps**  
+   Test only high-value parameter interactions where coupling is expected.
+
+This avoids a full Cartesian product over all knobs (which grows to millions of
+runs and is usually not actionable).
+
+## Default Matrix Definition
+
+The script’s default matrix includes the following families.
+
+### A) Baseline
+
+- Single baseline config with balanced CPU/GPU and midrange batch sizes.
+- Purpose: anchor for all deltas and detect regressions quickly.
+
+### B) OFAT Sweeps
+
+- `pdf_workers`: `[4, 8, 12, 16]`
+- `pdf_num_cpus`: `[1.0, 2.0, 3.0, 4.0]`
+- `pdf_split_bs`: `[1, 4, 8]`
+- `pdf_bs`: `[8, 16, 24, 32]`
+- `page_elements_bs`: `[8, 16, 24, 32]`
+- `page_elements_workers`: `[1, 2, 3]`
+- `ocr_workers`: `[1, 2, 3]`
+- `ocr_bs`: `[8, 16, 24, 32]`
+- `embed_workers`: `[1, 2, 3]`
+- `embed_bs`: `[128, 256, 512, 768]`
+- `page_elements_cpus_per_actor`: `[1.0, 2.0, 4.0]`
+- `ocr_cpus_per_actor`: `[1.0, 2.0, 4.0]`
+- `embed_cpus_per_actor`: `[1.0, 2.0, 4.0]`
+- `gpu_page_elements`: `[0.25, 0.5, 0.75]`
+- `gpu_ocr`: `[0.75, 1.0]`
+- `gpu_embed`: `[0.25, 0.5, 0.75]`
+
+Why this matters:
+
+- Identifies which knobs are low-impact (can be fixed) vs high-impact (worth
+  deeper search).
+- Narrows the search space before trying interactions.
+
+### C) Targeted Interaction Grids
+
+1. **OCR throughput coupling**
+   - `ocr_bs x ocr_workers x gpu_ocr`
+2. **Embedding throughput coupling**
+   - `embed_bs x embed_workers x gpu_embed`
+3. **Page-elements throughput coupling**
+   - `page_elements_bs x page_elements_workers x gpu_page_elements`
+4. **CPU extraction balance**
+   - `pdf_workers x pdf_num_cpus x pdf_bs`
+5. **Actor CPU pressure**
+   - `page_elements_cpus_per_actor x ocr_cpus_per_actor x embed_cpus_per_actor`
+6. **Pipeline batch-shape interaction**
+   - `pdf_bs x ocr_bs x embed_bs`
+
+Why this matters:
+
+- These are the pairs/triples most likely to create backpressure or starvation.
+- Captures non-linear behavior without exploding matrix size.
+
+## What Has Been Tried So Far
+
+- Full/fat sweeps were tested early and found to be too large operationally.
+- Matrix generation now deduplicates repeated variants and focuses on high-signal
+  combinations.
+- Row-range sharding support (`--row-start`, `--row-end`) is used for distributed
+  execution across machines.
+- Runtime metrics are captured per run:
+  - Ray Data operator stats (`rd_dataset.stats()`)
+  - Ray timeline (`ray.timeline(...)`)
+
+## GPU Constraint Handling
+
+Some deployments reject fractional `num_gpus` values above `1.0` per actor.
+
+To avoid invalid scheduling requests, matrix generation/loading normalizes any
+`gpu_* > 1.0` request by:
+
+- setting per-actor GPU to `1.0`, and
+- multiplying the corresponding actor count (`*_workers`) by `ceil(gpu_*)`.
+
+This keeps total requested GPU capacity similar while using valid actor specs.
+
+## Runtime Metrics Artifacts
+
+For each run, the pipeline writes metrics files under the run logs directory
+(`runtime_metrics/` subdir) with the run prefix:
+
+- `<prefix>.rd_dataset.stats.txt` (per-operator Ray Data stats)
+- `<prefix>.ray.timeline.json` (cluster task timeline)
+- `<prefix>.runtime.summary.json` (top-level run summary)
+
+## LanceDB Isolation and Recall Guarantees
+
+To prevent cross-run contamination:
+
+- The matrix runner deletes the configured LanceDB URI path before each run.
+- Each run then recreates and writes a fresh `nv-ingest` table.
+
+To ensure recall is actually executed:
+
+- The batch pipeline now treats a missing LanceDB table as a hard failure
+  (after a short retry), instead of silently skipping recall.
+- The matrix results CSV includes a `recall_ran` flag and marks runs as failed
+  if recall metrics are absent.
+
+## How to Generate and Run
+
+Generate matrix CSV only:
+
+```bash
+python nemo_retriever/src/nemo_retriever/ray_balance_dag.py \
+  --input-dir /path/to/pdfs \
+  --write-default-matrix-csv nemo_retriever/ray_balance_variants.csv \
+  --exit-after-writing-matrix
+```
+
+Run a shard:
+
+```bash
+python nemo_retriever/src/nemo_retriever/ray_balance_dag.py \
+  --input-dir /path/to/pdfs \
+  --matrix-csv nemo_retriever/ray_balance_variants.csv \
+  --row-start 1 \
+  --row-end 200 \
+  --output-csv nemo_retriever/ray_balance_results_001_200.csv
+```
+
+## Recommended Next Experiments
+
+1. **Adaptive second-pass search**
+   - Keep top 10-20% by throughput and run local neighborhood sweeps.
+2. **Constraint-aware optimization**
+   - Add objective penalties for GPU OOM, high object-store pressure, or low
+     recall to avoid fragile winners.
+3. **Dataset-stratified tests**
+   - Split small/medium/large PDFs and optimize per segment; mixed corpora often
+     hide better settings.
+4. **Stability runs**
+   - Re-run top candidates 3-5 times and compare variance, not just best mean.
+5. **Multi-objective scoring**
+   - Rank by weighted score: throughput, recall@k, and cost (GPU-hours).
diff --git a/nemo_retriever/README.md b/nemo_retriever/README.md
new file mode 100644
index 000000000..6edd125e8
--- /dev/null
+++ b/nemo_retriever/README.md
@@ -0,0 +1,124 @@
+# Retriever
+
+RAG ingestion pipeline for PDFs: extract structure (text, tables, charts, infographics), embed, optionally upload to LanceDB, and run recall evaluation.
+
+## Prerequisites
+
+- **CUDA 13** — required for **OCR** (Nemotron); text extraction and other stages may work without it.
+- **Python 3.12**
+- **UV** (required) — [install UV](https://docs.astral.sh/uv/getting-started/installation/) (e.g. `curl -LsSf https://astral.sh/uv/install.sh | sh`)
+
+## Installation
+
+Installation is done with **UV** from the **nv-ingest root**. UV manages the environment and dependencies; pip is not supported.
+
+From the repo root:
+
+```bash
+cd /path/to/nv-ingest
+uv venv .retriever
+source .retriever/bin/activate
+uv pip install -e ./nemo_retriever
+```
+
+This installs the retriever in editable mode and its in-repo dependencies. Core dependencies (see `nemo_retriever/pyproject.toml`) include Ray, pypdfium2, pandas, LanceDB, PyYAML, torch, transformers, and the Nemotron packages (page-elements, graphic-elements, table-structure). The retriever also depends on the sibling packages `nv-ingest`, `nv-ingest-api`, and `nv-ingest-client` in this repo.
+
+### OCR and CUDA 13 runtime
+
+The Nemotron OCR native extension requires **libcudart.so.13** (CUDA 13 runtime). If you see:
+
+```text
+ImportError: libcudart.so.13: cannot open shared object file: No such file or directory
+```
+
+your system CUDA Toolkit is missing or older than 13. Install CUDA 13 runtime support on your host, or run the retriever Docker image which includes the required runtime.
+
+If CUDA libraries are installed in a non-standard path, expose them explicitly:
+   ```bash
+   export LD_LIBRARY_PATH=/path/to/cuda/lib64:$LD_LIBRARY_PATH
+   ```
+
+## Quick start
+
+From the nv-ingest root, install with UV then run the batch pipeline with a directory of PDFs:
+
+```bash
+cd /path/to/nv-ingest
+uv venv .retriever
+source .retriever/bin/activate
+uv pip install -e ./nemo_retriever
+uv run python nemo_retriever/src/nemo_retriever/examples/batch_pipeline.py /path/to/pdfs
+```
+
+Pass the directory that contains your PDFs as the first argument (`input-dir`). For recall evaluation, the pipeline uses `bo767_query_gt.csv` in the current directory by default; override with `--query-csv <path>`. Recall is skipped if the query CSV file does not exist. By default, per-query details (query, gold, hits) are printed; use `--no-recall-details` to print only the missed-gold summary and recall metrics. To use an existing Ray cluster, pass `--ray-address auto`. If OCR fails with a missing `libcudart.so.13`, install the CUDA 13 runtime and set `LD_LIBRARY_PATH` as shown above.
+
+For **HTML** or **text** ingestion, use `--input-type html` or `--input-type txt` with the same examples (e.g. `batch_pipeline.py <dir> --input-type html`). HTML files are converted to markdown via markitdown, then chunked with the same tokenizer as .txt. Staged CLI: `retriever html run --input-dir <dir>` writes `*.html_extraction.json`; then `retriever local stage5 run --input-dir <dir> --pattern "*.html_extraction.json"` and `retriever local stage6 run --input-dir <dir>`.
+
+### Audio pipeline
+
+Audio ingestion uses `.files("mp3/*.mp3").extract_audio(...).embed().vdb_upload().ingest()` in batch, inprocess, or fused mode. **ASR** (speech-to-text) can be:
+
+- **Local**: When `audio_endpoints` are not set (e.g. `[null, null]` in `ingest-config.yaml` under `audio_asr`), the pipeline uses the local HuggingFace model **nvidia/parakeet-ctc-1.1b** (Transformers first, with NeMo fallback if needed). No NIM or gRPC endpoint required.
+- **Remote**: When `audio_endpoints` is set (e.g. Parakeet NIM or self-deployed Riva gRPC), the pipeline uses the remote client. Set `AUDIO_GRPC_ENDPOINT`, `NGC_API_KEY`, and optionally `AUDIO_FUNCTION_ID` for NGC cloud ASR.
+
+See `ingest-config.yaml` (`audio_chunk`, `audio_asr`) and the audio scripts under `retriever/scripts/` for examples.
+
+### Starting a Ray cluster
+
+This project uses Ray Data. You can start a Ray cluster yourself to use the dashboard and control GPU usage.
+
+**Cluster with Ray Dashboard**
+
+Start a head node (dashboard is enabled by default on port 8265):
+
+```bash
+ray start --head
+```
+
+Open the dashboard at **http://127.0.0.1:8265**. Run your pipeline in the same machine; pass `--ray-address auto` to attach to this cluster (e.g. `uv run python nemo_retriever/src/nemo_retriever/examples/batch_pipeline.py /path/to/pdfs --ray-address auto` or the batch pipeline CLI with `--ray-address auto`).
+
+**Single-GPU cluster (multi-GPU nodes)**
+
+To use only one GPU on a node that has more (e.g. for testing), limit visible devices and start Ray with one GPU:
+
+```bash
+CUDA_VISIBLE_DEVICES=0 ray start --head --num-gpus=1
+```
+
+Then run your pipeline as above (e.g. `--ray-address auto` for the CLI, or `ray_address="auto"` in Python).
+
+### Running multiple NIM service instances on multi-GPU hosts
+
+If you want more than one `page-elements` and `ocr` instance on the same machine, run separate Docker Compose projects and pin each project to a specific physical GPU.
+
+From the `nv-ingest` repo root:
+
+```bash
+# GPU 0 stack
+GPU_ID=0 \
+PAGE_ELEMENTS_HTTP_PORT=8000 PAGE_ELEMENTS_GRPC_PORT=8001 PAGE_ELEMENTS_METRICS_PORT=8002 \
+OCR_HTTP_PORT=8019 OCR_GRPC_PORT=8010 OCR_METRICS_PORT=8011 \
+docker compose -p ingest-gpu0 up -d page-elements ocr
+
+# GPU 1 stack
+GPU_ID=1 \
+PAGE_ELEMENTS_HTTP_PORT=8100 PAGE_ELEMENTS_GRPC_PORT=8101 PAGE_ELEMENTS_METRICS_PORT=8102 \
+OCR_HTTP_PORT=8119 OCR_GRPC_PORT=8110 OCR_METRICS_PORT=8111 \
+docker compose -p ingest-gpu1 up -d page-elements ocr
+```
+
+The `-p` values create isolated stacks, while `GPU_ID` pins each stack to a different physical GPU. Distinct host ports prevent collisions and keep both stacks externally accessible.
+
+Useful checks:
+
+```bash
+docker compose -p ingest-gpu0 ps
+docker compose -p ingest-gpu1 ps
+```
+
+To stop and remove both stacks:
+
+```bash
+docker compose -p ingest-gpu0 down
+docker compose -p ingest-gpu1 down
+```
diff --git a/nemo_retriever/chart_stage_config.yaml b/nemo_retriever/chart_stage_config.yaml
new file mode 100644
index 000000000..fada15b68
--- /dev/null
+++ b/nemo_retriever/chart_stage_config.yaml
@@ -0,0 +1,53 @@
+# Example config for chart extraction.
+#
+# Intended usage (once the chart stage CLI is wired up similarly to table stage):
+#   - `retriever chart stage run --config <this.yaml> --input <primitives.parquet>`
+#   - `retriever local stage4 run --config <this.yaml> --input <primitives.parquet>`
+#
+# This YAML is parsed into `nv_ingest_api.internal.schemas.extract.extract_chart_schema.ChartExtractorSchema`
+# via `nemo_retriever.chart.config.load_chart_extractor_schema_from_dict`.
+#
+# IMPORTANT:
+# If `endpoint_config.yolox_endpoints` is null/empty, chart extraction will fall back to the local
+# HuggingFace model (`nemo_retriever.model.local.nemotron_graphic_elements_v1`).
+# If `endpoint_config.ocr_endpoints` is null/empty, chart extraction falls back to local Nemotron OCR
+# (`nemo_retriever.model.local.nemotron_ocr_v1`) with default HuggingFace model loading.
+#
+
+# Optional worker settings
+max_queue_size: 1
+n_workers: 2
+raise_on_failure: false
+
+# Endpoint configuration for chart extraction (YOLOX graphic-elements + OCR).
+endpoint_config:
+  # Optional auth token for secured services (NIM / hosted endpoints)
+  auth_token: null
+
+  # Tuple/list in the form: [grpc, http]
+  #
+  # Chart extraction uses the YOLOX *graphic-elements* model (not page-elements).
+  #
+  # For the provided `docker-compose.yaml`, the host-mapped ports are:
+  #   - graphic-elements HTTP: 8003 (container 8000)
+  #   - graphic-elements gRPC: 8004 (container 8001)
+  #
+  # If you're running from inside the docker compose network instead, these often look like:
+  #   - "graphic-elements:8001" and "http://graphic-elements:8000/v1/infer"
+  # yolox_endpoints: ["localhost:8004", "http://localhost:8003/v1/infer"]
+  yolox_endpoints: null
+  # Optional; if omitted it is inferred from which endpoint is present.
+  # yolox_infer_protocol: grpc
+
+  # OCR model endpoints (same pattern: [grpc, http]).
+  # For the provided `docker-compose.yaml`, the host-mapped ports are:
+  #   - ocr HTTP: 8019 (container 8000)
+  #   - ocr gRPC: 8010 (container 8001)
+  # ocr_endpoints: ["localhost:8010", "http://localhost:8019/v1/infer"]
+  ocr_endpoints: null
+  # Optional; if omitted it is inferred from which endpoint is present.
+  # ocr_infer_protocol: grpc
+
+  # Optional performance knobs
+  nim_batch_size: 2
+  workers_per_progress_engine: 5
diff --git a/nemo_retriever/embedding_stage_config.yaml b/nemo_retriever/embedding_stage_config.yaml
new file mode 100644
index 000000000..46c45d170
--- /dev/null
+++ b/nemo_retriever/embedding_stage_config.yaml
@@ -0,0 +1,43 @@
+# Text embedding stage config (nemo_retriever.text_embed)
+#
+# This YAML is passed to:
+#   nemo_retriever.text_embed.config.load_text_embedding_schema_from_dict(...)
+# which validates against nv-ingest-api's `TextEmbeddingSchema`.
+#
+# Minimal required fields are optional (schema provides defaults), but you
+# typically set api_key / endpoint / model to point at your embedding service.
+
+# Auth (optional; can also be provided via task_config overrides)
+api_key: ""  # e.g. $NGC_API_KEY or $NVIDIA_API_KEY
+
+# Embedding service settings
+# If set to null/empty, `retriever local stage5` will fall back to local HF embeddings
+# via `nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder`.
+embedding_nim_endpoint: null
+# embedding_nim_endpoint: "http://localhost:8012/v1"
+embedding_model: "nvidia/llama-3.2-nv-embedqa-1b-v2"
+
+# Request formatting
+encoding_format: "float"   # usually "float"
+input_type: "passage"      # "passage" (docs) or "query" (queries)
+truncate: "END"            # how the service truncates long inputs
+
+# Batch sizing (NIM-side batching is handled internally; this is stage batching)
+batch_size: 4
+
+# Modalities for multi-modal models (leave as "text" for text-only models)
+text_elements_modality: "text"
+image_elements_modality: "text"
+structured_elements_modality: "text"
+audio_elements_modality: "text"
+
+# Behavior
+raise_on_failure: false
+httpx_log_level: "WARNING"  # DEBUG | INFO | WARNING | ERROR | CRITICAL
+
+# Optional: embed custom content from metadata.custom_content via glom path
+# custom_content_field: "my_field"                 # e.g. "foo" or "nested.foo"
+# result_target_field: "my_field_embedding"        # where to write embedding under custom_content
+
+# Optional: request embedding vector size if the backend supports it
+# dimensions: 1024
diff --git a/nemo_retriever/infographic_stage_config.yaml b/nemo_retriever/infographic_stage_config.yaml
new file mode 100644
index 000000000..67ac68546
--- /dev/null
+++ b/nemo_retriever/infographic_stage_config.yaml
@@ -0,0 +1,33 @@
+# Example config for:
+#   - `retriever infographic stage run --config <this.yaml> --input <primitives.parquet>`
+#   - `retriever local stage2 run --config <this.yaml> --input <primitives.parquet>`
+#
+# This YAML is parsed into `nv_ingest_api.internal.schemas.extract.extract_infographic_schema.InfographicExtractorSchema`
+# via `nemo_retriever.infographic.config.load_infographic_extractor_schema_from_dict`.
+#
+# IMPORTANT:
+# `endpoint_config.ocr_endpoints` must provide at least one endpoint (gRPC or HTTP). Both cannot be null/empty.
+#
+
+# Optional worker settings
+max_queue_size: 1
+n_workers: 2
+raise_on_failure: false
+
+# Endpoint configuration for OCR used to enrich infographic primitives.
+endpoint_config:
+  # Tuple/list in the form: [grpc, http]
+  # - gRPC example: "ocr:8001"
+  # - HTTP example: "http://ocr:8000/v1/infer"
+  #ocr_endpoints: ["localhost:8001", "http://localhost:8019/v1/infer"]
+  ocr_endpoints: null
+
+  # Optional; if omitted it is inferred from which endpoint is present.
+  # ocr_infer_protocol: grpc
+
+  # Optional auth token for secured services (NIM)
+  auth_token: null
+
+  # Optional performance knobs
+  nim_batch_size: 2
+  workers_per_progress_engine: 5
diff --git a/nemo_retriever/pdf_stage_config.yaml b/nemo_retriever/pdf_stage_config.yaml
new file mode 100644
index 000000000..33126ba61
--- /dev/null
+++ b/nemo_retriever/pdf_stage_config.yaml
@@ -0,0 +1,49 @@
+# Example config for: `retriever pdf stage page-elements --config <this.yaml>`
+#
+# CLI override rule:
+# - If you pass an option explicitly on the CLI, it wins.
+# - Otherwise the value from this YAML file is used.
+#
+# You can run repeatedly:
+#   retriever pdf stage page-elements --config nemo_retriever/pdf_stage_config.yaml
+#
+
+# Directory containing PDFs (scanned recursively for *.pdf)
+input_dir: /home/local/jdyer/datasets/bo767
+
+# PDF extraction method: pdfium | pdfium_hybrid | ocr | nemotron_parse | tika | unstructured_io | adobe | llama
+method: pdfium
+
+# Optional auth token for NIM-backed services
+auth_token: null
+
+endpoints:
+  yolox:
+    # If set to null then HuggingFace models will be used instead of NIMs
+    # grpc: localhost:8001
+    # http: http://localhost:8000/v1/infer
+    grpc: null
+    http: null
+
+  # Only required for method: nemotron_parse
+  nemotron_parse:
+    grpc: null
+    http: null
+    model_name: null
+
+extract:
+  text: true
+  # Text depth: page | document
+  text_depth: page
+  images: false
+  tables: true
+  charts: true
+  infographics: true
+  page_as_image: false
+
+outputs:
+  write_json: true
+  json_output_dir: /home/local/jdyer/datasets/bo767-results-hf-standalone/
+
+# Optionally limit number of PDFs processed
+limit: null
diff --git a/nemo_retriever/pyproject.toml b/nemo_retriever/pyproject.toml
new file mode 100644
index 000000000..0e40fb5ad
--- /dev/null
+++ b/nemo_retriever/pyproject.toml
@@ -0,0 +1,106 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel>=0.46.2"]
+build-backend = "setuptools.build_meta"
+
+[tool.uv]
+managed = true
+package = true
+
+[project]
+name = "nemo-retriever"
+dynamic = ["version"]
+description = "A modern RAG ingestion pipeline from Nvidia"
+readme = "README.md"
+requires-python = ">=3.12"
+authors = [
+  { name = "Jeremy Dyer", email = "jdyer@nvidia.com" },
+]
+license = { text = "Apache-2.0" }
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "License :: OSI Approved :: Apache Software License",
+  "Operating System :: OS Independent",
+]
+dependencies = [
+  "ray[data,serve]>=2.49.0",
+  "pypdfium2==4.30.0",
+  "pandas>=2.0,<3",
+  "tqdm>=4.66.0",
+  "typer>=0.12.0",
+  "pyyaml>=6.0",
+  "lancedb",
+  "nv-ingest",
+  "nv-ingest-api",
+  "nv-ingest-client",
+  "fastapi>=0.114.0",
+  "uvicorn[standard]>=0.30.0",
+  "httpx>=0.27.0",
+  "requests>=2.31.0",
+  "pydantic>=2.8.0",
+  "typer>=0.12.0",
+  "rich>=13.7.0",
+  "pillow>=12.0.0",
+  "numpy>=1.26.0",
+  "debugpy>=1.8.0",
+  "python-multipart>=0.0.9",
+  # transformers>=5 enables loading nvidia/parakeet-ctc-1.1b via pipeline (see
+  # parakeet-ctc-1.1b README). If using llama_nemotron_embed_1b_v2, verify
+  # compatibility with transformers 5 (it previously relied on HybridCache).
+  "transformers>=5.0.0",
+  "tokenizers>=0.20.3",
+  "accelerate>=1.1.0",
+  "torch~=2.9.1",
+  "torchvision>=0.24,<0.25",
+  "einops",
+  "easydict",
+  "addict",
+  "nemotron-page-elements-v3>=0.dev0",
+  "nemotron-graphic-elements-v1>=0.dev0",
+  "nemotron-table-structure-v1>=0.dev0",
+  "nemotron-ocr>=0.dev0",
+  "markitdown",
+  "timm==1.0.22",
+  "accelerate==1.12.0",
+  "albumentations==2.0.8",
+  "open-clip-torch==3.2.0",
+  # Local ASR (Parakeet): read chunk files and resample to 16 kHz mono
+  "soundfile>=0.12.0",
+  "scipy>=1.11.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "build>=1.2.2",
+  "pytest>=8.0.2",
+]
+
+[project.scripts]
+retriever = "nemo_retriever.__main__:main"
+
+[tool.setuptools.dynamic]
+version = {attr = "nemo_retriever.version.get_build_version"}
+
+[tool.uv.sources]
+nv-ingest = { path = "../src/", editable = true }
+nv-ingest-api = { path = "../api/", editable = true }
+nv-ingest-client = { path = "../client/", editable = true }
+nemotron-page-elements-v3 = { index = "test-pypi" }
+nemotron-graphic-elements-v1 = { index = "test-pypi" }
+nemotron-table-structure-v1 = { index = "test-pypi" }
+nemotron-ocr = { index = "test-pypi" }
+torch = { index = "torch-cuda"}
+torchvision = { index ="torch-cuda"}
+
+[[tool.uv.index]]
+name = "test-pypi"
+url = "https://test.pypi.org/simple/"
+explicit = true
+
+[[tool.uv.index]]
+name = "torch-cuda"
+url = "https://download.pytorch.org/whl/cu128"
+explicit = true
+
+[tool.setuptools.packages.find]
+where = ["src"]
diff --git a/nemo_retriever/ray_balance_variants.csv b/nemo_retriever/ray_balance_variants.csv
new file mode 100644
index 000000000..309b3cdf4
--- /dev/null
+++ b/nemo_retriever/ray_balance_variants.csv
@@ -0,0 +1,240 @@
+run_id,pdf_workers,pdf_num_cpus,pdf_split_bs,pdf_bs,page_elements_bs,page_elements_workers,ocr_workers,ocr_bs,embed_workers,embed_bs,page_elements_cpus_per_actor,ocr_cpus_per_actor,embed_cpus_per_actor,gpu_page_elements,gpu_ocr,gpu_embed,ray_address,start_ray
+V00001,8,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00002,4,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00003,12,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00004,16,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00005,8,1.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00006,8,3.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00007,8,4.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00008,8,2.0,4,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00009,8,2.0,8,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00010,8,2.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00011,8,2.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00012,8,2.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00013,8,2.0,1,16,8,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00014,8,2.0,1,16,24,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00015,8,2.0,1,16,32,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00016,8,2.0,1,16,16,2,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00017,8,2.0,1,16,16,3,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00018,8,2.0,1,16,16,1,1,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00019,8,2.0,1,16,16,1,3,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00020,8,2.0,1,16,16,1,2,8,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00021,8,2.0,1,16,16,1,2,24,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00022,8,2.0,1,16,16,1,2,32,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00023,8,2.0,1,16,16,1,2,16,2,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00024,8,2.0,1,16,16,1,2,16,3,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00025,8,2.0,1,16,16,1,2,16,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00026,8,2.0,1,16,16,1,2,16,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00027,8,2.0,1,16,16,1,2,16,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00028,8,2.0,1,16,16,1,2,16,1,256,2.0,2.0,1.0,0.5,1.0,0.5,,false
+V00029,8,2.0,1,16,16,1,2,16,1,256,4.0,2.0,1.0,0.5,1.0,0.5,,false
+V00030,8,2.0,1,16,16,1,2,16,1,256,1.0,1.0,1.0,0.5,1.0,0.5,,false
+V00031,8,2.0,1,16,16,1,2,16,1,256,1.0,4.0,1.0,0.5,1.0,0.5,,false
+V00032,8,2.0,1,16,16,1,2,16,1,256,1.0,2.0,2.0,0.5,1.0,0.5,,false
+V00033,8,2.0,1,16,16,1,2,16,1,256,1.0,2.0,4.0,0.5,1.0,0.5,,false
+V00034,8,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00035,8,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00036,8,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00037,8,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00038,8,2.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00039,8,2.0,1,16,16,1,1,8,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00040,8,2.0,1,16,16,1,1,8,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00041,8,2.0,1,16,16,1,2,8,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00042,8,2.0,1,16,16,1,3,8,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00043,8,2.0,1,16,16,1,3,8,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00044,8,2.0,1,16,16,1,1,16,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00045,8,2.0,1,16,16,1,3,16,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00046,8,2.0,1,16,16,1,1,24,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00047,8,2.0,1,16,16,1,1,24,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00048,8,2.0,1,16,16,1,2,24,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00049,8,2.0,1,16,16,1,3,24,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00050,8,2.0,1,16,16,1,3,24,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00051,8,2.0,1,16,16,1,1,32,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00052,8,2.0,1,16,16,1,1,32,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00053,8,2.0,1,16,16,1,2,32,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00054,8,2.0,1,16,16,1,3,32,1,256,1.0,2.0,1.0,0.5,0.75,0.5,,false
+V00055,8,2.0,1,16,16,1,3,32,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00056,8,2.0,1,16,16,1,2,16,1,128,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00057,8,2.0,1,16,16,1,2,16,1,128,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00058,8,2.0,1,16,16,1,2,16,2,128,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00059,8,2.0,1,16,16,1,2,16,2,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00060,8,2.0,1,16,16,1,2,16,2,128,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00061,8,2.0,1,16,16,1,2,16,3,128,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00062,8,2.0,1,16,16,1,2,16,3,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00063,8,2.0,1,16,16,1,2,16,3,128,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00064,8,2.0,1,16,16,1,2,16,2,256,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00065,8,2.0,1,16,16,1,2,16,2,256,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00066,8,2.0,1,16,16,1,2,16,3,256,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00067,8,2.0,1,16,16,1,2,16,3,256,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00068,8,2.0,1,16,16,1,2,16,1,512,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00069,8,2.0,1,16,16,1,2,16,1,512,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00070,8,2.0,1,16,16,1,2,16,2,512,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00071,8,2.0,1,16,16,1,2,16,2,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00072,8,2.0,1,16,16,1,2,16,2,512,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00073,8,2.0,1,16,16,1,2,16,3,512,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00074,8,2.0,1,16,16,1,2,16,3,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00075,8,2.0,1,16,16,1,2,16,3,512,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00076,8,2.0,1,16,16,1,2,16,1,768,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00077,8,2.0,1,16,16,1,2,16,1,768,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00078,8,2.0,1,16,16,1,2,16,2,768,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00079,8,2.0,1,16,16,1,2,16,2,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00080,8,2.0,1,16,16,1,2,16,2,768,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00081,8,2.0,1,16,16,1,2,16,3,768,1.0,2.0,1.0,0.5,1.0,0.25,,false
+V00082,8,2.0,1,16,16,1,2,16,3,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00083,8,2.0,1,16,16,1,2,16,3,768,1.0,2.0,1.0,0.5,1.0,0.75,,false
+V00084,8,2.0,1,16,8,1,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00085,8,2.0,1,16,8,1,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00086,8,2.0,1,16,8,2,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00087,8,2.0,1,16,8,2,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00088,8,2.0,1,16,8,2,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00089,8,2.0,1,16,8,3,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00090,8,2.0,1,16,8,3,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00091,8,2.0,1,16,8,3,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00092,8,2.0,1,16,16,2,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00093,8,2.0,1,16,16,2,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00094,8,2.0,1,16,16,3,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00095,8,2.0,1,16,16,3,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00096,8,2.0,1,16,24,1,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00097,8,2.0,1,16,24,1,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00098,8,2.0,1,16,24,2,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00099,8,2.0,1,16,24,2,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00100,8,2.0,1,16,24,2,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00101,8,2.0,1,16,24,3,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00102,8,2.0,1,16,24,3,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00103,8,2.0,1,16,24,3,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00104,8,2.0,1,16,32,1,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00105,8,2.0,1,16,32,1,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00106,8,2.0,1,16,32,2,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00107,8,2.0,1,16,32,2,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00108,8,2.0,1,16,32,2,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00109,8,2.0,1,16,32,3,2,16,1,256,1.0,2.0,1.0,0.25,1.0,0.5,,false
+V00110,8,2.0,1,16,32,3,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00111,8,2.0,1,16,32,3,2,16,1,256,1.0,2.0,1.0,0.75,1.0,0.5,,false
+V00112,4,1.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00113,4,1.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00114,4,1.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00115,4,1.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00116,4,2.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00117,4,2.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00118,4,2.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00119,4,3.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00120,4,3.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00121,4,3.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00122,4,3.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00123,4,4.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00124,4,4.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00125,4,4.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00126,4,4.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00127,8,1.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00128,8,1.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00129,8,1.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00130,8,3.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00131,8,3.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00132,8,3.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00133,8,4.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00134,8,4.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00135,8,4.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00136,12,1.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00137,12,1.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00138,12,1.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00139,12,1.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00140,12,2.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00141,12,2.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00142,12,2.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00143,12,3.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00144,12,3.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00145,12,3.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00146,12,3.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00147,12,4.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00148,12,4.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00149,12,4.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00150,12,4.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00151,16,1.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00152,16,1.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00153,16,1.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00154,16,1.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00155,16,2.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00156,16,2.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00157,16,2.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00158,16,3.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00159,16,3.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00160,16,3.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00161,16,3.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00162,16,4.0,1,8,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00163,16,4.0,1,16,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00164,16,4.0,1,24,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00165,16,4.0,1,32,16,1,2,16,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00166,8,2.0,1,16,16,1,2,16,1,256,1.0,1.0,2.0,0.5,1.0,0.5,,false
+V00167,8,2.0,1,16,16,1,2,16,1,256,1.0,1.0,4.0,0.5,1.0,0.5,,false
+V00168,8,2.0,1,16,16,1,2,16,1,256,1.0,4.0,2.0,0.5,1.0,0.5,,false
+V00169,8,2.0,1,16,16,1,2,16,1,256,1.0,4.0,4.0,0.5,1.0,0.5,,false
+V00170,8,2.0,1,16,16,1,2,16,1,256,2.0,1.0,1.0,0.5,1.0,0.5,,false
+V00171,8,2.0,1,16,16,1,2,16,1,256,2.0,1.0,2.0,0.5,1.0,0.5,,false
+V00172,8,2.0,1,16,16,1,2,16,1,256,2.0,1.0,4.0,0.5,1.0,0.5,,false
+V00173,8,2.0,1,16,16,1,2,16,1,256,2.0,2.0,2.0,0.5,1.0,0.5,,false
+V00174,8,2.0,1,16,16,1,2,16,1,256,2.0,2.0,4.0,0.5,1.0,0.5,,false
+V00175,8,2.0,1,16,16,1,2,16,1,256,2.0,4.0,1.0,0.5,1.0,0.5,,false
+V00176,8,2.0,1,16,16,1,2,16,1,256,2.0,4.0,2.0,0.5,1.0,0.5,,false
+V00177,8,2.0,1,16,16,1,2,16,1,256,2.0,4.0,4.0,0.5,1.0,0.5,,false
+V00178,8,2.0,1,16,16,1,2,16,1,256,4.0,1.0,1.0,0.5,1.0,0.5,,false
+V00179,8,2.0,1,16,16,1,2,16,1,256,4.0,1.0,2.0,0.5,1.0,0.5,,false
+V00180,8,2.0,1,16,16,1,2,16,1,256,4.0,1.0,4.0,0.5,1.0,0.5,,false
+V00181,8,2.0,1,16,16,1,2,16,1,256,4.0,2.0,2.0,0.5,1.0,0.5,,false
+V00182,8,2.0,1,16,16,1,2,16,1,256,4.0,2.0,4.0,0.5,1.0,0.5,,false
+V00183,8,2.0,1,16,16,1,2,16,1,256,4.0,4.0,1.0,0.5,1.0,0.5,,false
+V00184,8,2.0,1,16,16,1,2,16,1,256,4.0,4.0,2.0,0.5,1.0,0.5,,false
+V00185,8,2.0,1,16,16,1,2,16,1,256,4.0,4.0,4.0,0.5,1.0,0.5,,false
+V00186,8,2.0,1,8,16,1,2,8,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00187,8,2.0,1,8,16,1,2,8,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00188,8,2.0,1,8,16,1,2,8,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00189,8,2.0,1,8,16,1,2,8,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00190,8,2.0,1,8,16,1,2,16,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00191,8,2.0,1,8,16,1,2,16,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00192,8,2.0,1,8,16,1,2,16,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00193,8,2.0,1,8,16,1,2,24,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00194,8,2.0,1,8,16,1,2,24,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00195,8,2.0,1,8,16,1,2,24,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00196,8,2.0,1,8,16,1,2,24,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00197,8,2.0,1,8,16,1,2,32,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00198,8,2.0,1,8,16,1,2,32,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00199,8,2.0,1,8,16,1,2,32,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00200,8,2.0,1,8,16,1,2,32,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00201,8,2.0,1,16,16,1,2,8,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00202,8,2.0,1,16,16,1,2,8,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00203,8,2.0,1,16,16,1,2,8,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00204,8,2.0,1,16,16,1,2,24,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00205,8,2.0,1,16,16,1,2,24,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00206,8,2.0,1,16,16,1,2,24,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00207,8,2.0,1,16,16,1,2,32,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00208,8,2.0,1,16,16,1,2,32,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00209,8,2.0,1,16,16,1,2,32,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00210,8,2.0,1,24,16,1,2,8,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00211,8,2.0,1,24,16,1,2,8,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00212,8,2.0,1,24,16,1,2,8,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00213,8,2.0,1,24,16,1,2,8,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00214,8,2.0,1,24,16,1,2,16,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00215,8,2.0,1,24,16,1,2,16,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00216,8,2.0,1,24,16,1,2,16,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00217,8,2.0,1,24,16,1,2,24,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00218,8,2.0,1,24,16,1,2,24,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00219,8,2.0,1,24,16,1,2,24,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00220,8,2.0,1,24,16,1,2,24,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00221,8,2.0,1,24,16,1,2,32,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00222,8,2.0,1,24,16,1,2,32,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00223,8,2.0,1,24,16,1,2,32,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00224,8,2.0,1,24,16,1,2,32,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00225,8,2.0,1,32,16,1,2,8,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00226,8,2.0,1,32,16,1,2,8,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00227,8,2.0,1,32,16,1,2,8,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00228,8,2.0,1,32,16,1,2,8,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00229,8,2.0,1,32,16,1,2,16,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00230,8,2.0,1,32,16,1,2,16,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00231,8,2.0,1,32,16,1,2,16,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00232,8,2.0,1,32,16,1,2,24,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00233,8,2.0,1,32,16,1,2,24,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00234,8,2.0,1,32,16,1,2,24,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00235,8,2.0,1,32,16,1,2,24,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00236,8,2.0,1,32,16,1,2,32,1,128,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00237,8,2.0,1,32,16,1,2,32,1,256,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00238,8,2.0,1,32,16,1,2,32,1,512,1.0,2.0,1.0,0.5,1.0,0.5,,false
+V00239,8,2.0,1,32,16,1,2,32,1,768,1.0,2.0,1.0,0.5,1.0,0.5,,false
diff --git a/nemo_retriever/src/nemo_retriever/__init__.py b/nemo_retriever/src/nemo_retriever/__init__.py
new file mode 100644
index 000000000..6a40b6948
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/__init__.py
@@ -0,0 +1,33 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Retriever application package."""
+
+from __future__ import annotations
+
+from .retriever import retriever as _retriever_cls
+
+__all__ = ["__version__", "create_ingestor", "get_version", "get_version_info", "ingestor", "retriever"]
+
+retriever = _retriever_cls()
+
+
+def __getattr__(name: str):
+    if name == "create_ingestor":
+        from .api import create_ingestor
+
+        return create_ingestor
+    if name in {"__version__", "get_version", "get_version_info"}:
+        from .version import __version__, get_version, get_version_info
+
+        return {
+            "__version__": __version__,
+            "get_version": get_version,
+            "get_version_info": get_version_info,
+        }[name]
+    if name == "ingestor":
+        from .ingestor import ingestor
+
+        return ingestor
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/nemo_retriever/src/nemo_retriever/__main__.py b/nemo_retriever/src/nemo_retriever/__main__.py
new file mode 100644
index 000000000..652df9193
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/__main__.py
@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from .adapters.cli.main import app, main
+
+__all__ = ["app", "main"]
diff --git a/nemo_retriever/src/nemo_retriever/_build_info.py b/nemo_retriever/src/nemo_retriever/_build_info.py
new file mode 100644
index 000000000..c446b4406
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/_build_info.py
@@ -0,0 +1,8 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Build metadata written by CI before packaging."""
+
+BUILD_GIT_SHA = "unknown"
+BUILD_DATE = "unknown"
diff --git a/nemo_retriever/src/nemo_retriever/adapters/__init__.py b/nemo_retriever/src/nemo_retriever/adapters/__init__.py
new file mode 100644
index 000000000..81fe18c18
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/adapters/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Adapter layer for external entry surfaces (CLI/service/integrations)."""
diff --git a/nemo_retriever/src/nemo_retriever/adapters/cli/__init__.py b/nemo_retriever/src/nemo_retriever/adapters/cli/__init__.py
new file mode 100644
index 000000000..f3ccf5c5d
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/adapters/cli/__init__.py
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .main import app, main
+
+__all__ = ["app", "main"]
diff --git a/nemo_retriever/src/nemo_retriever/adapters/cli/main.py b/nemo_retriever/src/nemo_retriever/adapters/cli/main.py
new file mode 100644
index 000000000..7ba8c7e80
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/adapters/cli/main.py
@@ -0,0 +1,60 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from nemo_retriever.audio import app as audio_app
+from nemo_retriever.utils.benchmark import app as benchmark_app
+from nemo_retriever.chart import app as chart_app
+from nemo_retriever.utils.compare import app as compare_app
+from nemo_retriever.html import __main__ as html_main
+from nemo_retriever.utils.image import app as image_app
+from nemo_retriever.local import app as local_app
+from nemo_retriever.online import __main__ as online_main
+from nemo_retriever.pdf import app as pdf_app
+from nemo_retriever.recall import app as recall_app
+from nemo_retriever.txt import __main__ as txt_main
+from nemo_retriever.vector_store import app as vector_store_app
+from nemo_retriever.version import get_version_info
+
+app = typer.Typer(help="Retriever")
+app.add_typer(audio_app, name="audio")
+app.add_typer(image_app, name="image")
+app.add_typer(pdf_app, name="pdf")
+app.add_typer(local_app, name="local")
+app.add_typer(chart_app, name="chart")
+app.add_typer(compare_app, name="compare")
+app.add_typer(benchmark_app, name="benchmark")
+app.add_typer(vector_store_app, name="vector-store")
+app.add_typer(recall_app, name="recall")
+app.add_typer(txt_main.app, name="txt")
+app.add_typer(html_main.app, name="html")
+app.add_typer(online_main.app, name="online")
+
+
+def _version_callback(value: bool) -> None:
+    if not value:
+        return
+    info = get_version_info()
+    typer.echo(info["full_version"])
+    raise typer.Exit()
+
+
+def main() -> None:
+    app()
+
+
+@app.callback()
+def _callback(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        help="Show retriever version metadata and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    )
+) -> None:
+    _ = version
diff --git a/nemo_retriever/src/nemo_retriever/adapters/service/__init__.py b/nemo_retriever/src/nemo_retriever/adapters/service/__init__.py
new file mode 100644
index 000000000..a71338f88
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/adapters/service/__init__.py
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Service adapters for API app and online CLI entrypoints."""
+
+__all__: list[str] = []
diff --git a/nemo_retriever/src/nemo_retriever/adapters/service/app.py b/nemo_retriever/src/nemo_retriever/adapters/service/app.py
new file mode 100644
index 000000000..b16b4e3f9
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/adapters/service/app.py
@@ -0,0 +1,101 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Ray Serve application integrated with FastAPI.
+"""
+
+from __future__ import annotations
+
+import json
+from io import BytesIO
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
+
+try:
+    from ray import serve
+except ImportError:
+    serve = None  # type: ignore[assignment]
+
+app = None
+
+if serve is not None:
+    from fastapi import FastAPI, File, HTTPException, UploadFile
+    from fastapi.responses import StreamingResponse
+
+    app = FastAPI(title="Retriever", description="Retriever online service")
+
+    # Max PDF size for stream-pdf (50 MiB)
+    STREAM_PDF_MAX_BYTES = 50 * 1024 * 1024
+
+    def _pdf_page_text_stream(pdf_bytes: bytes):
+        """Open PDF with pypdfium2 and yield (page_number_1based, text) for each page."""
+        import pypdfium2 as pdfium
+
+        try:
+            doc = pdfium.PdfDocument(pdf_bytes)
+        except Exception:
+            doc = pdfium.PdfDocument(BytesIO(pdf_bytes))
+        try:
+            for i in range(len(doc)):
+                page = doc.get_page(i)
+                tp = page.get_textpage()
+                text = tp.get_text_bounded()
+                if text is None:
+                    text = ""
+                yield (i + 1, text)
+        finally:
+            try:
+                doc.close()
+            except Exception:
+                pass
+
+    @app.get("/version")
+    def version() -> dict:
+        """Return the running application version and build metadata."""
+        try:
+            from nemo_retriever.version import get_version_info
+
+            return get_version_info()
+        except Exception:
+            return {"version": "unknown", "git_sha": "unknown", "build_date": "unknown", "full_version": "unknown"}
+
+    @app.post("/stream-pdf")
+    def stream_pdf(
+        file: UploadFile = File(..., description="PDF file to extract text from (page-by-page stream)."),
+    ):
+        """Stream back pdfium get_text (per page) as NDJSON. Accepts a PDF upload."""
+        if file.content_type and file.content_type not in (
+            "application/pdf",
+            "application/octet-stream",
+        ):
+            raise HTTPException(400, detail="Expected a PDF file (application/pdf).")
+        try:
+            import pypdfium2 as pdfium  # noqa: F401
+        except ImportError as e:
+            raise HTTPException(503, detail="PDF processing (pypdfium2) is not available.") from e
+
+        raw = file.file.read()
+        if len(raw) > STREAM_PDF_MAX_BYTES:
+            raise HTTPException(413, detail=f"PDF larger than {STREAM_PDF_MAX_BYTES // (1024 * 1024)} MiB not allowed.")
+
+        def ndjson_stream():
+            for page_num, text in _pdf_page_text_stream(raw):
+                line = json.dumps({"page": page_num, "text": text}, ensure_ascii=False) + "\n"
+                yield line.encode("utf-8")
+
+        return StreamingResponse(
+            ndjson_stream(),
+            media_type="application/x-ndjson",
+            headers={"Content-Disposition": "inline; filename=pages.ndjson"},
+        )
+
+    @serve.deployment(name="retriever_api", num_replicas=1, ray_actor_options={"num_cpus": 1})
+    @serve.ingress(app)
+    class RetrieverAPIDeployment:
+        """Ray Serve deployment that serves the FastAPI app."""
+
+        pass
diff --git a/nemo_retriever/src/nemo_retriever/adapters/service/cli.py b/nemo_retriever/src/nemo_retriever/adapters/service/cli.py
new file mode 100644
index 000000000..412b78cfa
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/adapters/service/cli.py
@@ -0,0 +1,127 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Online service CLI: start the Ray Serve + FastAPI REST API.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+
+app = typer.Typer(
+    help="Online service: Ray Serve + FastAPI REST API (serve) and CLI to submit documents (submit).",
+)
+
+
+@app.command("serve")
+def serve_cmd(
+    host: str = typer.Option("0.0.0.0", "--host", help="Bind host for the HTTP server."),
+    port: int = typer.Option(7670, "--port", help="Port for the HTTP server."),
+    ray_address: Optional[str] = typer.Option(None, "--ray-address", help="Ray cluster address (default: local)."),
+) -> None:
+    """Start the Retriever Ray Serve + FastAPI REST API (e.g. GET /version)."""
+    try:
+        import ray
+        from ray import serve
+        from ray.serve.config import HTTPOptions
+    except ImportError as e:
+        typer.echo(f"Ray Serve is required: {e}", err=True)
+        raise typer.Exit(1)
+
+    from nemo_retriever.adapters.service.app import RetrieverAPIDeployment
+
+    if ray_address:
+        ray.init(address=ray_address, ignore_reinit_error=True)
+    else:
+        ray.init(ignore_reinit_error=True)
+
+    serve.start(http_options=HTTPOptions(host=host, port=port))
+
+    serve.run(
+        RetrieverAPIDeployment.bind(),
+        name="retriever_api",
+        route_prefix="/",
+        blocking=True,
+    )
+
+
+@app.command("submit")
+def submit_cmd(
+    files: List[Path] = typer.Argument(
+        ...,
+        help="PDF files to submit (ingest endpoint not yet implemented).",
+        path_type=Path,
+        exists=True,
+    ),
+    base_url: str = typer.Option(
+        "http://localhost:7670",
+        "--base-url",
+        "-u",
+        help="Base URL of the running service.",
+    ),
+) -> None:
+    """Submit PDFs to the online ingest endpoint (not yet implemented). Use GET /version to check the service."""
+    _ = base_url
+    typer.echo("Submit (POST /ingest) is not yet implemented. Use GET /version to verify the service is running.")
+    for path in files:
+        typer.echo(f"  Would submit: {path}")
+    sys.exit(0)
+
+
+@app.command("stream-pdf")
+def stream_pdf_cmd(
+    files: List[Path] = typer.Argument(
+        ...,
+        help="PDF files to stream (POST /stream-pdf, print NDJSON per page).",
+        path_type=Path,
+        exists=True,
+    ),
+    base_url: str = typer.Option(
+        "http://localhost:7670",
+        "--base-url",
+        "-u",
+        help="Base URL of the running service.",
+    ),
+) -> None:
+    """Submit PDFs to POST /stream-pdf and print the streaming page-by-page text (NDJSON)."""
+    import requests
+
+    url = f"{base_url.rstrip('/')}/stream-pdf"
+    for path in files:
+        path = path.resolve()
+        typer.echo(f"--- {path} ---", err=True)
+        try:
+            with path.open("rb") as file_handle:
+                response = requests.post(
+                    url,
+                    files={"file": (path.name, file_handle, "application/pdf")},
+                    stream=True,
+                    timeout=60,
+                )
+            response.raise_for_status()
+            for line in response.iter_lines(decode_unicode=True):
+                if not line:
+                    continue
+                try:
+                    obj = json.loads(line)
+                    page = obj.get("page", "?")
+                    text = obj.get("text", "")
+                    typer.echo(f"Page {page}:")
+                    typer.echo(text if text else "(no text)")
+                except json.JSONDecodeError:
+                    typer.echo(line)
+        except requests.RequestException as e:
+            typer.echo(f"Error: {e}", err=True)
+            sys.exit(1)
+        typer.echo("", err=True)
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/api/__init__.py b/nemo_retriever/src/nemo_retriever/api/__init__.py
new file mode 100644
index 000000000..fc16fb19b
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/api/__init__.py
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .ingestor import Ingestor, RunMode, create_ingestor
+
+__all__ = ["Ingestor", "RunMode", "create_ingestor"]
diff --git a/nemo_retriever/src/nemo_retriever/api/ingestor.py b/nemo_retriever/src/nemo_retriever/api/ingestor.py
new file mode 100644
index 000000000..43323e2d9
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/api/ingestor.py
@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from ..ingestor import Ingestor, RunMode, create_ingestor
+
+__all__ = ["Ingestor", "RunMode", "create_ingestor"]
diff --git a/nemo_retriever/src/nemo_retriever/application/__init__.py b/nemo_retriever/src/nemo_retriever/application/__init__.py
new file mode 100644
index 000000000..d8a5510da
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/__init__.py
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Application layer (pipeline and runmode orchestration)."""
+
+__all__: list[str] = []
diff --git a/nemo_retriever/src/nemo_retriever/application/modes/__init__.py b/nemo_retriever/src/nemo_retriever/application/modes/__init__.py
new file mode 100644
index 000000000..a4ca36132
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/modes/__init__.py
@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .executor import run_mode_ingest
+from .factory import RunMode, create_runmode_ingestor
+from .run_batch import run_batch
+from .run_fused import run_fused
+from .run_inprocess import run_inprocess
+from .run_online import run_online
+
+__all__ = [
+    "RunMode",
+    "create_runmode_ingestor",
+    "run_mode_ingest",
+    "run_batch",
+    "run_fused",
+    "run_inprocess",
+    "run_online",
+]
diff --git a/nemo_retriever/src/nemo_retriever/application/modes/executor.py b/nemo_retriever/src/nemo_retriever/application/modes/executor.py
new file mode 100644
index 000000000..b95d4e150
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/modes/executor.py
@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+from nemo_retriever.params import RunMode
+
+from .factory import create_runmode_ingestor
+
+
+def run_mode_ingest(
+    *,
+    run_mode: RunMode,
+    create_params: IngestorCreateParams | None = None,
+    ingest_params: IngestExecuteParams | None = None,
+) -> object:
+    ingestor = create_runmode_ingestor(run_mode=run_mode, params=create_params)
+    return ingestor.ingest(params=ingest_params)
diff --git a/nemo_retriever/src/nemo_retriever/application/modes/factory.py b/nemo_retriever/src/nemo_retriever/application/modes/factory.py
new file mode 100644
index 000000000..fdb4ffd60
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/modes/factory.py
@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.params import IngestorCreateParams
+from nemo_retriever.params import RunMode
+
+
+def create_runmode_ingestor(*, run_mode: RunMode = "inprocess", params: IngestorCreateParams | None = None):
+    p = params or IngestorCreateParams()
+    if run_mode == "inprocess":
+        from nemo_retriever.ingest_modes.inprocess import InProcessIngestor
+
+        return InProcessIngestor(documents=p.documents)
+    if run_mode == "batch":
+        from nemo_retriever.ingest_modes.batch import BatchIngestor
+
+        return BatchIngestor(
+            documents=p.documents,
+            ray_address=p.ray_address,
+            ray_log_to_driver=p.ray_log_to_driver,
+        )
+    if run_mode == "fused":
+        from nemo_retriever.ingest_modes.fused import FusedIngestor
+
+        return FusedIngestor(
+            documents=p.documents,
+            ray_address=p.ray_address,
+            ray_log_to_driver=p.ray_log_to_driver,
+        )
+    if run_mode == "online":
+        from nemo_retriever.ingest_modes.online import OnlineIngestor
+
+        return OnlineIngestor(documents=p.documents, base_url=p.base_url)
+    raise ValueError(f"Unknown run_mode: {run_mode!r}")
diff --git a/nemo_retriever/src/nemo_retriever/application/modes/run_batch.py b/nemo_retriever/src/nemo_retriever/application/modes/run_batch.py
new file mode 100644
index 000000000..affa968a8
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/modes/run_batch.py
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+
+from .executor import run_mode_ingest
+
+
+def run_batch(
+    *,
+    create_params: IngestorCreateParams | None = None,
+    ingest_params: IngestExecuteParams | None = None,
+) -> object:
+    return run_mode_ingest(run_mode="batch", create_params=create_params, ingest_params=ingest_params)
diff --git a/nemo_retriever/src/nemo_retriever/application/modes/run_fused.py b/nemo_retriever/src/nemo_retriever/application/modes/run_fused.py
new file mode 100644
index 000000000..a5496bc44
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/modes/run_fused.py
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+
+from .executor import run_mode_ingest
+
+
+def run_fused(
+    *,
+    create_params: IngestorCreateParams | None = None,
+    ingest_params: IngestExecuteParams | None = None,
+) -> object:
+    return run_mode_ingest(run_mode="fused", create_params=create_params, ingest_params=ingest_params)
diff --git a/nemo_retriever/src/nemo_retriever/application/modes/run_inprocess.py b/nemo_retriever/src/nemo_retriever/application/modes/run_inprocess.py
new file mode 100644
index 000000000..b9ed663cf
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/modes/run_inprocess.py
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+
+from .executor import run_mode_ingest
+
+
+def run_inprocess(
+    *,
+    create_params: IngestorCreateParams | None = None,
+    ingest_params: IngestExecuteParams | None = None,
+) -> object:
+    return run_mode_ingest(run_mode="inprocess", create_params=create_params, ingest_params=ingest_params)
diff --git a/nemo_retriever/src/nemo_retriever/application/modes/run_online.py b/nemo_retriever/src/nemo_retriever/application/modes/run_online.py
new file mode 100644
index 000000000..7c95a7d0e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/modes/run_online.py
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+
+from .executor import run_mode_ingest
+
+
+def run_online(
+    *,
+    create_params: IngestorCreateParams | None = None,
+    ingest_params: IngestExecuteParams | None = None,
+) -> object:
+    return run_mode_ingest(run_mode="online", create_params=create_params, ingest_params=ingest_params)
diff --git a/nemo_retriever/src/nemo_retriever/application/pipeline/__init__.py b/nemo_retriever/src/nemo_retriever/application/pipeline/__init__.py
new file mode 100644
index 000000000..911e6e665
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/pipeline/__init__.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .build_plan import build_stage_plan
+from .contracts import StageContract, StageProcessor, validate_stage_input
+from .run_plan import run_stage_plan
+from .stage_registry import STAGE_REGISTRY
+
+__all__ = [
+    "STAGE_REGISTRY",
+    "StageContract",
+    "StageProcessor",
+    "build_stage_plan",
+    "run_stage_plan",
+    "validate_stage_input",
+]
diff --git a/nemo_retriever/src/nemo_retriever/application/pipeline/build_plan.py b/nemo_retriever/src/nemo_retriever/application/pipeline/build_plan.py
new file mode 100644
index 000000000..a1986b9ea
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/pipeline/build_plan.py
@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any, Dict, Iterable, List, Sequence, Tuple
+
+from .stage_registry import STAGE_REGISTRY
+
+StagePlan = List[Tuple[str, Dict[str, Any]]]
+
+
+def build_stage_plan(stage_names: Sequence[str], *, stage_kwargs: Dict[str, Dict[str, Any]] | None = None) -> StagePlan:
+    stage_kwargs = stage_kwargs or {}
+    plan: StagePlan = []
+    for stage_name in stage_names:
+        if stage_name not in STAGE_REGISTRY:
+            raise ValueError(f"Unknown stage '{stage_name}'. Registered stages: {sorted(STAGE_REGISTRY)}")
+        plan.append((stage_name, dict(stage_kwargs.get(stage_name, {}))))
+    return plan
+
+
+def stage_names_from_flags(
+    *,
+    extract_infographics: bool = False,
+    extract_tables: bool = False,
+    extract_charts: bool = False,
+    embed_text: bool = False,
+) -> Iterable[str]:
+    if extract_infographics:
+        yield "enrich_infographic"
+    if extract_tables:
+        yield "enrich_table"
+    if extract_charts:
+        yield "enrich_chart"
+    if embed_text:
+        yield "embed_text"
diff --git a/nemo_retriever/src/nemo_retriever/application/pipeline/contracts.py b/nemo_retriever/src/nemo_retriever/application/pipeline/contracts.py
new file mode 100644
index 000000000..8c7937b9d
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/pipeline/contracts.py
@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, Protocol, Tuple
+
+import pandas as pd
+
+
+class StageProcessor(Protocol):
+    def __call__(
+        self, df_primitives: pd.DataFrame, params: Any | None = None
+    ) -> Tuple[pd.DataFrame, Dict[str, Any]]: ...
+
+
+@dataclass(frozen=True)
+class StageContract:
+    name: str
+    required_input_columns: tuple[str, ...] = ("metadata",)
+
+
+DEFAULT_STAGE_CONTRACT = StageContract(name="primitives-stage")
+
+
+def validate_stage_input(df_primitives: pd.DataFrame, contract: StageContract = DEFAULT_STAGE_CONTRACT) -> None:
+    missing = [column for column in contract.required_input_columns if column not in df_primitives.columns]
+    if missing:
+        raise KeyError(f"Stage '{contract.name}' requires missing columns: {missing}")
diff --git a/nemo_retriever/src/nemo_retriever/application/pipeline/run_plan.py b/nemo_retriever/src/nemo_retriever/application/pipeline/run_plan.py
new file mode 100644
index 000000000..e275f6b5b
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/pipeline/run_plan.py
@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Tuple
+
+import pandas as pd
+
+from .contracts import StageContract, validate_stage_input
+
+from .stage_registry import STAGE_REGISTRY
+
+
+def run_stage_plan(
+    df: pd.DataFrame, stage_plan: List[Tuple[str, Dict[str, Any]]]
+) -> tuple[pd.DataFrame, Dict[str, Any]]:
+    validate_stage_input(df, StageContract(name="pipeline-entry"))
+    current_df = df
+    stage_info: Dict[str, Any] = {}
+
+    for stage_name, kwargs in stage_plan:
+        handler = STAGE_REGISTRY[stage_name]
+        current_df, info = handler(current_df, **kwargs)
+        stage_info[stage_name] = info
+
+    return current_df, stage_info
diff --git a/nemo_retriever/src/nemo_retriever/application/pipeline/stage_registry.py b/nemo_retriever/src/nemo_retriever/application/pipeline/stage_registry.py
new file mode 100644
index 000000000..b426e5405
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/application/pipeline/stage_registry.py
@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any, Callable, Dict
+
+from nemo_retriever.chart.processor import extract_chart_data_from_primitives_df
+from nemo_retriever.infographic.processor import extract_infographic_data_from_primitives_df
+from nemo_retriever.table.processor import extract_table_data_from_primitives_df
+from nemo_retriever.text_embed.processor import embed_text_from_primitives_df
+
+StageHandler = Callable[..., Any]
+
+# Registry can be extended by future package integrations without changing
+# pipeline orchestration internals.
+STAGE_REGISTRY: Dict[str, StageHandler] = {
+    "enrich_infographic": extract_infographic_data_from_primitives_df,
+    "enrich_table": extract_table_data_from_primitives_df,
+    "enrich_chart": extract_chart_data_from_primitives_df,
+    "embed_text": embed_text_from_primitives_df,
+}
diff --git a/nemo_retriever/src/nemo_retriever/audio/__init__.py b/nemo_retriever/src/nemo_retriever/audio/__init__.py
new file mode 100644
index 000000000..a84da1435
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/audio/__init__.py
@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Audio pipeline: media chunking (MediaChunkActor) and ASR (ASRActor).
+
+Provides the same semantics as nv-ingest-api dataloader + Parakeet for
+batch, inprocess, fused, and online run modes.
+"""
+
+from __future__ import annotations
+
+from nemo_retriever.audio.asr_actor import ASRActor
+from nemo_retriever.audio.asr_actor import asr_params_from_env
+from nemo_retriever.audio.chunk_actor import MediaChunkActor
+from nemo_retriever.audio.media_interface import MediaInterface
+from nemo_retriever.params import ASRParams
+from nemo_retriever.params import AudioChunkParams
+
+from .cli import app
+
+__all__ = [
+    "ASRActor",
+    "ASRParams",
+    "app",
+    "asr_params_from_env",
+    "AudioChunkParams",
+    "MediaChunkActor",
+    "MediaInterface",
+]
diff --git a/nemo_retriever/src/nemo_retriever/audio/__main__.py b/nemo_retriever/src/nemo_retriever/audio/__main__.py
new file mode 100644
index 000000000..dd2257cad
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/audio/__main__.py
@@ -0,0 +1,12 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Entrypoint for `python -m nemo_retriever.audio`. Do not import this from the package __init__."""
+
+from __future__ import annotations
+
+from .cli import app
+
+if __name__ == "__main__":
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/audio/asr_actor.py b/nemo_retriever/src/nemo_retriever/audio/asr_actor.py
new file mode 100644
index 000000000..019df4761
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/audio/asr_actor.py
@@ -0,0 +1,245 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+ASRActor: Ray Data map_batches callable for speech-to-text.
+
+Supports remote (Parakeet/Riva gRPC) or local (HuggingFace nvidia/parakeet-ctc-1.1b).
+When audio_endpoints are both null/empty, uses local model; otherwise uses remote client.
+
+Consumes chunk rows (path, bytes, source_path, duration, chunk_index, metadata)
+and produces rows with text (transcript) for downstream embed/VDB.
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from nemo_retriever.params import ASRParams
+
+
+def _use_remote(params: ASRParams) -> bool:
+    """True if at least one of audio_endpoints is set (use remote gRPC client)."""
+    grpc = (params.audio_endpoints[0] or "").strip()
+    http = (params.audio_endpoints[1] or "").strip()
+    return bool(grpc or http)
+
+
+logger = logging.getLogger(__name__)
+
+# Default NGC/NVCF Parakeet gRPC endpoint when using cloud ASR
+DEFAULT_NGC_ASR_GRPC_ENDPOINT = "grpc.nvcf.nvidia.com:443"
+# Default NVCF function ID for Parakeet NIM (same as nv-ingest default_libmode_pipeline_impl)
+DEFAULT_NGC_ASR_FUNCTION_ID = "1598d209-5e27-4d3c-8079-4751568b1081"
+
+
+def asr_params_from_env(
+    *,
+    grpc_endpoint_var: str = "AUDIO_GRPC_ENDPOINT",
+    auth_token_var: str = "NGC_API_KEY",
+    function_id_var: str = "AUDIO_FUNCTION_ID",
+    default_grpc_endpoint: Optional[str] = DEFAULT_NGC_ASR_GRPC_ENDPOINT,
+    default_function_id: Optional[str] = DEFAULT_NGC_ASR_FUNCTION_ID,
+) -> ASRParams:
+    """
+    Build ASRParams from environment variables for cloud/NGC ASR.
+
+    - AUDIO_GRPC_ENDPOINT: gRPC endpoint (default: grpc.nvcf.nvidia.com:443 for NGC).
+    - NGC_API_KEY: Bearer token for NGC/NVCF (required for cloud).
+    - AUDIO_FUNCTION_ID: NVCF function ID for the Parakeet NIM (default: same as nv-ingest libmode).
+
+    Returns ASRParams with auth_token and function_id set from env when present.
+    When NGC_API_KEY is set but AUDIO_FUNCTION_ID is not, uses the nv-ingest default Parakeet NIM function ID.
+    Local ASR always uses the transformers backend (nvidia/parakeet-ctc-1.1b).
+    """
+    import os
+
+    auth_token = (os.environ.get(auth_token_var) or "").strip() or None
+    function_id = (os.environ.get(function_id_var) or "").strip() or None
+    if auth_token and function_id is None and default_function_id:
+        function_id = default_function_id
+
+    # Only use remote (NGC) endpoint when credentials are set; otherwise use local Parakeet.
+    grpc_from_env = (os.environ.get(grpc_endpoint_var) or "").strip()
+    if grpc_from_env:
+        grpc_endpoint = grpc_from_env
+    elif auth_token or function_id:
+        grpc_endpoint = default_grpc_endpoint or ""
+    else:
+        grpc_endpoint = ""  # Local ASR (nvidia/parakeet-ctc-1.1b via Transformers)
+
+    return ASRParams(
+        audio_endpoints=(grpc_endpoint or None, None),
+        audio_infer_protocol="grpc",
+        function_id=function_id,
+        auth_token=auth_token,
+    )
+
+
+try:
+    from nv_ingest_api.internal.primitives.nim.model_interface.parakeet import (
+        create_audio_inference_client,
+    )
+
+    _PARAKEET_AVAILABLE = True
+except ImportError:
+    create_audio_inference_client = None  # type: ignore[misc, assignment]
+    _PARAKEET_AVAILABLE = False
+
+
+def _get_client(params: ASRParams):  # noqa: ANN201
+    if not _PARAKEET_AVAILABLE or create_audio_inference_client is None:
+        raise RuntimeError(
+            "ASRActor requires nv-ingest-api (Parakeet client). "
+            "Install with: pip install nv-ingest-api (or add nv-ingest-api to dependencies)."
+        )
+    grpc_endpoint = (params.audio_endpoints[0] or "").strip() or None
+    http_endpoint = (params.audio_endpoints[1] or "").strip() or None
+    if not grpc_endpoint:
+        raise ValueError(
+            "ASR audio_endpoints[0] (gRPC) must be set for Parakeet (e.g. localhost:50051 or grpc.nvcf.nvidia.com:443)."
+        )
+    return create_audio_inference_client(
+        (grpc_endpoint, http_endpoint or ""),
+        infer_protocol=params.audio_infer_protocol or "grpc",
+        auth_token=params.auth_token,
+        function_id=params.function_id,
+        use_ssl=bool("nvcf.nvidia.com" in grpc_endpoint and params.function_id),
+        ssl_cert=None,
+    )
+
+
+class ASRActor:
+    """
+    Ray Data map_batches callable: chunk rows (path/bytes) -> rows with text (transcript).
+
+    When audio_endpoints are set, uses Parakeet (Riva ASR) via gRPC. When both are
+    null/empty, uses local HuggingFace/NeMo Parakeet (nvidia/parakeet-ctc-1.1b).
+    Output rows have path, text, page_number, metadata for downstream embed.
+    """
+
+    def __init__(self, params: ASRParams | None = None) -> None:
+        self._params = params or ASRParams()
+        if _use_remote(self._params):
+            self._client = _get_client(self._params)
+            self._model = None
+        else:
+            self._client = None
+            from nemo_retriever.model.local import ParakeetCTC1B1ASR
+
+            self._model = ParakeetCTC1B1ASR()
+
+    def __call__(self, batch_df: pd.DataFrame) -> pd.DataFrame:
+        if not isinstance(batch_df, pd.DataFrame) or batch_df.empty:
+            return pd.DataFrame(
+                columns=["path", "source_path", "duration", "chunk_index", "metadata", "page_number", "text"]
+            )
+
+        out_rows: List[Dict[str, Any]] = []
+        for _, row in batch_df.iterrows():
+            try:
+                out_row = self._transcribe_one(row)
+                if out_row is not None:
+                    out_rows.append(out_row)
+            except Exception as e:
+                logger.exception("ASR failed for row path=%s: %s", row.get("path"), e)
+                continue
+
+        if not out_rows:
+            return pd.DataFrame(
+                columns=["path", "source_path", "duration", "chunk_index", "metadata", "page_number", "text"]
+            )
+        return pd.DataFrame(out_rows)
+
+    def _transcribe_remote(self, raw: bytes, path: Optional[str]) -> Optional[str]:
+        """Use remote gRPC client to transcribe audio bytes."""
+        audio_b64 = base64.b64encode(raw).decode("ascii")
+        try:
+            segments, transcript = self._client.infer(
+                audio_b64,
+                model_name="parakeet",
+            )
+            return transcript if transcript else ""
+        except Exception as e:
+            logger.warning("Parakeet infer failed for path=%s: %s", path, e)
+            return None
+
+    def _transcribe_local(self, raw: bytes, path: Optional[str]) -> Optional[str]:
+        """Use local Parakeet model to transcribe; path or temp file with raw bytes."""
+        if self._model is None:
+            return None
+        path_to_use = path
+        if not path_to_use or not Path(path_to_use).exists():
+            # Raw bytes: write to temp file (format detected by loader/ffmpeg)
+            with tempfile.NamedTemporaryFile(suffix=".audio", delete=False) as f:
+                f.write(raw)
+                path_to_use = f.name
+            try:
+                transcripts = self._model.transcribe([path_to_use])
+                return transcripts[0] if transcripts else ""
+            finally:
+                Path(path_to_use).unlink(missing_ok=True)
+        else:
+            transcripts = self._model.transcribe([path_to_use])
+            return transcripts[0] if transcripts else ""
+
+    def _transcribe_one(self, row: pd.Series) -> Optional[Dict[str, Any]]:
+        raw = row.get("bytes")
+        path = row.get("path")
+        if raw is None and path:
+            try:
+                with open(path, "rb") as f:
+                    raw = f.read()
+            except Exception as e:
+                logger.warning("Could not read %s: %s", path, e)
+                return None
+        if raw is None:
+            return None
+
+        if self._client is not None:
+            transcript = self._transcribe_remote(raw, path)
+        else:
+            transcript = self._transcribe_local(raw, path)
+
+        if transcript is None:
+            return None
+        source_path = row.get("source_path", path)
+        duration = row.get("duration")
+        chunk_index = row.get("chunk_index", 0)
+        metadata = row.get("metadata")
+        if not isinstance(metadata, dict):
+            metadata = {"source_path": source_path, "chunk_index": chunk_index, "duration": duration}
+        page_number = row.get("page_number", chunk_index)
+
+        return {
+            "path": path,
+            "source_path": source_path,
+            "duration": duration,
+            "chunk_index": chunk_index,
+            "metadata": metadata,
+            "page_number": page_number,
+            "text": transcript,
+        }
+
+
+def apply_asr_to_df(
+    batch_df: pd.DataFrame,
+    asr_params: Optional[dict] = None,
+    **kwargs: Any,
+) -> pd.DataFrame:
+    """
+    Inprocess helper: apply ASR to a DataFrame of chunk rows; returns DataFrame with text column set.
+
+    Used by InProcessIngestor when _pipeline_type == "audio". asr_params can be a dict
+    to construct ASRParams (e.g. from model_dump()).
+    """
+    params = ASRParams(**(asr_params or {}))
+    actor = ASRActor(params=params)
+    return actor(batch_df)
diff --git a/nemo_retriever/src/nemo_retriever/audio/chunk_actor.py b/nemo_retriever/src/nemo_retriever/audio/chunk_actor.py
new file mode 100644
index 000000000..5e73c5b2c
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/audio/chunk_actor.py
@@ -0,0 +1,133 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+MediaChunkActor: Ray Data map_batches callable for audio/video chunking.
+
+Consumes rows from rd.read_binary_files (path, bytes) and produces one row
+per chunk with path, source_path, duration, chunk_index, metadata.
+"""
+
+from __future__ import annotations
+
+import logging
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List
+
+import pandas as pd
+
+from nemo_retriever.audio.media_interface import MediaInterface
+from nemo_retriever.audio.media_interface import is_media_available
+from nemo_retriever.params import AudioChunkParams
+
+logger = logging.getLogger(__name__)
+
+# Output columns for downstream (ASR, embed, VDB). bytes optional for in-memory pipeline.
+CHUNK_COLUMNS = ["path", "source_path", "duration", "chunk_index", "metadata", "page_number", "bytes"]
+
+
+class MediaChunkActor:
+    """
+    Ray Data map_batches callable: DataFrame with path, bytes -> DataFrame of chunk rows.
+
+    Each output row has: path (chunk file), source_path, duration, chunk_index,
+    metadata (dict with source_path, chunk_index, duration), page_number (= chunk_index).
+    """
+
+    def __init__(self, params: AudioChunkParams | None = None) -> None:
+        if not is_media_available():
+            raise RuntimeError(
+                "MediaChunkActor requires ffmpeg. Install with: pip install ffmpeg-python and system ffmpeg."
+            )
+        self._params = params or AudioChunkParams()
+        self._interface = MediaInterface()
+
+    def __call__(self, batch_df: pd.DataFrame) -> pd.DataFrame:
+        if not isinstance(batch_df, pd.DataFrame) or batch_df.empty:
+            return pd.DataFrame(columns=CHUNK_COLUMNS)
+
+        out_rows: List[Dict[str, Any]] = []
+        for _, row in batch_df.iterrows():
+            path = row.get("path")
+            if path is None:
+                continue
+            path_str = str(path)
+            if not path_str.strip():
+                continue
+            try:
+                chunk_rows = _chunk_one(path_str, self._params, self._interface)
+                out_rows.extend(chunk_rows)
+            except Exception as e:
+                logger.exception("Error chunking %s: %s", path_str, e)
+                continue
+
+        if not out_rows:
+            return pd.DataFrame(columns=CHUNK_COLUMNS)
+        return pd.DataFrame(out_rows)
+
+
+def _chunk_one(source_path: str, params: AudioChunkParams, interface: MediaInterface) -> List[Dict[str, Any]]:
+    """Run split for one file and return list of row dicts."""
+    with tempfile.TemporaryDirectory(prefix="retriever_audio_chunk_") as tmpdir:
+        files = interface.split(
+            source_path,
+            tmpdir,
+            split_interval=params.split_interval,
+            split_type=params.split_type,
+            video_audio_separate=params.video_audio_separate,
+            audio_only=params.audio_only,
+        )
+        if not files:
+            return []
+
+        rows: List[Dict[str, Any]] = []
+        for idx, chunk_path in enumerate(files):
+            _, _, duration = interface.probe_media(
+                Path(chunk_path),
+                params.split_interval,
+                params.split_type,
+            )
+            duration = duration if duration is not None else 0.0
+            meta = {
+                "source_path": source_path,
+                "chunk_index": idx,
+                "duration": duration,
+            }
+            chunk_bytes: bytes
+            try:
+                with open(chunk_path, "rb") as f:
+                    chunk_bytes = f.read()
+            except Exception as e:
+                logger.warning("Could not read chunk %s: %s", chunk_path, e)
+                continue
+            rows.append(
+                {
+                    "path": chunk_path,
+                    "source_path": source_path,
+                    "duration": duration,
+                    "chunk_index": idx,
+                    "metadata": meta,
+                    "page_number": idx,
+                    "bytes": chunk_bytes,
+                }
+            )
+        return rows
+
+
+def audio_path_to_chunks_df(path: str, params: AudioChunkParams | None = None) -> pd.DataFrame:
+    """
+    Synchronous loader: one media file path -> DataFrame of chunk rows (path, source_path, duration, chunk_index,
+    metadata, page_number, bytes).
+
+    Used by inprocess ingest() when _pipeline_type == "audio".
+    """
+    if not is_media_available():
+        raise RuntimeError("audio_path_to_chunks_df requires ffmpeg.")
+    params = params or AudioChunkParams()
+    interface = MediaInterface()
+    rows = _chunk_one(path, params, interface)
+    if not rows:
+        return pd.DataFrame(columns=CHUNK_COLUMNS)
+    return pd.DataFrame(rows)
diff --git a/nemo_retriever/src/nemo_retriever/audio/cli.py b/nemo_retriever/src/nemo_retriever/audio/cli.py
new file mode 100644
index 000000000..1dbb6ee6d
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/audio/cli.py
@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Audio extraction CLI (chunk + ASR, write *.audio_extraction.json sidecars).
+
+This module intentionally contains **no configuration logic**. It simply re-exports the
+`nemo_retriever.audio.stage` Typer application so any arguments provided to:
+
+  `retriever audio ...`
+
+are handled exactly the same as the stage commands (e.g. `extract`, `discover`).
+"""
+
+from __future__ import annotations
+
+from nemo_retriever.audio.stage import app as app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/audio/media_interface.py b/nemo_retriever/src/nemo_retriever/audio/media_interface.py
new file mode 100644
index 000000000..a06bc9e3a
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/audio/media_interface.py
@@ -0,0 +1,240 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Shared media (audio/video) chunking logic for the retriever.
+
+Minimal copy of ffmpeg/ffprobe and MediaInterface semantics from
+nv-ingest-api dataloader so the retriever stays self-contained.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import math
+import os
+import shutil
+import subprocess
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, List, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+try:
+    import ffmpeg
+
+    _FFMPEG_AVAILABLE = True
+except Exception:
+    ffmpeg = None  # type: ignore[assignment]
+    _FFMPEG_AVAILABLE = False
+
+
+class SplitType:
+    """Split strategy for media; values match nv-ingest-api."""
+
+    SIZE = "size"
+    TIME = "time"
+    FRAME = "frame"
+
+
+def _probe(
+    filename: str,
+    format: Optional[str] = None,
+    file_handle: Any = None,
+    timeout: Optional[float] = None,
+    **kwargs: Any,
+) -> Any:
+    if not _FFMPEG_AVAILABLE or ffmpeg is None:
+        raise RuntimeError("ffmpeg is required for media probing; install ffmpeg-python and system ffmpeg.")
+    args = ["ffprobe", "-show_format", "-show_streams", "-of", "json"]
+    args += ffmpeg._utils.convert_kwargs_to_cmd_line_args(kwargs)
+    if file_handle:
+        args += ["pipe:"]
+    else:
+        args += [filename]
+    p = subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    communicate_kwargs: dict = {}
+    if timeout is not None:
+        communicate_kwargs["timeout"] = timeout
+    if file_handle:
+        communicate_kwargs["input"] = file_handle
+    out, err = p.communicate(**communicate_kwargs)
+    if p.returncode != 0:
+        raise ffmpeg._run.Error("ffprobe", out, err)
+    return json.loads(out.decode("utf-8"))
+
+
+def _get_audio_from_video(input_path: str, output_file: str, cache_path: Optional[str] = None) -> Optional[Path]:
+    """Extract audio from a video file. Returns output Path or None on failure."""
+    if not _FFMPEG_AVAILABLE or ffmpeg is None:
+        raise RuntimeError("ffmpeg is required; install ffmpeg-python and system ffmpeg.")
+    output_path = Path(output_file)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        (
+            ffmpeg.input(str(input_path))
+            .output(str(output_path), acodec="libmp3lame", map="0:a")
+            .overwrite_output()
+            .run(capture_stdout=True, capture_stderr=True)
+        )
+        return output_path
+    except ffmpeg.Error as e:
+        logger.error("FFmpeg error for file %s: %s", input_path, e.stderr.decode())
+        return None
+
+
+def _effective_cores() -> int:
+    return int(max((os.cpu_count() or 4) * 0.2, 4))
+
+
+class _LoaderInterface(ABC):
+    @abstractmethod
+    def split(self, input_path: str, output_dir: str, split_interval: int = 0) -> Any:
+        pass
+
+    @abstractmethod
+    def _get_path_metadata(self, path: Optional[str] = None) -> Any:
+        pass
+
+
+class MediaInterface(_LoaderInterface):
+    """Split and probe media files (audio/video) using ffmpeg/ffprobe."""
+
+    def __init__(self) -> None:
+        self.path_metadata: dict = {}
+
+    def probe_media(
+        self,
+        path_file: Path,
+        split_interval: int,
+        split_type: str,
+        file_handle: Any = None,
+    ) -> Tuple[Optional[Any], Optional[float], Optional[float]]:
+        """Return (probe, num_splits, duration)."""
+        num_splits = None
+        duration = None
+        probe = None
+        try:
+            file_size = path_file.stat().st_size
+            if file_handle:
+                probe = _probe("pipe:", format=path_file.suffix, file_handle=file_handle)
+            else:
+                probe = _probe(str(path_file), format=path_file.suffix)
+            if probe["streams"][0]["codec_type"] == "video":
+                sample_rate = float(probe["streams"][0]["avg_frame_rate"].split("/")[0])
+                duration = float(probe["format"]["duration"])
+            elif probe["streams"][0]["codec_type"] == "audio":
+                sample_rate = float(probe["streams"][0]["sample_rate"])
+                bitrate = probe["format"]["bit_rate"]
+                duration = (file_size * 8) / float(bitrate)
+            else:
+                raise ValueError(f"Unknown codec_type: {probe['streams'][0]}")
+            num_splits = self.find_num_splits(file_size, sample_rate, duration, split_interval, split_type)
+        except ffmpeg.Error as e:
+            logger.error("FFmpeg error for file %s: %s", path_file, e.stderr.decode())
+        except ValueError as e:
+            logger.error("Error finding splits for file %s: %s", path_file, e)
+        return (probe, num_splits, duration)
+
+    def get_audio_from_video(
+        self,
+        input_path: str,
+        output_file: str,
+        cache_path: Optional[str] = None,
+    ) -> Optional[Path]:
+        return _get_audio_from_video(input_path, output_file, cache_path)
+
+    def split(
+        self,
+        input_path: str,
+        output_dir: str,
+        split_interval: int = 0,
+        split_type: str = SplitType.SIZE,
+        cache_path: Optional[str] = None,
+        video_audio_separate: bool = False,
+        audio_only: bool = False,
+    ) -> List[str]:
+        """Split media into chunk files. Returns list of chunk file paths."""
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        original_input_path = input_path
+        path_input = Path(input_path)
+        if audio_only and path_input.suffix.lower() in [".mp4", ".mov", ".avi", ".mkv"]:
+            out_mp3 = output_dir / f"{path_input.stem}.mp3"
+            result = self.get_audio_from_video(str(input_path), str(out_mp3), cache_path)
+            if result is None:
+                return []
+            input_path = str(result)
+        path_file = Path(input_path)
+        file_name = path_file.stem
+        suffix = path_file.suffix
+        output_pattern = output_dir / f"{file_name}_chunk_%04d{suffix}"
+        num_splits = 0
+        cache_path = cache_path or output_dir
+        try:
+            probe, num_splits, duration = self.probe_media(path_file, split_interval, split_type)
+            if num_splits is None or duration is None or num_splits <= 0:
+                return []
+            segment_time = math.ceil(duration / num_splits)
+            output_kwargs = {
+                "f": "segment",
+                "segment_time": segment_time,
+                "c": "copy",
+                "map": "0",
+                "threads": _effective_cores(),
+            }
+            if suffix.lower() == ".mp4":
+                output_kwargs.update(
+                    {
+                        "force_key_frames": f"expr:gte(t,n_forced*{segment_time})",
+                        "crf": 22,
+                        "g": 50,
+                        "sc_threshold": 0,
+                    }
+                )
+            (
+                ffmpeg.input(str(input_path))
+                .output(str(output_pattern), **output_kwargs)
+                .run(capture_stdout=True, capture_stderr=True)
+            )
+            self.path_metadata[str(input_path)] = probe
+        except ffmpeg.Error as e:
+            logger.error("FFmpeg error for file %s: %s", original_input_path, e.stderr.decode())
+            return []
+        # Use actual chunk files produced by ffmpeg (may differ from num_splits)
+        files = sorted(str(p) for p in output_dir.glob(f"{file_name}_chunk_*{suffix}") if p.is_file())
+        if video_audio_separate and suffix.lower() in [".mp4", ".mov", ".avi", ".mkv"]:
+            for f in files:
+                fp = Path(f)
+                audio_path = self.get_audio_from_video(f, str(fp.with_suffix(".mp3")), str(cache_path))
+                if audio_path is not None:
+                    files.append(str(audio_path))
+        return files
+
+    def find_num_splits(
+        self,
+        file_size: int,
+        sample_rate: float,
+        duration: float,
+        split_interval: int,
+        split_type: str,
+    ) -> float:
+        if split_type == SplitType.SIZE:
+            return math.ceil(file_size / split_interval)
+        if split_type == SplitType.TIME:
+            return math.ceil(duration / split_interval)
+        if split_type == SplitType.FRAME:
+            seconds_cap = split_interval / sample_rate
+            return math.ceil(duration / seconds_cap)
+        raise ValueError(f"Invalid split type: {split_type}")
+
+    def _get_path_metadata(self, path: Optional[str] = None) -> dict:
+        return self.path_metadata
+
+
+def is_media_available() -> bool:
+    """True if ffmpeg-python is installed and the ffprobe binary is on PATH."""
+    return _FFMPEG_AVAILABLE and ffmpeg is not None and shutil.which("ffprobe") is not None
diff --git a/nemo_retriever/src/nemo_retriever/audio/stage.py b/nemo_retriever/src/nemo_retriever/audio/stage.py
new file mode 100644
index 000000000..000ae99c9
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/audio/stage.py
@@ -0,0 +1,297 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Audio extraction stage: chunk + ASR only, write *.audio_extraction.json sidecars.
+
+Invoked as `retriever audio extract` / `retriever audio discover` (or
+`python -m nemo_retriever.audio extract` / `discover`). Analogous to `retriever pdf stage page-elements`.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+import typer
+
+from nemo_retriever.audio.asr_actor import apply_asr_to_df
+from nemo_retriever.audio.asr_actor import asr_params_from_env
+from nemo_retriever.audio.chunk_actor import audio_path_to_chunks_df
+from nemo_retriever.audio.media_interface import is_media_available
+from nemo_retriever.params import ASRParams
+from nemo_retriever.params import AudioChunkParams
+
+logger = logging.getLogger(__name__)
+
+app = typer.Typer(help="Audio extraction stage (chunk + ASR, write sidecar JSON).")
+
+# Default globs for discovering audio/video files (ffmpeg-readable).
+DEFAULT_AUDIO_GLOBS = ["*.wav", "*.mp3", "*.m4a", "*.mp4", "*.mov", "*.avi", "*.mkv"]
+
+
+def _atomic_write_json(path: Path, obj: Any) -> None:
+    """Atomically write JSON (write temp then replace)."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_name(path.name + ".tmp")
+    with tmp_path.open("w", encoding="utf-8") as f:
+        json.dump(obj, f, ensure_ascii=False, indent=2)
+        f.flush()
+    tmp_path.replace(path)
+
+
+def _to_jsonable(obj: Any) -> Any:
+    """Best-effort conversion to JSON-serializable builtins."""
+    if obj is None or isinstance(obj, (str, int, float, bool)):
+        return obj
+    if isinstance(obj, dict):
+        return {str(k): _to_jsonable(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_to_jsonable(v) for v in obj]
+    item = getattr(obj, "item", None)
+    if callable(item):
+        try:
+            return _to_jsonable(item())
+        except Exception:
+            pass
+    tolist = getattr(obj, "tolist", None)
+    if callable(tolist):
+        try:
+            return _to_jsonable(tolist())
+        except Exception:
+            pass
+    return str(obj)
+
+
+def _audio_extraction_json_path(source_path: Path, output_dir: Optional[Path]) -> Path:
+    """Sidecar path: <source>.audio_extraction.json beside file or under output_dir."""
+    sidecar = source_path.with_name(source_path.name + ".audio_extraction.json")
+    if output_dir is not None:
+        return output_dir / sidecar.name
+    return sidecar
+
+
+@app.command("discover")
+def discover(
+    input_dir: Path = typer.Option(
+        ...,
+        "--input-dir",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to scan for audio/video files.",
+    ),
+    glob: str = typer.Option(
+        "*.mp3,*.wav",
+        "--glob",
+        help="Comma-separated glob pattern(s) for discovery.",
+    ),
+) -> None:
+    """
+    List files that would be processed and where sidecars would be written (no ASR).
+    Use to verify mount and paths.
+    """
+    patterns = [g.strip() for g in glob.split(",") if g.strip()] or ["*.mp3", "*.wav"]
+    paths_set: set[Path] = set()
+    for pat in patterns:
+        for p in input_dir.rglob(pat):
+            if p.is_file():
+                paths_set.add(p)
+    paths = sorted(paths_set)
+    if not paths:
+        print(f"No files matching {patterns} under {input_dir}", flush=True)
+        raise typer.Exit(code=2)
+    print(f"Would process {len(paths)} file(s). Sidecar paths:", flush=True)
+    for p in paths:
+        out = _audio_extraction_json_path(p, None)
+        print(f"  {p} -> {out}", flush=True)
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+
+def _run_extract_one(
+    source_path: str,
+    chunk_params: AudioChunkParams,
+    asr_params: ASRParams,
+) -> pd.DataFrame:
+    """Chunk one file and run ASR; return DataFrame with path, source_path, duration, chunk_index, text, metadata."""
+    chunk_df = audio_path_to_chunks_df(source_path, params=chunk_params)
+    if chunk_df.empty:
+        return chunk_df
+    asr_kw = asr_params.model_dump(mode="python")
+    return apply_asr_to_df(chunk_df, asr_params=asr_kw)
+
+
+@app.command("extract")
+def extract(
+    input_dir: Path = typer.Option(
+        ...,
+        "--input-dir",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to scan for audio/video files.",
+    ),
+    glob: str = typer.Option(
+        "*.mp3,*.wav",
+        "--glob",
+        help="Comma-separated glob(s) for discovery (e.g. '*.mp3', '*.wav'). Default: *.mp3,*.wav.",
+    ),
+    output_dir: Optional[Path] = typer.Option(
+        None,
+        "--output-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to write sidecar JSONs (default: next to each source file).",
+    ),
+    split_type: str = typer.Option(
+        "size",
+        "--split-type",
+        help="Chunk split type: 'size', 'time', or 'frame'.",
+    ),
+    split_interval: int = typer.Option(
+        450,
+        "--split-interval",
+        min=1,
+        help="Chunk split interval (bytes for size, seconds for time, frames for frame).",
+    ),
+    audio_only: bool = typer.Option(
+        False,
+        "--audio-only/--no-audio-only",
+        help="If true and file is video, extract audio to MP3 then chunk.",
+    ),
+    video_audio_separate: bool = typer.Option(
+        False,
+        "--video-audio-separate/--no-video-audio-separate",
+        help="If true and video, also add extracted MP3 as separate item.",
+    ),
+    use_env_asr: bool = typer.Option(
+        True,
+        "--use-env-asr/--no-use-env-asr",
+        help="Build ASR params from AUDIO_GRPC_ENDPOINT, NGC_API_KEY, AUDIO_FUNCTION_ID when set.",
+    ),
+    audio_grpc_endpoint: Optional[str] = typer.Option(
+        None,
+        "--audio-grpc-endpoint",
+        help="Override gRPC endpoint for ASR (else from env or local Parakeet).",
+    ),
+    auth_token: Optional[str] = typer.Option(
+        None,
+        "--auth-token",
+        help="Override auth token for cloud ASR.",
+    ),
+    limit: Optional[int] = typer.Option(
+        None,
+        "--limit",
+        help="Limit number of files processed.",
+    ),
+    write_json: bool = typer.Option(
+        True,
+        "--write-json/--no-write-json",
+        help="Write one <file>.audio_extraction.json sidecar per source file.",
+    ),
+) -> None:
+    """
+    Scan input_dir for audio/video files, run chunk + ASR, and write extraction JSON sidecars.
+
+    Uses local Parakeet when no ASR endpoint is set; use NGC_API_KEY + AUDIO_FUNCTION_ID
+    (or --audio-grpc-endpoint) for cloud ASR.
+    """
+    print(f"Audio stage extract: input_dir={input_dir!s} glob={glob!r} output_dir={output_dir!s}", flush=True)
+    sys.stdout.flush()
+    sys.stderr.flush()
+
+    if not is_media_available():
+        raise typer.BadParameter("Audio stage requires ffmpeg. Install system ffmpeg and ensure it is on PATH.")
+
+    if split_type not in ("size", "time", "frame"):
+        raise typer.BadParameter("--split-type must be one of: size, time, frame")
+    chunk_params = AudioChunkParams(
+        split_type=split_type,
+        split_interval=split_interval,
+        audio_only=audio_only,
+        video_audio_separate=video_audio_separate,
+    )
+
+    if use_env_asr:
+        asr_params = asr_params_from_env()
+        if audio_grpc_endpoint is not None:
+            asr_params = asr_params.model_copy(
+                update={"audio_endpoints": (audio_grpc_endpoint, asr_params.audio_endpoints[1])}
+            )
+        if auth_token is not None:
+            asr_params = asr_params.model_copy(update={"auth_token": auth_token})
+    else:
+        asr_params = ASRParams(
+            audio_endpoints=(audio_grpc_endpoint or "", None),
+            auth_token=auth_token,
+        )
+
+    # Discover files: comma-separated globs (e.g. *.mp3,*.wav).
+    patterns = [g.strip() for g in glob.split(",") if g.strip()] or ["*.mp3", "*.wav"]
+    paths_set: set[Path] = set()
+    for pat in patterns:
+        for p in input_dir.rglob(pat):
+            if p.is_file():
+                paths_set.add(p)
+    paths = sorted(paths_set)
+    if not paths:
+        typer.echo(f"No files matching {patterns} under {input_dir}", err=True)
+        sys.stderr.flush()
+        raise typer.Exit(code=2)
+
+    asr_mode = "remote" if (asr_params.audio_endpoints[0] or "").strip() else "local (Parakeet)"
+    typer.echo(f"Found {len(paths)} file(s) matching {patterns}. ASR: {asr_mode}.", err=True)
+    sys.stderr.flush()
+
+    if limit is not None:
+        paths = paths[: int(limit)]
+
+    written: List[Path] = []
+    for i, p in enumerate(paths):
+        try:
+            df = _run_extract_one(str(p), chunk_params, asr_params)
+        except Exception as e:
+            logger.exception("Extraction failed for %s: %s", p, e)
+            typer.echo(f"Extraction failed for {p}: {e}", err=True)
+            sys.stderr.flush()
+            continue
+
+        if write_json:
+            records = []
+            for _, row in df.iterrows():
+                records.append(
+                    {
+                        "path": str(row.get("path")),
+                        "source_path": str(row.get("source_path", p)),
+                        "duration": _to_jsonable(row.get("duration")),
+                        "chunk_index": int(row.get("chunk_index", 0)),
+                        "text": str(row.get("text", "")),
+                        "metadata": _to_jsonable(row.get("metadata")),
+                    }
+                )
+            out_path = _audio_extraction_json_path(p, output_dir)
+            payload: Dict[str, Any] = {
+                "schema_version": 1,
+                "stage": "audio_extract",
+                "source_path": str(p.resolve()),
+                "chunks": records,
+                "num_chunks": len(records),
+            }
+            try:
+                _atomic_write_json(out_path, payload)
+                written.append(out_path)
+                typer.echo(f"Wrote {out_path}", err=True)
+                sys.stderr.flush()
+            except OSError as write_err:
+                typer.echo(f"Failed to write {out_path}: {write_err}", err=True)
+                sys.stderr.flush()
+                logger.exception("Write failed for %s: %s", out_path, write_err)
+
+    print(f"Processed {len(paths)} file(s), wrote {len(written)} JSON sidecar(s).", flush=True)
+    sys.stdout.flush()
diff --git a/nemo_retriever/src/nemo_retriever/chart/__init__.py b/nemo_retriever/src/nemo_retriever/chart/__init__.py
new file mode 100644
index 000000000..77d86cd93
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/chart/__init__.py
@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Chart extraction stage (pure Python + Ray Data adapters).
+
+This stage enriches existing STRUCTURED/chart primitives by populating
+`metadata.table_metadata.table_content` using YOLOX + OCR fusion.
+"""
+
+from .config import ChartExtractionStageConfig, load_chart_extractor_schema_from_dict
+from .commands import app
+from .processor import extract_chart_data_from_primitives_df
+
+__all__ = [
+    "app",
+    "ChartExtractionStageConfig",
+    "extract_chart_data_from_primitives_df",
+    "load_chart_extractor_schema_from_dict",
+]
diff --git a/nemo_retriever/src/nemo_retriever/chart/__main__.py b/nemo_retriever/src/nemo_retriever/chart/__main__.py
new file mode 100644
index 000000000..5483a457e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/chart/__main__.py
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from . import commands
+
+app = typer.Typer(help="Chart Extraction")
+app.add_typer(commands.app, name="stage")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/chart/chart_detection.py b/nemo_retriever/src/nemo_retriever/chart/chart_detection.py
new file mode 100644
index 000000000..2ffac0fb5
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/chart/chart_detection.py
@@ -0,0 +1,642 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence, Tuple, cast
+
+import base64
+import io
+import time
+import traceback
+
+import pandas as pd
+
+try:
+    import numpy as np
+except Exception:  # pragma: no cover
+    np = None  # type: ignore[assignment]
+
+try:
+    import torch
+except Exception:  # pragma: no cover
+    torch = None  # type: ignore[assignment]
+
+try:
+    from PIL import Image
+except Exception:  # pragma: no cover
+    Image = None  # type: ignore[assignment]
+
+
+def _error_payload(*, stage: str, exc: BaseException) -> Dict[str, Any]:
+    return {
+        "detections": [],
+        "error": {
+            "stage": str(stage),
+            "type": exc.__class__.__name__,
+            "message": str(exc),
+            "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+        },
+    }
+
+
+def _decode_b64_image_to_chw_tensor(image_b64: str) -> Tuple["torch.Tensor", Tuple[int, int]]:
+    if torch is None or Image is None or np is None:  # pragma: no cover
+        raise ImportError("chart detection requires torch, pillow, and numpy.")
+
+    raw = base64.b64decode(image_b64)
+    with Image.open(io.BytesIO(raw)) as im0:
+        im = im0.convert("RGB")
+        w, h = im.size
+        arr = np.array(im, dtype=np.uint8)  # (H,W,3)
+
+    t = torch.from_numpy(arr).permute(2, 0, 1).contiguous()  # (3,H,W) uint8
+    t = t.to(dtype=torch.float32) / 255.0
+    return t, (int(h), int(w))
+
+
+def _crop_b64_image_by_norm_bbox(
+    page_image_b64: str,
+    *,
+    bbox_xyxy_norm: Sequence[float],
+    image_format: str = "png",
+) -> Tuple[Optional[str], Optional[Tuple[int, int]]]:
+    """
+    Crop a base64-encoded RGB image by a normalized xyxy bbox.
+
+    Returns:
+      - cropped_image_b64 (png) or None
+      - cropped_shape_hw (H,W) or None
+    """
+    if Image is None:  # pragma: no cover
+        raise ImportError("Cropping requires pillow.")
+    if not isinstance(page_image_b64, str) or not page_image_b64:
+        return None, None
+    try:
+        x1n, y1n, x2n, y2n = [float(x) for x in bbox_xyxy_norm]
+    except Exception:
+        return None, None
+
+    try:
+        raw = base64.b64decode(page_image_b64)
+        with Image.open(io.BytesIO(raw)) as im0:
+            im = im0.convert("RGB")
+            w, h = im.size
+            if w <= 1 or h <= 1:
+                return None, None
+
+            def _clamp_int(v: float, lo: int, hi: int) -> int:
+                if v != v:  # NaN
+                    return lo
+                return int(min(max(v, float(lo)), float(hi)))
+
+            x1 = _clamp_int(x1n * w, 0, w)
+            x2 = _clamp_int(x2n * w, 0, w)
+            y1 = _clamp_int(y1n * h, 0, h)
+            y2 = _clamp_int(y2n * h, 0, h)
+
+            if x2 <= x1 or y2 <= y1:
+                return None, None
+
+            crop = im.crop((x1, y1, x2, y2))
+            cw, ch = crop.size
+            if cw <= 1 or ch <= 1:
+                return None, None
+
+            buf = io.BytesIO()
+            fmt = str(image_format or "png").lower()
+            if fmt not in {"png"}:
+                fmt = "png"
+            crop.save(buf, format=fmt.upper())
+            return base64.b64encode(buf.getvalue()).decode("ascii"), (int(ch), int(cw))
+    except Exception:
+        return None, None
+
+
+def _labels_from_model(model: Any) -> List[str]:
+    try:
+        labels = getattr(getattr(model, "_model", None), "labels", None)
+        if isinstance(labels, (list, tuple)) and all(isinstance(x, str) for x in labels):
+            return [str(x) for x in labels]
+    except Exception:
+        pass
+
+    try:
+        out = getattr(model, "output", None)
+        if isinstance(out, dict):
+            classes = out.get("classes")
+            if isinstance(classes, (list, tuple)) and all(isinstance(x, str) for x in classes):
+                return [str(x) for x in classes]
+    except Exception:
+        pass
+
+    return []
+
+
+def _prediction_to_detections(pred: Any, *, label_names: List[str]) -> List[Dict[str, Any]]:
+    if torch is None:  # pragma: no cover
+        raise ImportError("torch required for prediction parsing.")
+
+    boxes = labels = scores = None
+    if isinstance(pred, dict):
+        # IMPORTANT: do not use `or` chains here. torch.Tensor truthiness is ambiguous and raises.
+        def _get_any(d: Dict[str, Any], *keys: str) -> Any:
+            for k in keys:
+                if k in d:
+                    v = d.get(k)
+                    if v is not None:
+                        return v
+            return None
+
+        boxes = _get_any(pred, "boxes", "bboxes", "bbox", "box")
+        labels = _get_any(pred, "labels", "classes", "class_ids", "class")
+        scores = _get_any(pred, "scores", "conf", "confidences", "score")
+    elif isinstance(pred, (list, tuple)) and len(pred) >= 3:
+        boxes, labels, scores = pred[0], pred[1], pred[2]
+
+    if boxes is None or labels is None:
+        return []
+
+    def _to_tensor(x: Any) -> Optional["torch.Tensor"]:
+        if x is None:
+            return None
+        if isinstance(x, torch.Tensor):
+            return x.detach().cpu()
+        try:
+            return torch.as_tensor(x).detach().cpu()
+        except Exception:
+            return None
+
+    b = _to_tensor(boxes)
+    l = _to_tensor(labels)  # noqa: E741
+    s = _to_tensor(scores) if scores is not None else None
+    if b is None or l is None:
+        return []
+
+    if b.ndim != 2 or int(b.shape[-1]) != 4:
+        return []
+    if l.ndim == 2 and int(l.shape[-1]) == 1:
+        l = l.squeeze(-1)  # noqa: E741
+    if l.ndim != 1:
+        return []
+
+    n = int(min(b.shape[0], l.shape[0]))
+    dets: List[Dict[str, Any]] = []
+    for i in range(n):
+        try:
+            x1, y1, x2, y2 = [float(x) for x in b[i].tolist()]
+        except Exception:
+            continue
+
+        label_i: Optional[int]
+        try:
+            label_i = int(l[i].item())
+        except Exception:
+            label_i = None
+
+        score_f: Optional[float]
+        if s is not None and s.ndim >= 1 and int(s.shape[0]) > i:
+            try:
+                score_f = float(s[i].item())
+            except Exception:
+                score_f = None
+        else:
+            score_f = None
+
+        label_name = None
+        if label_i is not None and 0 <= label_i < len(label_names):
+            label_name = label_names[label_i]
+        if not label_name:
+            label_name = f"label_{label_i}" if label_i is not None else "unknown"
+
+        dets.append(
+            {
+                "bbox_xyxy_norm": [x1, y1, x2, y2],
+                "label": label_i,
+                "label_name": str(label_name),
+                "score": score_f,
+            }
+        )
+    return dets
+
+
+def _counts_by_label(detections: Sequence[Dict[str, Any]]) -> Dict[str, int]:
+    out: Dict[str, int] = {}
+    for d in detections:
+        if not isinstance(d, dict):
+            continue
+        name = d.get("label_name")
+        if not isinstance(name, str) or not name.strip():
+            name = f"label_{d.get('label')}"
+        k = str(name)
+        out[k] = int(out.get(k, 0) + 1)
+    return out
+
+
+def detect_graphic_elements_v1(
+    batch_df: Any,
+    *,
+    model: Any,
+    inference_batch_size: int = 8,
+    output_column: str = "graphic_elements_v1",
+    num_detections_column: str = "graphic_elements_v1_num_detections",
+    counts_by_label_column: str = "graphic_elements_v1_counts_by_label",
+) -> Any:
+    """
+    Run Nemotron Graphic Elements v1 on a pandas batch.
+    """
+    if not isinstance(batch_df, pd.DataFrame):
+        raise NotImplementedError("detect_graphic_elements_v1 currently only supports pandas.DataFrame input.")
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+
+    label_names = _labels_from_model(model)
+
+    tensors: List[Optional["torch.Tensor"]] = []
+    shapes: List[Optional[Tuple[int, int]]] = []
+    payloads: List[Dict[str, Any]] = []
+    for _, row in batch_df.iterrows():
+        try:
+            b64 = row.get("page_image", {}).get("image_b64", None)
+            if not b64:
+                raise ValueError("No usable image_b64 found in row.")
+            t, orig_shape = _decode_b64_image_to_chw_tensor(b64)
+            tensors.append(t)
+            shapes.append(orig_shape)
+            payloads.append({"detections": []})
+        except BaseException as e:
+            tensors.append(None)
+            shapes.append(None)
+            payloads.append(_error_payload(stage="decode_image", exc=e))
+
+    valid = [i for i, t in enumerate(tensors) if t is not None and shapes[i] is not None]
+
+    for chunk_start in range(0, len(valid), int(inference_batch_size)):
+        idxs = valid[chunk_start : chunk_start + int(inference_batch_size)]
+        if not idxs:
+            continue
+
+        pre_list: List["torch.Tensor"] = []
+        orig_shapes: List[Tuple[int, int]] = []
+        for i in idxs:
+            t = tensors[i]
+            sh = shapes[i]
+            if t is None or sh is None:
+                continue
+            orig_shapes.append(sh)
+            x = t.unsqueeze(0)  # BCHW
+            try:
+                pre = model.preprocess(x)
+            except Exception:
+                pre = x
+            if isinstance(pre, torch.Tensor) and pre.ndim == 4 and int(pre.shape[0]) == 1:
+                pre_list.append(pre[0])
+            elif isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                pre_list.append(pre)
+            else:
+                pre_list.append(t)
+
+        if not pre_list:
+            continue
+
+        batch = torch.stack(pre_list, dim=0)
+        t0 = time.perf_counter()
+        try:
+            preds = model.invoke(batch, orig_shapes)  # type: ignore[arg-type]
+            elapsed = time.perf_counter() - t0
+            if isinstance(preds, list):
+                preds_list = preds
+            else:
+                preds_list = [preds]
+            if len(preds_list) != len(idxs):
+                raise RuntimeError("Batched invoke returned unexpected output shape; falling back to per-image calls.")
+            for local_j, row_i in enumerate(idxs):
+                dets = _prediction_to_detections(preds_list[local_j], label_names=label_names)
+                payloads[row_i] = {"detections": dets, "timing": {"seconds": float(elapsed)}, "error": None}
+        except BaseException:
+            for local_j, row_i in enumerate(idxs):
+                t = tensors[row_i]
+                sh = shapes[row_i]
+                if t is None or sh is None:
+                    continue
+                x = t.unsqueeze(0)
+                t1 = time.perf_counter()
+                try:
+                    try:
+                        pre = model.preprocess(x)
+                    except Exception:
+                        pre = x
+                    if isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                        pre = pre.unsqueeze(0)
+                    pred = model.invoke(pre, sh)
+                    dets = _prediction_to_detections(pred, label_names=label_names)
+                    payloads[row_i] = {
+                        "detections": dets,
+                        "timing": {"seconds": float(time.perf_counter() - t1)},
+                        "error": None,
+                    }
+                except BaseException as e:
+                    payloads[row_i] = _error_payload(stage="invoke", exc=e) | {
+                        "timing": {"seconds": float(time.perf_counter() - t1)}
+                    }
+
+    out = batch_df.copy()
+    out[output_column] = payloads
+    out[num_detections_column] = [int(len(p.get("detections") or [])) if isinstance(p, dict) else 0 for p in payloads]
+    out[counts_by_label_column] = [
+        _counts_by_label(p.get("detections") or []) if isinstance(p, dict) else {} for p in payloads
+    ]
+    return out
+
+
+def detect_graphic_elements_v1_from_page_elements_v3(
+    pages_df: Any,
+    *,
+    model: Any,
+    inference_batch_size: int = 8,
+    page_elements_column: str = "page_elements_v3",
+    page_elements_counts_by_label_column: str = "page_elements_v3_counts_by_label",
+    page_image_column: str = "page_image",
+    output_column: str = "graphic_elements_v1",
+    num_detections_column: str = "graphic_elements_v1_num_detections",
+    counts_by_label_column: str = "graphic_elements_v1_counts_by_label",
+) -> Any:
+    """
+    Run Nemotron Graphic Elements v1 only on cropped chart regions.
+
+    Gate per page on `page_elements_v3_counts_by_label["chart"] > 0`, then crop
+    `page_image.image_b64` to each detection whose `label_name == "chart"`, and
+    run the model on those crops.
+
+    Output payload shape:
+      - `output_column`: {"regions": [...], "timing": {...}, "error": ...}
+    """
+    if not isinstance(pages_df, pd.DataFrame):
+        raise NotImplementedError(
+            "detect_graphic_elements_v1_from_page_elements_v3 currently only supports pandas.DataFrame input."
+        )
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+
+    out_payloads: List[Dict[str, Any]] = []
+    out_total_dets: List[int] = []
+    out_counts: List[Dict[str, int]] = []
+
+    crop_b64s: List[str] = []
+    crop_shapes: List[Tuple[int, int]] = []
+    crop_region_refs: List[Dict[str, Any]] = []
+
+    t0_total = time.perf_counter()
+
+    for _, row in pages_df.iterrows():
+        page_payload: Dict[str, Any] = {"regions": [], "timing": {"seconds": 0.0}, "error": None}
+
+        counts = row.get(page_elements_counts_by_label_column)
+        chart_count = 0
+        if isinstance(counts, dict):
+            try:
+                chart_count = int(counts.get("chart") or 0)
+            except Exception:
+                chart_count = 0
+
+        if chart_count <= 0:
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        pe = row.get(page_elements_column)
+        dets = pe.get("detections") if isinstance(pe, dict) else None
+        if not isinstance(dets, list) or not dets:
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        page_image = row.get(page_image_column) or {}
+        page_image_b64 = page_image.get("image_b64") if isinstance(page_image, dict) else None
+        if not isinstance(page_image_b64, str) or not page_image_b64:
+            page_payload["error"] = {
+                "stage": "crop",
+                "type": "ValueError",
+                "message": "page_image.image_b64 missing; cannot crop charts for graphic_elements_v1.",
+                "traceback": "",
+            }
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        regions: List[Dict[str, Any]] = []
+        for det in dets:
+            if not isinstance(det, dict):
+                continue
+            if str(det.get("label_name") or "").strip() != "chart":
+                continue
+            bbox = det.get("bbox_xyxy_norm")
+            if not isinstance(bbox, (list, tuple)) or len(bbox) != 4:
+                continue
+
+            crop_b64, crop_shape_hw = _crop_b64_image_by_norm_bbox(
+                page_image_b64, bbox_xyxy_norm=cast(Sequence[float], bbox)
+            )
+            if not crop_b64 or crop_shape_hw is None:
+                continue
+
+            region_payload: Dict[str, Any] = {
+                "label_name": "chart",
+                "bbox_xyxy_norm": [float(x) for x in bbox],
+                "score": det.get("score"),
+                "orig_shape_hw": crop_shape_hw,
+                "detections": [],
+                "timing": None,
+                "error": None,
+            }
+            regions.append(region_payload)
+            crop_b64s.append(crop_b64)
+            crop_shapes.append(crop_shape_hw)
+            crop_region_refs.append(region_payload)
+
+        page_payload["regions"] = regions
+        out_payloads.append(page_payload)
+        out_total_dets.append(0)
+        out_counts.append({})
+
+    if crop_b64s:
+        label_names = _labels_from_model(model)
+
+        tensors: List[Optional["torch.Tensor"]] = []
+        shapes: List[Optional[Tuple[int, int]]] = []
+        crop_payloads: List[Dict[str, Any]] = []
+        for b64 in crop_b64s:
+            try:
+                t, orig_shape = _decode_b64_image_to_chw_tensor(b64)
+                tensors.append(t)
+                shapes.append(orig_shape)
+                crop_payloads.append({"detections": []})
+            except BaseException as e:
+                tensors.append(None)
+                shapes.append(None)
+                crop_payloads.append(_error_payload(stage="decode_image", exc=e))
+
+        valid = [i for i, t in enumerate(tensors) if t is not None and shapes[i] is not None]
+
+        for chunk_start in range(0, len(valid), int(inference_batch_size)):
+            idxs = valid[chunk_start : chunk_start + int(inference_batch_size)]
+            if not idxs:
+                continue
+
+            pre_list: List["torch.Tensor"] = []
+            orig_shapes: List[Tuple[int, int]] = []
+            for i in idxs:
+                t = tensors[i]
+                sh = shapes[i]
+                if t is None or sh is None:
+                    continue
+                orig_shapes.append(sh)
+                x = t.unsqueeze(0)
+                try:
+                    pre = model.preprocess(x)
+                except Exception:
+                    pre = x
+                if isinstance(pre, torch.Tensor) and pre.ndim == 4 and int(pre.shape[0]) == 1:
+                    pre_list.append(pre[0])
+                elif isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                    pre_list.append(pre)
+                else:
+                    pre_list.append(t)
+
+            if not pre_list:
+                continue
+
+            batch = torch.stack(pre_list, dim=0)
+            t0 = time.perf_counter()
+            try:
+                preds = model.invoke(batch, orig_shapes)  # type: ignore[arg-type]
+                elapsed = time.perf_counter() - t0
+                preds_list = preds if isinstance(preds, list) else [preds]
+                if len(preds_list) != len(idxs):
+                    raise RuntimeError(
+                        "Batched invoke returned unexpected output shape; falling back to per-image calls."
+                    )
+                for local_j, crop_i in enumerate(idxs):
+                    dets = _prediction_to_detections(preds_list[local_j], label_names=label_names)
+                    crop_payloads[crop_i] = {"detections": dets, "timing": {"seconds": float(elapsed)}, "error": None}
+            except BaseException:
+                for crop_i in idxs:
+                    t = tensors[crop_i]
+                    sh = shapes[crop_i]
+                    if t is None or sh is None:
+                        continue
+                    x = t.unsqueeze(0)
+                    t1 = time.perf_counter()
+                    try:
+                        try:
+                            pre = model.preprocess(x)
+                        except Exception:
+                            pre = x
+                        if isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                            pre = pre.unsqueeze(0)
+                        pred = model.invoke(pre, sh)
+                        dets = _prediction_to_detections(pred, label_names=label_names)
+                        crop_payloads[crop_i] = {
+                            "detections": dets,
+                            "timing": {"seconds": float(time.perf_counter() - t1)},
+                            "error": None,
+                        }
+                    except BaseException as e:
+                        crop_payloads[crop_i] = _error_payload(stage="invoke", exc=e) | {
+                            "timing": {"seconds": float(time.perf_counter() - t1)}
+                        }
+
+        for crop_i, region_ref in enumerate(crop_region_refs):
+            payload = crop_payloads[crop_i] if crop_i < len(crop_payloads) else {"detections": []}
+            if isinstance(payload, dict):
+                region_ref["detections"] = payload.get("detections") or []
+                region_ref["timing"] = payload.get("timing")
+                region_ref["error"] = payload.get("error")
+            else:
+                region_ref["detections"] = []
+                region_ref["timing"] = None
+                region_ref["error"] = {
+                    "stage": "invoke",
+                    "type": "TypeError",
+                    "message": "Unexpected payload type",
+                    "traceback": "",
+                }
+
+    # Aggregate counts per page.
+    for i, page_payload in enumerate(out_payloads):
+        regions = page_payload.get("regions") or []
+        total_dets = 0
+        agg_counts: Dict[str, int] = {}
+        if isinstance(regions, list):
+            for r in regions:
+                if not isinstance(r, dict):
+                    continue
+                dets = r.get("detections") or []
+                if isinstance(dets, list):
+                    total_dets += int(len(dets))
+                    for d in dets:
+                        if not isinstance(d, dict):
+                            continue
+                        name = d.get("label_name")
+                        if not isinstance(name, str) or not name.strip():
+                            name = f"label_{d.get('label')}"
+                        k = str(name)
+                        agg_counts[k] = int(agg_counts.get(k, 0) + 1)
+        out_total_dets[i] = int(total_dets)
+        out_counts[i] = agg_counts
+
+    elapsed_total = time.perf_counter() - t0_total
+    for page_payload in out_payloads:
+        if isinstance(page_payload, dict):
+            page_payload["timing"] = {"seconds": float(elapsed_total)}
+
+    out = pages_df.copy()
+    out[output_column] = out_payloads
+    out[num_detections_column] = out_total_dets
+    out[counts_by_label_column] = out_counts
+    return out
+
+
+@dataclass(slots=True)
+class ChartDetectionActor:
+    """
+    Ray-friendly callable that initializes Nemotron Graphic Elements v1 once.
+    """
+
+    detect_kwargs: Dict[str, Any]
+
+    def __init__(self, **detect_kwargs: Any) -> None:
+        self.detect_kwargs = dict(detect_kwargs)
+        from nemo_retriever.model.local import NemotronGraphicElementsV1
+
+        self._model = NemotronGraphicElementsV1()
+
+    def __call__(self, batch_df: Any, **override_kwargs: Any) -> Any:
+        try:
+            # Prefer crop-based execution when page-elements are present.
+            if isinstance(batch_df, pd.DataFrame) and (
+                "page_elements_v3" in batch_df.columns or "page_elements_v3_counts_by_label" in batch_df.columns
+            ):
+                return detect_graphic_elements_v1_from_page_elements_v3(
+                    batch_df,
+                    model=self._model,
+                    **self.detect_kwargs,
+                    **override_kwargs,
+                )
+            return detect_graphic_elements_v1(batch_df, model=self._model, **self.detect_kwargs, **override_kwargs)
+        except BaseException as e:
+            if isinstance(batch_df, pd.DataFrame):
+                out = batch_df.copy()
+                payload = _error_payload(stage="actor_call", exc=e)
+                out["graphic_elements_v1"] = [
+                    {"regions": [], "timing": None, "error": payload.get("error")} for _ in range(len(out.index))
+                ]
+                out["graphic_elements_v1_num_detections"] = [0 for _ in range(len(out.index))]
+                out["graphic_elements_v1_counts_by_label"] = [{} for _ in range(len(out.index))]
+                return out
+            return [{"graphic_elements_v1": _error_payload(stage="actor_call", exc=e)}]
diff --git a/nemo_retriever/src/nemo_retriever/chart/commands.py b/nemo_retriever/src/nemo_retriever/chart/commands.py
new file mode 100644
index 000000000..7f40238ff
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/chart/commands.py
@@ -0,0 +1,137 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import typer
+from rich.console import Console
+
+from nemo_retriever.ingest_config import load_ingest_config_section
+from nemo_retriever.io.dataframe import read_dataframe, write_dataframe
+
+from nemo_retriever.chart.config import load_chart_extractor_schema_from_dict
+from nemo_retriever.chart.processor import extract_chart_data_from_primitives_df
+
+app = typer.Typer(help="Chart Extraction Stage")
+console = Console()
+
+
+@app.command()
+def run(
+    input_path: Path = typer.Option(
+        ...,
+        "--input",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="Input primitives as a DataFrame file (.parquet, .jsonl, or .json). Must include a 'metadata' column.",
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        dir_okay=False,
+        file_okay=True,
+        help="Output path (.parquet, .jsonl, or .json). Defaults to <input>.+chart<ext>.",
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help=(
+            "Optional ingest YAML config file. If omitted, we auto-discover ./ingest-config.yaml then "
+            "$HOME/.ingest-config.yaml. Uses section: chart."
+        ),
+    ),
+) -> None:
+    """
+    Load a primitives DataFrame, run chart enrichment, and write the enriched DataFrame.
+    """
+    try:
+        df = read_dataframe(input_path)
+    except ValueError as e:
+        raise typer.BadParameter(str(e)) from e
+
+    cfg_dict: Dict[str, Any] = load_ingest_config_section(config, section="chart")
+    schema = load_chart_extractor_schema_from_dict(cfg_dict)
+    out_df, _info = extract_chart_data_from_primitives_df(df, extractor_config=schema, task_config={})
+
+    if output_path is None:
+        output_path = input_path.with_name(input_path.stem + ".chart" + input_path.suffix)
+
+    try:
+        write_dataframe(out_df, output_path)
+    except ValueError as e:
+        raise typer.BadParameter(str(e)) from e
+
+    console.print(f"[green]Done[/green] wrote={output_path} rows={len(out_df)}")
+
+
+@app.command("graphic-elements")
+def render_graphic_elements(
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="Optional YAML config file. If set, values are loaded from YAML; "
+        "explicitly passed CLI flags override YAML.",
+    ),
+    input_dir: Optional[Path] = typer.Option(
+        None,
+        "--input-dir",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to scan recursively for *.pdf (can be provided via --config).",
+    ),
+    method: str = typer.Option("pdfium", "--method", help="PDF extraction method."),
+    auth_token: Optional[str] = typer.Option(None, "--auth-token", help="Auth token for NIM-backed services."),
+    yolox_grpc_endpoint: Optional[str] = typer.Option(None, "--yolox-grpc-endpoint"),
+    yolox_http_endpoint: Optional[str] = typer.Option(None, "--yolox-http-endpoint"),
+    nemotron_parse_grpc_endpoint: Optional[str] = typer.Option(None, "--nemotron-parse-grpc-endpoint"),
+    nemotron_parse_http_endpoint: Optional[str] = typer.Option(None, "--nemotron-parse-http-endpoint"),
+    nemotron_parse_model_name: Optional[str] = typer.Option(None, "--nemotron-parse-model-name"),
+    extract_text: bool = typer.Option(True, "--extract-text/--no-extract-text"),
+    extract_images: bool = typer.Option(False, "--extract-images/--no-extract-images"),
+    extract_tables: bool = typer.Option(False, "--extract-tables/--no-extract-tables"),
+    extract_charts: bool = typer.Option(False, "--extract-charts/--no-extract-charts"),
+    extract_infographics: bool = typer.Option(False, "--extract-infographics/--no-extract-infographics"),
+    extract_page_as_image: bool = typer.Option(False, "--extract-page-as-image/--no-extract-page-as-image"),
+    text_depth: str = typer.Option("page", "--text-depth"),
+    write_json_outputs: bool = typer.Option(True, "--write-json-outputs/--no-write-json-outputs"),
+    json_output_dir: Optional[Path] = typer.Option(None, "--json-output-dir", file_okay=False, dir_okay=True),
+    limit: Optional[int] = typer.Option(None, "--limit", help="Optionally limit number of PDFs processed."),
+) -> None:
+    _ = (
+        config,
+        input_dir,
+        method,
+        auth_token,
+        yolox_grpc_endpoint,
+        yolox_http_endpoint,
+        nemotron_parse_grpc_endpoint,
+        nemotron_parse_http_endpoint,
+        nemotron_parse_model_name,
+        extract_text,
+        extract_images,
+        extract_tables,
+        extract_charts,
+        extract_infographics,
+        extract_page_as_image,
+        text_depth,
+        write_json_outputs,
+        json_output_dir,
+        limit,
+    )
+    typer.echo("graphic-elements command is not implemented yet.")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/chart/config.py b/nemo_retriever/src/nemo_retriever/chart/config.py
new file mode 100644
index 000000000..a9dbadf44
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/chart/config.py
@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from nemo_retriever.config_utils import endpoints_from_yaml
+
+from nv_ingest_api.internal.schemas.extract.extract_chart_schema import ChartExtractorSchema
+
+
+def load_chart_extractor_schema_from_dict(cfg: Dict[str, Any]) -> ChartExtractorSchema:
+    cfg = dict(cfg or {})
+    endpoint_cfg = cfg.get("endpoint_config")
+    if isinstance(endpoint_cfg, dict):
+        endpoint_cfg = dict(endpoint_cfg)
+        if "yolox_endpoints" in endpoint_cfg:
+            endpoint_cfg["yolox_endpoints"] = endpoints_from_yaml(endpoint_cfg.get("yolox_endpoints"))
+        if "ocr_endpoints" in endpoint_cfg:
+            endpoint_cfg["ocr_endpoints"] = endpoints_from_yaml(endpoint_cfg.get("ocr_endpoints"))
+        cfg["endpoint_config"] = endpoint_cfg
+    return ChartExtractorSchema(**cfg)
+
+
+@dataclass(frozen=True)
+class ChartExtractionStageConfig:
+    batch_size: int = 64
+    stage_name: str = "chart_extraction"
diff --git a/nemo_retriever/src/nemo_retriever/chart/processor.py b/nemo_retriever/src/nemo_retriever/chart/processor.py
new file mode 100644
index 000000000..d6114bbb5
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/chart/processor.py
@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+import pandas as pd
+
+from nv_ingest_api.internal.extract.image.chart_extractor import extract_chart_data_from_image_internal
+from nv_ingest_api.internal.primitives.tracing.tagging import traceable_func
+from nv_ingest_api.internal.schemas.extract.extract_chart_schema import ChartExtractorSchema
+
+from nemo_retriever.io.dataframe import validate_primitives_dataframe
+
+logger = logging.getLogger(__name__)
+
+
+@traceable_func(trace_name="retriever::chart_extraction")
+def extract_chart_data_from_primitives_df(
+    df_primitives: pd.DataFrame,
+    *,
+    extractor_config: ChartExtractorSchema,
+    task_config: Optional[Dict[str, Any]] = None,
+    trace_info: Optional[Dict[str, Any]] = None,
+) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    """Enrich chart primitives in-place by running YOLOX/OCR and writing chart content."""
+    _ = trace_info
+    validate_primitives_dataframe(df_primitives)
+
+    if task_config is None:
+        task_config = {}
+
+    execution_trace_log: Dict[str, Any] = {}
+    try:
+        out_df, info = extract_chart_data_from_image_internal(
+            df_extraction_ledger=df_primitives,
+            task_config=task_config,
+            extraction_config=extractor_config,
+            execution_trace_log=execution_trace_log,
+        )
+    except Exception:
+        logger.exception("Chart extraction failed")
+        raise
+
+    info = dict(info or {})
+    info.setdefault("execution_trace_log", execution_trace_log)
+    return out_df, info
diff --git a/nemo_retriever/src/nemo_retriever/chart/stage.py b/nemo_retriever/src/nemo_retriever/chart/stage.py
new file mode 100644
index 000000000..1c5f40332
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/chart/stage.py
@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.chart.commands import app, main, render_graphic_elements, run
+from nemo_retriever.chart.processor import extract_chart_data_from_primitives_df
+
+__all__ = ["app", "extract_chart_data_from_primitives_df", "main", "render_graphic_elements", "run"]
diff --git a/nemo_retriever/src/nemo_retriever/config/__init__.py b/nemo_retriever/src/nemo_retriever/config/__init__.py
new file mode 100644
index 000000000..23432d208
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/config/__init__.py
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .loader import load_config_file, load_config_section, resolve_config_path
+
+__all__ = ["load_config_file", "load_config_section", "resolve_config_path"]
diff --git a/nemo_retriever/src/nemo_retriever/config/loader.py b/nemo_retriever/src/nemo_retriever/config/loader.py
new file mode 100644
index 000000000..a21532d33
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/config/loader.py
@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+from nemo_retriever.ingest_config import (
+    load_ingest_config_file,
+    load_ingest_config_section,
+    resolve_ingest_config_path,
+)
+
+
+def resolve_config_path(explicit: Optional[Path]) -> Tuple[Optional[Path], str]:
+    return resolve_ingest_config_path(explicit)
+
+
+def load_config_file(explicit: Optional[Path], *, verbose: bool = True) -> Tuple[Dict[str, Any], Optional[Path], str]:
+    return load_ingest_config_file(explicit, verbose=verbose)
+
+
+def load_config_section(
+    explicit: Optional[Path],
+    *,
+    section: str,
+    verbose: bool = True,
+    warn_if_missing_section: bool = True,
+) -> Dict[str, Any]:
+    return load_ingest_config_section(
+        explicit,
+        section=section,
+        verbose=verbose,
+        warn_if_missing_section=warn_if_missing_section,
+    )
diff --git a/nemo_retriever/src/nemo_retriever/config_utils.py b/nemo_retriever/src/nemo_retriever/config_utils.py
new file mode 100644
index 000000000..7a7143048
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/config_utils.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any, Optional, Tuple
+
+
+def endpoints_from_yaml(value: Any) -> Tuple[Optional[str], Optional[str]]:
+    """Normalize YAML endpoint values into the tuple shape used by nv-ingest-api schemas."""
+    if value is None:
+        return (None, None)
+    if isinstance(value, (tuple, list)) and len(value) == 2:
+        a, b = value[0], value[1]
+        return (a or None, b or None)
+    raise ValueError(f"Expected endpoints as [grpc, http] (len=2), got: {value!r}")
diff --git a/nemo_retriever/src/nemo_retriever/examples/batch_pipeline.py b/nemo_retriever/src/nemo_retriever/examples/batch_pipeline.py
new file mode 100644
index 000000000..97e8637be
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/examples/batch_pipeline.py
@@ -0,0 +1,944 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Batch ingestion pipeline with optional recall evaluation.
+Run with: uv run python -m nemo_retriever.examples.batch_pipeline <input-dir>
+"""
+
+import json
+import logging
+import os
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from importlib import import_module
+from pathlib import Path
+from typing import Optional, TextIO
+
+import ray
+import typer
+from nemo_retriever import create_ingestor
+from nemo_retriever.params import EmbedParams
+from nemo_retriever.params import ExtractParams
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+from nemo_retriever.params import TextChunkParams
+from nemo_retriever.params import VdbUploadParams
+from nemo_retriever.recall.core import RecallConfig, retrieve_and_score
+
+app = typer.Typer()
+
+LANCEDB_URI = "lancedb"
+LANCEDB_TABLE = "nv-ingest"
+
+
+def _lancedb():
+    """Import lancedb lazily to avoid fork warnings during early process setup."""
+    return import_module("lancedb")
+
+
+class _TeeStream:
+    """Write stream output to terminal and optional log file."""
+
+    def __init__(self, primary: TextIO, mirror: TextIO) -> None:
+        self._primary = primary
+        self._mirror = mirror
+
+    def write(self, data: str) -> int:
+        self._primary.write(data)
+        self._mirror.write(data)
+        return len(data)
+
+    def flush(self) -> None:
+        self._primary.flush()
+        self._mirror.flush()
+
+    def isatty(self) -> bool:
+        return bool(getattr(self._primary, "isatty", lambda: False)())
+
+    def fileno(self) -> int:
+        return int(getattr(self._primary, "fileno")())
+
+    def writable(self) -> bool:
+        return bool(getattr(self._primary, "writable", lambda: True)())
+
+    @property
+    def encoding(self) -> str:
+        return str(getattr(self._primary, "encoding", "utf-8"))
+
+
+def _configure_logging(log_file: Optional[Path]) -> tuple[Optional[TextIO], TextIO, TextIO]:
+    """Configure root logging; optionally tee stdout/stderr into one file."""
+    original_stdout = sys.stdout
+    original_stderr = sys.stderr
+    if log_file is None:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+        )
+        return None, original_stdout, original_stderr
+
+    target = Path(log_file).expanduser().resolve()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    fh = open(target, "a", encoding="utf-8", buffering=1)
+
+    # Tee stdout/stderr so print(), tracebacks, and Ray driver-forwarded logs
+    # all land in the same place while still showing on the console.
+    sys.stdout = _TeeStream(sys.__stdout__, fh)
+    sys.stderr = _TeeStream(sys.__stderr__, fh)
+
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s %(levelname)s %(name)s: %(message)s",
+        handlers=[
+            logging.StreamHandler(sys.stdout),
+        ],
+        force=True,
+    )
+    logging.getLogger(__name__).info("Writing combined pipeline logs to %s", str(target))
+    return fh, original_stdout, original_stderr
+
+
+def _estimate_processed_pages(uri: str, table_name: str) -> Optional[int]:
+    """
+    Estimate pages processed by counting unique (source_id, page_number) pairs.
+
+    Falls back to table row count if page-level fields are unavailable.
+    """
+    try:
+        db = _lancedb().connect(uri)
+        table = db.open_table(table_name)
+    except Exception:
+        return None
+
+    try:
+        df = table.to_pandas()[["source_id", "page_number"]]
+        return int(df.dropna(subset=["source_id", "page_number"]).drop_duplicates().shape[0])
+    except Exception:
+        try:
+            return int(table.count_rows())
+        except Exception:
+            return None
+
+
+def _to_int(value: object, default: int = 0) -> int:
+    try:
+        if value is None:
+            return default
+        return int(value)
+    except Exception:
+        return default
+
+
+def _collect_detection_summary(uri: str, table_name: str) -> Optional[dict]:
+    """
+    Collect per-model detection totals deduped by (source_id, page_number).
+
+    Counts are read from LanceDB row `metadata`, which is populated during batch
+    ingestion by the Ray write stage.
+    """
+    try:
+        db = _lancedb().connect(uri)
+        table = db.open_table(table_name)
+        df = table.to_pandas()[["source_id", "page_number", "metadata"]]
+    except Exception:
+        return None
+
+    # Deduplicate exploded rows by page key; keep max per-page counts.
+    per_page: dict[tuple[str, int], dict] = {}
+    for row in df.itertuples(index=False):
+        source_id = str(getattr(row, "source_id", "") or "")
+        page_number = _to_int(getattr(row, "page_number", -1), default=-1)
+        key = (source_id, page_number)
+
+        raw_metadata = getattr(row, "metadata", None)
+        meta: dict = {}
+        if isinstance(raw_metadata, str) and raw_metadata.strip():
+            try:
+                parsed = json.loads(raw_metadata)
+                if isinstance(parsed, dict):
+                    meta = parsed
+            except Exception:
+                meta = {}
+
+        entry = per_page.setdefault(
+            key,
+            {
+                "page_elements_total": 0,
+                "ocr_table_total": 0,
+                "ocr_chart_total": 0,
+                "ocr_infographic_total": 0,
+                "page_elements_by_label": defaultdict(int),
+            },
+        )
+
+        pe_total = _to_int(meta.get("page_elements_v3_num_detections"), default=0)
+        entry["page_elements_total"] = max(entry["page_elements_total"], pe_total)
+
+        ocr_table = _to_int(meta.get("ocr_table_detections"), default=0)
+        ocr_chart = _to_int(meta.get("ocr_chart_detections"), default=0)
+        ocr_infographic = _to_int(meta.get("ocr_infographic_detections"), default=0)
+        entry["ocr_table_total"] = max(entry["ocr_table_total"], ocr_table)
+        entry["ocr_chart_total"] = max(entry["ocr_chart_total"], ocr_chart)
+        entry["ocr_infographic_total"] = max(entry["ocr_infographic_total"], ocr_infographic)
+
+        label_counts = meta.get("page_elements_v3_counts_by_label")
+        if isinstance(label_counts, dict):
+            for label, count in label_counts.items():
+                if not isinstance(label, str):
+                    continue
+                entry["page_elements_by_label"][label] = max(
+                    entry["page_elements_by_label"][label],
+                    _to_int(count, default=0),
+                )
+
+    pe_by_label_totals: dict[str, int] = defaultdict(int)
+    page_elements_total = 0
+    ocr_table_total = 0
+    ocr_chart_total = 0
+    ocr_infographic_total = 0
+    for page_entry in per_page.values():
+        page_elements_total += int(page_entry["page_elements_total"])
+        ocr_table_total += int(page_entry["ocr_table_total"])
+        ocr_chart_total += int(page_entry["ocr_chart_total"])
+        ocr_infographic_total += int(page_entry["ocr_infographic_total"])
+        for label, count in page_entry["page_elements_by_label"].items():
+            pe_by_label_totals[label] += int(count)
+
+    return {
+        "pages_seen": int(len(per_page)),
+        "page_elements_v3_total_detections": int(page_elements_total),
+        "page_elements_v3_counts_by_label": dict(sorted(pe_by_label_totals.items())),
+        "ocr_table_total_detections": int(ocr_table_total),
+        "ocr_chart_total_detections": int(ocr_chart_total),
+        "ocr_infographic_total_detections": int(ocr_infographic_total),
+    }
+
+
+def _print_detection_summary(summary: Optional[dict]) -> None:
+    if summary is None:
+        print("Detection summary: unavailable (could not read LanceDB metadata).")
+        return
+    print("\nDetection summary (deduped by source_id/page_number):")
+    print(f"  Pages seen: {summary['pages_seen']}")
+    print(f"  PageElements v3 total detections: {summary['page_elements_v3_total_detections']}")
+    print(f"  OCR table detections: {summary['ocr_table_total_detections']}")
+    print(f"  OCR chart detections: {summary['ocr_chart_total_detections']}")
+    print(f"  OCR infographic detections: {summary['ocr_infographic_total_detections']}")
+    print("  PageElements v3 counts by label:")
+    by_label = summary.get("page_elements_v3_counts_by_label") or {}
+    if not by_label:
+        print("    (none)")
+    else:
+        for label, count in by_label.items():
+            print(f"    {label}: {count}")
+
+
+def _write_detection_summary(path: Path, summary: Optional[dict]) -> None:
+    target = Path(path).expanduser().resolve()
+    target.parent.mkdir(parents=True, exist_ok=True)
+    payload = summary if summary is not None else {"error": "Detection summary unavailable."}
+    target.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def _print_pages_per_second(processed_pages: Optional[int], ingest_elapsed_s: float) -> None:
+    if ingest_elapsed_s <= 0:
+        print("Pages/sec: unavailable (ingest elapsed time was non-positive).")
+        return
+    if processed_pages is None:
+        print("Pages/sec: unavailable (could not estimate processed pages). " f"Ingest time: {ingest_elapsed_s:.2f}s")
+        return
+
+    pps = processed_pages / ingest_elapsed_s
+    print(f"Pages processed: {processed_pages}")
+    print(f"Pages/sec (ingest only; excludes Ray startup and recall): {pps:.2f}")
+
+
+def _ensure_lancedb_table(uri: str, table_name: str) -> None:
+    """
+    Ensure the local LanceDB URI exists and table can be opened.
+
+    Creates an empty table with the expected schema if it does not exist yet.
+    """
+    # Local path URI in this pipeline.
+    Path(uri).mkdir(parents=True, exist_ok=True)
+
+    db = _lancedb().connect(uri)
+    try:
+        db.open_table(table_name)
+        return
+    except Exception:
+        pass
+
+    import pyarrow as pa  # type: ignore
+
+    schema = pa.schema(
+        [
+            pa.field("vector", pa.list_(pa.float32(), 2048)),
+            pa.field("pdf_page", pa.string()),
+            pa.field("filename", pa.string()),
+            pa.field("pdf_basename", pa.string()),
+            pa.field("page_number", pa.int32()),
+            pa.field("source_id", pa.string()),
+            pa.field("path", pa.string()),
+            pa.field("text", pa.string()),
+            pa.field("metadata", pa.string()),
+            pa.field("source", pa.string()),
+        ]
+    )
+    empty = pa.table(
+        {
+            "vector": [],
+            "pdf_page": [],
+            "filename": [],
+            "pdf_basename": [],
+            "page_number": [],
+            "source_id": [],
+            "path": [],
+            "text": [],
+            "metadata": [],
+            "source": [],
+        },
+        schema=schema,
+    )
+    db.create_table(table_name, data=empty, schema=schema, mode="create")
+
+
+def _gold_to_doc_page(golden_key: str) -> tuple[str, str]:
+    s = str(golden_key)
+    if "_" not in s:
+        return s, ""
+    doc, page = s.rsplit("_", 1)
+    return doc, page
+
+
+def _is_hit_at_k(golden_key: str, retrieved_keys: list[str], k: int) -> bool:
+    doc, page = _gold_to_doc_page(golden_key)
+    specific_page = f"{doc}_{page}"
+    entire_document = f"{doc}_-1"
+    top = (retrieved_keys or [])[: int(k)]
+    return (specific_page in top) or (entire_document in top)
+
+
+def _hit_key_and_distance(hit: dict) -> tuple[str | None, float | None]:
+    try:
+        res = json.loads(hit.get("metadata", "{}"))
+        source = json.loads(hit.get("source", "{}"))
+    except Exception:
+        return None, None
+
+    source_id = source.get("source_id")
+    page_number = res.get("page_number")
+    if not source_id or page_number is None:
+        return None, float(hit.get("_distance")) if "_distance" in hit else None
+
+    key = f"{Path(str(source_id)).stem}_{page_number}"
+    dist = float(hit["_distance"]) if "_distance" in hit else float(hit["_score"]) if "_score" in hit else None
+    return key, dist
+
+
+@app.command()
+def main(
+    input_dir: Path = typer.Argument(
+        ...,
+        help="Directory containing PDFs, .txt, .html, or .doc/.pptx files to ingest.",
+        path_type=Path,
+        exists=True,
+    ),
+    input_type: str = typer.Option(
+        "pdf",
+        "--input-type",
+        help="Input format: 'pdf', 'txt', 'html', or 'doc'. Use 'txt' for .txt, 'html' for .html (markitdown -> chunks), 'doc' for .docx/.pptx (converted to PDF via LibreOffice).",  # noqa: E501
+    ),
+    ray_address: Optional[str] = typer.Option(
+        None,
+        "--ray-address",
+        help="URL or address of a running Ray cluster (e.g. 'auto' or 'ray://host:10001'). Omit for in-process Ray.",
+    ),
+    start_ray: bool = typer.Option(
+        False,
+        "--start-ray",
+        help=(
+            "Start a Ray head node (ray start --head) and connect to it. "
+            "Dashboard at http://127.0.0.1:8265. Ignores --ray-address."
+        ),
+    ),
+    query_csv: Path = typer.Option(
+        "bo767_query_gt.csv",
+        "--query-csv",
+        path_type=Path,
+        help=(
+            "Path to query CSV for recall evaluation. Default: bo767_query_gt.csv "
+            "(current directory). Recall is skipped if the file does not exist."
+        ),
+    ),
+    no_recall_details: bool = typer.Option(
+        False,
+        "--no-recall-details",
+        help=(
+            "Do not print per-query retrieval details (query, gold, hits). "
+            "Only the missed-gold summary and recall metrics are printed."
+        ),
+    ),
+    pdf_extract_workers: int = typer.Option(
+        12,
+        "--pdf-extract-workers",
+        min=1,
+        help="Number of CPU workers for PDF extraction stage.",
+    ),
+    pdf_extract_num_cpus: float = typer.Option(
+        2.0,
+        "--pdf-extract-num-cpus",
+        min=0.1,
+        help="CPUs reserved per PDF extraction task.",
+    ),
+    pdf_extract_batch_size: int = typer.Option(
+        4,
+        "--pdf-extract-batch-size",
+        min=1,
+        help="Batch size for PDF extraction stage.",
+    ),
+    pdf_split_batch_size: int = typer.Option(
+        1,
+        "--pdf-split-batch-size",
+        min=1,
+        help="Batch size for PDF split stage.",
+    ),
+    page_elements_batch_size: int = typer.Option(
+        24,
+        "--page-elements-batch-size",
+        min=1,
+        help="Ray Data batch size for page-elements stage.",
+    ),
+    ocr_workers: int = typer.Option(
+        1,
+        "--ocr-workers",
+        min=1,
+        help="Actor count for OCR stage.",
+    ),
+    page_elements_workers: int = typer.Option(
+        1,
+        "--page-elements-workers",
+        min=1,
+        help="Actor count for page-elements stage.",
+    ),
+    ocr_batch_size: int = typer.Option(
+        16,
+        "--ocr-batch-size",
+        min=1,
+        help="Ray Data batch size for OCR stage.",
+    ),
+    page_elements_cpus_per_actor: float = typer.Option(
+        1.0,
+        "--page-elements-cpus-per-actor",
+        min=0.1,
+        help="CPUs reserved per page-elements actor.",
+    ),
+    ocr_cpus_per_actor: float = typer.Option(
+        1.0,
+        "--ocr-cpus-per-actor",
+        min=0.1,
+        help="CPUs reserved per OCR actor.",
+    ),
+    embed_workers: int = typer.Option(
+        1,
+        "--embed-workers",
+        min=1,
+        help="Actor count for embedding stage.",
+    ),
+    embed_batch_size: int = typer.Option(
+        256,
+        "--embed-batch-size",
+        min=1,
+        help="Ray Data batch size for embedding stage.",
+    ),
+    embed_cpus_per_actor: float = typer.Option(
+        1.0,
+        "--embed-cpus-per-actor",
+        min=0.1,
+        help="CPUs reserved per embedding actor.",
+    ),
+    gpu_page_elements: float = typer.Option(
+        0.5,
+        "--gpu-page-elements",
+        min=0.0,
+        help="GPUs reserved per page-elements actor.",
+    ),
+    gpu_ocr: float = typer.Option(
+        1.0,
+        "--gpu-ocr",
+        min=0.0,
+        help="GPUs reserved per OCR actor.",
+    ),
+    gpu_embed: float = typer.Option(
+        0.5,
+        "--gpu-embed",
+        min=0.0,
+        help="GPUs reserved per embedding actor.",
+    ),
+    # fmt: off
+    nemotron_parse_workers: float = typer.Option(
+        0.0,
+        "--nemotron-parse-workers",
+        min=0.0,
+        help=(
+            "Actor count for Nemotron Parse stage "
+            "(enables parse-only mode when > 0.0 with parse GPU/batch-size)."
+        ),  # noqa: E501
+    ),
+    # fmt: on
+    gpu_nemotron_parse: float = typer.Option(
+        0.0,
+        "--gpu-nemotron-parse",
+        min=0.0,
+        help="GPUs reserved per Nemotron Parse actor.",
+    ),
+    nemotron_parse_batch_size: float = typer.Option(
+        0.0,
+        "--nemotron-parse-batch-size",
+        min=0.0,
+        help="Ray Data batch size for Nemotron Parse stage "
+        "(enables parse-only mode when > 0.0 with parse workers/GPU).",
+    ),
+    page_elements_invoke_url: Optional[str] = typer.Option(
+        None,
+        "--page-elements-invoke-url",
+        help="Optional remote endpoint URL for page-elements model inference.",
+    ),
+    ocr_invoke_url: Optional[str] = typer.Option(
+        None,
+        "--ocr-invoke-url",
+        help="Optional remote endpoint URL for OCR model inference.",
+    ),
+    embed_invoke_url: Optional[str] = typer.Option(
+        None,
+        "--embed-invoke-url",
+        help="Optional remote endpoint URL for embedding model inference.",
+    ),
+    embed_model_name: str = typer.Option(
+        "nvidia/llama-3.2-nv-embedqa-1b-v2",
+        "--embed-model-name",
+        help="Embedding model name passed to .embed().",
+    ),
+    embed_modality: str = typer.Option(
+        "text",
+        "--embed-modality",
+        help="Default embedding modality for all element types: "
+        "'text', 'image', or 'text_image' ('image_text' is also accepted).",
+    ),
+    text_elements_modality: Optional[str] = typer.Option(
+        None,
+        "--text-elements-modality",
+        help="Embedding modality override for page-text rows. Falls back to --embed-modality.",
+    ),
+    structured_elements_modality: Optional[str] = typer.Option(
+        None,
+        "--structured-elements-modality",
+        help="Embedding modality override for table/chart/infographic rows. Falls back to --embed-modality.",
+    ),
+    runtime_metrics_dir: Optional[Path] = typer.Option(
+        None,
+        "--runtime-metrics-dir",
+        path_type=Path,
+        file_okay=False,
+        dir_okay=True,
+        help="Optional directory where Ray runtime metrics are written per run.",
+    ),
+    runtime_metrics_prefix: Optional[str] = typer.Option(
+        None,
+        "--runtime-metrics-prefix",
+        help="Optional filename prefix for per-run metrics artifacts.",
+    ),
+    lancedb_uri: str = typer.Option(
+        LANCEDB_URI,
+        "--lancedb-uri",
+        help="LanceDB URI/path for this run.",
+    ),
+    log_file: Optional[Path] = typer.Option(
+        None,
+        "--log-file",
+        path_type=Path,
+        dir_okay=False,
+        help="Optional file to collect all pipeline + Ray driver logs for this run.",
+    ),
+    ray_log_to_driver: bool = typer.Option(
+        True,
+        "--ray-log-to-driver/--no-ray-log-to-driver",
+        help="Forward Ray worker logs to the driver (recommended with --log-file).",
+    ),
+    detection_summary_file: Optional[Path] = typer.Option(
+        None,
+        "--detection-summary-file",
+        path_type=Path,
+        dir_okay=False,
+        help="Optional JSON file path to write end-of-run detection counts summary.",
+    ),
+    hybrid: bool = typer.Option(
+        False,
+        "--hybrid/--no-hybrid",
+        help="Enable LanceDB hybrid mode (dense + FTS text).",
+    ),
+) -> None:
+    log_handle, original_stdout, original_stderr = _configure_logging(log_file)
+    try:
+        os.environ["RAY_LOG_TO_DRIVER"] = "1" if ray_log_to_driver else "0"
+        # Use an absolute path so driver and Ray actors resolve the same LanceDB URI.
+        lancedb_uri = str(Path(lancedb_uri).expanduser().resolve())
+        _ensure_lancedb_table(lancedb_uri, LANCEDB_TABLE)
+
+        # Remote endpoints don't need local model GPUs for their stage.
+        if page_elements_invoke_url and float(gpu_page_elements) != 0.0:
+            print(
+                "[WARN] --page-elements-invoke-url is set; forcing --gpu-page-elements from "
+                f"{float(gpu_page_elements):.3f} to 0.0"
+            )
+            gpu_page_elements = 0.0
+
+        if ocr_invoke_url and float(gpu_ocr) != 0.0:
+            print("[WARN] --ocr-invoke-url is set; forcing --gpu-ocr from " f"{float(gpu_ocr):.3f} to 0.0")
+            gpu_ocr = 0.0
+
+        if embed_invoke_url and float(gpu_embed) != 0.0:
+            print("[WARN] --embed-invoke-url is set; forcing --gpu-embed from " f"{float(gpu_embed):.3f} to 0.0")
+            gpu_embed = 0.0
+
+        # Resolve Ray: start a head node, connect to given address, or run in-process
+        if start_ray:
+            subprocess.run(["ray", "start", "--head"], check=True, env=os.environ)
+            ray_address = "auto"
+
+        input_dir = Path(input_dir)
+        if input_type == "txt":
+            glob_pattern = str(input_dir / "*.txt")
+            ingestor = create_ingestor(
+                run_mode="batch",
+                params=IngestorCreateParams(ray_address=ray_address, ray_log_to_driver=ray_log_to_driver),
+            )
+            ingestor = (
+                ingestor.files(glob_pattern)
+                .extract_txt(TextChunkParams(max_tokens=512, overlap_tokens=0))
+                .embed(
+                    EmbedParams(
+                        model_name=str(embed_model_name),
+                        embed_invoke_url=embed_invoke_url,
+                        embed_modality=embed_modality,
+                        text_elements_modality=text_elements_modality,
+                        structured_elements_modality=structured_elements_modality,
+                    )
+                )
+                .vdb_upload(
+                    VdbUploadParams(
+                        lancedb={
+                            "lancedb_uri": lancedb_uri,
+                            "table_name": LANCEDB_TABLE,
+                            "overwrite": True,
+                            "create_index": True,
+                            "hybrid": hybrid,
+                        }
+                    )
+                )
+            )
+        elif input_type == "html":
+            glob_pattern = str(input_dir / "*.html")
+            ingestor = create_ingestor(
+                run_mode="batch",
+                params=IngestorCreateParams(ray_address=ray_address, ray_log_to_driver=ray_log_to_driver),
+            )
+            ingestor = (
+                ingestor.files(glob_pattern)
+                .extract_html(TextChunkParams(max_tokens=512, overlap_tokens=0))
+                .embed(
+                    EmbedParams(
+                        model_name=str(embed_model_name),
+                        embed_invoke_url=embed_invoke_url,
+                        embed_modality=embed_modality,
+                        text_elements_modality=text_elements_modality,
+                        structured_elements_modality=structured_elements_modality,
+                    )
+                )
+                .vdb_upload(
+                    VdbUploadParams(
+                        lancedb={
+                            "lancedb_uri": lancedb_uri,
+                            "table_name": LANCEDB_TABLE,
+                            "overwrite": True,
+                            "create_index": True,
+                            "hybrid": hybrid,
+                        }
+                    )
+                )
+            )
+        elif input_type == "doc":
+            # DOCX/PPTX: same pipeline as PDF; DocToPdfConversionActor converts before split.
+            doc_globs = [str(input_dir / "*.docx"), str(input_dir / "*.pptx")]
+            ingestor = create_ingestor(
+                run_mode="batch",
+                params=IngestorCreateParams(ray_address=ray_address, ray_log_to_driver=ray_log_to_driver),
+            )
+            ingestor = (
+                ingestor.files(doc_globs)
+                .extract(
+                    ExtractParams(
+                        extract_text=True,
+                        extract_tables=True,
+                        extract_charts=True,
+                        extract_infographics=False,
+                        page_elements_invoke_url=page_elements_invoke_url,
+                        ocr_invoke_url=ocr_invoke_url,
+                        batch_tuning={
+                            "debug_run_id": str(runtime_metrics_prefix or "unknown"),
+                            "pdf_extract_workers": int(pdf_extract_workers),
+                            "pdf_extract_num_cpus": float(pdf_extract_num_cpus),
+                            "pdf_split_batch_size": int(pdf_split_batch_size),
+                            "pdf_extract_batch_size": int(pdf_extract_batch_size),
+                            "page_elements_batch_size": int(page_elements_batch_size),
+                            "page_elements_workers": int(page_elements_workers),
+                            "detect_workers": int(ocr_workers),
+                            "detect_batch_size": int(ocr_batch_size),
+                            "page_elements_cpus_per_actor": float(page_elements_cpus_per_actor),
+                            "ocr_cpus_per_actor": float(ocr_cpus_per_actor),
+                            "gpu_page_elements": float(gpu_page_elements),
+                            "gpu_ocr": float(gpu_ocr),
+                            "gpu_embed": float(gpu_embed),
+                            "nemotron_parse_workers": float(nemotron_parse_workers),
+                            "gpu_nemotron_parse": float(gpu_nemotron_parse),
+                            "nemotron_parse_batch_size": float(nemotron_parse_batch_size),
+                        },
+                    )
+                )
+                .embed(
+                    EmbedParams(
+                        model_name=str(embed_model_name),
+                        embed_invoke_url=embed_invoke_url,
+                        embed_modality=embed_modality,
+                        text_elements_modality=text_elements_modality,
+                        structured_elements_modality=structured_elements_modality,
+                        batch_tuning={
+                            "embed_workers": int(embed_workers),
+                            "embed_batch_size": int(embed_batch_size),
+                            "embed_cpus_per_actor": float(embed_cpus_per_actor),
+                        },
+                    )
+                )
+                .vdb_upload(
+                    VdbUploadParams(
+                        lancedb={
+                            "lancedb_uri": lancedb_uri,
+                            "table_name": LANCEDB_TABLE,
+                            "overwrite": True,
+                            "create_index": True,
+                            "hybrid": hybrid,
+                        }
+                    )
+                )
+            )
+        else:
+            pdf_glob = str(input_dir / "*.pdf")
+            ingestor = create_ingestor(
+                run_mode="batch",
+                params=IngestorCreateParams(ray_address=ray_address, ray_log_to_driver=ray_log_to_driver),
+            )
+            ingestor = (
+                ingestor.files(pdf_glob)
+                .extract(
+                    ExtractParams(
+                        extract_text=True,
+                        extract_tables=True,
+                        extract_charts=True,
+                        extract_infographics=False,
+                        page_elements_invoke_url=page_elements_invoke_url,
+                        ocr_invoke_url=ocr_invoke_url,
+                        batch_tuning={
+                            "debug_run_id": str(runtime_metrics_prefix or "unknown"),
+                            "pdf_extract_workers": int(pdf_extract_workers),
+                            "pdf_extract_num_cpus": float(pdf_extract_num_cpus),
+                            "pdf_split_batch_size": int(pdf_split_batch_size),
+                            "pdf_extract_batch_size": int(pdf_extract_batch_size),
+                            "page_elements_batch_size": int(page_elements_batch_size),
+                            "page_elements_workers": int(page_elements_workers),
+                            "detect_workers": int(ocr_workers),
+                            "detect_batch_size": int(ocr_batch_size),
+                            "page_elements_cpus_per_actor": float(page_elements_cpus_per_actor),
+                            "ocr_cpus_per_actor": float(ocr_cpus_per_actor),
+                            "gpu_page_elements": float(gpu_page_elements),
+                            "gpu_ocr": float(gpu_ocr),
+                            "gpu_embed": float(gpu_embed),
+                            "nemotron_parse_workers": float(nemotron_parse_workers),
+                            "gpu_nemotron_parse": float(gpu_nemotron_parse),
+                            "nemotron_parse_batch_size": float(nemotron_parse_batch_size),
+                        },
+                    )
+                )
+                .embed(
+                    EmbedParams(
+                        model_name=str(embed_model_name),
+                        embed_invoke_url=embed_invoke_url,
+                        embed_modality=embed_modality,
+                        text_elements_modality=text_elements_modality,
+                        structured_elements_modality=structured_elements_modality,
+                        batch_tuning={
+                            "embed_workers": int(embed_workers),
+                            "embed_batch_size": int(embed_batch_size),
+                            "embed_cpus_per_actor": float(embed_cpus_per_actor),
+                        },
+                    )
+                )
+                .vdb_upload(
+                    VdbUploadParams(
+                        lancedb={
+                            "lancedb_uri": lancedb_uri,
+                            "table_name": LANCEDB_TABLE,
+                            "overwrite": True,
+                            "create_index": True,
+                            "hybrid": hybrid,
+                        }
+                    )
+                )
+            )
+
+        print("Running extraction...")
+        ingest_start = time.perf_counter()
+        ingestor.ingest(
+            params=IngestExecuteParams(
+                runtime_metrics_dir=str(runtime_metrics_dir) if runtime_metrics_dir is not None else None,
+                runtime_metrics_prefix=runtime_metrics_prefix,
+            )
+        )
+        ingest_elapsed_s = time.perf_counter() - ingest_start
+        processed_pages = _estimate_processed_pages(lancedb_uri, LANCEDB_TABLE)
+        detection_summary = _collect_detection_summary(lancedb_uri, LANCEDB_TABLE)
+        print("Extraction complete.")
+        _print_detection_summary(detection_summary)
+        if detection_summary_file is not None:
+            _write_detection_summary(detection_summary_file, detection_summary)
+            print(f"Wrote detection summary JSON to {Path(detection_summary_file).expanduser().resolve()}")
+
+        ray.shutdown()
+
+        # ---------------------------------------------------------------------------
+        # Recall calculation (optional)
+        # ---------------------------------------------------------------------------
+        query_csv = Path(query_csv)
+        if not query_csv.exists():
+            print(f"Query CSV not found at {query_csv}; skipping recall evaluation.")
+            _print_pages_per_second(processed_pages, ingest_elapsed_s)
+            return
+
+        db = _lancedb().connect(lancedb_uri)
+        table = None
+        open_err: Optional[Exception] = None
+        for _ in range(3):
+            try:
+                table = db.open_table(LANCEDB_TABLE)
+                open_err = None
+                break
+            except Exception as e:
+                open_err = e
+                # Create table if missing, then retry open.
+                _ensure_lancedb_table(lancedb_uri, LANCEDB_TABLE)
+                time.sleep(2)
+        if table is None:
+            raise RuntimeError(
+                f"Recall stage requires LanceDB table {LANCEDB_TABLE!r} at {lancedb_uri!r}, " f"but it was not found."
+            ) from open_err
+        try:
+            if int(table.count_rows()) == 0:
+                print(f"LanceDB table {LANCEDB_TABLE!r} exists but is empty; skipping recall evaluation.")
+                _print_pages_per_second(processed_pages, ingest_elapsed_s)
+                return
+        except Exception:
+            pass
+        unique_basenames = table.to_pandas()["pdf_basename"].unique()
+        print(f"Unique basenames: {unique_basenames}")
+
+        # Resolve the HF model ID for recall query embedding so aliases
+        # (e.g. "nemo_retriever_v1") map to the correct model.
+        from nemo_retriever.model import resolve_embed_model
+
+        _recall_model = resolve_embed_model(str(embed_model_name))
+
+        cfg = RecallConfig(
+            lancedb_uri=str(lancedb_uri),
+            lancedb_table=str(LANCEDB_TABLE),
+            embedding_model=_recall_model,
+            embedding_http_endpoint=embed_invoke_url,
+            top_k=10,
+            ks=(1, 5, 10),
+            hybrid=hybrid,
+        )
+
+        _df_query, _gold, _raw_hits, _retrieved_keys, metrics = retrieve_and_score(query_csv=query_csv, cfg=cfg)
+
+        if not no_recall_details:
+            print("\nPer-query retrieval details:")
+        missed_gold: list[tuple[str, str]] = []
+        ext = (
+            ".html"
+            if input_type == "html"
+            else (".txt" if input_type == "txt" else (".docx" if input_type == "doc" else ".pdf"))
+        )
+        for i, (q, g, hits) in enumerate(
+            zip(
+                _df_query["query"].astype(str).tolist(),
+                _gold,
+                _raw_hits,
+            )
+        ):
+            doc, page = _gold_to_doc_page(g)
+
+            scored_hits: list[tuple[str, float | None]] = []
+            for h in hits:
+                key, dist = _hit_key_and_distance(h)
+                if key:
+                    scored_hits.append((key, dist))
+
+            top_keys = [k for (k, _d) in scored_hits]
+            hit = _is_hit_at_k(g, top_keys, cfg.top_k)
+
+            if not no_recall_details:
+                print(f"\nQuery {i}: {q}")
+                print(f"  Gold: {g}  (file: {doc}{ext}, page: {page})")
+                print(f"  Hit@{cfg.top_k}: {hit}")
+                print("  Top hits:")
+                if not scored_hits:
+                    print("    (no hits)")
+                else:
+                    for rank, (key, dist) in enumerate(scored_hits[: int(cfg.top_k)], start=1):
+                        if dist is None:
+                            print(f"    {rank:02d}. {key}")
+                        else:
+                            print(f"    {rank:02d}. {key}  distance={dist:.6f}")
+
+            if not hit:
+                missed_gold.append((f"{doc}{ext}", str(page)))
+
+        missed_unique = sorted(set(missed_gold), key=lambda x: (x[0], x[1]))
+        print("\nMissed gold (unique doc/page):")
+        if not missed_unique:
+            print("  (none)")
+        else:
+            for doc_page, page in missed_unique:
+                print(f"  {doc_page} page {page}")
+        print(f"\nTotal missed: {len(missed_unique)} / {len(_gold)}")
+
+        print("\nRecall metrics (matching nemo_retriever.recall.core):")
+        for k, v in metrics.items():
+            print(f"  {k}: {v:.4f}")
+        _print_pages_per_second(processed_pages, ingest_elapsed_s)
+    finally:
+        # Restore real stdio before closing the mirror file so exception hooks
+        # and late flushes never write to a closed stream wrapper.
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        if log_handle is not None:
+            try:
+                log_handle.flush()
+            finally:
+                log_handle.close()
+
+
+if __name__ == "__main__":
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/examples/fused_pipeline.py b/nemo_retriever/src/nemo_retriever/examples/fused_pipeline.py
new file mode 100644
index 000000000..36b101a28
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/examples/fused_pipeline.py
@@ -0,0 +1,354 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Fused ingestion pipeline with optional recall evaluation.
+Run with: uv run python -m nemo_retriever.examples.fused_pipeline <input-dir>
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import time
+from pathlib import Path
+from typing import Optional
+
+import lancedb
+import ray
+import typer
+from nemo_retriever import create_ingestor
+from nemo_retriever.params import EmbedParams
+from nemo_retriever.params import ExtractParams
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+from nemo_retriever.params import VdbUploadParams
+from nemo_retriever.examples.batch_pipeline import (
+    LANCEDB_TABLE,
+    LANCEDB_URI,
+    _configure_logging,
+    _ensure_lancedb_table,
+    _estimate_processed_pages,
+    _gold_to_doc_page,
+    _hit_key_and_distance,
+    _is_hit_at_k,
+    _print_detection_summary,
+    _print_pages_per_second,
+    _write_detection_summary,
+    _collect_detection_summary,
+)
+from nemo_retriever.recall.core import RecallConfig, retrieve_and_score
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    input_dir: Path = typer.Argument(
+        ...,
+        help="Directory containing PDFs to ingest.",
+        path_type=Path,
+        exists=True,
+    ),
+    ray_address: Optional[str] = typer.Option(
+        None,
+        "--ray-address",
+        help="URL or address of a running Ray cluster (e.g. 'auto' or 'ray://host:10001'). Omit for in-process Ray.",
+    ),
+    start_ray: bool = typer.Option(
+        False,
+        "--start-ray",
+        help=(
+            "Start a Ray head node (ray start --head) and connect to it. "
+            "Dashboard at http://127.0.0.1:8265. Ignores --ray-address."
+        ),
+    ),
+    query_csv: Path = typer.Option(
+        "bo767_query_gt.csv",
+        "--query-csv",
+        path_type=Path,
+        help=(
+            "Path to query CSV for recall evaluation. Default: bo767_query_gt.csv "
+            "(current directory). Recall is skipped if the file does not exist."
+        ),
+    ),
+    no_recall_details: bool = typer.Option(
+        False,
+        "--no-recall-details",
+        help=(
+            "Do not print per-query retrieval details (query, gold, hits). "
+            "Only the missed-gold summary and recall metrics are printed."
+        ),
+    ),
+    pdf_extract_workers: int = typer.Option(
+        12,
+        "--pdf-extract-workers",
+        min=1,
+        help="Number of CPU workers for PDF extraction stage.",
+    ),
+    pdf_extract_num_cpus: float = typer.Option(
+        2.0,
+        "--pdf-extract-num-cpus",
+        min=0.1,
+        help="CPUs reserved per PDF extraction task.",
+    ),
+    pdf_extract_batch_size: int = typer.Option(
+        4,
+        "--pdf-extract-batch-size",
+        min=1,
+        help="Batch size for PDF extraction stage.",
+    ),
+    pdf_split_batch_size: int = typer.Option(
+        1,
+        "--pdf-split-batch-size",
+        min=1,
+        help="Batch size for PDF split stage.",
+    ),
+    fused_workers: int = typer.Option(
+        1,
+        "--fused-workers",
+        min=1,
+        help="Actor count for fused model stage.",
+    ),
+    fused_batch_size: int = typer.Option(
+        64,
+        "--fused-batch-size",
+        min=1,
+        help="Ray Data batch size for fused model stage.",
+    ),
+    fused_cpus_per_actor: float = typer.Option(
+        1.0,
+        "--fused-cpus-per-actor",
+        min=0.1,
+        help="CPUs reserved per fused actor.",
+    ),
+    fused_gpus_per_actor: float = typer.Option(
+        1.0,
+        "--fused-gpus-per-actor",
+        min=0.0,
+        help="GPUs reserved per fused actor.",
+    ),
+    runtime_metrics_dir: Optional[Path] = typer.Option(
+        None,
+        "--runtime-metrics-dir",
+        path_type=Path,
+        file_okay=False,
+        dir_okay=True,
+        help="Optional directory where Ray runtime metrics are written per run.",
+    ),
+    runtime_metrics_prefix: Optional[str] = typer.Option(
+        None,
+        "--runtime-metrics-prefix",
+        help="Optional filename prefix for per-run metrics artifacts.",
+    ),
+    lancedb_uri: str = typer.Option(
+        LANCEDB_URI,
+        "--lancedb-uri",
+        help="LanceDB URI/path for this run.",
+    ),
+    log_file: Optional[Path] = typer.Option(
+        None,
+        "--log-file",
+        path_type=Path,
+        dir_okay=False,
+        help="Optional file to collect all pipeline + Ray driver logs for this run.",
+    ),
+    ray_log_to_driver: bool = typer.Option(
+        True,
+        "--ray-log-to-driver/--no-ray-log-to-driver",
+        help="Forward Ray worker logs to the driver (recommended with --log-file).",
+    ),
+    detection_summary_file: Optional[Path] = typer.Option(
+        None,
+        "--detection-summary-file",
+        path_type=Path,
+        dir_okay=False,
+        help="Optional JSON file path to write end-of-run detection counts summary.",
+    ),
+) -> None:
+    log_handle, original_stdout, original_stderr = _configure_logging(log_file)
+    try:
+        os.environ["RAY_LOG_TO_DRIVER"] = "1" if ray_log_to_driver else "0"
+        lancedb_uri = str(Path(lancedb_uri).expanduser().resolve())
+        _ensure_lancedb_table(lancedb_uri, LANCEDB_TABLE)
+
+        if start_ray:
+            subprocess.run(["ray", "start", "--head"], check=True, env=os.environ)
+            ray_address = "auto"
+
+        input_dir = Path(input_dir)
+        pdf_glob = str(input_dir / "*.pdf")
+
+        ingestor = create_ingestor(
+            run_mode="fused",
+            params=IngestorCreateParams(ray_address=ray_address, ray_log_to_driver=ray_log_to_driver),
+        )
+        ingestor = (
+            ingestor.files(pdf_glob)
+            .extract(
+                ExtractParams(
+                    extract_text=True,
+                    extract_tables=True,
+                    extract_charts=True,
+                    extract_infographics=False,
+                    batch_tuning={
+                        "pdf_extract_workers": int(pdf_extract_workers),
+                        "pdf_extract_num_cpus": float(pdf_extract_num_cpus),
+                        "pdf_split_batch_size": int(pdf_split_batch_size),
+                        "pdf_extract_batch_size": int(pdf_extract_batch_size),
+                    },
+                )
+            )
+            .embed(
+                EmbedParams(
+                    model_name="nemo_retriever_v1",
+                    fused_tuning={
+                        "fused_workers": int(fused_workers),
+                        "fused_batch_size": int(fused_batch_size),
+                        "fused_cpus_per_actor": float(fused_cpus_per_actor),
+                        "fused_gpus_per_actor": float(fused_gpus_per_actor),
+                    },
+                )
+            )
+            .vdb_upload(
+                VdbUploadParams(
+                    lancedb={
+                        "lancedb_uri": lancedb_uri,
+                        "table_name": LANCEDB_TABLE,
+                        "overwrite": True,
+                        "create_index": True,
+                    }
+                )
+            )
+        )
+
+        print("Running extraction...")
+        ingest_start = time.perf_counter()
+        ingestor.ingest(
+            params=IngestExecuteParams(
+                runtime_metrics_dir=str(runtime_metrics_dir) if runtime_metrics_dir is not None else None,
+                runtime_metrics_prefix=runtime_metrics_prefix,
+            )
+        )
+        ingest_elapsed_s = time.perf_counter() - ingest_start
+        processed_pages = _estimate_processed_pages(lancedb_uri, LANCEDB_TABLE)
+        detection_summary = _collect_detection_summary(lancedb_uri, LANCEDB_TABLE)
+        print("Extraction complete.")
+        _print_detection_summary(detection_summary)
+        if detection_summary_file is not None:
+            _write_detection_summary(detection_summary_file, detection_summary)
+            print(f"Wrote detection summary JSON to {Path(detection_summary_file).expanduser().resolve()}")
+
+        ray.shutdown()
+
+        query_csv = Path(query_csv)
+        if not query_csv.exists():
+            print(f"Query CSV not found at {query_csv}; skipping recall evaluation.")
+            _print_pages_per_second(processed_pages, ingest_elapsed_s)
+            return
+
+        db = lancedb.connect(lancedb_uri)
+        table = None
+        open_err: Optional[Exception] = None
+        for _ in range(3):
+            try:
+                table = db.open_table(LANCEDB_TABLE)
+                open_err = None
+                break
+            except Exception as e:
+                open_err = e
+                _ensure_lancedb_table(lancedb_uri, LANCEDB_TABLE)
+                time.sleep(2)
+        if table is None:
+            raise RuntimeError(
+                f"Recall stage requires LanceDB table {LANCEDB_TABLE!r} at {lancedb_uri!r}, " f"but it was not found."
+            ) from open_err
+        try:
+            if int(table.count_rows()) == 0:
+                print(f"LanceDB table {LANCEDB_TABLE!r} exists but is empty; skipping recall evaluation.")
+                _print_pages_per_second(processed_pages, ingest_elapsed_s)
+                return
+        except Exception:
+            pass
+
+        unique_basenames = table.to_pandas()["pdf_basename"].unique()
+        print(f"Unique basenames: {unique_basenames}")
+
+        cfg = RecallConfig(
+            lancedb_uri=str(lancedb_uri),
+            lancedb_table=str(LANCEDB_TABLE),
+            embedding_model="nvidia/llama-3.2-nv-embedqa-1b-v2",
+            top_k=10,
+            ks=(1, 5, 10),
+        )
+
+        _df_query, _gold, _raw_hits, _retrieved_keys, metrics = retrieve_and_score(query_csv=query_csv, cfg=cfg)
+
+        if not no_recall_details:
+            print("\nPer-query retrieval details:")
+        missed_gold: list[tuple[str, str]] = []
+        for i, (q, g, hits) in enumerate(
+            zip(
+                _df_query["query"].astype(str).tolist(),
+                _gold,
+                _raw_hits,
+            )
+        ):
+            doc, page = _gold_to_doc_page(g)
+
+            scored_hits: list[tuple[str, float | None]] = []
+            for h in hits:
+                key, dist = _hit_key_and_distance(h)
+                if key:
+                    scored_hits.append((key, dist))
+
+            top_keys = [k for (k, _d) in scored_hits]
+            hit = _is_hit_at_k(g, top_keys, cfg.top_k)
+
+            if not no_recall_details:
+                print(f"\nQuery {i}: {q}")
+                print(f"  Gold: {g}  (file: {doc}.pdf, page: {page})")
+                print(f"  Hit@{cfg.top_k}: {hit}")
+                print("  Top hits:")
+                if not scored_hits:
+                    print("    (no hits)")
+                else:
+                    for rank, (key, dist) in enumerate(scored_hits[: int(cfg.top_k)], start=1):
+                        if dist is None:
+                            print(f"    {rank:02d}. {key}")
+                        else:
+                            print(f"    {rank:02d}. {key}  distance={dist:.6f}")
+
+            if not hit:
+                missed_gold.append((f"{doc}.pdf", str(page)))
+
+        missed_unique = sorted(set(missed_gold), key=lambda x: (x[0], x[1]))
+        print("\nMissed gold (unique pdf/page):")
+        if not missed_unique:
+            print("  (none)")
+        else:
+            for pdf, page in missed_unique:
+                print(f"  {pdf} page {page}")
+        print(f"\nTotal missed: {len(missed_unique)} / {len(_gold)}")
+
+        print("\nRecall metrics (matching nemo_retriever.recall.core):")
+        for k, v in metrics.items():
+            print(f"  {k}: {v:.4f}")
+        _print_pages_per_second(processed_pages, ingest_elapsed_s)
+    finally:
+        # Restore real stdio before closing the mirror file so exception hooks
+        # and late flushes never write to a closed stream wrapper.
+        import sys
+
+        sys.stdout = original_stdout
+        sys.stderr = original_stderr
+        if log_handle is not None:
+            try:
+                log_handle.flush()
+            finally:
+                log_handle.close()
+
+
+if __name__ == "__main__":
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/examples/inprocess_pipeline.py b/nemo_retriever/src/nemo_retriever/examples/inprocess_pipeline.py
new file mode 100644
index 000000000..360194120
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/examples/inprocess_pipeline.py
@@ -0,0 +1,450 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+In-process ingestion pipeline (no Ray) with optional recall evaluation.
+Run with: uv run python -m nemo_retriever.examples.inprocess_pipeline <input-dir>
+"""
+
+import json
+import time
+from pathlib import Path
+from typing import Optional
+
+import lancedb
+import typer
+from nemo_retriever import create_ingestor
+from nemo_retriever.params import EmbedParams
+from nemo_retriever.params import ExtractParams
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import TextChunkParams
+from nemo_retriever.params import VdbUploadParams
+from nemo_retriever.recall.core import RecallConfig, retrieve_and_score
+
+app = typer.Typer()
+
+LANCEDB_URI = "lancedb"
+LANCEDB_TABLE = "nv-ingest"
+
+
+def _estimate_processed_pages(uri: str, table_name: str) -> Optional[int]:
+    """
+    Estimate pages processed by counting unique (source_id, page_number) pairs.
+
+    Falls back to table row count if page-level fields are unavailable.
+    """
+    try:
+        db = lancedb.connect(uri)
+        table = db.open_table(table_name)
+    except Exception:
+        return None
+
+    try:
+        df = table.to_pandas()[["source_id", "page_number"]]
+        return int(df.dropna(subset=["source_id", "page_number"]).drop_duplicates().shape[0])
+    except Exception:
+        try:
+            return int(table.count_rows())
+        except Exception:
+            return None
+
+
+def _print_pages_per_second(processed_pages: Optional[int], ingest_elapsed_s: float) -> None:
+    if ingest_elapsed_s <= 0:
+        print("Pages/sec: unavailable (ingest elapsed time was non-positive).")
+        return
+    if processed_pages is None:
+        print("Pages/sec: unavailable (could not estimate processed pages). " f"Ingest time: {ingest_elapsed_s:.2f}s")
+        return
+
+    pps = processed_pages / ingest_elapsed_s
+    print(f"Pages processed: {processed_pages}")
+    print(f"Pages/sec (ingest only): {pps:.2f}")
+
+
+def _gold_to_doc_page(golden_key: str) -> tuple[str, str]:
+    s = str(golden_key)
+    if "_" not in s:
+        return s, ""
+    doc, page = s.rsplit("_", 1)
+    return doc, page
+
+
+def _is_hit_at_k(golden_key: str, retrieved_keys: list[str], k: int) -> bool:
+    doc, page = _gold_to_doc_page(golden_key)
+    specific_page = f"{doc}_{page}"
+    entire_document = f"{doc}_-1"
+    top = (retrieved_keys or [])[: int(k)]
+    return (specific_page in top) or (entire_document in top)
+
+
+def _hit_key_and_distance(hit: dict) -> tuple[str | None, float | None]:
+    try:
+        res = json.loads(hit.get("metadata", "{}"))
+        source = json.loads(hit.get("source", "{}"))
+    except Exception:
+        return None, None
+
+    source_id = source.get("source_id")
+    page_number = res.get("page_number")
+    if not source_id or page_number is None:
+        return None, float(hit.get("_distance")) if "_distance" in hit else None
+
+    key = f"{Path(str(source_id)).stem}_{page_number}"
+    dist = float(hit.get("_distance")) if "_distance" in hit else None
+    return key, dist
+
+
+@app.command()
+def main(
+    input_dir: Path = typer.Argument(
+        ...,
+        help="Directory containing PDFs, .txt, .html, or .doc/.pptx files to ingest.",
+        path_type=Path,
+        exists=True,
+    ),
+    input_type: str = typer.Option(
+        "pdf",
+        "--input-type",
+        help="Input format: 'pdf', 'txt', 'html', or 'doc'. Use 'txt' for .txt, 'html' for .html (markitdown -> chunks), 'doc' for .docx/.pptx (converted to PDF via LibreOffice).",  # noqa: E501
+    ),
+    query_csv: Path = typer.Option(
+        "bo767_query_gt.csv",
+        "--query-csv",
+        path_type=Path,
+        help="Path to query CSV for recall evaluation. Default: bo767_query_gt.csv (current directory). Recall is skipped if the file does not exist.",  # noqa: E501
+    ),
+    no_recall_details: bool = typer.Option(
+        False,
+        "--no-recall-details",
+        help="Do not print per-query retrieval details (query, gold, hits). Only the missed-gold summary and recall metrics are printed.",  # noqa: E501
+    ),
+    max_workers: int = typer.Option(
+        16,
+        "--max-workers",
+        help="Maximum number of parallel ingest workers.",
+    ),
+    gpu_devices: Optional[str] = typer.Option(
+        None,
+        "--gpu-devices",
+        help="Comma-separated GPU device IDs (e.g. --gpu-devices 0,1,2). Mutually exclusive with --num-gpus.",
+    ),
+    num_gpus: Optional[int] = typer.Option(
+        None,
+        "--num-gpus",
+        help="Number of GPUs to use, starting from device 0 (e.g. --num-gpus 2 → GPUs 0,1). Mutually exclusive with --gpu-devices.",  # noqa: E501
+    ),
+    page_elements_invoke_url: Optional[str] = typer.Option(
+        None,
+        "--page-elements-invoke-url",
+        help="Optional remote endpoint URL for page-elements model inference.",
+    ),
+    ocr_invoke_url: Optional[str] = typer.Option(
+        None,
+        "--ocr-invoke-url",
+        help="Optional remote endpoint URL for OCR model inference.",
+    ),
+    embed_invoke_url: Optional[str] = typer.Option(
+        None,
+        "--embed-invoke-url",
+        help="Optional remote endpoint URL for embedding model inference.",
+    ),
+    embed_model_name: str = typer.Option(
+        "nvidia/llama-3.2-nv-embedqa-1b-v2",
+        "--embed-model-name",
+        help="Embedding model name passed to .embed().",
+    ),
+    nemotron_parse_workers: float = typer.Option(
+        0.0,
+        "--nemotron-parse-workers",
+        min=0.0,
+        help="Enable Parse-only extraction path when > 0.0 with parse GPU/batch-size.",
+    ),
+    gpu_nemotron_parse: float = typer.Option(
+        0.0,
+        "--gpu-nemotron-parse",
+        min=0.0,
+        help="GPU allocation hint for Parse-only extraction path.",
+    ),
+    nemotron_parse_batch_size: float = typer.Option(
+        0.0,
+        "--nemotron-parse-batch-size",
+        min=0.0,
+        help="Parse stage batch size (enables Parse-only path when > 0.0 with parse workers/GPU).",
+    ),
+    embed_modality: str = typer.Option(
+        "text",
+        "--embed-modality",
+        help="Default embedding modality for all element types: "
+        "'text', 'image', or 'text_image' ('image_text' is also accepted).",
+    ),
+    text_elements_modality: Optional[str] = typer.Option(
+        None,
+        "--text-elements-modality",
+        help="Embedding modality override for page-text rows. Falls back to --embed-modality.",
+    ),
+    structured_elements_modality: Optional[str] = typer.Option(
+        None,
+        "--structured-elements-modality",
+        help="Embedding modality override for table/chart/infographic rows. Falls back to --embed-modality.",
+    ),
+) -> None:
+    _ = input_type
+
+    if gpu_devices is not None and num_gpus is not None:
+        raise typer.BadParameter("--gpu-devices and --num-gpus are mutually exclusive.")
+    if gpu_devices is not None:
+        gpu_device_list = [d.strip() for d in gpu_devices.split(",") if d.strip()]
+    elif num_gpus is not None:
+        gpu_device_list = [str(i) for i in range(num_gpus)] if num_gpus > 0 else ["0"]
+    else:
+        gpu_device_list = ["0"]
+
+    input_dir = Path(input_dir)
+    if input_type == "txt":
+        glob_pattern = str(input_dir / "*.txt")
+        ingestor = create_ingestor(run_mode="inprocess")
+        ingestor = (
+            ingestor.files(glob_pattern)
+            .extract_txt(TextChunkParams(max_tokens=512, overlap_tokens=0))
+            .embed(
+                EmbedParams(
+                    model_name=str(embed_model_name),
+                    embed_invoke_url=embed_invoke_url,
+                    embed_modality=embed_modality,
+                    text_elements_modality=text_elements_modality,
+                    structured_elements_modality=structured_elements_modality,
+                )
+            )
+            .vdb_upload(
+                VdbUploadParams(
+                    lancedb={
+                        "lancedb_uri": LANCEDB_URI,
+                        "table_name": LANCEDB_TABLE,
+                        "overwrite": True,
+                        "create_index": True,
+                    }
+                )
+            )
+        )
+    elif input_type == "html":
+        glob_pattern = str(input_dir / "*.html")
+        ingestor = create_ingestor(run_mode="inprocess")
+        ingestor = (
+            ingestor.files(glob_pattern)
+            .extract_html(TextChunkParams(max_tokens=512, overlap_tokens=0))
+            .embed(
+                EmbedParams(
+                    model_name=str(embed_model_name),
+                    embed_invoke_url=embed_invoke_url,
+                    embed_modality=embed_modality,
+                    text_elements_modality=text_elements_modality,
+                    structured_elements_modality=structured_elements_modality,
+                )
+            )
+            .vdb_upload(
+                VdbUploadParams(
+                    lancedb={
+                        "lancedb_uri": LANCEDB_URI,
+                        "table_name": LANCEDB_TABLE,
+                        "overwrite": True,
+                        "create_index": True,
+                    }
+                )
+            )
+        )
+    elif input_type == "doc":
+        # DOCX/PPTX: same pipeline as PDF; inprocess loader converts to PDF then splits.
+        doc_globs = [str(input_dir / "*.docx"), str(input_dir / "*.pptx")]
+        ingestor = create_ingestor(run_mode="inprocess")
+        ingestor = (
+            ingestor.files(doc_globs)
+            .extract(
+                ExtractParams(
+                    method="pdfium",
+                    extract_text=True,
+                    extract_tables=True,
+                    extract_charts=True,
+                    extract_infographics=False,
+                    page_elements_invoke_url=page_elements_invoke_url,
+                    ocr_invoke_url=ocr_invoke_url,
+                    batch_tuning={
+                        "nemotron_parse_workers": float(nemotron_parse_workers),
+                        "gpu_nemotron_parse": float(gpu_nemotron_parse),
+                        "nemotron_parse_batch_size": float(nemotron_parse_batch_size),
+                    },
+                )
+            )
+            .embed(
+                EmbedParams(
+                    model_name=str(embed_model_name),
+                    embed_invoke_url=embed_invoke_url,
+                    embed_modality=embed_modality,
+                    text_elements_modality=text_elements_modality,
+                    structured_elements_modality=structured_elements_modality,
+                )
+            )
+            .vdb_upload(
+                VdbUploadParams(
+                    lancedb={
+                        "lancedb_uri": LANCEDB_URI,
+                        "table_name": LANCEDB_TABLE,
+                        "overwrite": True,
+                        "create_index": True,
+                    }
+                )
+            )
+        )
+    else:
+        glob_pattern = str(input_dir / "*.pdf")
+        ingestor = create_ingestor(run_mode="inprocess")
+        ingestor = (
+            ingestor.files(glob_pattern)
+            .extract(
+                ExtractParams(
+                    method="pdfium",
+                    extract_text=True,
+                    extract_tables=True,
+                    extract_charts=True,
+                    extract_infographics=False,
+                    page_elements_invoke_url=page_elements_invoke_url,
+                    ocr_invoke_url=ocr_invoke_url,
+                    batch_tuning={
+                        "nemotron_parse_workers": float(nemotron_parse_workers),
+                        "gpu_nemotron_parse": float(gpu_nemotron_parse),
+                        "nemotron_parse_batch_size": float(nemotron_parse_batch_size),
+                    },
+                )
+            )
+            .embed(
+                EmbedParams(
+                    model_name=str(embed_model_name),
+                    embed_invoke_url=embed_invoke_url,
+                    embed_modality=embed_modality,
+                    text_elements_modality=text_elements_modality,
+                    structured_elements_modality=structured_elements_modality,
+                )
+            )
+            .vdb_upload(
+                VdbUploadParams(
+                    lancedb={
+                        "lancedb_uri": LANCEDB_URI,
+                        "table_name": LANCEDB_TABLE,
+                        "overwrite": True,
+                        "create_index": True,
+                    }
+                )
+            )
+        )
+
+    print("Running extraction...")
+    ingest_start = time.perf_counter()
+    ingestor.ingest(
+        params=IngestExecuteParams(
+            parallel=True,
+            max_workers=max_workers,
+            gpu_devices=gpu_device_list,
+            show_progress=True,
+        )
+    )
+    ingest_elapsed_s = time.perf_counter() - ingest_start
+    processed_pages = _estimate_processed_pages(LANCEDB_URI, LANCEDB_TABLE)
+    print("Extraction complete.")
+
+    # ---------------------------------------------------------------------------
+    # Recall calculation (optional)
+    # ---------------------------------------------------------------------------
+    query_csv = Path(query_csv)
+    if not query_csv.exists():
+        print(f"Query CSV not found at {query_csv}; skipping recall evaluation.")
+        _print_pages_per_second(processed_pages, ingest_elapsed_s)
+        return
+
+    db = lancedb.connect(f"./{LANCEDB_URI}")
+    table = db.open_table(LANCEDB_TABLE)
+    unique_basenames = table.to_pandas()["pdf_basename"].unique()
+    print(f"Unique basenames: {unique_basenames}")
+
+    # Resolve the HF model ID for recall query embedding so aliases
+    # (e.g. "nemo_retriever_v1") map to the correct model.
+    from nemo_retriever.model import resolve_embed_model
+
+    _recall_model = resolve_embed_model(str(embed_model_name))
+
+    cfg = RecallConfig(
+        lancedb_uri=str(LANCEDB_URI),
+        lancedb_table=str(LANCEDB_TABLE),
+        embedding_model=_recall_model,
+        embedding_http_endpoint=embed_invoke_url,
+        top_k=10,
+        ks=(1, 5, 10),
+    )
+
+    _df_query, _gold, _raw_hits, _retrieved_keys, metrics = retrieve_and_score(query_csv=query_csv, cfg=cfg)
+
+    if not no_recall_details:
+        print("\nPer-query retrieval details:")
+    missed_gold: list[tuple[str, str]] = []
+    for i, (q, g, hits) in enumerate(
+        zip(
+            _df_query["query"].astype(str).tolist(),
+            _gold,
+            _raw_hits,
+        )
+    ):
+        doc, page = _gold_to_doc_page(g)
+
+        scored_hits: list[tuple[str, float | None]] = []
+        for h in hits:
+            key, dist = _hit_key_and_distance(h)
+            if key:
+                scored_hits.append((key, dist))
+
+        top_keys = [k for (k, _d) in scored_hits]
+        hit = _is_hit_at_k(g, top_keys, cfg.top_k)
+
+        if not no_recall_details:
+            ext = (
+                ".txt"
+                if input_type == "txt"
+                else (".html" if input_type == "html" else (".docx" if input_type == "doc" else ".pdf"))
+            )
+            print(f"\nQuery {i}: {q}")
+            print(f"  Gold: {g}  (file: {doc}{ext}, page: {page})")
+            print(f"  Hit@{cfg.top_k}: {hit}")
+            print("  Top hits:")
+            if not scored_hits:
+                print("    (no hits)")
+            else:
+                for rank, (key, dist) in enumerate(scored_hits[: int(cfg.top_k)], start=1):
+                    if dist is None:
+                        print(f"    {rank:02d}. {key}")
+                    else:
+                        print(f"    {rank:02d}. {key}  distance={dist:.6f}")
+
+        if not hit:
+            ext = (
+                ".txt"
+                if input_type == "txt"
+                else (".html" if input_type == "html" else (".docx" if input_type == "doc" else ".pdf"))
+            )
+            missed_gold.append((f"{doc}{ext}", str(page)))
+
+    missed_unique = sorted(set(missed_gold), key=lambda x: (x[0], x[1]))
+    print("\nMissed gold (unique doc/page):")
+    if not missed_unique:
+        print("  (none)")
+    else:
+        for doc_page, page in missed_unique:
+            print(f"  {doc_page} page {page}")
+    print(f"\nTotal missed: {len(missed_unique)} / {len(_gold)}")
+
+    print("\nRecall metrics (matching nemo_retriever.recall.core):")
+    for k, v in metrics.items():
+        print(f"  {k}: {v:.4f}")
+    _print_pages_per_second(processed_pages, ingest_elapsed_s)
+
+
+if __name__ == "__main__":
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/examples/online_pipeline.py b/nemo_retriever/src/nemo_retriever/examples/online_pipeline.py
new file mode 100644
index 000000000..6d1f098e5
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/examples/online_pipeline.py
@@ -0,0 +1,277 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Unified ingestion pipeline: inprocess (local) or online (REST API) with optional recall.
+
+- Inprocess: runs the full pipeline locally (no server).
+- Online: submits each document to the online ingest REST service (start with
+  `retriever online serve`). Uses the same LanceDB for recall evaluation.
+
+Run with:
+  uv run python -m nemo_retriever.examples.online_pipeline <input-dir>
+  uv run python -m nemo_retriever.examples.online_pipeline <input-dir>
+  --run-mode online --base-url http://localhost:7670
+"""
+
+import json
+from pathlib import Path
+
+import lancedb
+import typer
+from nemo_retriever import create_ingestor
+from nemo_retriever.params import EmbedParams
+from nemo_retriever.params import ExtractParams
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+from nemo_retriever.params import TextChunkParams
+from nemo_retriever.params import VdbUploadParams
+from nemo_retriever.recall.core import RecallConfig, retrieve_and_score
+
+app = typer.Typer()
+
+LANCEDB_URI = "lancedb"
+LANCEDB_TABLE = "nv-ingest"
+
+
+def _gold_to_doc_page(golden_key: str) -> tuple[str, str]:
+    s = str(golden_key)
+    if "_" not in s:
+        return s, ""
+    doc, page = s.rsplit("_", 1)
+    return doc, page
+
+
+def _is_hit_at_k(golden_key: str, retrieved_keys: list[str], k: int) -> bool:
+    doc, page = _gold_to_doc_page(golden_key)
+    specific_page = f"{doc}_{page}"
+    entire_document = f"{doc}_-1"
+    top = (retrieved_keys or [])[: int(k)]
+    return (specific_page in top) or (entire_document in top)
+
+
+def _hit_key_and_distance(hit: dict) -> tuple[str | None, float | None]:
+    try:
+        res = json.loads(hit.get("metadata", "{}"))
+        source = json.loads(hit.get("source", "{}"))
+    except Exception:
+        return None, None
+
+    source_id = source.get("source_id")
+    page_number = res.get("page_number")
+    if not source_id or page_number is None:
+        return None, float(hit.get("_distance")) if "_distance" in hit else None
+
+    key = f"{Path(str(source_id)).stem}_{page_number}"
+    dist = float(hit.get("_distance")) if "_distance" in hit else None
+    return key, dist
+
+
+@app.command()
+def main(
+    input_dir: Path = typer.Argument(
+        ...,
+        help="Directory containing PDFs or .txt files to ingest.",
+        path_type=Path,
+        exists=True,
+    ),
+    run_mode: str = typer.Option(
+        "inprocess",
+        "--run-mode",
+        "-m",
+        help="'inprocess' (local pipeline) or 'online' (submit to REST API).",
+    ),
+    base_url: str = typer.Option(
+        "http://localhost:7670",
+        "--base-url",
+        "-u",
+        help="Base URL of the online ingest service (used when run-mode=online).",
+    ),
+    input_type: str = typer.Option(
+        "pdf",
+        "--input-type",
+        help="Input format: 'pdf', 'txt', or 'doc'. Online mode supports PDF only.",
+    ),
+    query_csv: Path = typer.Option(
+        "bo767_query_gt.csv",
+        "--query-csv",
+        path_type=Path,
+        help="Path to query CSV for recall evaluation. Recall is skipped if the file does not exist.",
+    ),
+    no_recall_details: bool = typer.Option(
+        False,
+        "--no-recall-details",
+        help="Do not print per-query retrieval details.",
+    ),
+) -> None:
+    if run_mode not in ("inprocess", "online"):
+        raise typer.BadParameter("run_mode must be 'inprocess' or 'online'")
+
+    if run_mode == "online" and input_type != "pdf":
+        typer.echo("Online mode currently supports PDF only; use --input-type pdf.", err=True)
+        raise typer.Exit(1)
+
+    _ = input_type
+
+    input_dir = Path(input_dir)
+
+    if run_mode == "online":
+        ingestor = create_ingestor(run_mode="online", params=IngestorCreateParams(base_url=base_url))
+        glob_pattern = str(input_dir / "*.pdf")
+        ingestor = (
+            ingestor.files(glob_pattern)
+            .extract(ExtractParams(method="pdfium", extract_text=True, extract_tables=True, extract_charts=True))
+            .embed(EmbedParams(model_name="nemo_retriever_v1"))
+            .vdb_upload(
+                VdbUploadParams(
+                    lancedb={
+                        "lancedb_uri": LANCEDB_URI,
+                        "table_name": LANCEDB_TABLE,
+                        "overwrite": False,
+                        "create_index": True,
+                    }
+                )
+            )
+        )
+        typer.echo("Submitting documents to online ingest service...")
+        results = ingestor.ingest()
+        ok_count = sum(1 for r in results if r.get("ok"))
+        total_rows = sum(int(r.get("rows_written", 0)) for r in results if r.get("ok"))
+        total_sec = sum(float(r.get("total_duration_sec", 0)) for r in results if r.get("ok"))
+        typer.echo(f"Online ingest: {ok_count}/{len(results)} docs OK, {total_rows} rows, {total_sec:.2f}s total.")
+        for r in results:
+            if not r.get("ok"):
+                typer.echo(f"  FAIL {r.get('source_path', '?')}: {r.get('error', 'unknown')}", err=True)
+    else:
+        # Inprocess: same as inprocess_pipeline
+        if input_type == "txt":
+            glob_pattern = str(input_dir / "*.txt")
+            ingestor = create_ingestor(run_mode="inprocess")
+            ingestor = (
+                ingestor.files(glob_pattern)
+                .extract_txt(TextChunkParams(max_tokens=512, overlap_tokens=0))
+                .embed(EmbedParams(model_name="nemo_retriever_v1"))
+                .vdb_upload(
+                    VdbUploadParams(
+                        lancedb={
+                            "lancedb_uri": LANCEDB_URI,
+                            "table_name": LANCEDB_TABLE,
+                            "overwrite": False,
+                            "create_index": True,
+                        }
+                    )
+                )
+            )
+        elif input_type == "doc":
+            doc_globs = [str(input_dir / "*.docx"), str(input_dir / "*.pptx")]
+            ingestor = create_ingestor(run_mode="inprocess")
+            ingestor = (
+                ingestor.files(doc_globs)
+                .extract(ExtractParams(method="pdfium", extract_text=True, extract_tables=True, extract_charts=True))
+                .embed(EmbedParams(model_name="nemo_retriever_v1"))
+                .vdb_upload(
+                    VdbUploadParams(
+                        lancedb={
+                            "lancedb_uri": LANCEDB_URI,
+                            "table_name": LANCEDB_TABLE,
+                            "overwrite": False,
+                            "create_index": True,
+                        }
+                    )
+                )
+            )
+        else:
+            glob_pattern = str(input_dir / "*.pdf")
+            ingestor = create_ingestor(run_mode="inprocess")
+            ingestor = (
+                ingestor.files(glob_pattern)
+                .extract(ExtractParams(method="pdfium", extract_text=True, extract_tables=True, extract_charts=True))
+                .embed(EmbedParams(model_name="nemo_retriever_v1"))
+                .vdb_upload(
+                    VdbUploadParams(
+                        lancedb={
+                            "lancedb_uri": LANCEDB_URI,
+                            "table_name": LANCEDB_TABLE,
+                            "overwrite": False,
+                            "create_index": True,
+                        }
+                    )
+                )
+            )
+        typer.echo("Running inprocess extraction...")
+        ingestor.ingest(params=IngestExecuteParams(show_progress=True))
+        typer.echo("Extraction complete.")
+
+    # Recall evaluation (same for both modes)
+    query_csv = Path(query_csv)
+    if not query_csv.exists():
+        typer.echo(f"Query CSV not found at {query_csv}; skipping recall evaluation.")
+        return
+
+    db = lancedb.connect(f"./{LANCEDB_URI}")
+    table = db.open_table(LANCEDB_TABLE)
+    unique_basenames = table.to_pandas()["pdf_basename"].unique()
+    typer.echo(f"Unique basenames in VDB: {unique_basenames}")
+
+    cfg = RecallConfig(
+        lancedb_uri=str(LANCEDB_URI),
+        lancedb_table=str(LANCEDB_TABLE),
+        embedding_model="nvidia/llama-3.2-nv-embedqa-1b-v2",
+        top_k=10,
+        ks=(1, 5, 10),
+    )
+
+    _df_query, _gold, _raw_hits, _retrieved_keys, metrics = retrieve_and_score(query_csv=query_csv, cfg=cfg)
+
+    if not no_recall_details:
+        typer.echo("\nPer-query retrieval details:")
+    missed_gold: list[tuple[str, str]] = []
+    for i, (q, g, hits) in enumerate(
+        zip(
+            _df_query["query"].astype(str).tolist(),
+            _gold,
+            _raw_hits,
+        )
+    ):
+        doc, page = _gold_to_doc_page(g)
+        scored_hits: list[tuple[str, float | None]] = []
+        for h in hits:
+            key, dist = _hit_key_and_distance(h)
+            if key:
+                scored_hits.append((key, dist))
+        top_keys = [k for (k, _d) in scored_hits]
+        hit = _is_hit_at_k(g, top_keys, cfg.top_k)
+        if not no_recall_details:
+            ext = ".txt" if input_type == "txt" else (".docx" if input_type == "doc" else ".pdf")
+            typer.echo(f"\nQuery {i}: {q}")
+            typer.echo(f"  Gold: {g}  (file: {doc}{ext}, page: {page})")
+            typer.echo(f"  Hit@{cfg.top_k}: {hit}")
+            typer.echo("  Top hits:")
+            if not scored_hits:
+                typer.echo("    (no hits)")
+            else:
+                for rank, (key, dist) in enumerate(scored_hits[: int(cfg.top_k)], start=1):
+                    if dist is None:
+                        typer.echo(f"    {rank:02d}. {key}")
+                    else:
+                        typer.echo(f"    {rank:02d}. {key}  distance={dist:.6f}")
+        if not hit:
+            ext = ".txt" if input_type == "txt" else (".docx" if input_type == "doc" else ".pdf")
+            missed_gold.append((f"{doc}{ext}", str(page)))
+
+    missed_unique = sorted(set(missed_gold), key=lambda x: (x[0], x[1]))
+    typer.echo("\nMissed gold (unique doc/page):")
+    if not missed_unique:
+        typer.echo("  (none)")
+    else:
+        for doc_page, page in missed_unique:
+            typer.echo(f"  {doc_page} page {page}")
+    typer.echo(f"\nTotal missed: {len(missed_unique)} / {len(_gold)}")
+    typer.echo("\nRecall metrics:")
+    for k, v in metrics.items():
+        typer.echo(f"  {k}: {v:.4f}")
+
+
+if __name__ == "__main__":
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/html/__init__.py b/nemo_retriever/src/nemo_retriever/html/__init__.py
new file mode 100644
index 000000000..47141ccc0
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/html/__init__.py
@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+HTML ingestion: markitdown conversion to markdown, then tokenizer-based chunking.
+
+Compatible with the same embed and LanceDB stages as PDF/txt primitives.
+"""
+
+from .convert import (
+    html_bytes_to_chunks_df,
+    html_file_to_chunks_df,
+    html_to_markdown,
+)
+
+__all__ = [
+    "html_bytes_to_chunks_df",
+    "html_file_to_chunks_df",
+    "html_to_markdown",
+]
diff --git a/nemo_retriever/src/nemo_retriever/html/__main__.py b/nemo_retriever/src/nemo_retriever/html/__main__.py
new file mode 100644
index 000000000..28d4e9a37
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/html/__main__.py
@@ -0,0 +1,107 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+CLI for .html extraction: markitdown -> markdown -> tokenizer split, write *.html_extraction.json.
+
+Use with: retriever local stage5 run --pattern "*.html_extraction.json" then stage6.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+from rich.console import Console
+from nemo_retriever.params import HtmlChunkParams
+
+from . import html_file_to_chunks_df
+
+console = Console()
+app = typer.Typer(help="HTML extraction: markitdown -> markdown -> chunks, write primitives-like JSON.")
+
+
+def _to_jsonable(val: Any) -> Any:
+    """Convert to JSON-serializable (e.g. numpy int64 -> int)."""
+    if hasattr(val, "item"):
+        return val.item()
+    if hasattr(val, "tolist"):
+        return val.tolist()
+    if isinstance(val, dict):
+        return {k: _to_jsonable(v) for k, v in val.items()}
+    if isinstance(val, list):
+        return [_to_jsonable(x) for x in val]
+    return val
+
+
+@app.command("run")
+def run(
+    input_dir: Path = typer.Option(
+        ...,
+        "--input-dir",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to scan for *.html files.",
+    ),
+    output_dir: Optional[Path] = typer.Option(
+        None,
+        "--output-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to write *.html_extraction.json. Default: alongside each input file.",
+    ),
+    max_tokens: int = typer.Option(512, "--max-tokens", min=1, help="Max tokens per chunk."),
+    overlap: int = typer.Option(0, "--overlap", min=0, help="Overlap tokens between consecutive chunks."),
+    encoding: str = typer.Option("utf-8", "--encoding", help="File encoding for reading .html."),
+    limit: Optional[int] = typer.Option(None, "--limit", min=1, help="Limit number of .html files processed."),
+) -> None:
+    """
+    Scan input_dir for *.html, convert to markdown and chunk each, write <stem>.html_extraction.json.
+
+    Output JSON has the same primitives-like shape as stage5 input (text, path, page_number, metadata).
+    Then run: retriever local stage5 run --input-dir <dir> --pattern "*.html_extraction.json"
+    and retriever local stage6 run --input-dir <dir>.
+    """
+    input_dir = Path(input_dir)
+    html_files = sorted(input_dir.glob("*.html"))
+    if not html_files:
+        console.print(f"[red]No *.html files found in[/red] {input_dir}")
+        raise typer.Exit(code=2)
+    if limit is not None:
+        html_files = html_files[:limit]
+
+    for path in html_files:
+        try:
+            df = html_file_to_chunks_df(
+                str(path),
+                params=HtmlChunkParams(
+                    max_tokens=max_tokens,
+                    overlap_tokens=overlap,
+                    encoding=encoding,
+                ),
+            )
+        except Exception as e:
+            console.print(f"[red]Failed[/red] {path}: {e}")
+            continue
+
+        out_path: Path
+        if output_dir is not None:
+            output_dir.mkdir(parents=True, exist_ok=True)
+            out_path = Path(output_dir) / f"{path.stem}.html_extraction.json"
+        else:
+            out_path = path.with_suffix(".html_extraction.json")
+
+        records = df.to_dict(orient="records")
+        jsonable = _to_jsonable(records)
+        out_path.write_text(json.dumps(jsonable, ensure_ascii=False, indent=2), encoding="utf-8")
+        console.print(f"[green]Wrote[/green] {out_path} ({len(df)} chunks)")
+
+    console.print(f"[green]Done[/green] processed={len(html_files)}")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/html/convert.py b/nemo_retriever/src/nemo_retriever/html/convert.py
new file mode 100644
index 000000000..a4968a670
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/html/convert.py
@@ -0,0 +1,196 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+HTML to markdown conversion via markitdown, then tokenizer-based chunking.
+
+Produces chunk DataFrames compatible with embed_text_from_primitives_df
+and the LanceDB row builder (text, path, page_number, metadata).
+"""
+
+from __future__ import annotations
+
+import io
+import tempfile
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+import pandas as pd
+from nemo_retriever.params import HtmlChunkParams
+
+from ..txt.split import (
+    DEFAULT_TOKENIZER_MODEL_ID,
+    split_text_by_tokens,
+)
+from ..txt.split import _get_tokenizer as _get_txt_tokenizer
+
+
+def html_to_markdown(html_content: Union[str, bytes, Path]) -> str:
+    """
+    Convert HTML to markdown using markitdown.
+
+    Parameters
+    ----------
+    html_content : str | bytes | Path
+        HTML as a string, bytes, or path to an .html file.
+
+    Returns
+    -------
+    str
+        Markdown text.
+    """
+    from markitdown import MarkItDown
+
+    md = MarkItDown()
+    if isinstance(html_content, Path):
+        html_content = str(html_content)
+    if isinstance(html_content, str):
+        if Path(html_content).is_file():
+            result = md.convert(html_content)
+        else:
+            result = md.convert_stream(io.BytesIO(html_content.encode("utf-8", errors="replace")))
+    elif isinstance(html_content, bytes):
+        result = md.convert_stream(io.BytesIO(html_content))
+    else:
+        result = md.convert(html_content)
+    return result.text_content or ""
+
+
+def html_file_to_chunks_df(
+    path: str,
+    params: HtmlChunkParams | None = None,
+) -> pd.DataFrame:
+    chunk_params = params or HtmlChunkParams()
+    max_tokens = chunk_params.max_tokens
+    overlap_tokens = chunk_params.overlap_tokens
+    tokenizer_model_id = chunk_params.tokenizer_model_id
+    tokenizer_cache_dir = chunk_params.tokenizer_cache_dir
+
+    """
+    Read an .html file, convert to markdown via markitdown, chunk by tokens.
+
+    Columns: text, path, page_number (chunk index, 1-based), metadata.
+    Shape is compatible with embed_text_from_primitives_df and LanceDB row build.
+
+    Parameters
+    ----------
+    path : str
+        Path to the .html file.
+    max_tokens : int
+        Max tokens per chunk (default 512).
+    overlap_tokens : int
+        Overlap between consecutive chunks (default 0).
+    tokenizer_model_id : str, optional
+        HuggingFace model id for tokenizer (default: same as embedder).
+    encoding : str
+        File encoding (default utf-8).
+    tokenizer_cache_dir : str, optional
+        HuggingFace cache directory for tokenizer.
+
+    Returns
+    -------
+    pd.DataFrame
+        Columns: text, path, page_number, metadata.
+    """
+    path = str(Path(path).resolve())
+    from markitdown import MarkItDown
+
+    md = MarkItDown()
+    result = md.convert(path)
+    markdown_text = result.text_content or ""
+    return _markdown_to_chunks_df(
+        markdown_text,
+        path,
+        max_tokens=max_tokens,
+        overlap_tokens=overlap_tokens,
+        tokenizer_model_id=tokenizer_model_id,
+        tokenizer_cache_dir=tokenizer_cache_dir,
+    )
+
+
+def html_bytes_to_chunks_df(
+    content_bytes: bytes,
+    path: str,
+    params: HtmlChunkParams | None = None,
+) -> pd.DataFrame:
+    chunk_params = params or HtmlChunkParams()
+    max_tokens = chunk_params.max_tokens
+    overlap_tokens = chunk_params.overlap_tokens
+    tokenizer_model_id = chunk_params.tokenizer_model_id
+    tokenizer_cache_dir = chunk_params.tokenizer_cache_dir
+
+    """
+    Convert HTML bytes to markdown and return a DataFrame of chunks (same shape as html_file_to_chunks_df).
+
+    Used by batch HtmlSplitActor when input is bytes + path from read_binary_files.
+    """
+    path = str(Path(path).resolve())
+    # Use temp file so markitdown can detect HTML by extension
+    with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as f:
+        f.write(content_bytes)
+        tmp_path = f.name
+    try:
+        from markitdown import MarkItDown
+
+        md = MarkItDown()
+        result = md.convert(tmp_path)
+        markdown_text = result.text_content or ""
+    finally:
+        Path(tmp_path).unlink(missing_ok=True)
+    return _markdown_to_chunks_df(
+        markdown_text,
+        path,
+        max_tokens=max_tokens,
+        overlap_tokens=overlap_tokens,
+        tokenizer_model_id=tokenizer_model_id,
+        tokenizer_cache_dir=tokenizer_cache_dir,
+    )
+
+
+def _markdown_to_chunks_df(
+    markdown_text: str,
+    path: str,
+    *,
+    max_tokens: int,
+    overlap_tokens: int,
+    tokenizer_model_id: Optional[str],
+    tokenizer_cache_dir: Optional[str],
+) -> pd.DataFrame:
+    """Shared logic: markdown string -> tokenizer split -> chunk DataFrame."""
+    if not markdown_text or not markdown_text.strip():
+        return pd.DataFrame(
+            columns=["text", "path", "page_number", "metadata"],
+        ).astype({"page_number": "int64"})
+
+    model_id = tokenizer_model_id or DEFAULT_TOKENIZER_MODEL_ID
+    tokenizer = _get_txt_tokenizer(model_id, cache_dir=tokenizer_cache_dir)
+    chunk_texts = split_text_by_tokens(
+        markdown_text,
+        tokenizer=tokenizer,
+        max_tokens=max_tokens,
+        overlap_tokens=overlap_tokens,
+    )
+
+    if not chunk_texts:
+        return pd.DataFrame(
+            columns=["text", "path", "page_number", "metadata"],
+        ).astype({"page_number": "int64"})
+
+    rows: List[Dict[str, Any]] = []
+    for i, chunk in enumerate(chunk_texts):
+        rows.append(
+            {
+                "text": chunk,
+                "content": chunk,
+                "path": path,
+                "page_number": i + 1,
+                "metadata": {
+                    "source_path": path,
+                    "chunk_index": i,
+                    "content_metadata": {"type": "text"},
+                    "content": chunk,
+                },
+            }
+        )
+    return pd.DataFrame(rows)
diff --git a/nemo_retriever/src/nemo_retriever/html/ray_data.py b/nemo_retriever/src/nemo_retriever/html/ray_data.py
new file mode 100644
index 000000000..f2dafbd80
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/html/ray_data.py
@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Ray Data adapter for .html: HtmlSplitActor turns bytes+path batches into chunk rows.
+"""
+
+from __future__ import annotations
+
+from typing import List
+
+import pandas as pd
+
+from nemo_retriever.params import HtmlChunkParams
+
+from .convert import html_bytes_to_chunks_df
+
+
+class HtmlSplitActor:
+    """
+    Ray Data map_batches callable: DataFrame with bytes, path -> DataFrame of chunks.
+
+    Each output row has: text, path, page_number, metadata (same shape as html_file_to_chunks_df).
+    """
+
+    def __init__(self, params: HtmlChunkParams | None = None) -> None:
+        self._params = params or HtmlChunkParams()
+
+    def __call__(self, batch_df: pd.DataFrame) -> pd.DataFrame:
+        if not isinstance(batch_df, pd.DataFrame) or batch_df.empty:
+            return pd.DataFrame(columns=["text", "path", "page_number", "metadata"])
+
+        params = self._params
+        out_dfs: List[pd.DataFrame] = []
+        for _, row in batch_df.iterrows():
+            raw = row.get("bytes")
+            path = row.get("path")
+            if raw is None or path is None:
+                continue
+            path_str = str(path) if path is not None else ""
+            try:
+                chunk_df = html_bytes_to_chunks_df(raw, path_str, params=params)
+                if not chunk_df.empty:
+                    out_dfs.append(chunk_df)
+            except Exception:
+                continue
+        if not out_dfs:
+            return pd.DataFrame(columns=["text", "path", "page_number", "metadata"])
+        return pd.concat(out_dfs, ignore_index=True)
diff --git a/nemo_retriever/src/nemo_retriever/infographic/__init__.py b/nemo_retriever/src/nemo_retriever/infographic/__init__.py
new file mode 100644
index 000000000..05695c87b
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/infographic/__init__.py
@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Infographic extraction stage (pure Python + Ray Data adapters).
+
+This stage enriches existing STRUCTURED/infographic primitives by populating
+`metadata.table_metadata.table_content` via OCR, using `nv-ingest-api` internals.
+"""
+
+from .infographic_detection import InfographicDetectionActor, detect_infographic_elements_v1
+
+__all__ = ["InfographicDetectionActor", "detect_infographic_elements_v1"]
+
+# Optional imports: infographic *extraction* depends on nv-ingest-api (and its deps).
+# We keep detection importable even in lightweight environments.
+try:  # pragma: no cover
+    from .commands import app
+    from .config import InfographicExtractionStageConfig, load_infographic_extractor_schema_from_dict
+    from .processor import extract_infographic_data_from_primitives_df
+    from .ray_data import extract_infographic_data_ray_data
+
+    __all__ += [
+        "app",
+        "InfographicExtractionStageConfig",
+        "extract_infographic_data_from_primitives_df",
+        "extract_infographic_data_ray_data",
+        "load_infographic_extractor_schema_from_dict",
+    ]
+except Exception:
+    pass
diff --git a/nemo_retriever/src/nemo_retriever/infographic/commands.py b/nemo_retriever/src/nemo_retriever/infographic/commands.py
new file mode 100644
index 000000000..f3c6f12cb
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/infographic/commands.py
@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import typer
+from rich.console import Console
+
+from nemo_retriever.ingest_config import load_ingest_config_section
+from nemo_retriever.io.dataframe import read_dataframe, write_dataframe
+
+from nemo_retriever.infographic.config import load_infographic_extractor_schema_from_dict
+from nemo_retriever.infographic.processor import extract_infographic_data_from_primitives_df
+
+app = typer.Typer(help="Infographic extraction: enrich infographic primitives with OCR-derived table_content.")
+console = Console()
+
+
+@app.command()
+def run(
+    input_path: Path = typer.Option(
+        ...,
+        "--input",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="Input primitives as a DataFrame file (.parquet, .jsonl, or .json). Must include a 'metadata' column.",
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        dir_okay=False,
+        file_okay=True,
+        help="Output path (.parquet, .jsonl, or .json). Defaults to <input>.+infographic<ext>.",
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help=(
+            "Optional ingest YAML config file. If omitted, we auto-discover ./ingest-config.yaml then "
+            "$HOME/.ingest-config.yaml. Uses section: infographic."
+        ),
+    ),
+) -> None:
+    """
+    Load a primitives DataFrame, run infographic enrichment, and write the enriched DataFrame.
+    """
+    try:
+        df = read_dataframe(input_path)
+    except ValueError as e:
+        raise typer.BadParameter(str(e)) from e
+
+    cfg_dict: Dict[str, Any] = load_ingest_config_section(config, section="infographic")
+    schema = load_infographic_extractor_schema_from_dict(cfg_dict)
+    out_df, _info = extract_infographic_data_from_primitives_df(df, extractor_config=schema, task_config={})
+
+    if output_path is None:
+        output_path = input_path.with_name(input_path.stem + ".infographic" + input_path.suffix)
+
+    try:
+        write_dataframe(out_df, output_path)
+    except ValueError as e:
+        raise typer.BadParameter(str(e)) from e
+
+    console.print(f"[green]Done[/green] wrote={output_path} rows={len(out_df)}")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/infographic/config.py b/nemo_retriever/src/nemo_retriever/infographic/config.py
new file mode 100644
index 000000000..f44495890
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/infographic/config.py
@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from nemo_retriever.config_utils import endpoints_from_yaml
+
+from nv_ingest_api.internal.schemas.extract.extract_infographic_schema import InfographicExtractorSchema
+
+
+def load_infographic_extractor_schema_from_dict(cfg: Dict[str, Any]) -> InfographicExtractorSchema:
+    cfg = dict(cfg or {})
+    endpoint_cfg = cfg.get("endpoint_config")
+    if isinstance(endpoint_cfg, dict) and "ocr_endpoints" in endpoint_cfg:
+        endpoint_cfg = dict(endpoint_cfg)
+        ocr_endpoints = endpoints_from_yaml(endpoint_cfg.get("ocr_endpoints"))
+
+        # Special-case: treat "no endpoints" as "use local model".
+        # The nv-ingest-api schema forbids endpoint_config with both endpoints empty,
+        # so we drop endpoint_config entirely to allow stage code to choose local fallback.
+        if not (ocr_endpoints[0] or ocr_endpoints[1]):
+            cfg.pop("endpoint_config", None)
+        else:
+            endpoint_cfg["ocr_endpoints"] = ocr_endpoints
+            cfg["endpoint_config"] = endpoint_cfg
+    return InfographicExtractorSchema(**cfg)
+
+
+@dataclass(frozen=True)
+class InfographicExtractionStageConfig:
+    batch_size: int = 64
+    stage_name: str = "infographic_extraction"
diff --git a/nemo_retriever/src/nemo_retriever/infographic/infographic_detection.py b/nemo_retriever/src/nemo_retriever/infographic/infographic_detection.py
new file mode 100644
index 000000000..e85136116
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/infographic/infographic_detection.py
@@ -0,0 +1,783 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+"""
+Infographic detection (Nemotron Graphic Elements v1).
+
+This mirrors `nemo_retriever.chart.chart_detection.detect_graphic_elements_v1`, but:
+- prioritizes `infographics` crops when present
+- uses infographic-specific output column defaults
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence, Tuple, cast
+
+import base64
+import io
+import time
+import traceback
+
+import pandas as pd
+from nemo_retriever.params import RemoteRetryParams
+from nemo_retriever.nim.nim import invoke_image_inference_batches
+
+try:
+    import numpy as np
+except Exception:  # pragma: no cover
+    np = None  # type: ignore[assignment]
+
+try:
+    import torch
+except Exception:  # pragma: no cover
+    torch = None  # type: ignore[assignment]
+
+try:
+    from PIL import Image
+except Exception:  # pragma: no cover
+    Image = None  # type: ignore[assignment]
+
+
+def _error_payload(*, stage: str, exc: BaseException) -> Dict[str, Any]:
+    return {
+        "detections": [],
+        "error": {
+            "stage": str(stage),
+            "type": exc.__class__.__name__,
+            "message": str(exc),
+            "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+        },
+    }
+
+
+def _decode_b64_image_to_chw_tensor(image_b64: str) -> Tuple["torch.Tensor", Tuple[int, int]]:
+    if torch is None or Image is None or np is None:  # pragma: no cover
+        raise ImportError("infographic detection requires torch, pillow, and numpy.")
+
+    raw = base64.b64decode(image_b64)
+    with Image.open(io.BytesIO(raw)) as im0:
+        im = im0.convert("RGB")
+        w, h = im.size
+        arr = np.array(im, dtype=np.uint8)  # (H,W,3)
+
+    t = torch.from_numpy(arr).permute(2, 0, 1).contiguous()  # (3,H,W) uint8
+    t = t.to(dtype=torch.float32) / 255.0
+    return t, (int(h), int(w))
+
+
+def _crop_b64_image_by_norm_bbox(
+    page_image_b64: str,
+    *,
+    bbox_xyxy_norm: Sequence[float],
+    image_format: str = "png",
+) -> Tuple[Optional[str], Optional[Tuple[int, int]]]:
+    """
+    Crop a base64-encoded RGB image by a normalized xyxy bbox.
+
+    Returns:
+      - cropped_image_b64 (png) or None
+      - cropped_shape_hw (H,W) or None
+    """
+    if Image is None:  # pragma: no cover
+        raise ImportError("Cropping requires pillow.")
+    if not isinstance(page_image_b64, str) or not page_image_b64:
+        return None, None
+    try:
+        x1n, y1n, x2n, y2n = [float(x) for x in bbox_xyxy_norm]
+    except Exception:
+        return None, None
+
+    try:
+        raw = base64.b64decode(page_image_b64)
+        with Image.open(io.BytesIO(raw)) as im0:
+            im = im0.convert("RGB")
+            w, h = im.size
+            if w <= 1 or h <= 1:
+                return None, None
+
+            def _clamp_int(v: float, lo: int, hi: int) -> int:
+                if v != v:  # NaN
+                    return lo
+                return int(min(max(v, float(lo)), float(hi)))
+
+            x1 = _clamp_int(x1n * w, 0, w)
+            x2 = _clamp_int(x2n * w, 0, w)
+            y1 = _clamp_int(y1n * h, 0, h)
+            y2 = _clamp_int(y2n * h, 0, h)
+
+            if x2 <= x1 or y2 <= y1:
+                return None, None
+
+            crop = im.crop((x1, y1, x2, y2))
+            cw, ch = crop.size
+            if cw <= 1 or ch <= 1:
+                return None, None
+
+            buf = io.BytesIO()
+            fmt = str(image_format or "png").lower()
+            if fmt not in {"png"}:
+                fmt = "png"
+            crop.save(buf, format=fmt.upper())
+            return base64.b64encode(buf.getvalue()).decode("ascii"), (int(ch), int(cw))
+    except Exception:
+        return None, None
+
+
+def _labels_from_model(model: Any) -> List[str]:
+    try:
+        labels = getattr(getattr(model, "_model", None), "labels", None)
+        if isinstance(labels, (list, tuple)) and all(isinstance(x, str) for x in labels):
+            return [str(x) for x in labels]
+    except Exception:
+        pass
+
+    try:
+        out = getattr(model, "output", None)
+        if isinstance(out, dict):
+            classes = out.get("classes")
+            if isinstance(classes, (list, tuple)) and all(isinstance(x, str) for x in classes):
+                return [str(x) for x in classes]
+    except Exception:
+        pass
+
+    return []
+
+
+def _prediction_to_detections(pred: Any, *, label_names: List[str]) -> List[Dict[str, Any]]:
+    if torch is None:  # pragma: no cover
+        raise ImportError("torch required for prediction parsing.")
+
+    boxes = labels = scores = None
+    if isinstance(pred, dict):
+        # IMPORTANT: do not use `or` chains here. torch.Tensor truthiness is ambiguous and raises.
+        def _get_any(d: Dict[str, Any], *keys: str) -> Any:
+            for k in keys:
+                if k in d:
+                    v = d.get(k)
+                    if v is not None:
+                        return v
+            return None
+
+        boxes = _get_any(pred, "boxes", "bboxes", "bbox", "box")
+        labels = _get_any(pred, "labels", "classes", "class_ids", "class")
+        scores = _get_any(pred, "scores", "conf", "confidences", "score")
+    elif isinstance(pred, (list, tuple)) and len(pred) >= 3:
+        boxes, labels, scores = pred[0], pred[1], pred[2]
+
+    if boxes is None or labels is None:
+        return []
+
+    def _to_tensor(x: Any) -> Optional["torch.Tensor"]:
+        if x is None:
+            return None
+        if isinstance(x, torch.Tensor):
+            return x.detach().cpu()
+        try:
+            return torch.as_tensor(x).detach().cpu()
+        except Exception:
+            return None
+
+    b = _to_tensor(boxes)
+    l = _to_tensor(labels)  # noqa: E741
+    s = _to_tensor(scores) if scores is not None else None
+    if b is None or l is None:
+        return []
+
+    if b.ndim != 2 or int(b.shape[-1]) != 4:
+        return []
+    if l.ndim == 2 and int(l.shape[-1]) == 1:
+        l = l.squeeze(-1)  # noqa: E741
+    if l.ndim != 1:
+        return []
+
+    n = int(min(b.shape[0], l.shape[0]))
+    dets: List[Dict[str, Any]] = []
+    for i in range(n):
+        try:
+            x1, y1, x2, y2 = [float(x) for x in b[i].tolist()]
+        except Exception:
+            continue
+
+        label_i: Optional[int]
+        try:
+            label_i = int(l[i].item())
+        except Exception:
+            label_i = None
+
+        score_f: Optional[float]
+        if s is not None and s.ndim >= 1 and int(s.shape[0]) > i:
+            try:
+                score_f = float(s[i].item())
+            except Exception:
+                score_f = None
+        else:
+            score_f = None
+
+        label_name = None
+        if label_i is not None and 0 <= label_i < len(label_names):
+            label_name = label_names[label_i]
+        if not label_name:
+            label_name = f"label_{label_i}" if label_i is not None else "unknown"
+
+        dets.append(
+            {
+                "bbox_xyxy_norm": [x1, y1, x2, y2],
+                "label": label_i,
+                "label_name": str(label_name),
+                "score": score_f,
+            }
+        )
+    return dets
+
+
+def _extract_remote_pred_item(response_item: Any) -> Any:
+    if isinstance(response_item, dict):
+        for k in ("prediction", "predictions", "output", "outputs", "data"):
+            v = response_item.get(k)
+            if isinstance(v, list) and v:
+                return v[0]
+            if v is not None:
+                return v
+    return response_item
+
+
+def _counts_by_label(detections: Sequence[Dict[str, Any]]) -> Dict[str, int]:
+    out: Dict[str, int] = {}
+    for d in detections:
+        if not isinstance(d, dict):
+            continue
+        name = d.get("label_name")
+        if not isinstance(name, str) or not name.strip():
+            name = f"label_{d.get('label')}"
+        k = str(name)
+        out[k] = int(out.get(k, 0) + 1)
+    return out
+
+
+def detect_infographic_elements_v1(
+    batch_df: Any,
+    *,
+    model: Any = None,
+    invoke_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    request_timeout_s: float = 120.0,
+    inference_batch_size: int = 8,
+    output_column: str = "infographic_elements_v1",
+    num_detections_column: str = "infographic_elements_v1_num_detections",
+    counts_by_label_column: str = "infographic_elements_v1_counts_by_label",
+    remote_retry: RemoteRetryParams | None = None,
+    **kwargs: Any,
+) -> Any:
+    retry = remote_retry or RemoteRetryParams(
+        remote_max_pool_workers=int(kwargs.get("remote_max_pool_workers", 16)),
+        remote_max_retries=int(kwargs.get("remote_max_retries", 10)),
+        remote_max_429_retries=int(kwargs.get("remote_max_429_retries", 5)),
+    )
+    """
+    Run Nemotron Graphic Elements v1 on an infographic image source.
+
+    Input:
+      - pandas.DataFrame in/out
+      - expects a usable base64 image in one of:
+        - `image_b64` (direct column)
+        - `page_image.image_b64` (pdf extraction output)
+        - `infographics[0].image_b64` (preferred when available)
+    """
+    if not isinstance(batch_df, pd.DataFrame):
+        raise NotImplementedError("detect_infographic_elements_v1 currently only supports pandas.DataFrame input.")
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+
+    invoke_url = (invoke_url or kwargs.get("infographic_invoke_url") or "").strip()
+    use_remote = bool(invoke_url)
+    if not use_remote and model is None:
+        raise ValueError("A local `model` is required when `invoke_url` is not provided.")
+
+    label_names = _labels_from_model(model) if model is not None else []
+
+    tensors: List[Optional["torch.Tensor"]] = []
+    shapes: List[Optional[Tuple[int, int]]] = []
+    image_b64_list: List[Optional[str]] = []
+    payloads: List[Dict[str, Any]] = []
+    for _, row in batch_df.iterrows():
+        try:
+            b64 = row.get("page_image", {}).get("image_b64", None)
+            if not b64:
+                raise ValueError("No usable image_b64 found in row.")
+            image_b64_list.append(b64)
+            if use_remote:
+                tensors.append(None)
+                shapes.append(None)
+            else:
+                t, orig_shape = _decode_b64_image_to_chw_tensor(b64)
+                tensors.append(t)
+                shapes.append(orig_shape)
+            payloads.append({"detections": []})
+        except BaseException as e:
+            tensors.append(None)
+            shapes.append(None)
+            image_b64_list.append(None)
+            payloads.append(_error_payload(stage="decode_image", exc=e))
+
+    if use_remote:
+        valid = [i for i, b64 in enumerate(image_b64_list) if isinstance(b64, str) and bool(b64)]
+    else:
+        valid = [i for i, t in enumerate(tensors) if t is not None and shapes[i] is not None]
+
+    if use_remote and valid:
+        valid_b64 = [image_b64_list[i] for i in valid if image_b64_list[i]]
+        t0 = time.perf_counter()
+        try:
+            response_items = invoke_image_inference_batches(
+                invoke_url=invoke_url,
+                image_b64_list=cast(List[str], valid_b64),
+                api_key=api_key,
+                timeout_s=float(request_timeout_s),
+                max_batch_size=int(inference_batch_size),
+                max_pool_workers=int(retry.remote_max_pool_workers),
+                max_retries=int(retry.remote_max_retries),
+                max_429_retries=int(retry.remote_max_429_retries),
+            )
+            elapsed = time.perf_counter() - t0
+            if len(response_items) != len(valid):
+                raise RuntimeError(f"Expected {len(valid)} remote predictions, got {len(response_items)}")
+            for local_j, row_i in enumerate(valid):
+                pred_item = _extract_remote_pred_item(response_items[local_j])
+                dets = _prediction_to_detections(pred_item, label_names=label_names)
+                payloads[row_i] = {"detections": dets, "timing": {"seconds": float(elapsed)}, "error": None}
+        except BaseException as e:
+            elapsed = time.perf_counter() - t0
+            for row_i in valid:
+                payloads[row_i] = _error_payload(stage="remote_invoke", exc=e) | {"timing": {"seconds": float(elapsed)}}
+
+    for chunk_start in range(0, len(valid), int(inference_batch_size)):
+        if use_remote:
+            break
+        idxs = valid[chunk_start : chunk_start + int(inference_batch_size)]
+        if not idxs:
+            continue
+
+        pre_list: List["torch.Tensor"] = []
+        orig_shapes: List[Tuple[int, int]] = []
+        for i in idxs:
+            t = tensors[i]
+            sh = shapes[i]
+            if t is None or sh is None:
+                continue
+            orig_shapes.append(sh)
+            x = t.unsqueeze(0)  # BCHW
+            try:
+                pre = model.preprocess(x)
+            except Exception:
+                pre = x
+            if isinstance(pre, torch.Tensor) and pre.ndim == 4 and int(pre.shape[0]) == 1:
+                pre_list.append(pre[0])
+            elif isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                pre_list.append(pre)
+            else:
+                pre_list.append(t)
+
+        if not pre_list:
+            continue
+
+        batch = torch.stack(pre_list, dim=0)
+        t0 = time.perf_counter()
+        try:
+            preds = model.invoke(batch, orig_shapes)  # type: ignore[arg-type]
+            elapsed = time.perf_counter() - t0
+            if isinstance(preds, list):
+                preds_list = preds
+            else:
+                preds_list = [preds]
+            if len(preds_list) != len(idxs):
+                raise RuntimeError("Batched invoke returned unexpected output shape; falling back to per-image calls.")
+            for local_j, row_i in enumerate(idxs):
+                dets = _prediction_to_detections(preds_list[local_j], label_names=label_names)
+                payloads[row_i] = {"detections": dets, "timing": {"seconds": float(elapsed)}, "error": None}
+        except BaseException:
+            for local_j, row_i in enumerate(idxs):
+                t = tensors[row_i]
+                sh = shapes[row_i]
+                if t is None or sh is None:
+                    continue
+                x = t.unsqueeze(0)
+                t1 = time.perf_counter()
+                try:
+                    try:
+                        pre = model.preprocess(x)
+                    except Exception:
+                        pre = x
+                    if isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                        pre = pre.unsqueeze(0)
+                    pred = model.invoke(pre, sh)
+                    dets = _prediction_to_detections(pred, label_names=label_names)
+                    payloads[row_i] = {
+                        "detections": dets,
+                        "timing": {"seconds": float(time.perf_counter() - t1)},
+                        "error": None,
+                    }
+                except BaseException as e:
+                    payloads[row_i] = _error_payload(stage="invoke", exc=e) | {
+                        "timing": {"seconds": float(time.perf_counter() - t1)}
+                    }
+
+    out = batch_df.copy()
+    out[output_column] = payloads
+    out[num_detections_column] = [int(len(p.get("detections") or [])) if isinstance(p, dict) else 0 for p in payloads]
+    out[counts_by_label_column] = [
+        _counts_by_label(p.get("detections") or []) if isinstance(p, dict) else {} for p in payloads
+    ]
+    return out
+
+
+def detect_infographic_elements_v1_from_page_elements_v3(
+    pages_df: Any,
+    *,
+    model: Any = None,
+    invoke_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    request_timeout_s: float = 120.0,
+    inference_batch_size: int = 8,
+    page_elements_column: str = "page_elements_v3",
+    page_elements_counts_by_label_column: str = "page_elements_v3_counts_by_label",
+    page_image_column: str = "page_image",
+    allowed_page_element_labels: Sequence[str] = ("infographic", "title"),
+    output_column: str = "infographic_elements_v1",
+    num_detections_column: str = "infographic_elements_v1_num_detections",
+    counts_by_label_column: str = "infographic_elements_v1_counts_by_label",
+    remote_retry: RemoteRetryParams | None = None,
+    **kwargs: Any,
+) -> Any:
+    retry = remote_retry or RemoteRetryParams(
+        remote_max_pool_workers=int(kwargs.get("remote_max_pool_workers", 16)),
+        remote_max_retries=int(kwargs.get("remote_max_retries", 10)),
+        remote_max_429_retries=int(kwargs.get("remote_max_429_retries", 5)),
+    )
+    """
+    Run Nemotron Graphic Elements v1 only on cropped infographic/title regions.
+
+    Gate per page if any of `allowed_page_element_labels` has count > 0 in
+    `page_elements_v3_counts_by_label`, then crop `page_image.image_b64` to each
+    matching detection and run the model on those crops.
+
+    Output payload shape:
+      - `output_column`: {"regions": [...], "timing": {...}, "error": ...}
+    """
+    if not isinstance(pages_df, pd.DataFrame):
+        raise NotImplementedError(
+            "detect_infographic_elements_v1_from_page_elements_v3 currently only supports pandas.DataFrame input."
+        )
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+    invoke_url = (invoke_url or kwargs.get("infographic_invoke_url") or "").strip()
+    use_remote = bool(invoke_url)
+    if not use_remote and model is None:
+        raise ValueError("A local `model` is required when `invoke_url` is not provided.")
+
+    allowed = {str(x).strip() for x in (allowed_page_element_labels or []) if str(x).strip()}
+    if not allowed:
+        allowed = {"infographic", "title"}
+
+    out_payloads: List[Dict[str, Any]] = []
+    out_total_dets: List[int] = []
+    out_counts: List[Dict[str, int]] = []
+
+    crop_b64s: List[str] = []
+    crop_region_refs: List[Dict[str, Any]] = []
+
+    t0_total = time.perf_counter()
+
+    for _, row in pages_df.iterrows():
+        page_payload: Dict[str, Any] = {"regions": [], "timing": {"seconds": 0.0}, "error": None}
+
+        counts = row.get(page_elements_counts_by_label_column)
+        has_any = False
+        if isinstance(counts, dict):
+            for k in allowed:
+                try:
+                    if int(counts.get(k) or 0) > 0:
+                        has_any = True
+                        break
+                except Exception:
+                    continue
+
+        if not has_any:
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        pe = row.get(page_elements_column)
+        dets = pe.get("detections") if isinstance(pe, dict) else None
+        if not isinstance(dets, list) or not dets:
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        page_image = row.get(page_image_column) or {}
+        page_image_b64 = page_image.get("image_b64") if isinstance(page_image, dict) else None
+        if not isinstance(page_image_b64, str) or not page_image_b64:
+            page_payload["error"] = {
+                "stage": "crop",
+                "type": "ValueError",
+                "message": "page_image.image_b64 missing; cannot crop infographics for infographic_elements_v1.",
+                "traceback": "",
+            }
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        regions: List[Dict[str, Any]] = []
+        for det in dets:
+            if not isinstance(det, dict):
+                continue
+            det_label = str(det.get("label_name") or "").strip()
+            if det_label not in allowed:
+                continue
+            bbox = det.get("bbox_xyxy_norm")
+            if not isinstance(bbox, (list, tuple)) or len(bbox) != 4:
+                continue
+
+            crop_b64, crop_shape_hw = _crop_b64_image_by_norm_bbox(
+                page_image_b64, bbox_xyxy_norm=cast(Sequence[float], bbox)
+            )
+            if not crop_b64 or crop_shape_hw is None:
+                continue
+
+            region_payload: Dict[str, Any] = {
+                "label_name": det_label,
+                "bbox_xyxy_norm": [float(x) for x in bbox],
+                "score": det.get("score"),
+                "orig_shape_hw": crop_shape_hw,
+                "detections": [],
+                "timing": None,
+                "error": None,
+            }
+            regions.append(region_payload)
+            crop_b64s.append(crop_b64)
+            crop_region_refs.append(region_payload)
+
+        page_payload["regions"] = regions
+        out_payloads.append(page_payload)
+        out_total_dets.append(0)
+        out_counts.append({})
+
+    if crop_b64s:
+        label_names = _labels_from_model(model) if model is not None else []
+
+        crop_payloads: List[Dict[str, Any]] = []
+        if use_remote:
+            t0 = time.perf_counter()
+            try:
+                response_items = invoke_image_inference_batches(
+                    invoke_url=invoke_url,
+                    image_b64_list=crop_b64s,
+                    api_key=api_key,
+                    timeout_s=float(request_timeout_s),
+                    max_batch_size=int(inference_batch_size),
+                    max_pool_workers=int(retry.remote_max_pool_workers),
+                    max_retries=int(retry.remote_max_retries),
+                    max_429_retries=int(retry.remote_max_429_retries),
+                )
+                elapsed = time.perf_counter() - t0
+                if len(response_items) != len(crop_b64s):
+                    raise RuntimeError(f"Expected {len(crop_b64s)} remote predictions, got {len(response_items)}")
+                for resp in response_items:
+                    pred_item = _extract_remote_pred_item(resp)
+                    dets = _prediction_to_detections(pred_item, label_names=label_names)
+                    crop_payloads.append({"detections": dets, "timing": {"seconds": float(elapsed)}, "error": None})
+            except BaseException as e:
+                elapsed = time.perf_counter() - t0
+                for _ in crop_b64s:
+                    crop_payloads.append(
+                        _error_payload(stage="remote_invoke", exc=e) | {"timing": {"seconds": float(elapsed)}}
+                    )
+        else:
+            tensors: List[Optional["torch.Tensor"]] = []
+            shapes: List[Optional[Tuple[int, int]]] = []
+            for b64 in crop_b64s:
+                try:
+                    t, orig_shape = _decode_b64_image_to_chw_tensor(b64)
+                    tensors.append(t)
+                    shapes.append(orig_shape)
+                    crop_payloads.append({"detections": []})
+                except BaseException as e:
+                    tensors.append(None)
+                    shapes.append(None)
+                    crop_payloads.append(_error_payload(stage="decode_image", exc=e))
+
+            valid = [i for i, t in enumerate(tensors) if t is not None and shapes[i] is not None]
+
+            for chunk_start in range(0, len(valid), int(inference_batch_size)):
+                idxs = valid[chunk_start : chunk_start + int(inference_batch_size)]
+                if not idxs:
+                    continue
+
+                pre_list: List["torch.Tensor"] = []
+                orig_shapes: List[Tuple[int, int]] = []
+                for i in idxs:
+                    t = tensors[i]
+                    sh = shapes[i]
+                    if t is None or sh is None:
+                        continue
+                    orig_shapes.append(sh)
+                    x = t.unsqueeze(0)
+                    try:
+                        pre = model.preprocess(x)
+                    except Exception:
+                        pre = x
+                    if isinstance(pre, torch.Tensor) and pre.ndim == 4 and int(pre.shape[0]) == 1:
+                        pre_list.append(pre[0])
+                    elif isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                        pre_list.append(pre)
+                    else:
+                        pre_list.append(t)
+
+                if not pre_list:
+                    continue
+
+                batch = torch.stack(pre_list, dim=0)
+                t0 = time.perf_counter()
+                try:
+                    preds = model.invoke(batch, orig_shapes)  # type: ignore[arg-type]
+                    elapsed = time.perf_counter() - t0
+                    preds_list = preds if isinstance(preds, list) else [preds]
+                    if len(preds_list) != len(idxs):
+                        raise RuntimeError(
+                            "Batched invoke returned unexpected output shape; falling back to per-image calls."
+                        )
+                    for local_j, crop_i in enumerate(idxs):
+                        dets = _prediction_to_detections(preds_list[local_j], label_names=label_names)
+                        crop_payloads[crop_i] = {
+                            "detections": dets,
+                            "timing": {"seconds": float(elapsed)},
+                            "error": None,
+                        }
+                except BaseException:
+                    for crop_i in idxs:
+                        t = tensors[crop_i]
+                        sh = shapes[crop_i]
+                        if t is None or sh is None:
+                            continue
+                        x = t.unsqueeze(0)
+                        t1 = time.perf_counter()
+                        try:
+                            try:
+                                pre = model.preprocess(x)
+                            except Exception:
+                                pre = x
+                            if isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                                pre = pre.unsqueeze(0)
+                            pred = model.invoke(pre, sh)
+                            dets = _prediction_to_detections(pred, label_names=label_names)
+                            crop_payloads[crop_i] = {
+                                "detections": dets,
+                                "timing": {"seconds": float(time.perf_counter() - t1)},
+                                "error": None,
+                            }
+                        except BaseException as e:
+                            crop_payloads[crop_i] = _error_payload(stage="invoke", exc=e) | {
+                                "timing": {"seconds": float(time.perf_counter() - t1)}
+                            }
+
+        for crop_i, region_ref in enumerate(crop_region_refs):
+            payload = crop_payloads[crop_i] if crop_i < len(crop_payloads) else {"detections": []}
+            if isinstance(payload, dict):
+                region_ref["detections"] = payload.get("detections") or []
+                region_ref["timing"] = payload.get("timing")
+                region_ref["error"] = payload.get("error")
+            else:
+                region_ref["detections"] = []
+                region_ref["timing"] = None
+                region_ref["error"] = {
+                    "stage": "invoke",
+                    "type": "TypeError",
+                    "message": "Unexpected payload type",
+                    "traceback": "",
+                }
+
+    # Aggregate counts per page.
+    for i, page_payload in enumerate(out_payloads):
+        regions = page_payload.get("regions") or []
+        total_dets = 0
+        agg_counts: Dict[str, int] = {}
+        if isinstance(regions, list):
+            for r in regions:
+                if not isinstance(r, dict):
+                    continue
+                dets = r.get("detections") or []
+                if isinstance(dets, list):
+                    total_dets += int(len(dets))
+                    for d in dets:
+                        if not isinstance(d, dict):
+                            continue
+                        name = d.get("label_name")
+                        if not isinstance(name, str) or not name.strip():
+                            name = f"label_{d.get('label')}"
+                        k = str(name)
+                        agg_counts[k] = int(agg_counts.get(k, 0) + 1)
+        out_total_dets[i] = int(total_dets)
+        out_counts[i] = agg_counts
+
+    elapsed_total = time.perf_counter() - t0_total
+    for page_payload in out_payloads:
+        if isinstance(page_payload, dict):
+            page_payload["timing"] = {"seconds": float(elapsed_total)}
+
+    out = pages_df.copy()
+    out[output_column] = out_payloads
+    out[num_detections_column] = out_total_dets
+    out[counts_by_label_column] = out_counts
+    return out
+
+
+@dataclass(slots=True)
+class InfographicDetectionActor:
+    """
+    Ray-friendly callable that initializes Nemotron Graphic Elements v1 once.
+    """
+
+    detect_kwargs: Dict[str, Any]
+
+    def __init__(self, **detect_kwargs: Any) -> None:
+        self.detect_kwargs = dict(detect_kwargs)
+        invoke_url = str(
+            self.detect_kwargs.get("infographic_invoke_url") or self.detect_kwargs.get("invoke_url") or ""
+        ).strip()
+        if invoke_url and "invoke_url" not in self.detect_kwargs:
+            self.detect_kwargs["invoke_url"] = invoke_url
+        if invoke_url:
+            self._model = None
+        else:
+            from nemo_retriever.model.local import NemotronGraphicElementsV1
+
+            self._model = NemotronGraphicElementsV1()
+
+    def __call__(self, batch_df: Any, **override_kwargs: Any) -> Any:
+        try:
+            # Prefer crop-based execution when page-elements are present.
+            if isinstance(batch_df, pd.DataFrame) and (
+                "page_elements_v3" in batch_df.columns or "page_elements_v3_counts_by_label" in batch_df.columns
+            ):
+                return detect_infographic_elements_v1_from_page_elements_v3(
+                    batch_df,
+                    model=self._model,
+                    **self.detect_kwargs,
+                    **override_kwargs,
+                )
+            return detect_infographic_elements_v1(batch_df, model=self._model, **self.detect_kwargs, **override_kwargs)
+        except BaseException as e:
+            if isinstance(batch_df, pd.DataFrame):
+                out = batch_df.copy()
+                payload = _error_payload(stage="actor_call", exc=e)
+                out["infographic_elements_v1"] = [
+                    {"regions": [], "timing": None, "error": payload.get("error")} for _ in range(len(out.index))
+                ]
+                out["infographic_elements_v1_num_detections"] = [0 for _ in range(len(out.index))]
+                out["infographic_elements_v1_counts_by_label"] = [{} for _ in range(len(out.index))]
+                return out
+            return [{"infographic_elements_v1": _error_payload(stage="actor_call", exc=e)}]
diff --git a/nemo_retriever/src/nemo_retriever/infographic/processor.py b/nemo_retriever/src/nemo_retriever/infographic/processor.py
new file mode 100644
index 000000000..ed5b0dfc7
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/infographic/processor.py
@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+import pandas as pd
+
+from nv_ingest_api.internal.extract.image.infographic_extractor import extract_infographic_data_from_image_internal
+from nv_ingest_api.internal.primitives.tracing.tagging import traceable_func
+from nv_ingest_api.internal.schemas.extract.extract_infographic_schema import InfographicExtractorSchema
+
+from nemo_retriever.io.dataframe import validate_primitives_dataframe
+
+logger = logging.getLogger(__name__)
+
+
+@traceable_func(trace_name="retriever::infographic_extraction")
+def extract_infographic_data_from_primitives_df(
+    df_primitives: pd.DataFrame,
+    *,
+    extractor_config: InfographicExtractorSchema,
+    task_config: Optional[Dict[str, Any]] = None,
+    trace_info: Optional[Dict[str, Any]] = None,
+) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    """Enrich infographic primitives in-place by running OCR and writing table_content."""
+    _ = trace_info
+    validate_primitives_dataframe(df_primitives)
+
+    if task_config is None:
+        task_config = {}
+
+    execution_trace_log: Dict[str, Any] = {}
+    try:
+        out_df, info = extract_infographic_data_from_image_internal(
+            df_extraction_ledger=df_primitives,
+            task_config=task_config,
+            extraction_config=extractor_config,
+            execution_trace_log=execution_trace_log,
+        )
+    except Exception:
+        logger.exception("Infographic extraction failed")
+        raise
+
+    info = dict(info or {})
+    info.setdefault("execution_trace_log", execution_trace_log)
+    return out_df, info
diff --git a/nemo_retriever/src/nemo_retriever/infographic/ray_data.py b/nemo_retriever/src/nemo_retriever/infographic/ray_data.py
new file mode 100644
index 000000000..7f3babf50
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/infographic/ray_data.py
@@ -0,0 +1,36 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Dict, Optional  # noqa: F401
+
+import pandas as pd
+
+from .stage import extract_infographic_data_from_primitives_df
+
+logger = logging.getLogger(__name__)
+
+
+def extract_infographic_data_ray_data(
+    ds: "ray.data.Dataset",  # noqa: F821
+    *,
+    extractor_config: Any,
+    task_config: Optional[Dict[str, Any]] = None,
+    batch_size: int = 64,
+) -> "ray.data.Dataset":  # noqa: F821
+    """Ray Data adapter for infographic extraction (mutates metadata in-place)."""
+    import ray.data  # type: ignore  # noqa: F401
+
+    def _map_batch(batch: pd.DataFrame) -> pd.DataFrame:
+        out, _info = extract_infographic_data_from_primitives_df(
+            batch,
+            extractor_config=extractor_config,
+            task_config=task_config,
+        )
+        return out
+
+    logger.info("Running Ray Data infographic extraction: batch_size=%s", batch_size)
+    return ds.map_batches(_map_batch, batch_format="pandas", batch_size=batch_size)
diff --git a/nemo_retriever/src/nemo_retriever/infographic/stage.py b/nemo_retriever/src/nemo_retriever/infographic/stage.py
new file mode 100644
index 000000000..4a1a3191c
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/infographic/stage.py
@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.infographic.commands import app, main, run
+from nemo_retriever.infographic.processor import extract_infographic_data_from_primitives_df
+
+__all__ = ["app", "extract_infographic_data_from_primitives_df", "main", "run"]
diff --git a/nemo_retriever/src/nemo_retriever/ingest-batch-pipeline.py b/nemo_retriever/src/nemo_retriever/ingest-batch-pipeline.py
new file mode 100644
index 000000000..631916c05
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest-batch-pipeline.py
@@ -0,0 +1,979 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import base64
+import logging
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+import typer
+
+# If this file is executed directly (not via installed package), ensure `nemo_retriever/src`
+# is on sys.path so `import nemo_retriever...` works from a monorepo checkout.
+_THIS_FILE = Path(__file__).resolve()
+_RETRIEVER_SRC = _THIS_FILE.parents[1]  # .../nemo_retriever/src
+if (_RETRIEVER_SRC / "nemo_retriever").is_dir() and str(_RETRIEVER_SRC) not in sys.path:
+    sys.path.insert(0, str(_RETRIEVER_SRC))
+
+from nemo_retriever.chart.config import load_chart_extractor_schema_from_dict
+from nemo_retriever.chart.stage import extract_chart_data_from_primitives_df
+from nemo_retriever.ingest_config import load_ingest_config_file
+from nemo_retriever.pdf.config import load_pdf_extractor_schema_from_dict
+from nemo_retriever.pdf.stage import extract_pdf_primitives_from_ledger_df, make_pdf_task_config
+from nemo_retriever.table.config import load_table_extractor_schema_from_dict
+from nemo_retriever.table.stage import extract_table_data_from_primitives_df
+from nemo_retriever.text_embed.config import load_text_embedding_schema_from_dict
+from nemo_retriever.text_embed.stage import embed_text_from_primitives_df
+
+logger = logging.getLogger(__name__)
+app = typer.Typer(
+    help=(
+        "Ray Data batch pipeline for staged ingestion.\n"
+        "\n"
+        "1) Ingest: read all PDFs into a Ray Dataset with `read_binary*`\n"
+        "2) Actor stages: stage1 PDF extraction + stage3 table + stage4 chart + stage5 text embeddings\n"
+        "3) Driver sink (optional): stage6 upload embeddings to LanceDB for later querying\n"
+    )
+)
+
+if TYPE_CHECKING:  # pragma: no cover
+    import pandas as pd
+
+
+@dataclass(frozen=True)
+class LedgerRow:
+    source_id: str
+    source_name: str
+    content_b64: str
+    pdf_path: str
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "source_id": self.source_id,
+            "source_name": self.source_name,
+            "content": self.content_b64,
+            "document_type": "pdf",
+            "metadata": {"custom_content": {"path": self.pdf_path}},
+        }
+
+
+def _iter_pdf_paths(
+    *,
+    input_dir: Optional[Path],
+    pdf_list: Optional[Path],
+    limit_pdfs: Optional[int],
+) -> List[str]:
+    pdfs: List[str] = []
+
+    if input_dir is not None:
+        pdfs.extend(str(p) for p in sorted(input_dir.rglob("*.pdf")))
+
+    if pdf_list is not None:
+        lines = pdf_list.read_text(encoding="utf-8").splitlines()
+        for ln in lines:
+            s = ln.strip()
+            if not s or s.startswith("#"):
+                continue
+            pdfs.append(str(Path(s)))
+
+    # De-dupe while preserving order
+    seen = set()
+    ordered: List[str] = []
+    for p in pdfs:
+        if p in seen:
+            continue
+        seen.add(p)
+        ordered.append(p)
+
+    if limit_pdfs is not None:
+        ordered = ordered[: int(limit_pdfs)]
+
+    return ordered
+
+
+def _cfg_section(cfg: Dict[str, Any], section: str) -> Dict[str, Any]:
+    """
+    Return a nested mapping from cfg using dot-separated keys, else {}.
+    """
+    cur: Any = cfg
+    for part in section.split("."):
+        if not isinstance(cur, dict) or part not in cur:
+            return {}
+        cur = cur.get(part)
+    return dict(cur or {}) if isinstance(cur, dict) else {}
+
+
+def _normalize_pdf_binary_row(row: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Normalize Ray's binary reader output to stable keys:
+      - pdf_path: str
+      - pdf_bytes: bytes
+    """
+    path = row.get("path") or row.get("file_path") or row.get("uri") or row.get("filename")
+    b = row.get("bytes") or row.get("data") or row.get("content")
+    pdf_path = str(path) if path is not None else ""
+
+    pdf_bytes: bytes
+    if isinstance(b, bytes):
+        pdf_bytes = b
+    elif isinstance(b, bytearray):
+        pdf_bytes = bytes(b)
+    elif isinstance(b, memoryview):
+        pdf_bytes = b.tobytes()
+    else:
+        # Best-effort fallback; extraction will fail gracefully downstream if this isn't valid bytes.
+        pdf_bytes = bytes(b) if b is not None else b""  # type: ignore[arg-type]
+
+    return {"pdf_path": pdf_path, "pdf_bytes": pdf_bytes}
+
+
+def _binary_batch_to_ledger_df(batch: "pd.DataFrame") -> "pd.DataFrame":
+    import pandas as pd
+
+    rows: List[Dict[str, Any]] = []
+    for _, r in batch.iterrows():
+        pdf_path = str(r.get("pdf_path") or "")
+        b = r.get("pdf_bytes")
+
+        if isinstance(b, bytes):
+            raw = b
+        elif isinstance(b, bytearray):
+            raw = bytes(b)
+        elif isinstance(b, memoryview):
+            raw = b.tobytes()
+        else:
+            raw = bytes(b) if b is not None else b""  # type: ignore[arg-type]
+
+        content_b64 = base64.b64encode(raw).decode("utf-8")
+        led = LedgerRow(
+            source_id=pdf_path,
+            source_name=pdf_path,
+            content_b64=content_b64,
+            pdf_path=pdf_path,
+        )
+        rows.append(led.to_dict())
+
+    return pd.DataFrame(rows)
+
+
+def _build_pdf_extractor_and_task_cfg(
+    *,
+    method: str,
+    auth_token: Optional[str],
+    yolox_grpc_endpoint: Optional[str],
+    yolox_http_endpoint: Optional[str],
+    nemotron_parse_grpc_endpoint: Optional[str],
+    nemotron_parse_http_endpoint: Optional[str],
+    nemotron_parse_model_name: Optional[str],
+    extract_text: bool,
+    extract_images: bool,
+    extract_tables: bool,
+    extract_charts: bool,
+    extract_infographics: bool,
+    extract_page_as_image: bool,
+    text_depth: str,
+) -> tuple[Any, Dict[str, Any]]:
+    """
+    Mirror the config behavior from `nemo_retriever.pdf.stage` stage1 CLI.
+    """
+    method = str(method or "pdfium")
+
+    extractor_cfg: Dict[str, Any] = {}
+    if method in {"pdfium", "pdfium_hybrid", "ocr"}:
+        if not (yolox_grpc_endpoint or yolox_http_endpoint):
+            logger.info("YOLOX NIM endpoints not set; falling back to HuggingFace model.")
+        extractor_cfg["pdfium_config"] = {
+            "auth_token": auth_token,
+            "yolox_endpoints": [yolox_grpc_endpoint, yolox_http_endpoint],
+        }
+    elif method == "nemotron_parse":
+        if not (nemotron_parse_grpc_endpoint or nemotron_parse_http_endpoint):
+            raise typer.BadParameter(
+                "Nemotron Parse endpoint required for method 'nemotron_parse'. "
+                "Set --nemotron-parse-grpc-endpoint or --nemotron-parse-http-endpoint."
+            )
+        extractor_cfg["nemotron_parse_config"] = {
+            "auth_token": auth_token,
+            # Nemotron Parse may still rely on YOLOX for region proposals depending on config.
+            "yolox_endpoints": [yolox_grpc_endpoint, yolox_http_endpoint],
+            "nemotron_parse_endpoints": [nemotron_parse_grpc_endpoint, nemotron_parse_http_endpoint],
+            "nemotron_parse_model_name": nemotron_parse_model_name,
+        }
+
+    extractor_schema = load_pdf_extractor_schema_from_dict(extractor_cfg)
+    task_cfg = make_pdf_task_config(
+        method=method,
+        extract_text=bool(extract_text),
+        extract_images=bool(extract_images),
+        extract_tables=bool(extract_tables),
+        extract_charts=bool(extract_charts),
+        extract_infographics=bool(extract_infographics),
+        extract_page_as_image=bool(extract_page_as_image),
+        text_depth=str(text_depth or "page"),
+    )
+    return extractor_schema, task_cfg
+
+
+class PDFExtractionActorBatchFn:
+    """
+    Actor-based Ray Data stage that runs stage1 PDF extraction over binary-ingested PDFs.
+    """
+
+    def __init__(
+        self,
+        *,
+        method: str,
+        auth_token: Optional[str],
+        yolox_grpc_endpoint: Optional[str],
+        yolox_http_endpoint: Optional[str],
+        nemotron_parse_grpc_endpoint: Optional[str],
+        nemotron_parse_http_endpoint: Optional[str],
+        nemotron_parse_model_name: Optional[str],
+        extract_text: bool,
+        extract_images: bool,
+        extract_tables: bool,
+        extract_charts: bool,
+        extract_infographics: bool,
+        extract_page_as_image: bool,
+        text_depth: str,
+        write_json_outputs: bool,
+        json_output_dir: Optional[str],
+    ) -> None:
+        extractor_schema, task_cfg = _build_pdf_extractor_and_task_cfg(
+            method=str(method),
+            auth_token=auth_token,
+            yolox_grpc_endpoint=yolox_grpc_endpoint,
+            yolox_http_endpoint=yolox_http_endpoint,
+            nemotron_parse_grpc_endpoint=nemotron_parse_grpc_endpoint,
+            nemotron_parse_http_endpoint=nemotron_parse_http_endpoint,
+            nemotron_parse_model_name=nemotron_parse_model_name,
+            extract_text=bool(extract_text),
+            extract_images=bool(extract_images),
+            extract_tables=bool(extract_tables),
+            extract_charts=bool(extract_charts),
+            extract_infographics=bool(extract_infographics),
+            extract_page_as_image=bool(extract_page_as_image),
+            text_depth=str(text_depth),
+        )
+        self._extractor_schema = extractor_schema
+        self._task_cfg = task_cfg
+        self._write_json_outputs = bool(write_json_outputs)
+        self._json_output_dir = str(json_output_dir) if json_output_dir else None
+
+    def __call__(self, batch: "pd.DataFrame") -> "pd.DataFrame":
+        import pandas as pd
+
+        df_ledger = _binary_batch_to_ledger_df(batch)
+        extracted_df, _info = extract_pdf_primitives_from_ledger_df(
+            df_ledger,
+            task_config=self._task_cfg,
+            extractor_config=self._extractor_schema,
+            write_json_outputs=bool(self._write_json_outputs),
+            json_output_dir=self._json_output_dir,
+        )
+        # Always return a DataFrame (Ray expects batch outputs to be tabular).
+        if extracted_df is None or not isinstance(extracted_df, pd.DataFrame):
+            return pd.DataFrame({"document_type": [], "metadata": [], "uuid": []})
+        return extracted_df
+
+
+class TableExtractionActorBatchFn:
+    """
+    Actor-based stage3: table extraction enrichment over primitives DataFrames.
+    """
+
+    def __init__(self, *, config_dict: Dict[str, Any]) -> None:
+        self._schema = load_table_extractor_schema_from_dict(config_dict or {})
+
+    def __call__(self, batch: "pd.DataFrame") -> "pd.DataFrame":
+        import pandas as pd
+
+        out_df, _info = extract_table_data_from_primitives_df(batch, extractor_config=self._schema, task_config={})
+        if out_df is None or not isinstance(out_df, pd.DataFrame):
+            return batch
+        return out_df
+
+
+class ChartExtractionActorBatchFn:
+    """
+    Actor-based stage4: chart extraction enrichment over primitives DataFrames.
+    """
+
+    def __init__(self, *, config_dict: Dict[str, Any]) -> None:
+        self._schema = load_chart_extractor_schema_from_dict(config_dict or {})
+
+    def __call__(self, batch: "pd.DataFrame") -> "pd.DataFrame":
+        import pandas as pd
+
+        out_df, _info = extract_chart_data_from_primitives_df(batch, extractor_config=self._schema, task_config={})
+        if out_df is None or not isinstance(out_df, pd.DataFrame):
+            return batch
+        return out_df
+
+
+class TextEmbeddingActorBatchFn:
+    """
+    Actor-based stage5: text embeddings enrichment over primitives DataFrames.
+
+    This keeps any local HF embedder (if used) loaded once per actor.
+    """
+
+    def __init__(
+        self,
+        *,
+        config_dict: Dict[str, Any],
+        task_config: Dict[str, Any],
+    ) -> None:
+        self._schema = load_text_embedding_schema_from_dict(config_dict or {})
+        self._task_cfg = dict(task_config or {})
+
+        # If no endpoint URL is present, force local HuggingFace embeddings and keep the
+        # embedder loaded once per actor (avoids per-batch model reload).
+        endpoint_url = self._task_cfg.get("endpoint_url")
+        if endpoint_url is None:
+            try:
+                from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import (
+                    LlamaNemotronEmbed1BV2Embedder,
+                )
+
+                local_device = self._task_cfg.get("local_hf_device")
+                local_cache_dir = self._task_cfg.get("local_hf_cache_dir")
+                local_batch_size = int(self._task_cfg.get("local_hf_batch_size") or 64)
+
+                embedder = LlamaNemotronEmbed1BV2Embedder(
+                    device=str(local_device) if local_device is not None else None,
+                    hf_cache_dir=str(local_cache_dir) if local_cache_dir is not None else None,
+                    normalize=True,
+                )
+
+                def _embed(texts):
+                    vecs = embedder.embed(texts, batch_size=local_batch_size)
+                    return vecs.tolist()
+
+                # Force the API transform to use the callable path.
+                self._task_cfg["endpoint_url"] = None
+                self._task_cfg["embedder"] = _embed
+                self._task_cfg["local_batch_size"] = local_batch_size
+            except Exception as e:
+                raise RuntimeError(
+                    "Local HF embeddings requested (no --embed-endpoint-url), but local embedder init failed. "
+                    "Verify torch/CUDA and the `llama_nemotron_embed_1b_v2` package are installed."
+                ) from e
+
+    def __call__(self, batch: "pd.DataFrame") -> "pd.DataFrame":
+        import pandas as pd
+
+        out_df, _info = embed_text_from_primitives_df(
+            batch,
+            transform_config=self._schema,
+            task_config=self._task_cfg,
+        )
+        if out_df is None or not isinstance(out_df, pd.DataFrame):
+            return batch
+        return out_df
+
+
+@dataclass(frozen=True)
+class LanceDBUploadConfig:
+    uri: str
+    table_name: str
+    overwrite: bool
+    create_index: bool
+    index_type: str
+    metric: str
+    num_partitions: int
+    num_sub_vectors: int
+
+
+def _infer_vector_dim_from_lancedb_rows(rows: List[Dict[str, Any]]) -> int:
+    for r in rows:
+        v = r.get("vector")
+        if isinstance(v, list) and v:
+            return int(len(v))
+    return 0
+
+
+def _upload_embeddings_to_lancedb_driver_side(
+    ds: Any,
+    *,
+    cfg: LanceDBUploadConfig,
+    batch_size: int = 2048,
+    limit_batches: Optional[int] = None,
+) -> Dict[str, Any]:
+    """
+    Driver-side upload of embeddings into LanceDB.
+
+    This mirrors the intent of `nemo_retriever.vector_store.stage` / stage6, but uploads directly
+    from the final Ray Dataset (after stage5) instead of reading `*.text_embeddings.json` files.
+
+    We reuse `nv_ingest_client.util.vdb.lancedb.create_lancedb_results(...)` to build rows with:
+      - vector, text, metadata (JSON string), source (JSON string)
+    so stage7 can query the resulting LanceDB table.
+    """
+    try:
+        import lancedb  # type: ignore
+        import pyarrow as pa  # type: ignore
+        from nv_ingest_client.util.vdb.lancedb import create_lancedb_results
+    except Exception as e:
+        raise RuntimeError(
+            "LanceDB upload requested but dependencies are missing. "
+            "Ensure `lancedb`, `pyarrow`, and `nv_ingest_client` are installed."
+        ) from e
+
+    db = lancedb.connect(uri=str(cfg.uri))
+    table = None
+    schema = None
+
+    total_rows_written = 0
+    batches_seen = 0
+    batches_skipped = 0
+
+    for batch in ds.iter_batches(batch_format="pandas", batch_size=int(batch_size)):
+        batches_seen += 1
+        if limit_batches is not None and batches_seen > int(limit_batches):
+            break
+
+        # Convert to element dicts compatible with `create_lancedb_results`.
+        try:
+            elements = batch.to_dict(orient="records")
+        except Exception:
+            elements = []
+
+        # `create_lancedb_results` expects: list[result], each result is list[element]
+        lancedb_rows: List[Dict[str, Any]] = create_lancedb_results([elements])
+        if not lancedb_rows:
+            batches_skipped += 1
+            continue
+
+        if table is None:
+            dim = _infer_vector_dim_from_lancedb_rows(lancedb_rows)
+            if dim <= 0:
+                batches_skipped += 1
+                continue
+
+            schema = pa.schema(
+                [
+                    pa.field("vector", pa.list_(pa.float32(), dim)),
+                    pa.field("text", pa.string()),
+                    pa.field("metadata", pa.string()),
+                    pa.field("source", pa.string()),
+                ]
+            )
+
+            mode = "overwrite" if cfg.overwrite else "append"
+            table = db.create_table(str(cfg.table_name), data=lancedb_rows, schema=schema, mode=mode)
+            total_rows_written += len(lancedb_rows)
+            continue
+
+        # Subsequent batches: append rows.
+        try:
+            table.add(lancedb_rows)
+        except Exception:
+            # Fall back: open and add (handles older/newer LanceDB behaviors).
+            table = db.open_table(str(cfg.table_name))
+            table.add(lancedb_rows)
+        total_rows_written += len(lancedb_rows)
+
+    if table is None:
+        return {
+            "uploaded": False,
+            "reason": "no_embeddings_rows_found",
+            "batches_seen": batches_seen,
+            "batches_skipped": batches_skipped,
+            "rows_written": 0,
+            "lancedb": {"uri": cfg.uri, "table_name": cfg.table_name},
+        }
+
+    if cfg.create_index:
+        try:
+            table.create_index(
+                index_type=str(cfg.index_type),
+                metric=str(cfg.metric),
+                num_partitions=int(cfg.num_partitions),
+                num_sub_vectors=int(cfg.num_sub_vectors),
+                vector_column_name="vector",
+            )
+            # Best-effort wait when supported.
+            try:
+                for stub in table.list_indices():
+                    table.wait_for_index([stub.name])
+            except Exception:
+                pass
+        except TypeError:
+            table.create_index(vector_column_name="vector")
+
+    return {
+        "uploaded": True,
+        "batches_seen": batches_seen,
+        "batches_skipped": batches_skipped,
+        "rows_written": int(total_rows_written),
+        "lancedb": {"uri": cfg.uri, "table_name": cfg.table_name, "overwrite": cfg.overwrite},
+    }
+
+
+def _write_jsonl_driver_side(
+    ds: Any, *, output_dir: Path, rows_per_file: int = 50_000, file_ext: str = "jsonl"
+) -> None:
+    """
+    Write JSON Lines without pandas by streaming Arrow batches on the driver.
+
+    Ray's built-in `Dataset.write_json()` currently converts blocks to pandas, which can
+    fail in environments with incompatible pandas builds. This avoids pandas entirely.
+    """
+    import json
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    file_idx = 0
+    row_idx_in_file = 0
+    ext = str(file_ext or "jsonl").lstrip(".")
+    f = (output_dir / f"part-{file_idx:05d}.{ext}").open("w", encoding="utf-8")
+    try:
+        for batch in ds.iter_batches(batch_format="pyarrow", batch_size=1024):
+            rows = batch.to_pylist()
+            for r in rows:
+                f.write(json.dumps(r, ensure_ascii=False) + "\n")
+                row_idx_in_file += 1
+                if row_idx_in_file >= int(rows_per_file):
+                    f.close()
+                    file_idx += 1
+                    row_idx_in_file = 0
+                    f = (output_dir / f"part-{file_idx:05d}.{ext}").open("w", encoding="utf-8")
+    finally:
+        try:
+            f.close()
+        except Exception:
+            pass
+
+
+@app.command("run")
+def run(
+    input_dir: Optional[Path] = typer.Option(
+        None, "--input-dir", exists=True, file_okay=False, dir_okay=True, help="Directory to scan for *.pdf"
+    ),
+    pdf_list: Optional[Path] = typer.Option(
+        None,
+        "--pdf-list",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        help="Text file with one PDF path per line (comments with # supported).",
+    ),
+    limit_pdfs: Optional[int] = typer.Option(None, "--limit-pdfs", help="Optionally limit number of PDFs."),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help=(
+            "Optional ingest YAML config file. If omitted, we auto-discover ./ingest-config.yaml then "
+            "$HOME/.ingest-config.yaml. This file contains sections used by stage3/4/5."
+        ),
+    ),
+    # Ray
+    ray_address: Optional[str] = typer.Option(
+        None, "--ray-address", help="Ray cluster address (omit for local). Example: 'ray://host:10001' or 'auto'."
+    ),
+    # Stage1 PDF extraction (matches `retriever pdf page-elements` CLI defaults closely)
+    method: str = typer.Option(
+        "pdfium",
+        "--method",
+        help="PDF extraction method (e.g. 'pdfium', 'pdfium_hybrid', 'ocr', 'nemotron_parse', 'tika').",
+    ),
+    auth_token: Optional[str] = typer.Option(
+        None,
+        "--auth-token",
+        help="Auth token for NIM-backed services (e.g. YOLOX / Nemotron Parse).",
+    ),
+    yolox_grpc_endpoint: Optional[str] = typer.Option(
+        None,
+        "--yolox-grpc-endpoint",
+        help="YOLOX gRPC endpoint (e.g. 'page-elements:8001'). Used by method 'pdfium' family.",
+    ),
+    yolox_http_endpoint: Optional[str] = typer.Option(
+        None,
+        "--yolox-http-endpoint",
+        help="YOLOX HTTP endpoint (e.g. 'http://page-elements:8000/v1/infer'). Used by method 'pdfium' family.",
+    ),
+    nemotron_parse_grpc_endpoint: Optional[str] = typer.Option(
+        None,
+        "--nemotron-parse-grpc-endpoint",
+        help="Nemotron Parse gRPC endpoint (required for method 'nemotron_parse').",
+    ),
+    nemotron_parse_http_endpoint: Optional[str] = typer.Option(
+        None,
+        "--nemotron-parse-http-endpoint",
+        help="Nemotron Parse HTTP endpoint (required for method 'nemotron_parse').",
+    ),
+    nemotron_parse_model_name: Optional[str] = typer.Option(
+        None,
+        "--nemotron-parse-model-name",
+        help="Nemotron Parse model name (optional; defaults to schema default).",
+    ),
+    extract_text: bool = typer.Option(True, "--extract-text/--no-extract-text", help="Extract text primitives."),
+    extract_images: bool = typer.Option(
+        False, "--extract-images/--no-extract-images", help="Extract image primitives."
+    ),
+    extract_tables: bool = typer.Option(
+        False, "--extract-tables/--no-extract-tables", help="Extract table primitives."
+    ),
+    extract_charts: bool = typer.Option(
+        False, "--extract-charts/--no-extract-charts", help="Extract chart primitives."
+    ),
+    extract_infographics: bool = typer.Option(
+        False, "--extract-infographics/--no-extract-infographics", help="Extract infographic primitives."
+    ),
+    extract_page_as_image: bool = typer.Option(
+        False, "--extract-page-as-image/--no-extract-page-as-image", help="Extract full page images as primitives."
+    ),
+    text_depth: str = typer.Option(
+        "page",
+        "--text-depth",
+        help="Text depth for extracted text primitives: 'page' or 'document'.",
+    ),
+    write_json_outputs: bool = typer.Option(
+        True,
+        "--write-json-outputs/--no-write-json-outputs",
+        help="Write one <pdf>.pdf_extraction.json sidecar per input PDF (best-effort).",
+    ),
+    json_output_dir: Optional[Path] = typer.Option(
+        None,
+        "--json-output-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Optional directory to write JSON outputs into (instead of next to PDFs).",
+    ),
+    pdf_batch_size: int = typer.Option(8, "--pdf-batch-size", min=1, help="Ray Data batch size for PDF extraction."),
+    pdf_actors: int = typer.Option(1, "--pdf-actors", min=1, help="Number of PDF extraction actors."),
+    pdf_gpus_per_actor: float = typer.Option(
+        1.0, "--pdf-gpus-per-actor", min=0.0, help="GPUs reserved per PDF extraction actor."
+    ),
+    # Stage3 (table extraction)
+    run_table: bool = typer.Option(True, "--table/--no-table", help="Enable stage3 table extraction."),
+    table_config: Optional[Path] = typer.Option(
+        None,
+        "--table-config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="(Deprecated) Optional ingest YAML config file. Uses section: table. Prefer --config.",
+    ),
+    table_batch_size: int = typer.Option(64, "--table-batch-size", min=1, help="Ray Data batch size for table stage."),
+    table_actors: int = typer.Option(1, "--table-actors", min=1, help="Number of table extraction actors."),
+    table_cpus_per_actor: float = typer.Option(8.0, "--table-cpus-per-actor", min=0.0, help="CPUs per table actor."),
+    table_gpus_per_actor: float = typer.Option(1.0, "--table-gpus-per-actor", min=0.0, help="GPUs per table actor."),
+    # Stage4 (chart extraction)
+    run_chart: bool = typer.Option(True, "--chart/--no-chart", help="Enable stage4 chart extraction."),
+    chart_config: Optional[Path] = typer.Option(
+        None,
+        "--chart-config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="(Deprecated) Optional ingest YAML config file. Uses section: chart. Prefer --config.",
+    ),
+    chart_batch_size: int = typer.Option(64, "--chart-batch-size", min=1, help="Ray Data batch size for chart stage."),
+    chart_actors: int = typer.Option(1, "--chart-actors", min=1, help="Number of chart extraction actors."),
+    chart_cpus_per_actor: float = typer.Option(8.0, "--chart-cpus-per-actor", min=0.0, help="CPUs per chart actor."),
+    chart_gpus_per_actor: float = typer.Option(1.0, "--chart-gpus-per-actor", min=0.0, help="GPUs per chart actor."),
+    # Stage5 (text embeddings)
+    run_embed: bool = typer.Option(True, "--embed/--no-embed", help="Enable stage5 text embedding."),
+    embed_config: Optional[Path] = typer.Option(
+        None,
+        "--embed-config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="(Deprecated) Optional ingest YAML config file. Uses section: embedding. Prefer --config.",
+    ),
+    embed_api_key: Optional[str] = typer.Option(
+        None, "--embed-api-key", help="Optional API key override for embedding."
+    ),
+    embed_endpoint_url: Optional[str] = typer.Option(
+        None,
+        "--embed-endpoint-url",
+        help="Optional embedding endpoint override (use 'none' to force local HF fallback).",
+    ),
+    embed_model_name: Optional[str] = typer.Option(
+        None, "--embed-model-name", help="Optional embedding model name override."
+    ),
+    embed_dimensions: Optional[int] = typer.Option(
+        None, "--embed-dimensions", help="Optional embedding dimensions override."
+    ),
+    embed_local_hf_fallback: bool = typer.Option(
+        True, "--embed-local-hf-fallback/--no-embed-local-hf-fallback", help="Enable local HF fallback if no endpoint."
+    ),
+    embed_local_hf_device: Optional[str] = typer.Option(
+        None, "--embed-local-hf-device", help="Device for local HF embeddings (e.g. 'cuda', 'cpu', 'cuda:0')."
+    ),
+    embed_local_hf_cache_dir: Optional[Path] = typer.Option(
+        None, "--embed-local-hf-cache-dir", file_okay=False, dir_okay=True, help="Optional HF cache dir for embeddings."
+    ),
+    embed_local_hf_batch_size: int = typer.Option(
+        64, "--embed-local-hf-batch-size", min=1, help="Batch size for local HF embedding inference."
+    ),
+    embed_batch_size: int = typer.Option(
+        256, "--embed-batch-size", min=1, help="Ray Data batch size for embedding stage."
+    ),
+    embed_actors: int = typer.Option(1, "--embed-actors", min=1, help="Number of embedding actors."),
+    embed_cpus_per_actor: float = typer.Option(
+        4.0, "--embed-cpus-per-actor", min=0.0, help="CPUs per embedding actor."
+    ),
+    embed_gpus_per_actor: float = typer.Option(
+        1.0, "--embed-gpus-per-actor", min=0.0, help="GPUs per embedding actor."
+    ),
+    # Stage6 (vector DB upload; driver-side)
+    vdb_upload: bool = typer.Option(
+        False, "--vdb-upload/--no-vdb-upload", help="Upload embeddings to LanceDB (stage6)."
+    ),
+    vdb_upload_batch_size: int = typer.Option(
+        2048, "--vdb-upload-batch-size", min=1, help="Driver-side batch size for LanceDB upload."
+    ),
+    lancedb_uri: str = typer.Option("lancedb", "--lancedb-uri", help="LanceDB database URI (directory path)."),
+    lancedb_table_name: str = typer.Option("nv-ingest", "--table-name", help="LanceDB table name."),
+    lancedb_overwrite: bool = typer.Option(
+        True,
+        "--overwrite/--append",
+        help="Overwrite table (default) or append to existing.",
+    ),
+    lancedb_create_index: bool = typer.Option(
+        True, "--create-index/--no-create-index", help="Create a vector index after upload."
+    ),
+    lancedb_index_type: str = typer.Option("IVF_HNSW_SQ", "--index-type", help="LanceDB index type."),
+    lancedb_metric: str = typer.Option("l2", "--metric", help="Distance metric for the index."),
+    lancedb_num_partitions: int = typer.Option(16, "--num-partitions", min=1, help="Index partitions."),
+    lancedb_num_sub_vectors: int = typer.Option(256, "--num-sub-vectors", min=1, help="Index sub-vectors."),
+    materialize: bool = typer.Option(
+        True,
+        "--materialize/--no-materialize",
+        help="Materialize the final dataset once to avoid recomputing for multiple sinks (output + vdb upload).",
+    ),
+    # Output
+    output_format: str = typer.Option(
+        "json",
+        "--output-format",
+        help="Output format: 'json' (default), 'jsonl', or 'parquet'.",
+    ),
+    jsonl_rows_per_file: int = typer.Option(
+        50_000,
+        "--jsonl-rows-per-file",
+        min=1,
+        help="When --output-format=jsonl, max rows per output file (driver-side writer).",
+    ),
+    output_dir: Path = typer.Option(
+        Path("ray_ocr_outputs"),
+        "--output-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to write output shards into.",
+    ),
+) -> None:
+    """
+    Run the pipeline.
+    """
+    import ray  # type: ignore
+    import ray.data as rd
+
+    logging.basicConfig(level=logging.INFO)
+
+    ingest_cfg, _ingest_cfg_path, _ingest_cfg_source = load_ingest_config_file(config, verbose=True)
+    if config is not None and any([table_config, chart_config, embed_config]):
+        print(
+            "WARNING: --table-config/--chart-config/--embed-config are ignored because --config was provided.",
+            file=sys.stderr,
+        )
+
+    pdfs = _iter_pdf_paths(input_dir=input_dir, pdf_list=pdf_list, limit_pdfs=limit_pdfs)
+    if not pdfs:
+        raise typer.BadParameter("No PDFs found. Provide --input-dir and/or --pdf-list.")
+
+    ray.init(
+        address=ray_address,
+        ignore_reinit_error=True,
+    )
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    logger.info("Building binary dataset from PDFs: pdfs=%s", len(pdfs))
+    # Read all pdfs files into memory has it makes controlling parallelism easier and allows for distributed execution.
+    pdf_bin = rd.read_binary_files(pdfs, include_paths=True)
+
+    # Normalize schema so downstream stages are stable.
+    pdf_bin = pdf_bin.map(_normalize_pdf_binary_row)
+
+    logger.info("Actor stage: PDF extraction (actors=%s, batch_size=%s)", pdf_actors, pdf_batch_size)
+    extracted = pdf_bin.map_batches(
+        PDFExtractionActorBatchFn,
+        batch_format="pandas",
+        batch_size=int(pdf_batch_size),
+        num_cpus=8,
+        num_gpus=float(pdf_gpus_per_actor),
+        compute=rd.ActorPoolStrategy(size=int(pdf_actors)),
+        fn_constructor_kwargs={
+            "method": str(method),
+            "auth_token": auth_token,
+            "yolox_grpc_endpoint": yolox_grpc_endpoint,
+            "yolox_http_endpoint": yolox_http_endpoint,
+            "nemotron_parse_grpc_endpoint": nemotron_parse_grpc_endpoint,
+            "nemotron_parse_http_endpoint": nemotron_parse_http_endpoint,
+            "nemotron_parse_model_name": nemotron_parse_model_name,
+            "extract_text": bool(extract_text),
+            "extract_images": bool(extract_images),
+            "extract_tables": bool(extract_tables),
+            "extract_charts": bool(extract_charts),
+            "extract_infographics": bool(extract_infographics),
+            "extract_page_as_image": bool(extract_page_as_image),
+            "text_depth": str(text_depth),
+            "write_json_outputs": bool(write_json_outputs),
+            "json_output_dir": str(json_output_dir) if json_output_dir is not None else None,
+        },
+    )
+
+    if run_table:
+        table_cfg_dict: Dict[str, Any]
+        if config is not None:
+            table_cfg_dict = _cfg_section(ingest_cfg, "table")
+        elif table_config is not None:
+            table_file_cfg, _p, _s = load_ingest_config_file(table_config, verbose=True)
+            table_cfg_dict = _cfg_section(table_file_cfg, "table")
+        else:
+            table_cfg_dict = _cfg_section(ingest_cfg, "table")
+        logger.info("Actor stage: table extraction (actors=%s, batch_size=%s)", table_actors, table_batch_size)
+        extracted = extracted.map_batches(
+            TableExtractionActorBatchFn,
+            batch_format="pandas",
+            batch_size=int(table_batch_size),
+            num_cpus=float(table_cpus_per_actor),
+            num_gpus=float(table_gpus_per_actor),
+            compute=rd.ActorPoolStrategy(size=int(table_actors)),
+            fn_constructor_kwargs={"config_dict": table_cfg_dict},
+        )
+
+    if run_chart:
+        chart_cfg_dict: Dict[str, Any]
+        if config is not None:
+            chart_cfg_dict = _cfg_section(ingest_cfg, "chart")
+        elif chart_config is not None:
+            chart_file_cfg, _p, _s = load_ingest_config_file(chart_config, verbose=True)
+            chart_cfg_dict = _cfg_section(chart_file_cfg, "chart")
+        else:
+            chart_cfg_dict = _cfg_section(ingest_cfg, "chart")
+        logger.info("Actor stage: chart extraction (actors=%s, batch_size=%s)", chart_actors, chart_batch_size)
+        extracted = extracted.map_batches(
+            ChartExtractionActorBatchFn,
+            batch_format="pandas",
+            batch_size=int(chart_batch_size),
+            num_cpus=float(chart_cpus_per_actor),
+            num_gpus=float(chart_gpus_per_actor),
+            compute=rd.ActorPoolStrategy(size=int(chart_actors)),
+            fn_constructor_kwargs={"config_dict": chart_cfg_dict},
+        )
+
+    if run_embed:
+        embed_cfg_dict: Dict[str, Any]
+        if config is not None:
+            embed_cfg_dict = _cfg_section(ingest_cfg, "embedding")
+        elif embed_config is not None:
+            embed_file_cfg, _p, _s = load_ingest_config_file(embed_config, verbose=True)
+            embed_cfg_dict = _cfg_section(embed_file_cfg, "embedding")
+        else:
+            embed_cfg_dict = _cfg_section(ingest_cfg, "embedding")
+        # Task-config overrides (takes precedence over schema defaults).
+        embed_task_cfg: Dict[str, Any] = {}
+        if embed_api_key is not None:
+            embed_task_cfg["api_key"] = embed_api_key
+        # IMPORTANT:
+        # - If --embed-endpoint-url is NOT provided, we intentionally force local HF embeddings by setting
+        #   endpoint_url=None (even if the schema has a default endpoint configured).
+        # - If it IS provided, use it (with 'none' meaning force-local).
+        if embed_endpoint_url is None:
+            embed_task_cfg["endpoint_url"] = None
+        else:
+            v = embed_endpoint_url.strip()
+            embed_task_cfg["endpoint_url"] = None if v.lower() in ("", "none", "null") else v
+        if embed_model_name is not None:
+            embed_task_cfg["model_name"] = embed_model_name
+        if embed_dimensions is not None:
+            embed_task_cfg["dimensions"] = int(embed_dimensions)
+        embed_task_cfg["use_local_hf_if_no_endpoint"] = bool(embed_local_hf_fallback)
+        if embed_local_hf_device is not None:
+            embed_task_cfg["local_hf_device"] = str(embed_local_hf_device)
+        if embed_local_hf_cache_dir is not None:
+            embed_task_cfg["local_hf_cache_dir"] = str(embed_local_hf_cache_dir)
+        if embed_local_hf_batch_size is not None:
+            embed_task_cfg["local_hf_batch_size"] = int(embed_local_hf_batch_size)
+
+        logger.info("Actor stage: text embeddings (actors=%s, batch_size=%s)", embed_actors, embed_batch_size)
+        extracted = extracted.map_batches(
+            TextEmbeddingActorBatchFn,
+            batch_format="pandas",
+            batch_size=int(embed_batch_size),
+            num_cpus=float(embed_cpus_per_actor),
+            num_gpus=float(embed_gpus_per_actor),
+            compute=rd.ActorPoolStrategy(size=int(embed_actors)),
+            fn_constructor_kwargs={"config_dict": embed_cfg_dict, "task_config": embed_task_cfg},
+        )
+
+    if vdb_upload and not run_embed:
+        raise typer.BadParameter("--vdb-upload requires --embed (stage5) to be enabled.")
+
+    # If we have multiple sinks, materialize once to avoid recomputation.
+    if materialize and (vdb_upload or str(output_format or "").strip()):
+        if hasattr(extracted, "materialize"):
+            extracted = extracted.materialize()
+
+    fmt = str(output_format or "parquet").strip().lower()
+    if fmt == "parquet":
+        logger.info("Writing output Parquet shards to %s", output_dir)
+        extracted.write_parquet(str(output_dir))
+    elif fmt in {"json", "jsonl"}:
+        # Ray's write_json writes JSON Lines shards; it may use pandas internally in some versions.
+        try:
+            logger.info("Writing output JSON shards to %s", output_dir)
+            extracted.write_json(str(output_dir))
+        except Exception:
+            logger.exception("Dataset.write_json failed; falling back to driver-side JSONL writer")
+            ext = "json" if fmt == "json" else "jsonl"
+            _write_jsonl_driver_side(
+                extracted,
+                output_dir=output_dir,
+                rows_per_file=int(jsonl_rows_per_file),
+                file_ext=ext,
+            )
+    else:
+        raise typer.BadParameter("Unsupported --output-format. Use 'json', 'jsonl', or 'parquet'.")
+
+    if vdb_upload:
+        logger.info("Driver stage: uploading embeddings to LanceDB uri=%s table=%s", lancedb_uri, lancedb_table_name)
+        info = _upload_embeddings_to_lancedb_driver_side(
+            extracted,
+            cfg=LanceDBUploadConfig(
+                uri=str(lancedb_uri),
+                table_name=str(lancedb_table_name),
+                overwrite=bool(lancedb_overwrite),
+                create_index=bool(lancedb_create_index),
+                index_type=str(lancedb_index_type),
+                metric=str(lancedb_metric),
+                num_partitions=int(lancedb_num_partitions),
+                num_sub_vectors=int(lancedb_num_sub_vectors),
+            ),
+            batch_size=int(vdb_upload_batch_size),
+        )
+        logger.info("LanceDB upload done: %s", info)
+
+    logger.info("Done.")
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/ingest-config.yaml b/nemo_retriever/src/nemo_retriever/ingest-config.yaml
new file mode 100644
index 000000000..e354c2085
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest-config.yaml
@@ -0,0 +1,259 @@
+# nv-ingest retriever consolidated configuration
+#
+# This single file replaces the older per-stage YAML configs:
+#   - pdf_stage_config.yaml
+#   - table_stage_config.yaml
+#   - chart_stage_config.yaml
+#   - infographic_stage_config.yaml
+#   - embedding_stage_config.yaml
+#
+# Where this file is discovered (precedence):
+# - Explicit: pass `--config /path/to/ingest-config.yaml`
+# - Local:    `./ingest-config.yaml` (current working directory)
+# - Home:     `$HOME/.ingest-config.yaml`
+#
+# NOTE:
+# - CLI flags still override YAML values when the command supports it.
+# - Sections below are consumed by their respective stages.
+
+pdf:
+  # Example config for: `retriever pdf stage page-elements --config <this.yaml>`
+  #
+  # Directory containing PDFs (scanned recursively for *.pdf)
+  input_dir: /home/local/jdyer/datasets/jp20
+
+  # PDF extraction method: pdfium | pdfium_hybrid | ocr | nemotron_parse | tika | unstructured_io | adobe | llama
+  method: pdfium
+
+  # Optional auth token for NIM-backed services
+  auth_token: null
+
+  endpoints:
+    yolox:
+      # If set to null then HuggingFace models will be used instead of NIMs
+      # grpc: localhost:8001
+      # http: http://localhost:8000/v1/infer
+      grpc: null
+      http: null
+
+    # Only required for method: nemotron_parse
+    nemotron_parse:
+      grpc: null
+      http: null
+      model_name: null
+
+  extract:
+    text: true
+    # Text depth: page | document
+    text_depth: page
+    images: false
+    tables: true
+    charts: true
+    infographics: true
+    page_as_image: false
+
+  outputs:
+    write_json: true
+    json_output_dir: /home/local/jdyer/datasets/jp20-results-hf-standalone/
+
+  # Optionally limit number of PDFs processed
+  limit: null
+
+# Optional config for `retriever txt run` and .extract_txt() API
+txt:
+  max_tokens: 512
+  overlap_tokens: 0
+  tokenizer_model_id: nvidia/llama-3.2-nv-embedqa-1b-v2
+  encoding: utf-8
+
+# Optional config for `retriever html run` and .extract_html() API
+html:
+  max_tokens: 512
+  overlap_tokens: 0
+  tokenizer_model_id: nvidia/llama-3.2-nv-embedqa-1b-v2
+  encoding: utf-8
+
+# Optional config for .extract_audio() API (batch, inprocess, fused, online).
+# ASR can be remote (Parakeet/Riva gRPC) or local (HuggingFace nvidia/parakeet-ctc-1.1b).
+audio_chunk:
+  split_type: size
+  split_interval: 450
+  audio_only: false
+  video_audio_separate: false
+
+audio_asr:
+  # [grpc_endpoint, http_endpoint]; only gRPC is used for Parakeet when remote.
+  # When both null, local HF model (nvidia/parakeet-ctc-1.1b) is used; no NIM/gRPC required.
+  # For NGC cloud ASR: set auth_token from NGC_API_KEY and function_id from NGC catalog;
+  # or use env: AUDIO_GRPC_ENDPOINT (default grpc.nvcf.nvidia.com:443), NGC_API_KEY, AUDIO_FUNCTION_ID.
+  audio_endpoints: [null, null]
+  audio_infer_protocol: grpc
+  function_id: null
+  auth_token: null
+  segment_audio: false
+
+table:
+  # Example config for:
+  #   - `retriever table stage run --config <this.yaml> --input <primitives.parquet>`
+  #   - `retriever local stage3 run --config <this.yaml> --input <primitives.parquet>`
+  #
+  # This YAML is parsed into `nv_ingest_api.internal.schemas.extract.extract_table_schema.TableExtractorSchema`
+  # via `nemo_retriever.table.config.load_table_extractor_schema_from_dict`.
+  #
+  # IMPORTANT:
+  # `endpoint_config.yolox_endpoints` and `endpoint_config.ocr_endpoints` must each provide at least one
+  # endpoint (gRPC or HTTP). Both cannot be null/empty for either entry.
+
+  # Optional worker settings
+  max_queue_size: 1
+  n_workers: 2
+  raise_on_failure: false
+
+  # Endpoint configuration for table extraction (YOLOX table-structure + OCR).
+  endpoint_config:
+    # Optional auth token for secured services (NIM)
+    auth_token: null
+
+    # Tuple/list in the form: [grpc, http]
+    # YOLOX table-structure model endpoints
+    # yolox_endpoints: ["localhost:8007", "http://localhost:8006/v1/infer"]
+    yolox_endpoints: null
+    # Optional; if omitted it is inferred from which endpoint is present.
+    # yolox_infer_protocol: grpc
+
+    # OCR model endpoints
+    # ocr_endpoints: ["localhost:8010", "http://localhost:8019/v1/infer"]
+    ocr_endpoints: null
+    # Optional; if omitted it is inferred from which endpoint is present.
+    # ocr_infer_protocol: grpc
+
+    # Optional performance knobs
+    nim_batch_size: 2
+    workers_per_progress_engine: 5
+
+chart:
+  # Example config for:
+  #   - `retriever chart stage run --config <this.yaml> --input <primitives.parquet>`
+  #   - `retriever local stage4 run --config <this.yaml> --input <primitives.parquet>`
+  #
+  # This YAML is parsed into `nv_ingest_api.internal.schemas.extract.extract_chart_schema.ChartExtractorSchema`
+  # via `nemo_retriever.chart.config.load_chart_extractor_schema_from_dict`.
+  #
+  # IMPORTANT:
+  # If `endpoint_config.yolox_endpoints` is null/empty, chart extraction will fall back to the local
+  # HuggingFace model (`nemo_retriever.model.local.nemotron_graphic_elements_v1`).
+  # If `endpoint_config.ocr_endpoints` is null/empty, chart extraction falls back to local Nemotron OCR
+  # (`nemo_retriever.model.local.nemotron_ocr_v1`) with default HuggingFace model loading.
+
+  # Optional worker settings
+  max_queue_size: 1
+  n_workers: 2
+  raise_on_failure: false
+
+  # Endpoint configuration for chart extraction (YOLOX graphic-elements + OCR).
+  endpoint_config:
+    # Optional auth token for secured services (NIM / hosted endpoints)
+    auth_token: null
+
+    # Tuple/list in the form: [grpc, http]
+    #
+    # Chart extraction uses the YOLOX *graphic-elements* model (not page-elements).
+    #
+    # For the provided `docker-compose.yaml`, the host-mapped ports are:
+    #   - graphic-elements HTTP: 8003 (container 8000)
+    #   - graphic-elements gRPC: 8004 (container 8001)
+    #
+    # If you're running from inside the docker compose network instead, these often look like:
+    #   - "graphic-elements:8001" and "http://graphic-elements:8000/v1/infer"
+    # yolox_endpoints: ["localhost:8004", "http://localhost:8003/v1/infer"]
+    yolox_endpoints: null
+    # Optional; if omitted it is inferred from which endpoint is present.
+    # yolox_infer_protocol: grpc
+
+    # OCR model endpoints (same pattern: [grpc, http]).
+    # For the provided `docker-compose.yaml`, the host-mapped ports are:
+    #   - ocr HTTP: 8019 (container 8000)
+    #   - ocr gRPC: 8010 (container 8001)
+    # ocr_endpoints: ["localhost:8010", "http://localhost:8019/v1/infer"]
+    ocr_endpoints: null
+    # Optional; if omitted it is inferred from which endpoint is present.
+    # ocr_infer_protocol: grpc
+
+    # Optional performance knobs
+    nim_batch_size: 2
+    workers_per_progress_engine: 5
+
+infographic:
+  # Example config for:
+  #   - `retriever infographic stage run --config <this.yaml> --input <primitives.parquet>`
+  #   - `retriever local stage2 run --config <this.yaml> --input <primitives.parquet>`
+  #
+  # This YAML is parsed into `nv_ingest_api.internal.schemas.extract.extract_infographic_schema.InfographicExtractorSchema`
+  # via `nemo_retriever.infographic.config.load_infographic_extractor_schema_from_dict`.
+  #
+  # IMPORTANT:
+  # `endpoint_config.ocr_endpoints` must provide at least one endpoint (gRPC or HTTP). Both cannot be null/empty.
+
+  # Optional worker settings
+  max_queue_size: 1
+  n_workers: 2
+  raise_on_failure: false
+
+  # Endpoint configuration for OCR used to enrich infographic primitives.
+  endpoint_config:
+    # Tuple/list in the form: [grpc, http]
+    # - gRPC example: "ocr:8001"
+    # - HTTP example: "http://ocr:8000/v1/infer"
+    # ocr_endpoints: ["localhost:8001", "http://localhost:8019/v1/infer"]
+    ocr_endpoints: null
+
+    # Optional; if omitted it is inferred from which endpoint is present.
+    # ocr_infer_protocol: grpc
+
+    # Optional auth token for secured services (NIM)
+    auth_token: null
+
+    # Optional performance knobs
+    nim_batch_size: 2
+    workers_per_progress_engine: 5
+
+embedding:
+  # Text embedding stage config (nemo_retriever.text_embed)
+  #
+  # This YAML is passed to:
+  #   nemo_retriever.text_embed.config.load_text_embedding_schema_from_dict(...)
+  # which validates against nv-ingest-api's `TextEmbeddingSchema`.
+  #
+  # Minimal required fields are optional (schema provides defaults), but you
+  # typically set api_key / endpoint / model to point at your embedding service.
+
+  # Auth (optional; can also be provided via task_config overrides)
+  api_key: ""  # e.g. $NGC_API_KEY or $NVIDIA_API_KEY
+
+  # Embedding service settings
+  # If set to null/empty, `retriever local stage5` will fall back to local HF embeddings
+  # via `nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder`.
+  embedding_nim_endpoint: null
+  # embedding_nim_endpoint: "http://localhost:8012/v1"
+  embedding_model: "nvidia/llama-3.2-nv-embedqa-1b-v2"
+
+  # Request formatting
+  encoding_format: "float"   # usually "float"
+  input_type: "passage"      # "passage" (docs) or "query" (queries)
+  truncate: "END"            # how the service truncates long inputs
+
+  # Batch sizing (NIM-side batching is handled internally; this is stage batching)
+  batch_size: 4
+
+  # Modalities for multi-modal models (leave as "text" for text-only models)
+  text_elements_modality: "text"
+  image_elements_modality: "text"
+  structured_elements_modality: "text"
+  audio_elements_modality: "text"
+
+  # Behavior
+  raise_on_failure: false
+  httpx_log_level: "WARNING"  # DEBUG | INFO | WARNING | ERROR | CRITICAL
+
+  # Optional: request embedding vector size if the backend supports it
+  # dimensions: 1024
diff --git a/nemo_retriever/src/nemo_retriever/ingest_config.py b/nemo_retriever/src/nemo_retriever/ingest_config.py
new file mode 100644
index 000000000..f1a7e3a7e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_config.py
@@ -0,0 +1,144 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+import yaml
+
+DEFAULT_CWD_CONFIG_NAME = "ingest-config.yaml"
+DEFAULT_HOME_CONFIG_NAME = ".ingest-config.yaml"
+
+
+def resolve_ingest_config_path(explicit: Optional[Path]) -> Tuple[Optional[Path], str]:
+    """
+    Resolve which ingest config file to use.
+
+    Precedence:
+    1) explicit path (e.g. --config /path/to/ingest-config.yaml)
+    2) ./ingest-config.yaml (current working directory)
+    3) $HOME/.ingest-config.yaml
+    """
+    if explicit is not None:
+        p = Path(explicit).expanduser()
+        return p, "explicit"
+
+    local = Path.cwd() / DEFAULT_CWD_CONFIG_NAME
+    if local.is_file():
+        return local, "local"
+
+    home = Path.home() / DEFAULT_HOME_CONFIG_NAME
+    if home.is_file():
+        return home, "home"
+
+    return None, "none"
+
+
+def _read_yaml_mapping(path: Path) -> Dict[str, Any]:
+    try:
+        data = yaml.safe_load(path.read_text(encoding="utf-8"))
+    except Exception as e:
+        raise ValueError(f"Failed reading YAML config {path}: {e}") from e
+
+    if data is None:
+        return {}
+    if not isinstance(data, dict):
+        raise ValueError(f"YAML config must be a mapping/object at top-level: {path}")
+    return data
+
+
+def _get_section(cfg: Dict[str, Any], section: Optional[str]) -> Dict[str, Any]:
+    """
+    Return a nested section of cfg, using dot-separated keys.
+
+    - section=None => full config
+    - missing sections => {}
+    """
+    if not section:
+        return dict(cfg or {})
+
+    cur: Any = cfg
+    for part in section.split("."):
+        if not isinstance(cur, dict) or part not in cur:
+            return {}
+        cur = cur.get(part)
+
+    return dict(cur or {}) if isinstance(cur, dict) else {}
+
+
+def _yaml_dump(obj: Any) -> str:
+    return yaml.safe_dump(obj, sort_keys=False, default_flow_style=False).rstrip()
+
+
+def load_ingest_config_file(
+    explicit: Optional[Path],
+    *,
+    verbose: bool = True,
+) -> Tuple[Dict[str, Any], Optional[Path], str]:
+    """
+    Load the full ingest config file (multi-section).
+
+    Returns: (config_dict, resolved_path_or_none, source)
+    where source is one of: explicit | local | home | none.
+    """
+    path, source = resolve_ingest_config_path(explicit)
+    if path is None:
+        return {}, None, "none"
+
+    if not path.is_file():
+        raise FileNotFoundError(f"Ingest config not found: {path}")
+
+    cfg = _read_yaml_mapping(path)
+
+    if verbose:
+        if source in {"local", "home"}:
+            print(
+                f"WARNING: using ingest config from {path} (source={source}).",
+                file=sys.stderr,
+            )
+        else:
+            print(f"Using ingest config from {path} (source={source}).", file=sys.stderr)
+
+        print("--- ingest config (entire file) ---", file=sys.stderr)
+        dumped = _yaml_dump(cfg)
+        print(dumped if dumped else "{}", file=sys.stderr)
+        print("--- end ingest config ---", file=sys.stderr)
+
+    return cfg, path, source
+
+
+def load_ingest_config_section(
+    explicit: Optional[Path],
+    *,
+    section: str,
+    verbose: bool = True,
+    warn_if_missing_section: bool = True,
+) -> Dict[str, Any]:
+    """
+    Load a named section from the ingest config file.
+
+    If no config file is found, returns {}.
+    If the section does not exist, returns {} and optionally warns.
+    """
+    cfg, path, source = load_ingest_config_file(explicit, verbose=verbose)
+    if not cfg:
+        return {}
+
+    sub = _get_section(cfg, section)
+    if not sub and warn_if_missing_section and path is not None:
+        print(
+            f"WARNING: ingest config section '{section}' not found in {path} (source={source}); using defaults/CLI.",
+            file=sys.stderr,
+        )
+
+    if verbose and path is not None:
+        print(f"--- ingest config (section: {section}) ---", file=sys.stderr)
+        dumped = _yaml_dump(sub)
+        print(dumped if dumped else "{}", file=sys.stderr)
+        print(f"--- end ingest config section: {section} ---", file=sys.stderr)
+
+    return sub
diff --git a/nemo_retriever/src/nemo_retriever/ingest_modes/__init__.py b/nemo_retriever/src/nemo_retriever/ingest_modes/__init__.py
new file mode 100644
index 000000000..9a339bba3
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_modes/__init__.py
@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Ingestion runmodes.
+
+Each runmode provides a concrete `Ingestor` implementation with the same public
+method surface defined by `nemo_retriever.ingestor.Ingestor`.
+"""
+
+from __future__ import annotations
+
+from .batch import BatchIngestor
+from .fused import FusedIngestor
+from .inprocess import InProcessIngestor
+from .online import OnlineIngestor
+
+__all__ = [
+    "BatchIngestor",
+    "FusedIngestor",
+    "InProcessIngestor",
+    "OnlineIngestor",
+]
diff --git a/nemo_retriever/src/nemo_retriever/ingest_modes/batch.py b/nemo_retriever/src/nemo_retriever/ingest_modes/batch.py
new file mode 100644
index 000000000..e33f82ee3
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_modes/batch.py
@@ -0,0 +1,1112 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Batch runmode.
+
+Intended for large-scale batch execution over large inputs on multiple workers.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import glob
+import json
+import logging
+import os
+import time
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from datetime import timedelta
+
+from typing import Union
+
+import ray
+import ray.data as rd
+from nemo_retriever.utils.convert import DocToPdfConversionActor
+from nemo_retriever.page_elements import PageElementDetectionActor
+from nemo_retriever.ocr.ocr import NemotronParseActor, OCRActor
+from nemo_retriever.pdf.extract import PDFExtractionActor
+from nemo_retriever.pdf.split import PDFSplitActor
+
+from ..ingestor import Ingestor
+from ..params import ASRParams
+from ..params import AudioChunkParams
+from ..params import EmbedParams
+from ..params import ExtractParams
+from ..params import HtmlChunkParams
+from ..params import IngestExecuteParams
+from ..params import PdfSplitParams
+from ..params import TextChunkParams
+from ..params import VdbUploadParams
+
+DEBUG_LOG_PATH = "/home/jeremy/Development/nv-ingest/.cursor/debug-250ae2.log"
+
+
+def _coerce_params[T](params: T | None, model_cls: type[T], kwargs: dict[str, Any]) -> T:
+    if params is None:
+        return model_cls(**kwargs)
+    if kwargs:
+        return params.model_copy(update=kwargs)  # type: ignore[return-value]
+    return params
+
+
+# region agent log
+def _debug_log(*, run_id: str, hypothesis_id: str, location: str, message: str, data: dict[str, Any]) -> None:
+    payload = {
+        "sessionId": "250ae2",
+        "runId": run_id,
+        "hypothesisId": hypothesis_id,
+        "location": location,
+        "message": message,
+        "data": data,
+        "timestamp": int(time.time() * 1000),
+    }
+    try:
+        with open(DEBUG_LOG_PATH, "a", encoding="utf-8") as f:
+            f.write(json.dumps(payload, ensure_ascii=False) + "\n")
+    except Exception:
+        pass
+
+
+# endregion
+
+
+class _LanceDBWriteActor:
+    """Ray Data actor that streams batches into LanceDB as they arrive.
+
+    Creates the table on the first batch, then appends subsequent batches.
+    Index creation is intentionally deferred until after the full pipeline
+    has been consumed (handled by ``BatchIngestor.ingest()``).
+    """
+
+    def __init__(self, params: VdbUploadParams | None = None) -> None:
+        import json
+        from pathlib import Path
+
+        self._json = json
+        self._Path = Path
+        lancedb_params = (params or VdbUploadParams()).lancedb
+
+        self._lancedb_uri = lancedb_params.lancedb_uri
+        self._table_name = lancedb_params.table_name
+        self._overwrite = lancedb_params.overwrite
+        self._embedding_column = lancedb_params.embedding_column
+        self._embedding_key = lancedb_params.embedding_key
+        self._include_text = lancedb_params.include_text
+        self._text_column = lancedb_params.text_column
+
+        import lancedb  # type: ignore
+        import pyarrow as pa  # type: ignore
+
+        self._pa = pa
+        self._db = lancedb.connect(uri=self._lancedb_uri)
+        self._table = None
+        self._schema = None
+        self._first_batch = True
+        self._total_rows = 0
+        self._table = None
+        mode = "overwrite" if self._overwrite else "create"
+        fields = [
+            pa.field("vector", pa.list_(pa.float32(), 2048)),
+            pa.field("pdf_page", pa.string()),
+            pa.field("filename", pa.string()),
+            pa.field("pdf_basename", pa.string()),
+            pa.field("page_number", pa.int32()),
+            pa.field("source_id", pa.string()),
+            pa.field("path", pa.string()),
+            pa.field("text", pa.string()),
+            pa.field("metadata", pa.string()),
+            pa.field("source", pa.string()),
+        ]
+        self._schema = pa.schema(fields)
+
+        self._table = self._db.create_table(
+            self._table_name,
+            schema=self._schema,
+            mode=mode,
+        )
+
+    def _build_rows(self, df: Any) -> list:
+        """Build LanceDB rows from a pandas DataFrame batch.
+
+        Mirrors the row-building logic from
+        ``upload_embeddings_to_lancedb_inprocess`` in inprocess.py.
+        """
+        rows: list = []
+        for row in df.itertuples(index=False):
+            # Extract embedding
+            emb = None
+            meta = getattr(row, "metadata", None)
+            if isinstance(meta, dict):
+                emb = meta.get("embedding")
+                if not (isinstance(emb, list) and emb):
+                    emb = None
+            if emb is None:
+                payload = getattr(row, self._embedding_column, None)
+                if isinstance(payload, dict):
+                    emb = payload.get(self._embedding_key)
+                    if not (isinstance(emb, list) and emb):
+                        emb = None
+            if emb is None:
+                continue
+
+            # Extract source path and page number
+            path = ""
+            page = -1
+            v = getattr(row, "path", None)
+            if isinstance(v, str) and v.strip():
+                path = v.strip()
+            v = getattr(row, "page_number", None)
+            try:
+                if v is not None:
+                    page = int(v)
+            except Exception:
+                pass
+            if isinstance(meta, dict):
+                sp = meta.get("source_path")
+                if isinstance(sp, str) and sp.strip():
+                    path = sp.strip()
+
+            p = self._Path(path) if path else None
+            filename = p.name if p is not None else ""
+            pdf_basename = p.stem if p is not None else ""
+            pdf_page = f"{pdf_basename}_{page}" if (pdf_basename and page >= 0) else ""
+            source_id = path or filename or pdf_basename
+
+            metadata_obj = {"page_number": int(page) if page is not None else -1}
+            if pdf_page:
+                metadata_obj["pdf_page"] = pdf_page
+            # Persist per-page detection counters for end-of-run summaries.
+            # These may be duplicated across exploded content rows; downstream
+            # summary logic should dedupe by (source_id, page_number).
+            pe_num = getattr(row, "page_elements_v3_num_detections", None)
+            if pe_num is not None:
+                try:
+                    metadata_obj["page_elements_v3_num_detections"] = int(pe_num)
+                except Exception:
+                    pass
+            pe_counts = getattr(row, "page_elements_v3_counts_by_label", None)
+            if isinstance(pe_counts, dict):
+                metadata_obj["page_elements_v3_counts_by_label"] = {
+                    str(k): int(v) for k, v in pe_counts.items() if isinstance(k, str) and v is not None
+                }
+            for ocr_col in ("table", "chart", "infographic"):
+                entries = getattr(row, ocr_col, None)
+                if isinstance(entries, list):
+                    metadata_obj[f"ocr_{ocr_col}_detections"] = int(len(entries))
+            source_obj = {"source_id": str(path)}
+
+            row_out = {
+                "vector": emb,
+                "pdf_page": pdf_page,
+                "filename": filename,
+                "pdf_basename": pdf_basename,
+                "page_number": int(page) if page is not None else -1,
+                "source_id": str(source_id),
+                "path": str(path),
+                "metadata": self._json.dumps(metadata_obj, ensure_ascii=False),
+                "source": self._json.dumps(source_obj, ensure_ascii=False),
+            }
+
+            if self._include_text:
+                t = getattr(row, self._text_column, None)
+                row_out["text"] = str(t) if isinstance(t, str) else ""
+            else:
+                row_out["text"] = ""
+
+            rows.append(row_out)
+        return rows
+
+    def __call__(self, batch_df: Any) -> Any:
+        rows = self._build_rows(batch_df)
+        if rows:
+            # Infer schema from first batch
+            if self._table is None:
+                self._table = self._db.open_table(self._table_name)
+            self._table.add(rows)
+
+            self._total_rows += len(rows)
+
+        return batch_df
+
+
+class _BatchEmbedActor:
+    """Ray Data actor that holds a local text embedder on a single GPU.
+
+    When ``embedding_endpoint`` is provided in kwargs, the actor skips local
+    model creation and delegates to a remote NIM endpoint instead.
+    """
+
+    def __init__(self, params: EmbedParams) -> None:
+        self._params = params
+        self._kwargs = {
+            **params.model_dump(mode="python", exclude={"runtime", "batch_tuning", "fused_tuning"}, exclude_none=True),
+            **params.runtime.model_dump(mode="python", exclude_none=True),
+        }
+        if "embedding_endpoint" not in self._kwargs and self._kwargs.get("embed_invoke_url"):
+            self._kwargs["embedding_endpoint"] = self._kwargs.get("embed_invoke_url")
+
+        # If a remote NIM endpoint is configured, skip local model creation.
+        endpoint = (self._kwargs.get("embedding_endpoint") or self._kwargs.get("embed_invoke_url") or "").strip()
+        if endpoint:
+            self._model = None
+            return
+
+        device = self._kwargs.get("device")
+        hf_cache_dir = self._kwargs.get("hf_cache_dir")
+        normalize = bool(self._kwargs.get("normalize", True))
+        max_length = int(self._kwargs.get("max_length", 8192))
+        model_name_raw = self._kwargs.get("model_name")
+
+        from nemo_retriever.model import is_vl_embed_model, resolve_embed_model
+
+        model_id = resolve_embed_model(model_name_raw)
+
+        if is_vl_embed_model(model_name_raw):
+            from nemo_retriever.model.local.llama_nemotron_embed_vl_1b_v2_embedder import (
+                LlamaNemotronEmbedVL1BV2Embedder,
+            )
+
+            self._model = LlamaNemotronEmbedVL1BV2Embedder(
+                device=str(device) if device else None,
+                hf_cache_dir=str(hf_cache_dir) if hf_cache_dir else None,
+                model_id=model_id,
+            )
+        else:
+            from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import (
+                LlamaNemotronEmbed1BV2Embedder,
+            )
+
+            self._model = LlamaNemotronEmbed1BV2Embedder(
+                device=str(device) if device else None,
+                hf_cache_dir=str(hf_cache_dir) if hf_cache_dir else None,
+                normalize=normalize,
+                max_length=max_length,
+                model_id=model_id,
+            )
+
+    def __call__(self, batch_df: Any) -> Any:
+        from nemo_retriever.ingest_modes.inprocess import embed_text_main_text_embed
+
+        return embed_text_main_text_embed(batch_df, model=self._model, **self._kwargs)
+
+
+class BatchIngestor(Ingestor):
+    RUN_MODE = "batch"
+
+    def __init__(
+        self,
+        documents: Optional[List[str]] = None,
+        ray_address: Optional[str] = None,
+        ray_log_to_driver: bool = True,
+    ) -> None:
+        super().__init__(documents=documents)
+
+        logging.basicConfig(level=logging.INFO)
+
+        # Initialize Ray for distributed execution.
+        ray.init(address=ray_address or "local", ignore_reinit_error=True, log_to_driver=bool(ray_log_to_driver))
+
+        # Use the new Rich progress UI instead of verbose tqdm bars.
+        ctx = rd.DataContext.get_current()
+        ctx.enable_rich_progress_bars = True
+        ctx.use_ray_tqdm = False
+
+        # Query available resources so extract() can auto-size worker pools.
+        resources = ray.available_resources()
+        self._num_gpus = int(resources.get("GPU", 0))
+        self._num_cpus = int(resources.get("CPU", os.cpu_count() or 4))
+
+        # Builder-style task configuration recorded for later execution.
+        # Keep backwards-compatibility with code that inspects `Ingestor._documents`
+        # (older examples/tests) by ensuring both names refer to the same list.
+        self._input_documents: List[str] = self._documents  # List of original input documents.
+        self._rd_dataset: rd.Dataset = None  # Ray Data dataset created from input documents.
+        self._tasks: List[tuple[str, dict[str, Any]]] = []
+        self._intermediate_output_dir: Optional[str] = None
+        self._pipeline_type: str = "pdf"  # "pdf" | "txt" | "html"
+        self._extract_txt_kwargs: Dict[str, Any] = {}  # noqa: F821
+        self._extract_html_kwargs: Dict[str, Any] = {}  # noqa: F821
+
+    def files(self, documents: Union[str, List[str]]) -> "BatchIngestor":
+        """
+        Add local files for batch processing.
+
+        This runmode assumes all inputs are local. Any glob pattern or explicit
+        path must resolve to at least one existing file.
+        """
+        if isinstance(documents, str):
+            documents = [documents]
+
+        for pattern in documents:
+            if not isinstance(pattern, str) or not pattern:
+                raise ValueError(f"Invalid document pattern: {pattern!r}")
+
+            # Expand globs (supports ** when recursive=True).
+            matches = glob.glob(pattern, recursive=True)
+            if matches:
+                files = [os.path.abspath(p) for p in matches if os.path.isfile(p)]
+                if not files:
+                    raise FileNotFoundError(f"Pattern resolved, but no files found: {pattern!r}")
+                self._input_documents.extend(files)
+                continue
+
+            # No glob matches: treat as explicit path.
+            if os.path.isfile(pattern):
+                self._input_documents.append(os.path.abspath(pattern))
+                continue
+
+            raise FileNotFoundError(f"No local files found for: {pattern!r}")
+
+        self._rd_dataset = rd.read_binary_files(self._input_documents, include_paths=True)
+
+        return self
+
+    def extract(self, params: ExtractParams | None = None, **kwargs: Any) -> "BatchIngestor":
+        """
+        Configure extraction for batch processing (builder only).
+
+        This does not run extraction yet; it records configuration so the batch
+        executor can build a concrete pipeline later.
+
+        Resource-tuning kwargs (auto-detected from available resources if omitted):
+
+        - ``pdf_split_batch_size``: Batch size for PDF split stage (default 1).
+        - ``pdf_extract_batch_size``: Batch size for PDF extraction (default 32).
+        - ``pdf_extract_workers``: TaskPool size for extraction (default num_cpus // 8).
+        - ``page_elements_batch_size``: Batch size for page-element detection (default 16).
+        - ``page_elements_workers``: ActorPool size for page elements (default num_gpus // 2).
+        - ``detect_batch_size``: Batch size for detection stages (default 16).
+        - ``detect_workers``: ActorPool size for detection stages (default num_gpus // 4).
+        - ``page_elements_cpus_per_actor``: CPUs reserved per page-elements actor (default 1).
+        - ``ocr_cpus_per_actor``: CPUs reserved per OCR actor (default 1).
+        """
+
+        resolved = _coerce_params(params, ExtractParams, kwargs)
+        kwargs = {
+            **resolved.model_dump(mode="python", exclude={"remote_retry", "batch_tuning"}, exclude_none=True),
+            **resolved.remote_retry.model_dump(mode="python", exclude_none=True),
+            **resolved.batch_tuning.model_dump(mode="python", exclude_none=True),
+        }
+
+        # -- Pop resource-tuning kwargs before forwarding to actors --
+        def _endpoint_count(raw: Any) -> int:
+            s = str(raw or "").strip()
+            if not s:
+                return 0
+            return len([p for p in s.split(",") if p.strip()])
+
+        debug_run_id = str(kwargs.pop("debug_run_id", "unknown"))
+        pdf_split_batch_size = kwargs.pop("pdf_split_batch_size", 1)
+        pdf_extract_batch_size = kwargs.pop("pdf_extract_batch_size", 4)
+        pdf_extract_num_cpus = float(kwargs.pop("pdf_extract_num_cpus", 2))
+        page_elements_batch_size = kwargs.pop("page_elements_batch_size", 24)
+        detect_batch_size = kwargs.pop("detect_batch_size", 24)
+        nemotron_parse_workers = float(kwargs.pop("nemotron_parse_workers", 0.0))
+        gpu_nemotron_parse = float(kwargs.pop("gpu_nemotron_parse", 0.0))
+        nemotron_parse_batch_size = float(kwargs.pop("nemotron_parse_batch_size", 0.0))
+        use_nemotron_parse_only = (
+            nemotron_parse_workers > 0.0 and gpu_nemotron_parse > 0.0 and nemotron_parse_batch_size > 0.0
+        )
+
+        # Count GPU stages that will be created.
+        # +1 reserves headroom for a downstream embed() stage.
+        detect_stage_count = (
+            1 if any(kwargs.get(k) is True for k in ("extract_tables", "extract_charts", "extract_infographics")) else 0
+        )
+        if use_nemotron_parse_only:
+            gpu_stage_count = detect_stage_count + 1  # nemotron-parse + embed
+        else:
+            gpu_stage_count = 1 + detect_stage_count + 1  # page_elements + detection + embed
+
+        # Per-stage GPU allocation: give OCR (the bottleneck) a full GPU;
+        # page-elements (lightweight YOLOX) and embedding share 0.5 each.
+        # Total = 0.5 + 1.0 + 0.5 = 2.0, so all 3 stages run concurrently.
+        num_gpus = self._num_gpus
+        if num_gpus >= 2 and gpu_stage_count == 3:
+            gpu_page_elements = 0.5
+            gpu_ocr = 1.0
+            gpu_embed = 0.5
+        else:
+            gpu_per_stage = min(1.0, num_gpus / max(1, gpu_stage_count))
+            gpu_page_elements = gpu_per_stage
+            gpu_ocr = gpu_per_stage
+            gpu_embed = gpu_per_stage
+
+        # Allow explicit per-stage GPU overrides for controlled experiments.
+        gpu_page_elements = float(kwargs.pop("gpu_page_elements", gpu_page_elements))
+        gpu_ocr = float(kwargs.pop("gpu_ocr", gpu_ocr))
+        gpu_embed = float(kwargs.pop("gpu_embed", gpu_embed))
+
+        # Each GPU stage gets 1 worker by default (each worker holds 1 model).
+        page_elements_workers = kwargs.pop("page_elements_workers", 1)
+        ocr_workers = kwargs.pop("ocr_workers", 1)
+        detect_workers = kwargs.pop("detect_workers", ocr_workers)
+        page_elements_cpus_per_actor = float(kwargs.pop("page_elements_cpus_per_actor", 1))
+        ocr_cpus_per_actor = float(kwargs.pop("ocr_cpus_per_actor", 1))
+
+        # When remote endpoints are provided as a comma-separated list, scale
+        # actor count to match endpoint count so load can be distributed.
+        pe_endpoints = _endpoint_count(kwargs.get("page_elements_invoke_url", kwargs.get("invoke_url")))
+        if pe_endpoints > 0 and int(page_elements_workers) != int(pe_endpoints):
+            logging.warning(
+                "page_elements invoke URL list has %d endpoint(s); overriding page_elements_workers from %d to %d",
+                pe_endpoints,
+                int(page_elements_workers),
+                int(pe_endpoints),
+            )
+            page_elements_workers = int(pe_endpoints)
+
+        ocr_endpoints = _endpoint_count(kwargs.get("ocr_invoke_url", kwargs.get("invoke_url")))
+        if ocr_endpoints > 0 and int(detect_workers) != int(ocr_endpoints):
+            logging.warning(
+                "ocr invoke URL list has %d endpoint(s); overriding detect_workers from %d to %d",
+                ocr_endpoints,
+                int(detect_workers),
+                int(ocr_endpoints),
+            )
+            detect_workers = int(ocr_endpoints)
+
+        # Reserve CPUs for GPU actors, then divide the rest among extract workers.
+        if use_nemotron_parse_only:
+            total_gpu_cpus = int(nemotron_parse_workers) * ocr_cpus_per_actor
+        else:
+            total_gpu_cpus = (
+                page_elements_workers * page_elements_cpus_per_actor
+                + detect_workers * detect_stage_count * ocr_cpus_per_actor
+            )
+        cpus_for_extract = max(1, self._num_cpus - total_gpu_cpus)
+        pdf_extract_workers = kwargs.pop("pdf_extract_workers", max(1, cpus_for_extract // 2))
+
+        # region agent log
+        if use_nemotron_parse_only:
+            total_gpu_requested = float(gpu_nemotron_parse) * float(nemotron_parse_workers) + float(gpu_embed) * 1.0
+        else:
+            total_gpu_requested = (
+                float(gpu_page_elements) * float(page_elements_workers)
+                + float(gpu_ocr) * float(detect_workers * detect_stage_count)
+                + float(gpu_embed) * 1.0
+            )
+        _debug_log(
+            run_id=debug_run_id,
+            hypothesis_id="H1",
+            location="ingest_modes/batch.py:extract",
+            message="Resource envelope computed for Ray stages",
+            data={
+                "num_gpus_available": self._num_gpus,
+                "num_cpus_available": self._num_cpus,
+                "gpu_page_elements": gpu_page_elements,
+                "gpu_ocr": gpu_ocr,
+                "gpu_nemotron_parse": gpu_nemotron_parse,
+                "gpu_embed": gpu_embed,
+                "page_elements_workers": page_elements_workers,
+                "detect_workers": detect_workers,
+                "nemotron_parse_workers": nemotron_parse_workers,
+                "nemotron_parse_batch_size": nemotron_parse_batch_size,
+                "use_nemotron_parse_only": use_nemotron_parse_only,
+                "detect_stage_count": detect_stage_count,
+                "pdf_extract_workers": pdf_extract_workers,
+                "pdf_extract_num_cpus": pdf_extract_num_cpus,
+                "total_gpu_requested_across_stages": total_gpu_requested,
+                "can_fully_overlap_gpu_stages": bool(total_gpu_requested <= float(self._num_gpus)),
+            },
+        )
+        _debug_log(
+            run_id=debug_run_id,
+            hypothesis_id="H2",
+            location="ingest_modes/batch.py:extract",
+            message="CPU reservation breakdown for actors and extraction pool",
+            data={
+                "page_elements_cpus_per_actor": page_elements_cpus_per_actor,
+                "ocr_cpus_per_actor": ocr_cpus_per_actor,
+                "total_gpu_actor_cpus_reserved": total_gpu_cpus,
+                "cpus_for_extract": cpus_for_extract,
+            },
+        )
+        # endregion
+
+        # Store per-stage GPU allocations for downstream stages (e.g. embed).
+        self._gpu_page_elements = gpu_page_elements
+        self._gpu_ocr = gpu_ocr
+        self._gpu_embed = gpu_embed
+
+        logging.info(
+            "Batch extract resources: %d GPUs, %d CPUs | "
+            "pdf_extract_workers=%d, page_elements_workers=%d, ocr_workers=%d, "
+            "gpu_page_elements=%.2f, gpu_ocr=%.2f, gpu_nemotron_parse=%.2f, gpu_embed=%.2f, parse_only=%s",
+            self._num_gpus,
+            self._num_cpus,
+            pdf_extract_workers,
+            page_elements_workers,
+            detect_workers,
+            gpu_page_elements,
+            gpu_ocr,
+            gpu_nemotron_parse,
+            gpu_embed,
+            use_nemotron_parse_only,
+        )
+
+        # Downstream batch stages assume `page_image.image_b64` exists for every page.
+        # Ensure PDF extraction emits a page image unless the caller explicitly disables it.
+        kwargs.setdefault("extract_page_as_image", True)
+
+        # 200 DPI is sufficient for both detection and OCR.  YOLOX resizes to
+        # 1024x1024 internally, and NemotronOCR also resizes crops to 1024x1024,
+        # so resolution above ~1200px per side is wasted.  200 DPI (Letter =
+        # 1700x2200) gives enough detail while reducing extraction time and
+        # memory usage by ~30-40% vs 300 DPI.
+        kwargs.setdefault("dpi", 200)
+
+        self._pipeline_type = "pdf"
+        self._tasks.append(("extract", dict(kwargs)))
+
+        # Stage-specific kwargs: upstream PDF stages accept many options (dpi, extract_*),
+        # but downstream detect_* Ray actors accept only a small set. Passing the whole
+        # dict can cause TypeErrors (e.g. unexpected `method=`).
+        detect_passthrough_keys = {
+            "inference_batch_size",
+            "output_column",
+            "num_detections_column",
+            "counts_by_label_column",
+            "api_key",
+            "request_timeout_s",
+            "remote_max_pool_workers",
+            "remote_max_retries",
+            "remote_max_429_retries",
+        }
+        detect_kwargs = {k: kwargs[k] for k in detect_passthrough_keys if k in kwargs}
+        page_elements_invoke_url = kwargs.get("page_elements_invoke_url", kwargs.get("invoke_url"))
+        if page_elements_invoke_url:
+            detect_kwargs["invoke_url"] = page_elements_invoke_url
+        if "page_elements_request_timeout_s" in kwargs:
+            detect_kwargs["request_timeout_s"] = kwargs["page_elements_request_timeout_s"]
+        if "page_elements_api_key" in kwargs:
+            detect_kwargs["api_key"] = kwargs["page_elements_api_key"]
+
+        # Convert DOCX/PPTX to PDF before splitting.  CPU-only, one
+        # LibreOffice process per file (batch_size=1).
+        self._rd_dataset = self._rd_dataset.map_batches(
+            DocToPdfConversionActor,
+            batch_size=1,
+            num_cpus=1,
+            num_gpus=0,
+            batch_format="pandas",
+        )
+
+        # Splitting pdfs is broken into a separate stage to help amortize downstream
+        # processing if PDFs have vastly different numbers of pages.
+        pdf_split_actor = PDFSplitActor(
+            split_params=PdfSplitParams(
+                start_page=kwargs.get("start_page"),
+                end_page=kwargs.get("end_page"),
+            )
+        )
+        self._rd_dataset = self._rd_dataset.map_batches(
+            pdf_split_actor,
+            batch_size=pdf_split_batch_size,
+            num_cpus=1,
+            num_gpus=0,
+            batch_format="pandas",
+        )
+
+        # Pre-split pdfs are now ready for extraction — the main CPU bottleneck.
+        extraction_actor = PDFExtractionActor(**kwargs)
+        self._rd_dataset = self._rd_dataset.map_batches(
+            extraction_actor,
+            batch_size=pdf_extract_batch_size,
+            batch_format="pandas",
+            num_cpus=pdf_extract_num_cpus,
+            num_gpus=0,
+            compute=rd.TaskPoolStrategy(size=pdf_extract_workers),
+        )
+        self._rd_dataset = self._rd_dataset.repartition(target_num_rows_per_block=24)
+        if use_nemotron_parse_only:
+            parse_flags: dict[str, Any] = {}
+            if kwargs.get("extract_tables") is True:
+                parse_flags["extract_tables"] = True
+            if kwargs.get("extract_charts") is True:
+                parse_flags["extract_charts"] = True
+            if kwargs.get("extract_infographics") is True:
+                parse_flags["extract_infographics"] = True
+            for k in (
+                "api_key",
+                "request_timeout_s",
+                "remote_max_pool_workers",
+                "remote_max_retries",
+                "remote_max_429_retries",
+            ):
+                if k in kwargs:
+                    parse_flags[k] = kwargs[k]
+            parse_invoke_url = kwargs.get(
+                "nemotron_parse_invoke_url", kwargs.get("ocr_invoke_url", kwargs.get("invoke_url"))
+            )
+            if parse_invoke_url:
+                parse_flags["invoke_url"] = parse_invoke_url
+            self._rd_dataset = self._rd_dataset.map_batches(
+                NemotronParseActor,
+                batch_size=int(nemotron_parse_batch_size),
+                batch_format="pandas",
+                num_cpus=ocr_cpus_per_actor,
+                num_gpus=float(gpu_nemotron_parse),
+                compute=rd.ActorPoolStrategy(size=int(nemotron_parse_workers)),
+                fn_constructor_kwargs=parse_flags,
+            )
+        else:
+            # Page-element detection with a GPU actor pool.
+            self._rd_dataset = self._rd_dataset.map_batches(
+                PageElementDetectionActor,
+                batch_size=page_elements_batch_size,
+                batch_format="pandas",
+                num_cpus=page_elements_cpus_per_actor,
+                num_gpus=gpu_page_elements,
+                compute=rd.ActorPoolStrategy(size=page_elements_workers),
+                fn_constructor_kwargs=dict(detect_kwargs),
+            )
+
+            # OCR-based extraction for tables/charts/infographics (single stage).
+            ocr_flags = {}
+            if kwargs.get("extract_tables") is True:
+                ocr_flags["extract_tables"] = True
+            if kwargs.get("extract_charts") is True:
+                ocr_flags["extract_charts"] = True
+            if kwargs.get("extract_infographics") is True:
+                ocr_flags["extract_infographics"] = True
+            for k in (
+                "api_key",
+                "request_timeout_s",
+                "remote_max_pool_workers",
+                "remote_max_retries",
+                "remote_max_429_retries",
+            ):
+                if k in kwargs:
+                    ocr_flags[k] = kwargs[k]
+            ocr_invoke_url = kwargs.get("ocr_invoke_url", kwargs.get("invoke_url"))
+            if ocr_invoke_url:
+                ocr_flags["invoke_url"] = ocr_invoke_url
+            if "ocr_request_timeout_s" in kwargs:
+                ocr_flags["request_timeout_s"] = kwargs["ocr_request_timeout_s"]
+            if "ocr_api_key" in kwargs:
+                ocr_flags["api_key"] = kwargs["ocr_api_key"]
+
+            if ocr_flags:
+                self._rd_dataset = self._rd_dataset.map_batches(
+                    OCRActor,
+                    batch_size=detect_batch_size,
+                    batch_format="pandas",
+                    num_cpus=ocr_cpus_per_actor,
+                    num_gpus=gpu_ocr,
+                    compute=rd.ActorPoolStrategy(size=detect_workers),
+                    fn_constructor_kwargs=ocr_flags,
+                )
+
+        return self
+
+    def extract_txt(self, params: TextChunkParams | None = None, **kwargs: Any) -> "BatchIngestor":
+        """
+        Configure txt-only pipeline: read_binary_files -> TxtSplitActor (bytes -> chunk rows).
+
+        Use with .files("*.txt").extract_txt(...).embed().vdb_upload().ingest().
+        Do not call .extract() when using .extract_txt().
+        """
+        from nemo_retriever.txt.ray_data import TxtSplitActor
+
+        self._pipeline_type = "txt"
+        resolved = _coerce_params(params, TextChunkParams, kwargs)
+        self._extract_txt_kwargs = resolved.model_dump(mode="python")
+        self._tasks.append(("extract_txt", dict(self._extract_txt_kwargs)))
+
+        self._rd_dataset = self._rd_dataset.map_batches(
+            TxtSplitActor,
+            batch_size=4,
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+            fn_constructor_kwargs={"params": TextChunkParams(**self._extract_txt_kwargs)},
+        )
+        return self
+
+    def extract_html(self, params: HtmlChunkParams | None = None, **kwargs: Any) -> "BatchIngestor":
+        """
+        Configure HTML-only pipeline: read_binary_files -> HtmlSplitActor (bytes -> chunk rows).
+
+        Use with .files("*.html").extract_html(...).embed().vdb_upload().ingest().
+        Do not call .extract() when using .extract_html().
+        """
+        from nemo_retriever.html.ray_data import HtmlSplitActor
+
+        self._pipeline_type = "html"
+        resolved = _coerce_params(params, HtmlChunkParams, kwargs)
+        self._extract_html_kwargs = resolved.model_dump(mode="python")
+        self._tasks.append(("extract_html", dict(self._extract_html_kwargs)))
+
+        self._rd_dataset = self._rd_dataset.map_batches(
+            HtmlSplitActor,
+            batch_size=4,
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+            fn_constructor_kwargs={"params": HtmlChunkParams(**self._extract_html_kwargs)},
+        )
+        return self
+
+    def extract_audio(
+        self,
+        params: AudioChunkParams | None = None,
+        asr_params: ASRParams | None = None,
+        **kwargs: Any,
+    ) -> "BatchIngestor":
+        """
+        Configure audio pipeline: read_binary_files -> MediaChunkActor -> ASRActor (chunk -> transcript).
+
+        Use with .files("mp3/*.mp3").extract_audio(...).embed().vdb_upload().ingest().
+        Do not call .extract() when using .extract_audio().
+        ASR requires a remote or self-deployed Parakeet/Riva gRPC endpoint (see ASRParams.audio_endpoints).
+        """
+        from nemo_retriever.audio import ASRActor
+        from nemo_retriever.audio import MediaChunkActor
+
+        self._pipeline_type = "audio"
+        chunk_resolved = _coerce_params(params, AudioChunkParams, kwargs)
+        asr_resolved = _coerce_params(asr_params, ASRParams, kwargs)
+        self._extract_audio_chunk_kwargs = chunk_resolved.model_dump(mode="python")
+        self._extract_audio_asr_kwargs = asr_resolved.model_dump(mode="python")
+        self._tasks.append(
+            ("extract_audio", {"chunk": self._extract_audio_chunk_kwargs, "asr": self._extract_audio_asr_kwargs})
+        )
+
+        audio_chunk_batch_size = kwargs.get("audio_chunk_batch_size", 4)
+        asr_batch_size = kwargs.get("asr_batch_size", 8)
+
+        self._rd_dataset = self._rd_dataset.map_batches(
+            MediaChunkActor,
+            batch_size=audio_chunk_batch_size,
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+            fn_constructor_kwargs={"params": AudioChunkParams(**self._extract_audio_chunk_kwargs)},
+        )
+        self._rd_dataset = self._rd_dataset.map_batches(
+            ASRActor,
+            batch_size=asr_batch_size,
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+            fn_constructor_kwargs={"params": ASRParams(**self._extract_audio_asr_kwargs)},
+        )
+        return self
+
+    def embed(self, params: EmbedParams | None = None, **kwargs: Any) -> "BatchIngestor":
+        """
+        Add a text-embedding stage to the batch pipeline.
+
+        Uses a GPU actor pool so the HuggingFace model stays resident across
+        batches.  Resource-tuning kwargs:
+
+        - ``embed_workers``: ActorPool size (default 1).
+        - ``embed_batch_size``: Ray Data batch size (default 256).
+        - ``embed_cpus_per_actor``: CPUs reserved per embedding actor (default 1).
+        - ``device``, ``hf_cache_dir``, ``normalize``, ``max_length``:
+          forwarded to ``LlamaNemotronEmbed1BV2Embedder``.
+        - ``embedding_endpoint`` / ``embed_invoke_url``: optional NIM endpoint URL
+          (e.g. ``"http://embedding:8000/v1"``).  When set, the actor
+          delegates to the remote NIM instead of loading a local model,
+          and no GPU is requested for this stage.
+        """
+
+        resolved = _coerce_params(params, EmbedParams, kwargs)
+        kwargs = {
+            **resolved.model_dump(
+                mode="python", exclude={"runtime", "batch_tuning", "fused_tuning"}, exclude_none=True
+            ),
+            **resolved.runtime.model_dump(mode="python", exclude_none=True),
+            **resolved.batch_tuning.model_dump(mode="python", exclude_none=True),
+        }
+
+        def _endpoint_count(raw: Any) -> int:
+            s = str(raw or "").strip()
+            if not s:
+                return 0
+            return len([p for p in s.split(",") if p.strip()])
+
+        embed_workers = kwargs.pop("embed_workers", 1)
+        embed_batch_size = kwargs.pop("embed_batch_size", 256)
+        embed_cpus_per_actor = float(kwargs.pop("embed_cpus_per_actor", 1))
+
+        if "embedding_endpoint" not in kwargs and kwargs.get("embed_invoke_url"):
+            kwargs["embedding_endpoint"] = kwargs.get("embed_invoke_url")
+
+        endpoint_count = _endpoint_count(kwargs.get("embedding_endpoint"))
+        if endpoint_count > 0 and int(embed_workers) != int(endpoint_count):
+            logging.warning(
+                "embed endpoint list has %d endpoint(s); overriding embed_workers from %d to %d",
+                endpoint_count,
+                int(embed_workers),
+                int(endpoint_count),
+            )
+            embed_workers = int(endpoint_count)
+
+        # Remaining kwargs are forwarded to the actor constructor.
+        embed_modality = resolved.embed_modality
+        text_elements_modality = resolved.text_elements_modality or embed_modality
+        structured_elements_modality = resolved.structured_elements_modality or embed_modality
+        self._tasks.append(("embed", dict(kwargs)))
+
+        # Explode content rows before embedding so each table/chart/infographic
+        # gets its own embedding vector (mirrors nv-ingest per-element embeddings).
+        self._rd_dataset = self._rd_dataset.repartition(target_num_rows_per_block=256)
+
+        from functools import partial
+        from nemo_retriever.ingest_modes.inprocess import explode_content_to_rows
+
+        _explode_fn = partial(
+            explode_content_to_rows,
+            modality=embed_modality,
+            text_elements_modality=text_elements_modality,
+            structured_elements_modality=structured_elements_modality,
+        )
+        self._rd_dataset = self._rd_dataset.map_batches(
+            _explode_fn,
+            batch_size=embed_batch_size,
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+        )
+
+        # When using a remote NIM endpoint, no GPU is needed for embedding.
+        endpoint = (kwargs.get("embedding_endpoint") or kwargs.get("embed_invoke_url") or "").strip()
+        if endpoint:
+            gpu_per_stage = 0
+        else:
+            # Embedding is GPU-bound; only needs modest CPU for tokenisation.
+            # Requesting all CPUs would prevent this stage from overlapping with
+            # upstream extraction/detection in Ray Data's streaming pipeline.
+            gpu_per_stage = getattr(self, "_gpu_embed", 1.0)
+
+        self._rd_dataset = self._rd_dataset.map_batches(
+            _BatchEmbedActor,
+            batch_size=embed_batch_size,
+            batch_format="pandas",
+            num_cpus=embed_cpus_per_actor,
+            num_gpus=gpu_per_stage,
+            compute=rd.ActorPoolStrategy(size=embed_workers),
+            fn_constructor_kwargs={"params": resolved},
+        )
+
+        return self
+
+    def vdb_upload(self, params: VdbUploadParams | None = None, **kwargs: Any) -> "BatchIngestor":
+        """
+        Add a streaming LanceDB upload stage to the batch pipeline.
+
+        Instead of buffering the entire dataset into pandas, this adds a
+        ``map_batches`` stage with a ``_LanceDBWriteActor`` that writes each
+        batch to LanceDB as it streams through.  Index creation is deferred
+        to ``ingest()`` (must happen after all writes).
+
+        Accepts the same kwargs as
+        ``inprocess.upload_embeddings_to_lancedb_inprocess``.
+        """
+        p = params or VdbUploadParams()
+        if kwargs:
+            lancedb_kwargs = {k: v for k, v in kwargs.items() if k != "purge_results_after_upload"}
+            if lancedb_kwargs:
+                p = p.model_copy(update={"lancedb": p.lancedb.model_copy(update=lancedb_kwargs)})
+            if "purge_results_after_upload" in kwargs:
+                p = p.model_copy(update={"purge_results_after_upload": bool(kwargs["purge_results_after_upload"])})
+        _ = p.purge_results_after_upload
+        vdb_kwargs = p.lancedb.model_dump(mode="python")
+        self._tasks.append(("vdb_upload", dict(vdb_kwargs)))
+        self._vdb_upload_kwargs = dict(vdb_kwargs)
+
+        # Streaming write stage — single actor, CPU-only, no GPU needed.
+        self._rd_dataset = self._rd_dataset.map_batches(
+            _LanceDBWriteActor,
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+            compute=rd.ActorPoolStrategy(size=1),
+            fn_constructor_kwargs={"params": p},
+        )
+
+        return self
+
+    def save_intermediate_results(self, output_dir: str) -> "BatchIngestor":
+        """
+        Persist the current Ray Dataset to disk under `output_dir`.
+
+        Writes Parquet files (Ray Data's native/efficient on-disk format) so downstream
+        steps can reload as a Ray Dataset using `ray.data.read_parquet(...)`.
+        """
+        if not isinstance(output_dir, str) or not output_dir.strip():
+            raise ValueError(f"output_dir must be a non-empty string, got {output_dir!r}")
+        if self._rd_dataset is None:
+            raise RuntimeError("No Ray Dataset to write. Call .files(...) (and optionally .extract(...)) first.")
+
+        base_dir = os.path.abspath(output_dir)
+        os.makedirs(base_dir, exist_ok=True)
+
+        # Ray's writers typically expect a directory that does not already contain output.
+        # To avoid destructive behavior, if the directory is non-empty we write to a timestamped subdir.
+        target_dir = base_dir
+        try:
+            if os.listdir(base_dir):
+                ts = _dt.datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
+                target_dir = os.path.join(base_dir, f"ray_dataset_{ts}")
+                os.makedirs(target_dir, exist_ok=False)
+        except FileNotFoundError:
+            # Rare race: directory disappeared between abspath and listdir.
+            os.makedirs(base_dir, exist_ok=True)
+
+        # Trigger execution and write results.
+        # Parquet supports nested list/struct columns used by our stages (e.g. detections payloads).
+        self._rd_dataset.write_parquet(target_dir)
+        self._intermediate_output_dir = target_dir
+        return self
+
+    # Backwards-compatibility: some examples call `write_to_disk(...)`.
+    def write_to_disk(self, output_dir: str) -> "BatchIngestor":
+        return self.save_intermediate_results(output_dir=output_dir)
+
+    def ingest(self, params: IngestExecuteParams | None = None, **kwargs: Any) -> int:
+        """
+        Execute the Ray Data pipeline and return the total number of pages.
+
+        If a VDB upload stage was added (via ``vdb_upload()``), data is written
+        to LanceDB in a streaming fashion by ``_LanceDBWriteActor``.  After the
+        pipeline finishes, we create the LanceDB vector index (which must happen
+        after all writes are complete).
+        """
+        run_params = _coerce_params(params, IngestExecuteParams, kwargs)
+        _ = (
+            run_params.show_progress,
+            run_params.return_failures,
+            run_params.save_to_disk,
+            run_params.return_traces,
+        )
+        runtime_metrics_dir = run_params.runtime_metrics_dir
+        runtime_metrics_prefix = run_params.runtime_metrics_prefix
+        t0 = time.monotonic()
+        num_pages = self._rd_dataset.count()
+        elapsed = time.monotonic() - t0
+
+        print(f"[done] {len(self._input_documents)} files, {num_pages} pages in {elapsed:.1f}s")
+        # region agent log
+        _debug_log(
+            run_id=str(runtime_metrics_prefix or "unknown"),
+            hypothesis_id="H3",
+            location="ingest_modes/batch.py:ingest",
+            message="Pipeline completed with aggregate throughput",
+            data={
+                "input_files": len(self._input_documents),
+                "num_pages": int(num_pages),
+                "elapsed_seconds": float(elapsed),
+                "pages_per_second_total": float(num_pages / elapsed) if elapsed > 0 else None,
+                "runtime_metrics_dir": runtime_metrics_dir,
+            },
+        )
+        # endregion
+
+        # Best-effort runtime metrics capture for per-run stage-level debugging.
+        if runtime_metrics_dir:
+            metrics_dir = Path(runtime_metrics_dir)
+            metrics_dir.mkdir(parents=True, exist_ok=True)
+            prefix = (runtime_metrics_prefix or "run").strip() or "run"
+
+            stats_path = metrics_dir / f"{prefix}.rd_dataset.stats.txt"
+            timeline_path = metrics_dir / f"{prefix}.ray.timeline.json"
+            summary_path = metrics_dir / f"{prefix}.runtime.summary.json"
+
+            stats_text = ""
+            try:
+                stats_text = str(self._rd_dataset.stats())
+                stats_path.write_text(stats_text, encoding="utf-8")
+            except Exception as e:
+                print(f"Warning: failed writing dataset stats: {e}")
+
+            try:
+                ray.timeline(filename=str(timeline_path))
+            except Exception as e:
+                print(f"Warning: failed writing ray timeline: {e}")
+
+            try:
+                summary = {
+                    "input_files": int(len(self._input_documents)),
+                    "num_pages": int(num_pages),
+                    "elapsed_seconds": float(elapsed),
+                    "stats_path": str(stats_path),
+                    "timeline_path": str(timeline_path),
+                }
+                summary_path.write_text(json.dumps(summary, indent=2), encoding="utf-8")
+            except Exception as e:
+                print(f"Warning: failed writing runtime summary: {e}")
+
+        # Create LanceDB vector index after all streaming writes are complete.
+        if hasattr(self, "_vdb_upload_kwargs") and self._vdb_upload_kwargs:
+            self._create_lancedb_index()
+
+        return num_pages
+
+    def _create_lancedb_index(self) -> None:
+        """Create the LanceDB vector index after streaming writes finish."""
+        kw = self._vdb_upload_kwargs
+        if not kw.get("create_index", True):
+            return
+
+        lancedb_uri = str(kw.get("lancedb_uri", "lancedb"))
+        table_name = str(kw.get("table_name", "nv-ingest"))
+        index_type = str(kw.get("index_type", "IVF_HNSW_SQ"))
+        metric = str(kw.get("metric", "l2"))
+        num_partitions = int(kw.get("num_partitions", 16))
+        num_sub_vectors = int(kw.get("num_sub_vectors", 256))
+
+        try:
+            import lancedb  # type: ignore
+        except Exception as e:
+            print(f"Warning: lancedb not available for index creation: {e}")
+            return
+
+        try:
+            db = lancedb.connect(uri=lancedb_uri)
+            table = db.open_table(table_name)
+            n_vecs = table.count_rows()
+        except Exception as e:
+            print(f"Warning: could not open LanceDB table for indexing: {e}")
+            return
+
+        if n_vecs < 2:
+            print("Skipping LanceDB index creation (not enough vectors).")
+            return
+
+        k = int(num_partitions)
+        if k >= n_vecs:
+            k = max(1, n_vecs - 1)
+
+        try:
+            table.create_index(
+                index_type=index_type,
+                metric=metric,
+                num_partitions=k,
+                num_sub_vectors=num_sub_vectors,
+                vector_column_name="vector",
+            )
+        except TypeError:
+            table.create_index(vector_column_name="vector")
+        except Exception as e:
+            print(f"Warning: failed to create LanceDB index (continuing without index): {e}")
+
+        if kw.get("hybrid", False):
+            text_column = str(kw.get("text_column", "text"))
+            fts_language = str(kw.get("fts_language", "English"))
+            try:
+                table.create_fts_index(text_column, language=fts_language)
+            except Exception as e:
+                print(
+                    f"Warning: FTS index creation failed on column {text_column!r} (continuing with vector-only): {e}"
+                )
+
+        for index_stub in table.list_indices():
+            table.wait_for_index([index_stub.name], timeout=timedelta(seconds=600))
+
+        print(f"Wrote {n_vecs} rows to LanceDB uri={lancedb_uri!r} table={table_name!r}")
diff --git a/nemo_retriever/src/nemo_retriever/ingest_modes/fused.py b/nemo_retriever/src/nemo_retriever/ingest_modes/fused.py
new file mode 100644
index 000000000..e6b3c3f59
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_modes/fused.py
@@ -0,0 +1,248 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Fused runmode.
+
+This mode keeps GPU model stages in one Ray actor to avoid inter-stage Ray Data
+handoffs. It intentionally does not support remote NIM endpoints.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict
+
+import ray.data as rd
+
+from nemo_retriever.ocr import ocr_page_elements
+from nemo_retriever.page_elements import detect_page_elements_v3
+
+from ..pdf.extract import PDFExtractionActor
+from ..pdf.split import PDFSplitActor
+from ..params import EmbedParams
+from ..params import ExtractParams
+from ..params import PdfSplitParams
+from .batch import _BatchEmbedActor
+from .batch import BatchIngestor
+from .inprocess import embed_text_main_text_embed
+from .inprocess import explode_content_to_rows
+
+
+def _assert_no_remote_endpoints(kwargs: Dict[str, Any], *, context: str) -> None:
+    remote_keys = (
+        "invoke_url",
+        "page_elements_invoke_url",
+        "ocr_invoke_url",
+        "embedding_endpoint",
+        "embed_invoke_url",
+    )
+    present = [k for k in remote_keys if str(kwargs.get(k) or "").strip()]
+    if present:
+        raise ValueError(
+            f"fused mode does not support remote NIM endpoints ({context}); "
+            f"remove these args: {', '.join(sorted(present))}"
+        )
+
+
+class _FusedModelActor:
+    """Single actor that runs detect -> OCR -> explode -> embed locally."""
+
+    def __init__(self, **kwargs: Any) -> None:
+        _assert_no_remote_endpoints(dict(kwargs), context="actor init")
+
+        from nemo_retriever.model.local import NemotronOCRV1, NemotronPageElementsV3
+        from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import (
+            LlamaNemotronEmbed1BV2Embedder,
+        )
+
+        self._detect_kwargs = {
+            "inference_batch_size": int(kwargs.get("inference_batch_size", 8)),
+            "output_column": str(kwargs.get("output_column", "page_elements_v3")),
+            "num_detections_column": str(kwargs.get("num_detections_column", "page_elements_v3_num_detections")),
+            "counts_by_label_column": str(kwargs.get("counts_by_label_column", "page_elements_v3_counts_by_label")),
+        }
+        self._extract_tables = bool(kwargs.get("extract_tables", False))
+        self._extract_charts = bool(kwargs.get("extract_charts", False))
+        self._extract_infographics = bool(kwargs.get("extract_infographics", False))
+        self._embed_kwargs = {
+            "model_name": kwargs.get("model_name"),
+            "text_column": str(kwargs.get("text_column", "text")),
+            "inference_batch_size": int(
+                kwargs.get("embed_inference_batch_size", kwargs.get("inference_batch_size", 16))
+            ),
+            "output_column": str(kwargs.get("embed_output_column", "text_embeddings_1b_v2")),
+            "embedding_dim_column": str(kwargs.get("embedding_dim_column", "text_embeddings_1b_v2_dim")),
+            "has_embedding_column": str(kwargs.get("has_embedding_column", "text_embeddings_1b_v2_has_embedding")),
+        }
+
+        device = kwargs.get("device")
+        hf_cache_dir = kwargs.get("hf_cache_dir")
+        normalize = bool(kwargs.get("normalize", True))
+        max_length = int(kwargs.get("max_length", 8192))
+        model_name_raw = kwargs.get("model_name")
+        model_id = model_name_raw if (isinstance(model_name_raw, str) and "/" in model_name_raw) else None
+
+        self._page_elements_model = NemotronPageElementsV3()
+        self._ocr_model = NemotronOCRV1()
+        self._embed_model = LlamaNemotronEmbed1BV2Embedder(
+            device=str(device) if device else None,
+            hf_cache_dir=str(hf_cache_dir) if hf_cache_dir else None,
+            normalize=normalize,
+            max_length=max_length,
+            model_id=model_id,
+        )
+
+    def __call__(self, batch_df: Any) -> Any:
+        detected = detect_page_elements_v3(
+            batch_df,
+            model=self._page_elements_model,
+            **self._detect_kwargs,
+        )
+        ocred = ocr_page_elements(
+            detected,
+            model=self._ocr_model,
+            extract_tables=self._extract_tables,
+            extract_charts=self._extract_charts,
+            extract_infographics=self._extract_infographics,
+        )
+        exploded = explode_content_to_rows(ocred, text_column=str(self._embed_kwargs["text_column"]))
+        embedded = embed_text_main_text_embed(exploded, model=self._embed_model, **self._embed_kwargs)
+        return embedded
+
+
+class FusedIngestor(BatchIngestor):
+    RUN_MODE = "fused"
+    _fused_extract_flags: Dict[str, Any] = {}
+
+    def extract(self, params: ExtractParams | None = None, **kwargs: Any) -> "FusedIngestor":
+        """
+        Configure extraction for fused execution.
+
+        In fused mode, PDF split/extract are separate CPU stages, but all model
+        stages (page-elements, OCR, embedding) run in one actor in `.embed()`.
+        """
+        resolved = params or ExtractParams(**kwargs)
+        if params is not None and kwargs:
+            resolved = params.model_copy(update=kwargs)
+        kwargs = {
+            **resolved.model_dump(mode="python", exclude={"remote_retry", "batch_tuning"}, exclude_none=True),
+            **resolved.remote_retry.model_dump(mode="python", exclude_none=True),
+            **resolved.batch_tuning.model_dump(mode="python", exclude_none=True),
+        }
+        _assert_no_remote_endpoints(dict(kwargs), context="extract")
+
+        pdf_split_batch_size = kwargs.pop("pdf_split_batch_size", 1)
+        pdf_extract_batch_size = kwargs.pop("pdf_extract_batch_size", 4)
+        pdf_extract_num_cpus = float(kwargs.pop("pdf_extract_num_cpus", 2))
+        pdf_extract_workers = int(kwargs.pop("pdf_extract_workers", max(1, self._num_cpus // 2)))
+
+        kwargs.setdefault("extract_page_as_image", True)
+        kwargs.setdefault("dpi", 200)
+
+        self._tasks.append(("extract", dict(kwargs)))
+        self._fused_extract_flags = {
+            "extract_tables": bool(kwargs.get("extract_tables", False)),
+            "extract_charts": bool(kwargs.get("extract_charts", False)),
+            "extract_infographics": bool(kwargs.get("extract_infographics", False)),
+            "inference_batch_size": int(kwargs.get("inference_batch_size", 8)),
+        }
+
+        pdf_split_actor = PDFSplitActor(
+            split_params=PdfSplitParams(
+                start_page=kwargs.get("start_page"),
+                end_page=kwargs.get("end_page"),
+            )
+        )
+        self._rd_dataset = self._rd_dataset.map_batches(
+            pdf_split_actor,
+            batch_size=pdf_split_batch_size,
+            num_cpus=1,
+            num_gpus=0,
+            batch_format="pandas",
+        )
+
+        extraction_actor = PDFExtractionActor(**kwargs)
+        self._rd_dataset = self._rd_dataset.map_batches(
+            extraction_actor,
+            batch_size=pdf_extract_batch_size,
+            batch_format="pandas",
+            num_cpus=pdf_extract_num_cpus,
+            num_gpus=0,
+            compute=rd.TaskPoolStrategy(size=pdf_extract_workers),
+        )
+        self._rd_dataset = self._rd_dataset.repartition(target_num_rows_per_block=64)
+        return self
+
+    def embed(self, params: EmbedParams | None = None, **kwargs: Any) -> "FusedIngestor":
+        """
+        Run page-elements + OCR + explode + embed in one GPU actor stage.
+
+        `fused` mode intentionally does not support remote NIM invocation.
+        When _pipeline_type == "audio", uses explode + _BatchEmbedActor (no PDF stages).
+        """
+        resolved = params or EmbedParams(**kwargs)
+        if params is not None and kwargs:
+            resolved = params.model_copy(update=kwargs)
+        kwargs = {
+            **resolved.model_dump(
+                mode="python", exclude={"runtime", "batch_tuning", "fused_tuning"}, exclude_none=True
+            ),
+            **resolved.runtime.model_dump(mode="python", exclude_none=True),
+            **resolved.batch_tuning.model_dump(mode="python", exclude_none=True),
+            **resolved.fused_tuning.model_dump(mode="python", exclude_none=True),
+        }
+        _assert_no_remote_endpoints(dict(kwargs), context="embed")
+
+        if getattr(self, "_pipeline_type", None) == "audio":
+            embed_workers = int(kwargs.get("embed_workers", 1))
+            embed_batch_size = int(kwargs.get("embed_batch_size", 256))
+            embed_cpus_per_actor = float(kwargs.get("embed_cpus_per_actor", 1))
+            self._rd_dataset = self._rd_dataset.repartition(target_num_rows_per_block=256)
+            self._rd_dataset = self._rd_dataset.map_batches(
+                explode_content_to_rows,
+                batch_size=embed_batch_size,
+                batch_format="pandas",
+                num_cpus=1,
+                num_gpus=0,
+            )
+            self._rd_dataset = self._rd_dataset.map_batches(
+                _BatchEmbedActor,
+                batch_size=embed_batch_size,
+                batch_format="pandas",
+                num_cpus=embed_cpus_per_actor,
+                num_gpus=getattr(self, "_gpu_embed", 1.0),
+                compute=rd.ActorPoolStrategy(size=embed_workers),
+                fn_constructor_kwargs={"params": resolved},
+            )
+            return self
+
+        fused_workers = int(kwargs.pop("fused_workers", kwargs.pop("embed_workers", 1)))
+        fused_batch_size = int(kwargs.pop("fused_batch_size", kwargs.pop("embed_batch_size", 64)))
+        fused_cpus_per_actor = float(kwargs.pop("fused_cpus_per_actor", kwargs.pop("embed_cpus_per_actor", 1)))
+        fused_gpus_per_actor = float(kwargs.pop("fused_gpus_per_actor", kwargs.pop("gpu_fused", 1.0)))
+
+        stage_kwargs = dict(getattr(self, "_fused_extract_flags", {}))
+        stage_kwargs.update(dict(kwargs))
+
+        self._tasks.append(("embed", dict(stage_kwargs)))
+        self._rd_dataset = self._rd_dataset.repartition(target_num_rows_per_block=max(16, fused_batch_size))
+        self._rd_dataset = self._rd_dataset.map_batches(
+            _FusedModelActor,
+            batch_size=fused_batch_size,
+            batch_format="pandas",
+            num_cpus=fused_cpus_per_actor,
+            num_gpus=fused_gpus_per_actor,
+            compute=rd.ActorPoolStrategy(size=fused_workers),
+            fn_constructor_kwargs=stage_kwargs,
+        )
+
+        logging.info(
+            "Fused embed resources: workers=%d batch_size=%d cpus/actor=%.2f gpus/actor=%.2f",
+            fused_workers,
+            fused_batch_size,
+            fused_cpus_per_actor,
+            fused_gpus_per_actor,
+        )
+        return self
diff --git a/nemo_retriever/src/nemo_retriever/ingest_modes/gpu_pool.py b/nemo_retriever/src/nemo_retriever/ingest_modes/gpu_pool.py
new file mode 100644
index 000000000..10a9b38c6
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_modes/gpu_pool.py
@@ -0,0 +1,460 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Multi-GPU worker pool for distributing GPU pipeline stages across devices.
+
+Workers are persistent processes that load models once at startup, then
+process any number of DataFrame shards via queues.  Setting
+``CUDA_VISIBLE_DEVICES`` per worker (before torch import) maps ``cuda:0``
+inside each worker to a different physical GPU, so existing model code
+works unmodified.
+"""
+
+from __future__ import annotations
+
+import importlib
+import multiprocessing
+import os
+import traceback
+from dataclasses import dataclass, field
+from typing import Any, Callable, Optional, Sequence
+
+import numpy as np
+import pandas as pd
+
+
+# ---------------------------------------------------------------------------
+# Model config dataclasses — picklable recipes to recreate models in workers
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class PageElementsModelConfig:
+    """Config to recreate a page-elements model via ``define_model("page_element_v3")``."""
+
+    config_name: str = "page_element_v3"
+
+    def create(self) -> Any:
+        from nemo_retriever.model.local import NemotronPageElementsV3
+
+        return NemotronPageElementsV3()
+
+
+@dataclass
+class OCRModelConfig:
+    """Config to recreate a NemotronOCRV1 model."""
+
+    model_dir: str = ""
+
+    def create(self) -> Any:
+        from nemo_retriever.model.local import NemotronOCRV1
+
+        return NemotronOCRV1(model_dir=self.model_dir)
+
+
+@dataclass
+class NemotronParseModelConfig:
+    """Config to recreate a NemotronParseV12 model."""
+
+    task_prompt: str = "</s><s><predict_bbox><predict_classes><output_markdown><predict_no_text_in_pic>"
+
+    def create(self) -> Any:
+        from nemo_retriever.model.local import NemotronParseV12
+
+        return NemotronParseV12(task_prompt=self.task_prompt)
+
+
+@dataclass
+class EmbeddingModelConfig:
+    """Config to recreate an embedding model (VL or non-VL)."""
+
+    device: Optional[str] = None
+    hf_cache_dir: Optional[str] = None
+    normalize: bool = True
+    max_length: int = 8192
+    model_id: Optional[str] = None
+
+    def create(self) -> Any:
+        from nemo_retriever.model import is_vl_embed_model
+
+        if is_vl_embed_model(self.model_id):
+            from nemo_retriever.model.local.llama_nemotron_embed_vl_1b_v2_embedder import (
+                LlamaNemotronEmbedVL1BV2Embedder,
+            )
+
+            return LlamaNemotronEmbedVL1BV2Embedder(
+                device=self.device,
+                hf_cache_dir=self.hf_cache_dir,
+                model_id=self.model_id,
+            )
+
+        from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import (
+            LlamaNemotronEmbed1BV2Embedder,
+        )
+
+        return LlamaNemotronEmbed1BV2Embedder(
+            device=self.device,
+            hf_cache_dir=self.hf_cache_dir,
+            normalize=self.normalize,
+            max_length=self.max_length,
+            model_id=self.model_id,
+        )
+
+
+# ---------------------------------------------------------------------------
+# GPUTaskDescriptor — picklable replacement for (func, kwargs_with_model)
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class GPUTaskDescriptor:
+    """Picklable description of a single GPU pipeline stage.
+
+    Stores the function as ``module_name`` + ``func_name`` (resolved via
+    import in the worker) and the kwargs *without* the ``model`` object.
+    A :class:`ModelConfig` (if any) recreates the model in the worker.
+    """
+
+    module_name: str
+    func_name: str
+    kwargs: dict = field(default_factory=dict)
+    model_config: Any = None  # One of the *ModelConfig dataclasses, or None
+
+    def resolve(self) -> tuple[Callable[..., Any], dict[str, Any]]:
+        """Import the function and rebuild kwargs with a live model."""
+        mod = importlib.import_module(self.module_name)
+        func = getattr(mod, self.func_name)
+        kwargs = dict(self.kwargs)
+        if self.model_config is not None:
+            kwargs["model"] = self.model_config.create()
+        return func, kwargs
+
+
+# ---------------------------------------------------------------------------
+# Conversion: live (func, kwargs) → GPUTaskDescriptor
+# ---------------------------------------------------------------------------
+
+
+def _extract_model_config(func: Callable, kwargs: dict[str, Any]) -> Any:
+    """Extract a picklable model config from live kwargs, or None."""
+    from nemo_retriever.page_elements import detect_page_elements_v3
+    from nemo_retriever.ocr.ocr import nemotron_parse_page_elements, ocr_page_elements
+    from .inprocess import embed_text_main_text_embed, explode_content_to_rows
+
+    if func is detect_page_elements_v3:
+        if kwargs.get("invoke_url"):
+            return None  # Remote endpoint, no local model
+        return PageElementsModelConfig()
+
+    if func is ocr_page_elements:
+        if kwargs.get("invoke_url"):
+            return None  # Remote endpoint, no local model
+        model = kwargs.get("model")
+        model_dir = ""
+        if model is not None and hasattr(model, "_model_dir"):
+            model_dir = str(model._model_dir)
+        return OCRModelConfig(model_dir=model_dir)
+
+    if func is nemotron_parse_page_elements:
+        if kwargs.get("invoke_url"):
+            return None  # Remote endpoint, no local model
+        return NemotronParseModelConfig(
+            task_prompt=str(kwargs.get("task_prompt") or NemotronParseModelConfig.task_prompt)
+        )
+
+    if func is embed_text_main_text_embed:
+        model = kwargs.get("model")
+        if model is None:
+            return None  # Remote endpoint, no local model
+        return EmbeddingModelConfig(
+            device=getattr(model, "device", None),
+            hf_cache_dir=getattr(model, "hf_cache_dir", None),
+            normalize=getattr(model, "normalize", True),
+            max_length=getattr(model, "max_length", 8192),
+            model_id=getattr(model, "model_id", None),
+        )
+
+    if func is explode_content_to_rows:
+        return None  # CPU-only, no model
+
+    return None
+
+
+def gpu_tasks_to_descriptors(
+    gpu_tasks: list[tuple[Callable[..., Any], dict[str, Any]]],
+) -> list[GPUTaskDescriptor]:
+    """Convert live ``[(func, kwargs_with_model), ...]`` into picklable descriptors."""
+    descriptors: list[GPUTaskDescriptor] = []
+    for func, kwargs in gpu_tasks:
+        model_config = _extract_model_config(func, kwargs)
+        # Strip model from kwargs (will be recreated from config in worker)
+        clean_kwargs = {k: v for k, v in kwargs.items() if k != "model"}
+        descriptors.append(
+            GPUTaskDescriptor(
+                module_name=func.__module__,
+                func_name=func.__qualname__,
+                kwargs=clean_kwargs,
+                model_config=model_config,
+            )
+        )
+    return descriptors
+
+
+# ---------------------------------------------------------------------------
+# Worker entry point
+# ---------------------------------------------------------------------------
+
+
+def _gpu_worker_entry(
+    gpu_index: int,
+    physical_device_id: str,
+    task_descriptors: list[GPUTaskDescriptor],
+    input_queue: multiprocessing.Queue,
+    output_queue: multiprocessing.Queue,
+    ready_event: multiprocessing.Event,
+) -> None:
+    """Worker process entry point.  Runs in a ``spawn``-ed process.
+
+    1. Set CUDA_VISIBLE_DEVICES *before* torch import
+    2. Resolve functions and create models from configs
+    3. Signal ready
+    4. Loop: receive (shard_id, DataFrame) → run pipeline → put result
+    5. Exit on None sentinel
+    """
+    # Step 1: Isolate GPU visibility
+    os.environ["CUDA_VISIBLE_DEVICES"] = physical_device_id
+
+    try:
+        # Step 2: Resolve all tasks (imports torch, loads models)
+        resolved: list[tuple[Callable[..., Any], dict[str, Any]]] = []
+        for desc in task_descriptors:
+            func, kwargs = desc.resolve()
+            resolved.append((func, kwargs))
+
+        # Step 3: Signal ready
+        ready_event.set()
+
+        # Step 4: Processing loop
+        while True:
+            item = input_queue.get()
+            if item is None:
+                break  # Sentinel: shutdown
+
+            shard_id, shard_df = item
+            try:
+                current = shard_df
+                for func, kwargs in resolved:
+                    current = func(current, **kwargs)
+                output_queue.put((shard_id, current, None))
+            except Exception as e:
+                tb = traceback.format_exc()
+                output_queue.put((shard_id, shard_df, f"{type(e).__name__}: {e}\n{tb}"))
+
+    except Exception as e:
+        # Startup failure — signal ready so the main process doesn't hang,
+        # then put an error on the output queue.
+        if not ready_event.is_set():
+            ready_event.set()
+        output_queue.put((-1, None, f"Worker {gpu_index} startup failed: {e}\n{traceback.format_exc()}"))
+
+
+# ---------------------------------------------------------------------------
+# GPUWorkerPool
+# ---------------------------------------------------------------------------
+
+
+class GPUWorkerPool:
+    """Pool of persistent GPU worker processes for multi-GPU inference.
+
+    Usage::
+
+        with GPUWorkerPool(["0", "1"], descriptors) as pool:
+            result_df = pool.process(combined_df)
+    """
+
+    def __init__(
+        self,
+        gpu_devices: Sequence[str],
+        task_descriptors: list[GPUTaskDescriptor],
+        startup_timeout: float = 600.0,
+    ) -> None:
+        self._gpu_devices = list(gpu_devices)
+        self._task_descriptors = task_descriptors
+        self._startup_timeout = startup_timeout
+        self._ctx = multiprocessing.get_context("spawn")
+        self._workers: list[multiprocessing.Process] = []
+        self._input_queues: list[multiprocessing.Queue] = []
+        self._output_queue: Optional[multiprocessing.Queue] = None
+        self._started = False
+        self._shards_submitted = 0
+
+    def start(self) -> None:
+        """Spawn workers and wait for all models to load."""
+        if self._started:
+            return
+
+        self._output_queue = self._ctx.Queue()
+        ready_events: list[multiprocessing.Event] = []
+
+        for idx, device_id in enumerate(self._gpu_devices):
+            iq = self._ctx.Queue()
+            evt = self._ctx.Event()
+            p = self._ctx.Process(
+                target=_gpu_worker_entry,
+                args=(idx, device_id, self._task_descriptors, iq, self._output_queue, evt),
+                daemon=True,
+            )
+            p.start()
+            self._workers.append(p)
+            self._input_queues.append(iq)
+            ready_events.append(evt)
+
+        # Wait for all workers to signal ready
+        for idx, evt in enumerate(ready_events):
+            if not evt.wait(timeout=self._startup_timeout):
+                alive = self._workers[idx].is_alive()
+                raise RuntimeError(
+                    f"GPU worker {idx} (device {self._gpu_devices[idx]}) "
+                    f"failed to become ready within {self._startup_timeout}s "
+                    f"(alive={alive})"
+                )
+            # Check if worker died during startup
+            if not self._workers[idx].is_alive():
+                raise RuntimeError(f"GPU worker {idx} (device {self._gpu_devices[idx]}) " f"died during startup")
+
+        self._started = True
+
+    def submit(self, shard_id: int, df: pd.DataFrame) -> None:
+        """Queue a shard for GPU processing (non-blocking).
+
+        The shard is assigned to a worker via round-robin on *shard_id*.
+        """
+        if not self._started:
+            raise RuntimeError("GPUWorkerPool.start() must be called before submit()")
+        worker_idx = shard_id % len(self._workers)
+        self._input_queues[worker_idx].put((shard_id, df))
+        self._shards_submitted += 1
+
+    def collect_all(
+        self,
+        show_progress: bool = False,
+        on_shard_done: Optional[Callable[[int], None]] = None,
+    ) -> pd.DataFrame:
+        """Block until all submitted shards complete, return concatenated result.
+
+        Parameters
+        ----------
+        show_progress : bool
+            Show an internal tqdm bar (only used when *on_shard_done* is None).
+        on_shard_done : callable, optional
+            Called with the *shard_id* after each shard completes.  When
+            provided, the internal tqdm bar is suppressed so the caller
+            can drive its own progress.
+        """
+        if not self._started:
+            raise RuntimeError("GPUWorkerPool.start() must be called before collect_all()")
+
+        n = self._shards_submitted
+        if n == 0:
+            return pd.DataFrame()
+
+        results: dict[int, pd.DataFrame] = {}
+        errors: list[str] = []
+
+        try:
+            from tqdm.auto import tqdm as _tqdm
+        except Exception:
+            _tqdm = None
+
+        progress = None
+        if show_progress and on_shard_done is None and _tqdm is not None:
+            progress = _tqdm(total=n, desc="GPU shards", unit="shard")
+
+        collect_timeout = 3600.0  # 1 hour per shard max
+        for _ in range(n):
+            shard_id, result_df, error = self._output_queue.get(timeout=collect_timeout)
+            if error is not None:
+                errors.append(f"Shard {shard_id}: {error}")
+                print(f"Warning: GPU shard {shard_id} failed: {error}")
+                # On error, include the original shard data so we don't lose rows
+                if result_df is not None and isinstance(result_df, pd.DataFrame):
+                    results[shard_id] = result_df
+            else:
+                results[shard_id] = result_df
+            if progress is not None:
+                progress.update(1)
+            if on_shard_done is not None:
+                on_shard_done(shard_id)
+
+        if progress is not None:
+            progress.close()
+
+        if errors:
+            print(f"Warning: {len(errors)} GPU shard(s) had errors")
+
+        # Reset counter for potential reuse
+        self._shards_submitted = 0
+
+        if not results:
+            return pd.DataFrame()
+
+        # Reassemble in original shard order
+        ordered = [results[sid] for sid in sorted(results.keys())]
+        return pd.concat(ordered, ignore_index=True)
+
+    def process(
+        self,
+        df: pd.DataFrame,
+        show_progress: bool = False,
+    ) -> pd.DataFrame:
+        """Shard *df* across workers, collect results, return concatenated DataFrame.
+
+        This is a convenience wrapper around :meth:`submit` + :meth:`collect_all`
+        for callers that have a single combined DataFrame.
+        """
+        if not self._started:
+            raise RuntimeError("GPUWorkerPool.start() must be called before process()")
+
+        n_workers = len(self._workers)
+        n_rows = len(df)
+
+        if n_rows == 0:
+            return df
+
+        # Shard by rows and submit
+        indices = np.array_split(range(n_rows), n_workers)
+        for shard_id, idx_chunk in enumerate(indices):
+            if len(idx_chunk) == 0:
+                continue
+            shard_df = df.iloc[idx_chunk].reset_index(drop=True)
+            self.submit(shard_id, shard_df)
+
+        result = self.collect_all(show_progress=show_progress)
+        return result if not result.empty else df
+
+    def shutdown(self) -> None:
+        """Send shutdown sentinels, join workers, terminate stragglers."""
+        for iq in self._input_queues:
+            try:
+                iq.put(None)
+            except Exception:
+                pass
+
+        for p in self._workers:
+            p.join(timeout=30.0)
+            if p.is_alive():
+                p.terminate()
+                p.join(timeout=5.0)
+
+        self._workers.clear()
+        self._input_queues.clear()
+        self._started = False
+
+    def __enter__(self) -> "GPUWorkerPool":
+        self.start()
+        return self
+
+    def __exit__(self, *exc_info: Any) -> None:
+        self.shutdown()
diff --git a/nemo_retriever/src/nemo_retriever/ingest_modes/inprocess.py b/nemo_retriever/src/nemo_retriever/ingest_modes/inprocess.py
new file mode 100644
index 000000000..963f64b97
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_modes/inprocess.py
@@ -0,0 +1,1818 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+In-process runmode.
+
+Intended to run locally in a plain Python process with minimal assumptions
+about surrounding framework/runtime.
+"""
+
+from __future__ import annotations
+
+import glob
+import json
+import multiprocessing
+import os
+import re
+import time
+import uuid
+from collections import defaultdict
+from concurrent.futures import ProcessPoolExecutor, as_completed
+from datetime import datetime, timezone
+from io import BytesIO
+from collections.abc import Callable, Iterator
+from pathlib import Path
+from typing import Any, Dict, List, Literal, Optional, Sequence, Tuple, Union
+
+
+import pandas as pd
+from nemo_retriever.model.local import NemotronOCRV1, NemotronPageElementsV3, NemotronParseV12
+from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import LlamaNemotronEmbed1BV2Embedder
+from nemo_retriever.page_elements import detect_page_elements_v3
+from nemo_retriever.ocr.ocr import _crop_b64_image_by_norm_bbox, nemotron_parse_page_elements, ocr_page_elements
+from nemo_retriever.text_embed.main_text_embed import TextEmbeddingConfig, create_text_embeddings_for_df
+
+try:
+    from tqdm.auto import tqdm
+except Exception:  # pragma: no cover
+    tqdm = None  # type: ignore[assignment]
+
+try:
+    import pypdfium2 as pdfium
+except Exception as e:  # pragma: no cover
+    pdfium = None  # type: ignore[assignment]
+    _PDFIUM_IMPORT_ERROR = e
+
+from ..utils.convert import SUPPORTED_EXTENSIONS, convert_to_pdf_bytes
+from ..ingestor import Ingestor
+from ..params import ASRParams
+from ..params import AudioChunkParams
+from ..params import EmbedParams
+from ..params.models import IMAGE_MODALITIES
+from ..params import ExtractParams
+from ..params import HtmlChunkParams
+from ..params import IngestExecuteParams
+from ..params import TextChunkParams
+from ..params import VdbUploadParams
+from ..pdf.extract import pdf_extraction
+from ..pdf.split import _split_pdf_to_single_page_bytes, pdf_path_to_pages_df
+from ..txt import txt_file_to_chunks_df
+from ..html import html_file_to_chunks_df
+
+_CONTENT_COLUMNS = ("table", "chart", "infographic")
+
+
+def _coerce_params[T](params: T | None, model_cls: type[T], kwargs: dict[str, Any]) -> T:
+    if params is None:
+        return model_cls(**kwargs)
+    if kwargs:
+        return params.model_copy(update=kwargs)  # type: ignore[return-value]
+    return params
+
+
+def _combine_text_with_content(row, text_column, content_columns):
+    """Combine page text with OCR content text for embedding."""
+    parts = []
+    base = row.get(text_column)
+    if isinstance(base, str) and base.strip():
+        parts.append(base.strip())
+    for col in content_columns:
+        content_list = row.get(col)
+        if isinstance(content_list, list):
+            for item in content_list:
+                if isinstance(item, dict):
+                    t = item.get("text", "")
+                    if isinstance(t, str) and t.strip():
+                        parts.append(t.strip())
+    return "\n\n".join(parts) if parts else ""
+
+
+def _deep_copy_row(row_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """Shallow-copy a row dict but deep-copy any nested mutable values.
+
+    This avoids the problem where multiple exploded rows share the same
+    metadata dict reference, causing later embedding writes to overwrite
+    earlier ones.  We only deep-copy dicts and lists (the common mutable
+    types in row data); scalars and strings are immutable and safe to share.
+    """
+    import copy
+
+    out: Dict[str, Any] = {}
+    for k, v in row_dict.items():
+        if isinstance(v, (dict, list)):
+            out[k] = copy.deepcopy(v)
+        else:
+            out[k] = v
+    return out
+
+
+def explode_content_to_rows(
+    batch_df: Any,
+    *,
+    text_column: str = "text",
+    content_columns: Sequence[str] = _CONTENT_COLUMNS,
+    modality: str = "text",
+    text_elements_modality: Optional[str] = None,
+    structured_elements_modality: Optional[str] = None,
+) -> Any:
+    """Expand each page row into multiple rows for per-element embedding.
+
+    For each row in *batch_df*:
+    - One row with the original page text (``text_column``).
+    - One additional row per table / chart / infographic item whose
+      ``"text"`` field is non-empty.  The item text replaces
+      ``text_column`` so the downstream embedding stage embeds each
+      element independently.
+
+    This mirrors the nv-ingest pipeline where every structural element
+    gets its own embedding vector, improving recall for queries that
+    target specific tables or charts.
+
+    If a row has no page text *and* no structured content, the original
+    row is preserved as-is to maintain batch shape.
+
+    When a row's effective modality is ``"image"`` or ``"text_image"``,
+    the page image (or a cropped region for structured content) is
+    carried in a new ``_image_b64`` column so that the downstream
+    embedding stage can use it for multimodal embeddings.
+
+    Each exploded row is tagged with ``_embed_modality`` so that
+    ``embed_text_main_text_embed`` can embed different element types
+    with different methods (e.g. text-only for page text but
+    text+image for tables).
+
+    Parameters
+    ----------
+    modality : str
+        Base modality for all element types (default ``"text"``).
+    text_elements_modality : str | None
+        Override modality for page-text rows.  Falls back to *modality*.
+    structured_elements_modality : str | None
+        Override modality for table/chart/infographic rows.  Falls back
+        to *modality*.
+    """
+    text_mod = text_elements_modality or modality
+    struct_mod = structured_elements_modality or modality
+
+    if not isinstance(batch_df, pd.DataFrame) or batch_df.empty:
+        return batch_df
+
+    # Whether *any* element type requires images.
+    any_images = text_mod in IMAGE_MODALITIES or struct_mod in IMAGE_MODALITIES
+
+    # Fast path: if none of the content columns exist there is nothing to explode.
+    if not any(c in batch_df.columns for c in content_columns):
+        batch_df = batch_df.copy()
+        if text_mod in IMAGE_MODALITIES and "page_image" in batch_df.columns:
+            batch_df["_image_b64"] = batch_df["page_image"].apply(
+                lambda pi: pi.get("image_b64") if isinstance(pi, dict) else None
+            )
+        batch_df["_embed_modality"] = text_mod
+        return batch_df
+
+    new_rows: List[Dict[str, Any]] = []
+    for _, row in batch_df.iterrows():
+        row_dict = row.to_dict()
+        exploded_any = False
+
+        # Extract page-level image b64 once per source row.
+        page_image = row_dict.get("page_image")
+        page_image_b64: Optional[str] = None
+        if any_images and isinstance(page_image, dict):
+            page_image_b64 = page_image.get("image_b64")
+
+        # Row for page text.
+        page_text = row_dict.get(text_column)
+        if isinstance(page_text, str) and page_text.strip():
+            page_row = _deep_copy_row(row_dict)
+            page_row["_embed_modality"] = text_mod
+            if text_mod in IMAGE_MODALITIES:
+                page_row["_image_b64"] = page_image_b64
+            new_rows.append(page_row)
+            exploded_any = True
+
+        # One row per structured content item.
+        for col in content_columns:
+            content_list = row_dict.get(col)
+            if not isinstance(content_list, list):
+                continue
+            for item in content_list:
+                if not isinstance(item, dict):
+                    continue
+                t = item.get("text", "")
+                if not isinstance(t, str) or not t.strip():
+                    continue
+                content_row = _deep_copy_row(row_dict)
+                content_row[text_column] = t.strip()
+                content_row["_embed_modality"] = struct_mod
+                if struct_mod in IMAGE_MODALITIES and page_image_b64:
+                    bbox = item.get("bbox_xyxy_norm")
+                    if bbox and len(bbox) == 4:
+                        cropped_b64, _ = _crop_b64_image_by_norm_bbox(page_image_b64, bbox_xyxy_norm=bbox)
+                        content_row["_image_b64"] = cropped_b64
+                    else:
+                        content_row["_image_b64"] = page_image_b64
+                elif struct_mod in IMAGE_MODALITIES:
+                    content_row["_image_b64"] = None
+                new_rows.append(content_row)
+                exploded_any = True
+
+        # Preserve row if nothing was exploded (no text, no content).
+        if not exploded_any:
+            preserved = _deep_copy_row(row_dict)
+            preserved["_embed_modality"] = text_mod
+            if text_mod in IMAGE_MODALITIES:
+                preserved["_image_b64"] = page_image_b64
+            new_rows.append(preserved)
+
+    return pd.DataFrame(new_rows).reset_index(drop=True)
+
+
+def _embed_group(
+    group_df: pd.DataFrame,
+    *,
+    group_modality: str,
+    model: Any,
+    endpoint: Optional[str],
+    text_column: str,
+    inference_batch_size: int,
+    output_column: str,
+    resolved_model_name: str,
+) -> pd.DataFrame:
+    """Embed a single modality group via ``create_text_embeddings_for_df``.
+
+    This is an internal helper called by ``embed_text_main_text_embed``
+    once per distinct ``_embed_modality`` value found in the batch.
+    """
+    _embed = None
+    _multimodal_embedder = None
+
+    if endpoint is None and model is not None:
+        if group_modality in IMAGE_MODALITIES:
+            _multimodal_embedder = model
+        else:
+            _skip_prefix = hasattr(model, "embed_queries")
+
+            def _embed(texts: Sequence[str]) -> Sequence[Sequence[float]]:  # noqa: F811
+                batch = texts if _skip_prefix else [f"passage: {t}" for t in texts]
+                vecs = model.embed(batch, batch_size=int(inference_batch_size))
+                tolist = getattr(vecs, "tolist", None)
+                if callable(tolist):
+                    return tolist()
+                return vecs  # type: ignore[return-value]
+
+    # For remote image/text_image embedding, cap the HTTP batch size to avoid
+    # sending huge JSON payloads (each item includes a base64 page image).
+    _DEFAULT_REMOTE_IMAGE_BATCH_SIZE = 4
+    effective_batch_size = inference_batch_size
+    if endpoint is not None and group_modality in IMAGE_MODALITIES:
+        effective_batch_size = min(inference_batch_size, _DEFAULT_REMOTE_IMAGE_BATCH_SIZE)
+
+    cfg = TextEmbeddingConfig(
+        text_column=str(text_column),
+        output_payload_column=str(output_column) if output_column else None,
+        write_embedding_to_metadata=True,
+        metadata_column="metadata",
+        batch_size=int(effective_batch_size),
+        encoding_format="float",
+        input_type="passage",
+        truncate="END",
+        dimensions=None,
+        embedding_nim_endpoint=endpoint or "http://localhost:8012/v1",
+        embedding_model=resolved_model_name or "nvidia/llama-3.2-nv-embedqa-1b-v2",
+        embed_modality=group_modality,
+    )
+
+    out_df, _ = create_text_embeddings_for_df(
+        group_df,
+        task_config={
+            "embedder": _embed,
+            "multimodal_embedder": _multimodal_embedder,
+            "endpoint_url": endpoint,
+            "local_batch_size": int(inference_batch_size),
+        },
+        transform_config=cfg,
+    )
+    return out_df
+
+
+def embed_text_main_text_embed(
+    batch_df: Any,
+    *,
+    model: Any = None,
+    # Keep compatibility with previous `embed_text_1b_v2` signature so `.embed(...)` kwargs
+    # don't need to change for inprocess mode.
+    model_name: Optional[str] = None,
+    embedding_endpoint: Optional[str] = None,
+    embed_invoke_url: Optional[str] = None,
+    text_column: str = "text",
+    inference_batch_size: int = 16,
+    output_column: str = "text_embeddings_1b_v2",
+    embedding_dim_column: str = "text_embeddings_1b_v2_dim",
+    has_embedding_column: str = "text_embeddings_1b_v2_has_embedding",
+    embed_modality: str = "text",
+    **_: Any,
+) -> Any:
+    """
+    Inprocess embedding task implemented via `nemo_retriever.text_embed.main_text_embed`.
+
+    This is a thin adapter that preserves the old output columns:
+    - `output_column` (payload dict with embedding)
+    - `embedding_dim_column` (int)
+    - `has_embedding_column` (bool)
+
+    It also writes `metadata.embedding` for compatibility with downstream uploaders.
+
+    When *embedding_endpoint* is set (e.g. ``"http://embedding:8000/v1"``), a remote
+    NIM endpoint is used instead of the local HF model.  The NIM handles prefixing
+    (``input_type="passage"``) server-side.
+
+    Rows are grouped by their ``_embed_modality`` column (populated by
+    ``explode_content_to_rows``) so that different element types can be
+    embedded with different methods (e.g. text-only for page text,
+    text+image for tables).  If no ``_embed_modality`` column exists,
+    *embed_modality* is used uniformly.
+    """
+    if not isinstance(batch_df, pd.DataFrame):
+        raise NotImplementedError("embed_text_main_text_embed currently only supports pandas.DataFrame input.")
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+
+    # Resolve endpoint: strip whitespace, treat empty string as None.
+    _endpoint = (embedding_endpoint or embed_invoke_url or "").strip() or None
+
+    if _endpoint is None and model is None:
+        raise ValueError("Either a local model or an embedding_endpoint must be provided.")
+
+    # Resolve NIM aliases to the actual HF model ID.
+    from nemo_retriever.model import resolve_embed_model
+
+    _resolved_model_name = resolve_embed_model(model_name)
+
+    # Determine per-row modalities.  If _embed_modality column exists (set by
+    # explode_content_to_rows), group by it; otherwise fall back to the single
+    # embed_modality parameter.
+    has_per_row_modality = "_embed_modality" in batch_df.columns
+    if has_per_row_modality:
+        modalities = batch_df["_embed_modality"].fillna(embed_modality).unique().tolist()
+    else:
+        modalities = [embed_modality]
+
+    try:
+        if len(modalities) == 1:
+            # Fast path: all rows share the same modality — process in one shot.
+            out_df = _embed_group(
+                batch_df,
+                group_modality=modalities[0],
+                model=model,
+                endpoint=_endpoint,
+                text_column=text_column,
+                inference_batch_size=inference_batch_size,
+                output_column=output_column,
+                resolved_model_name=_resolved_model_name,
+            )
+        else:
+            # Multiple modalities: group, embed each, reassemble in original order.
+            parts: List[pd.DataFrame] = []
+            for mod in modalities:
+                mask = batch_df["_embed_modality"] == mod
+                group_df = batch_df.loc[mask]
+                if group_df.empty:
+                    continue
+                part = _embed_group(
+                    group_df,
+                    group_modality=mod,
+                    model=model,
+                    endpoint=_endpoint,
+                    text_column=text_column,
+                    inference_batch_size=inference_batch_size,
+                    output_column=output_column,
+                    resolved_model_name=_resolved_model_name,
+                )
+                parts.append(part)
+            out_df = pd.concat(parts).sort_index()
+
+    except BaseException as e:
+        # Fail-soft: preserve batch shape and set an error payload per-row.
+        import traceback as _tb
+
+        print(f"Warning: embedding failed: {type(e).__name__}: {e}")
+        _tb.print_exc()
+        err_payload = {"embedding": None, "error": {"stage": "embed", "type": e.__class__.__name__, "message": str(e)}}
+        out_df = batch_df.copy()
+        if output_column:
+            out_df[output_column] = [err_payload for _ in range(len(out_df.index))]
+        out_df[embedding_dim_column] = [0 for _ in range(len(out_df.index))]
+        out_df[has_embedding_column] = [False for _ in range(len(out_df.index))]
+        out_df["_contains_embeddings"] = [False for _ in range(len(out_df.index))]
+        return out_df
+
+    # Add backwards-compatible dim/has columns (these were produced by `embed_text_1b_v2`).
+    if embedding_dim_column:
+
+        def _dim(row: pd.Series) -> int:
+            md = row.get("metadata")
+            if isinstance(md, dict):
+                emb = md.get("embedding")
+                if isinstance(emb, list):
+                    return int(len(emb))
+            payload = row.get(output_column) if output_column else None
+            if isinstance(payload, dict) and isinstance(payload.get("embedding"), list):
+                return int(len(payload.get("embedding") or []))
+            return 0
+
+        out_df[embedding_dim_column] = out_df.apply(_dim, axis=1)
+    else:
+        out_df[embedding_dim_column] = [0 for _ in range(len(out_df.index))]
+
+    out_df[has_embedding_column] = [bool(int(d) > 0) for d in out_df[embedding_dim_column].tolist()]
+
+    # Drop helper columns after embedding to free memory.
+    for col in ("_image_b64", "_embed_modality"):
+        if col in out_df.columns:
+            out_df = out_df.drop(columns=[col])
+
+    return out_df
+
+
+def _to_jsonable(obj: Any) -> Any:
+    """
+    Best-effort conversion of arbitrary objects into JSON-serializable types.
+    """
+    if obj is None or isinstance(obj, (str, int, float, bool)):
+        return obj
+
+    if isinstance(obj, dict):
+        return {str(k): _to_jsonable(v) for k, v in obj.items()}
+
+    if isinstance(obj, (list, tuple)):
+        return [_to_jsonable(v) for v in obj]
+
+    # Common numeric scalar types (numpy, pandas).
+    item = getattr(obj, "item", None)
+    if callable(item):
+        try:
+            return _to_jsonable(item())
+        except Exception:
+            pass
+
+    # Common array/tensor types (numpy, torch).
+    tolist = getattr(obj, "tolist", None)
+    if callable(tolist):
+        try:
+            return _to_jsonable(tolist())
+        except Exception:
+            pass
+
+    # Pandas timestamps.
+    isoformat = getattr(obj, "isoformat", None)
+    if callable(isoformat):
+        try:
+            return str(isoformat())
+        except Exception:
+            pass
+
+    return str(obj)
+
+
+def _atomic_write_json(path: str, payload: Any) -> None:
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tmp = path + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(payload, f, ensure_ascii=False, indent=2)
+        f.flush()
+        try:
+            os.fsync(f.fileno())
+        except Exception:
+            pass
+    os.replace(tmp, path)
+
+
+def _safe_stem(name: str) -> str:
+    s = str(name or "").strip() or "document"
+    s = os.path.splitext(os.path.basename(s))[0] or "document"
+    # Keep it filesystem-friendly.
+    s = re.sub(r"[^A-Za-z0-9._-]+", "_", s)
+    return s[:160] if len(s) > 160 else s
+
+
+def pages_df_from_pdf_bytes(pdf_bytes: Union[bytes, bytearray], source_path: str) -> pd.DataFrame:
+    """
+    Build a per-page DataFrame from raw PDF bytes (same schema as pdf_path_to_pages_df).
+
+    Used by the online ingest mode to run the same pipeline on document bytes
+    received via REST. Columns: bytes, path, page_number.
+    """
+    pages = _split_pdf_to_single_page_bytes(pdf_bytes)
+    out_rows = [{"bytes": b, "path": source_path, "page_number": i + 1} for i, b in enumerate(pages)]
+    return pd.DataFrame(out_rows)
+
+
+def run_pipeline_tasks_on_df(
+    initial_df: pd.DataFrame,
+    per_doc_tasks: Sequence[Tuple[Callable[..., Any], Dict[str, Any]]],
+    post_tasks: Optional[Sequence[Tuple[Callable[..., Any], Dict[str, Any]]]] = None,
+) -> Tuple[Any, List[Dict[str, Any]]]:
+    """
+    Run the inprocess pipeline task chain on a single document DataFrame.
+
+    Returns (final_result, metrics) where metrics is a list of
+    {"stage": str, "duration_sec": float} for each stage. Used by both
+    InProcessIngestor.ingest() and the online Ray Serve deployment.
+    """
+    import time
+
+    metrics: List[Dict[str, Any]] = []
+    current: Any = initial_df
+    for func, kwargs in per_doc_tasks:
+        t0 = time.perf_counter()
+        if func is pdf_extraction:
+            current = func(pdf_binary=current, **kwargs)
+        else:
+            current = func(current, **kwargs)
+        metrics.append({"stage": getattr(func, "__name__", "unknown"), "duration_sec": time.perf_counter() - t0})
+
+    if post_tasks and current is not None:
+        combined = current if isinstance(current, pd.DataFrame) else pd.concat(current, ignore_index=True)
+        for func, kwargs in post_tasks:
+            t0 = time.perf_counter()
+            combined = func(combined, **kwargs)
+            metrics.append({"stage": getattr(func, "__name__", "unknown"), "duration_sec": time.perf_counter() - t0})
+        return combined, metrics
+    return current, metrics
+
+
+def save_dataframe_to_disk_json(df: Any, *, output_directory: str) -> Any:
+    """
+    Pipeline task: persist a pandas DataFrame as a timestamped JSON file.
+
+    Returns the input unchanged so it can stay in the pipeline.
+    """
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError(f"save_dataframe_to_disk_json expects pandas.DataFrame, got {type(df)!r}")
+    if not isinstance(output_directory, str) or not output_directory.strip():
+        raise ValueError("output_directory must be a non-empty string")
+
+    out_dir = os.path.abspath(output_directory)
+    os.makedirs(out_dir, exist_ok=True)
+
+    # Try to derive a human-friendly filename prefix from the source PDF path.
+    source_path = None
+    try:
+        if "metadata" in df.columns and len(df.index) > 0:
+            md = df.iloc[0]["metadata"]
+            if isinstance(md, dict):
+                source_path = md.get("source_path")
+    except Exception:
+        source_path = None
+
+    ts = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+    stem = _safe_stem(str(source_path) if source_path else "results")
+    uniq = uuid.uuid4().hex[:8]
+    out_path = os.path.join(out_dir, f"{stem}.{ts}.{uniq}.json")
+
+    payload = {
+        "schema_version": 1,
+        "run_mode": "inprocess",
+        "created_at_utc": ts,
+        "source_path": str(source_path) if source_path else None,
+        "rows": int(len(df.index)),
+        "columns": [str(c) for c in df.columns.tolist()],
+        "records": _to_jsonable(df.to_dict(orient="records")),
+    }
+
+    _atomic_write_json(out_path, payload)
+    return df
+
+
+def _extract_embedding_from_row(
+    row: Any,
+    *,
+    embedding_column: str = "text_embeddings_1b_v2",
+    embedding_key: str = "embedding",
+) -> Optional[List[float]]:
+    """
+    Extract an embedding vector from a row (namedtuple or pd.Series).
+
+    Supports:
+    - `metadata.embedding` (preferred if present)
+    - `embedding_column` payloads like `{"embedding": [...], ...}` (from `embed_text_1b_v2`)
+    """
+    meta = getattr(row, "metadata", None)
+    if isinstance(meta, dict):
+        emb = meta.get("embedding")
+        if isinstance(emb, list) and emb:
+            return emb  # type: ignore[return-value]
+
+    payload = getattr(row, embedding_column, None)
+    if isinstance(payload, dict):
+        emb = payload.get(embedding_key)
+        if isinstance(emb, list) and emb:
+            return emb  # type: ignore[return-value]
+    return None
+
+
+def _extract_source_path_and_page(row: Any) -> Tuple[str, int]:
+    """
+    Best-effort extract of source path and page number for LanceDB row metadata.
+    """
+    path = ""
+    page = -1
+
+    v = getattr(row, "path", None)
+    if isinstance(v, str) and v.strip():
+        path = v.strip()
+
+    v = getattr(row, "page_number", None)
+    try:
+        if v is not None:
+            page = int(v)
+    except Exception:
+        pass
+
+    meta = getattr(row, "metadata", None)
+    if isinstance(meta, dict):
+        sp = meta.get("source_path")
+        if isinstance(sp, str) and sp.strip():
+            path = sp.strip()
+        # Some schemas store page under content metadata; support if present.
+        cm = meta.get("content_metadata")
+        if isinstance(cm, dict) and page == -1:
+            h = cm.get("hierarchy")
+            if isinstance(h, dict) and "page" in h:
+                try:
+                    page = int(h.get("page"))
+                except Exception:
+                    pass
+
+    return path, page
+
+
+def upload_embeddings_to_lancedb_inprocess(
+    df: Any,
+    *,
+    lancedb_uri: str = "lancedb",
+    table_name: str = "nv-ingest",
+    overwrite: bool = True,
+    create_index: bool = True,
+    index_type: str = "IVF_HNSW_SQ",
+    metric: str = "l2",
+    num_partitions: int = 16,
+    num_sub_vectors: int = 256,
+    embedding_column: str = "text_embeddings_1b_v2",
+    embedding_key: str = "embedding",
+    include_text: bool = True,
+    text_column: str = "text",
+    hybrid: bool = False,
+    fts_language: str = "English",
+    **_ignored: Any,
+) -> Any:
+    """
+    Pipeline task: upload embeddings from a pandas DataFrame into LanceDB.
+
+    The embedding is sourced from:
+    - `metadata.embedding` if present, else
+    - `embedding_column` payloads like those produced by `embed_text_1b_v2`
+
+    Parameters (all can be passed via `.vdb_upload(...)` kwargs):
+    - **lancedb_uri**: LanceDB URI (directory path), default `"lancedb"`
+    - **table_name**: table name, default `"nv-ingest"`
+    - **overwrite**: overwrite table (True) or append (False)
+    - **create_index**: create vector index after upload
+    - **index_type**: LanceDB index type (e.g. `"IVF_HNSW_SQ"`)
+    - **metric**: distance metric (e.g. `"l2"`, `"cosine"`)
+    - **num_partitions**: index partitions
+    - **num_sub_vectors**: index sub-vectors
+    - **embedding_column**: column name containing embedding payload dicts
+    - **embedding_key**: key inside payload dict to read embedding list from
+    - **include_text**: if True, store `text_column` content alongside the vector
+    - **text_column**: column to read text from when `include_text=True`
+    - **hybrid**: if True, additionally build an FTS index on `text`
+    - **fts_language**: language passed to LanceDB FTS index creation
+
+    Returns the input DataFrame unchanged (so it can remain in the pipeline).
+    """
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError(f"upload_embeddings_to_lancedb_inprocess expects pandas.DataFrame, got {type(df)!r}")
+
+    rows: List[Dict[str, Any]] = []
+    for r in df.itertuples(index=False):
+        emb = _extract_embedding_from_row(r, embedding_column=str(embedding_column), embedding_key=str(embedding_key))
+        if emb is None:
+            continue
+
+        path, page_number = _extract_source_path_and_page(r)
+        p = Path(path) if path else None
+        filename = p.name if p is not None else ""
+        pdf_basename = p.stem if p is not None else ""
+        pdf_page = f"{pdf_basename}_{page_number}" if (pdf_basename and page_number >= 0) else ""
+        source_id = path or filename or pdf_basename
+
+        # Provide fields compatible with `nemo_retriever.recall.core` which expects LanceDB hits
+        # to include JSON-encoded `metadata` and `source` strings.
+        metadata_obj: Dict[str, Any] = {"page_number": int(page_number) if page_number is not None else -1}
+        if pdf_page:
+            metadata_obj["pdf_page"] = pdf_page
+        # Persist per-page detection counters for end-of-run summaries.
+        # Mirrors batch.py so LanceDB-based summary reads also work.
+        pe_num = getattr(r, "page_elements_v3_num_detections", None)
+        if pe_num is not None:
+            try:
+                metadata_obj["page_elements_v3_num_detections"] = int(pe_num)
+            except Exception:
+                pass
+        pe_counts = getattr(r, "page_elements_v3_counts_by_label", None)
+        if isinstance(pe_counts, dict):
+            metadata_obj["page_elements_v3_counts_by_label"] = {
+                str(k): int(v) for k, v in pe_counts.items() if isinstance(k, str) and v is not None
+            }
+        for ocr_col in ("table", "chart", "infographic"):
+            entries = getattr(r, ocr_col, None)
+            if isinstance(entries, list):
+                metadata_obj[f"ocr_{ocr_col}_detections"] = int(len(entries))
+        source_obj: Dict[str, Any] = {"source_id": str(path)}
+
+        row_out: Dict[str, Any] = {
+            "vector": emb,
+            "pdf_page": pdf_page,
+            "filename": filename,
+            "pdf_basename": pdf_basename,
+            "page_number": int(page_number) if page_number is not None else -1,
+            "source_id": str(source_id),
+            "path": str(path),
+            "metadata": json.dumps(metadata_obj, ensure_ascii=False),
+            "source": json.dumps(source_obj, ensure_ascii=False),
+        }
+
+        if include_text:
+            t = getattr(r, text_column, None)
+            row_out["text"] = str(t) if isinstance(t, str) else ""
+        else:
+            # Still include the column for compatibility with the recall script's `.select(["text",...])`.
+            row_out["text"] = ""
+
+        rows.append(row_out)
+
+    if not rows:
+        print("No embeddings found to upload to LanceDB (no rows had embeddings).")
+        return df
+
+    # Infer vector dim from first row.
+    dim = 0
+    for rr in rows:
+        v = rr.get("vector")
+        if isinstance(v, list) and v:
+            dim = int(len(v))
+            break
+    if dim <= 0:
+        raise ValueError("Failed to infer embedding dimension from DataFrame rows.")
+
+    try:
+        import lancedb  # type: ignore
+        import pyarrow as pa  # type: ignore
+    except Exception as e:
+        raise RuntimeError(
+            "LanceDB upload requested but dependencies are missing. Install `lancedb` and `pyarrow`."
+        ) from e
+
+    db = lancedb.connect(uri=str(lancedb_uri))
+
+    fields = [
+        pa.field("vector", pa.list_(pa.float32(), dim)),
+        pa.field("pdf_page", pa.string()),
+        pa.field("filename", pa.string()),
+        pa.field("pdf_basename", pa.string()),
+        pa.field("page_number", pa.int32()),
+        pa.field("source_id", pa.string()),
+        pa.field("path", pa.string()),
+        # Compatibility columns expected by `nemo_retriever.recall.core`:
+        pa.field("text", pa.string()),
+        pa.field("metadata", pa.string()),
+        pa.field("source", pa.string()),
+    ]
+    schema = pa.schema(fields)
+
+    # Overwrite vs append.
+    if overwrite:
+        table = db.create_table(str(table_name), data=list(rows), schema=schema, mode="overwrite")
+    else:
+        try:
+            table = db.open_table(str(table_name))
+            table.add(list(rows))
+        except Exception:
+            table = db.create_table(str(table_name), data=list(rows), schema=schema, mode="create")
+
+    if create_index:
+        # LanceDB IVF-based indexes train k-means with K=num_partitions. K must be < N vectors.
+        n_vecs = int(len(rows))
+        if n_vecs < 2:
+            print("Skipping LanceDB index creation (not enough vectors).")
+        else:
+            k = int(num_partitions)
+            if k >= n_vecs:
+                k = max(1, n_vecs - 1)
+            try:
+                table.create_index(
+                    index_type=str(index_type),
+                    metric=str(metric),
+                    num_partitions=int(k),
+                    num_sub_vectors=int(num_sub_vectors),
+                    vector_column_name="vector",
+                )
+            except TypeError:
+                # Older/newer LanceDB versions may have different signatures; fall back to minimal call.
+                table.create_index(vector_column_name="vector")
+            except Exception as e:
+                # Don't fail ingestion due to index training; users can rebuild later with more data.
+                print(f"Warning: failed to create LanceDB index (continuing without index): {e}")
+
+    if hybrid:
+        # Build text index for hybrid retrieval when text is present.
+        try:
+            table.create_fts_index("text", language=str(fts_language))
+        except Exception as e:
+            # Keep ingestion resilient: vector data was already written.
+            print(f"Warning: failed to create LanceDB FTS index (continuing without FTS): {e}")
+
+    print(f"Wrote {len(rows)} rows to LanceDB uri={lancedb_uri!r} table={table_name!r}")
+    return df
+
+
+def pdf_to_pages_df(path: str) -> pd.DataFrame:
+    """
+    Convert a document at *path* into a DataFrame where each row
+    contains a *single-page* PDF's raw bytes.
+
+    For ``.docx`` / ``.pptx`` files the document is first converted
+    to PDF via LibreOffice, then split into pages.  The original
+    *path* is preserved so downstream metadata tracks the source file.
+
+    Columns:
+    - bytes: single-page PDF bytes
+    - path: original input path
+    - page_number: 1-indexed page number
+    """
+    if pdfium is None:  # pragma: no cover
+        raise ImportError("pypdfium2 is required for inprocess ingestion.") from _PDFIUM_IMPORT_ERROR
+
+    abs_path = os.path.abspath(path)
+    ext = os.path.splitext(abs_path)[1].lower()
+    out_rows: list[dict[str, Any]] = []
+    doc = None
+    try:
+        if ext in SUPPORTED_EXTENSIONS and ext != ".pdf":
+            # Convert DOCX/PPTX to PDF bytes first.
+            with open(abs_path, "rb") as f:
+                file_bytes = f.read()
+            pdf_bytes = convert_to_pdf_bytes(file_bytes, ext)
+            doc = pdfium.PdfDocument(BytesIO(pdf_bytes))
+        else:
+            doc = pdfium.PdfDocument(abs_path)
+
+        for page_idx in range(len(doc)):
+            single = pdfium.PdfDocument.new()
+            try:
+                single.import_pages(doc, pages=[page_idx])
+                buf = BytesIO()
+                single.save(buf)
+                out_rows.append(
+                    {
+                        "bytes": buf.getvalue(),
+                        "path": abs_path,
+                        "page_number": page_idx + 1,
+                    }
+                )
+            finally:
+                try:
+                    single.close()
+                except Exception:
+                    pass
+    except BaseException as e:
+        # Preserve shape expected downstream (pdf_extraction emits error
+        # records per-row, so we return a single row to trigger that).
+        out_rows.append({"bytes": b"", "path": abs_path, "page_number": 0, "error": str(e)})
+    finally:
+        try:
+            if doc is not None:
+                doc.close()
+        except Exception:
+            pass
+
+    return pd.DataFrame(out_rows)
+
+
+def _iter_page_chunks(path: str, chunk_size: int = 32) -> Iterator[pd.DataFrame]:
+    """Yield DataFrames of *chunk_size* pages from a document.
+
+    Reuses the same pdfium page-splitting logic as :func:`pdf_to_pages_df`
+    but yields incrementally so that downstream work can begin before the
+    entire document is split.  At most *chunk_size* single-page PDF blobs
+    are in memory per yield.
+
+    Handles DOCX/PPTX conversion (same as ``pdf_to_pages_df``).
+    """
+    if pdfium is None:  # pragma: no cover
+        raise ImportError("pypdfium2 is required for inprocess ingestion.") from _PDFIUM_IMPORT_ERROR
+
+    abs_path = os.path.abspath(path)
+    ext = os.path.splitext(abs_path)[1].lower()
+    doc = None
+    try:
+        if ext in SUPPORTED_EXTENSIONS and ext != ".pdf":
+            with open(abs_path, "rb") as f:
+                pdf_bytes = convert_to_pdf_bytes(f.read(), ext)
+            doc = pdfium.PdfDocument(BytesIO(pdf_bytes))
+        else:
+            doc = pdfium.PdfDocument(abs_path)
+
+        chunk: list[dict] = []
+        for page_idx in range(len(doc)):
+            single = pdfium.PdfDocument.new()
+            try:
+                single.import_pages(doc, pages=[page_idx])
+                buf = BytesIO()
+                single.save(buf)
+                chunk.append({"bytes": buf.getvalue(), "path": abs_path, "page_number": page_idx + 1})
+            finally:
+                try:
+                    single.close()
+                except Exception:
+                    pass
+            if len(chunk) >= chunk_size:
+                yield pd.DataFrame(chunk)
+                chunk = []
+        if chunk:
+            yield pd.DataFrame(chunk)
+    except BaseException as e:
+        yield pd.DataFrame([{"bytes": b"", "path": abs_path, "page_number": 0, "error": str(e)}])
+    finally:
+        if doc is not None:
+            try:
+                doc.close()
+            except Exception:
+                pass
+
+
+def _process_doc_cpu(doc_path: str, cpu_tasks: list) -> pd.DataFrame:
+    """Worker function for ProcessPoolExecutor.
+
+    Runs ``pdf_to_pages_df`` followed by all CPU-bound pipeline tasks on a
+    single document.  All arguments are picklable (strings, module-level
+    functions, and dicts of simple types).
+    """
+    try:
+        current: Any = pdf_to_pages_df(doc_path)
+        for func, kwargs in cpu_tasks:
+            if func is pdf_extraction:
+                current = func(pdf_binary=current, **kwargs)
+            else:
+                current = func(current, **kwargs)
+        return current
+    except Exception as e:
+        # Return a minimal error DataFrame so one failed document does not
+        # halt the pipeline.
+        return pd.DataFrame([{"bytes": b"", "path": doc_path, "page_number": 0, "error": f"{type(e).__name__}: {e}"}])
+
+
+def _process_chunk_cpu(chunk_df: pd.DataFrame, cpu_tasks: list) -> pd.DataFrame:
+    """Worker function for ProcessPoolExecutor — page-chunk variant.
+
+    Runs CPU-bound pipeline tasks on a pre-split page-chunk DataFrame.
+    Similar to :func:`_process_doc_cpu` but skips ``pdf_to_pages_df``
+    since the page splitting has already been done by the caller.
+    """
+    try:
+        current: Any = chunk_df
+        for func, kwargs in cpu_tasks:
+            if func is pdf_extraction:
+                current = func(pdf_binary=current, **kwargs)
+            else:
+                current = func(current, **kwargs)
+        return current
+    except Exception as e:
+        return pd.DataFrame([{"bytes": b"", "path": "", "page_number": 0, "error": f"{type(e).__name__}: {e}"}])
+
+
+def _collect_summary_from_df(df: pd.DataFrame) -> dict:
+    """Compute detection summary from a result DataFrame.
+
+    Mirrors the batch pipeline's ``_collect_detection_summary`` but reads
+    directly from the in-memory DataFrame instead of LanceDB.  Rows are
+    deduplicated by ``(path, page_number)`` so exploded content rows don't
+    inflate counts.
+    """
+    per_page: dict[tuple, dict] = {}
+
+    for _, row in df.iterrows():
+        row_dict = row.to_dict()
+
+        path = str(row_dict.get("path") or row_dict.get("source_id") or "")
+        page_number = -1
+        try:
+            page_number = int(row_dict.get("page_number", -1))
+        except (TypeError, ValueError):
+            pass
+
+        key = (path, page_number)
+
+        meta = row_dict.get("metadata")
+        if isinstance(meta, str):
+            try:
+                meta = json.loads(meta)
+            except Exception:
+                meta = {}
+        if not isinstance(meta, dict):
+            meta = {}
+
+        entry = per_page.setdefault(
+            key,
+            {
+                "pe": 0,
+                "ocr_table": 0,
+                "ocr_chart": 0,
+                "ocr_infographic": 0,
+                "pe_by_label": defaultdict(int),
+            },
+        )
+
+        # Check metadata first, then fall back to direct DataFrame columns.
+        # The batch pipeline stores these inside the metadata JSON, but the
+        # inprocess pipeline keeps them as top-level DataFrame columns.
+        try:
+            pe = int(
+                meta.get("page_elements_v3_num_detections") or row_dict.get("page_elements_v3_num_detections") or 0
+            )
+        except (TypeError, ValueError):
+            pe = 0
+        entry["pe"] = max(entry["pe"], pe)
+
+        for field, meta_key, col_key in [
+            ("ocr_table", "ocr_table_detections", "table"),
+            ("ocr_chart", "ocr_chart_detections", "chart"),
+            ("ocr_infographic", "ocr_infographic_detections", "infographic"),
+        ]:
+            try:
+                val = int(meta.get(meta_key, 0) or 0)
+            except (TypeError, ValueError):
+                val = 0
+            # Fall back to counting direct list columns (e.g. row["table"]).
+            if val == 0:
+                col_val = row_dict.get(col_key)
+                if isinstance(col_val, list):
+                    val = len(col_val)
+            entry[field] = max(entry[field], val)
+
+        label_counts = meta.get("page_elements_v3_counts_by_label") or row_dict.get("page_elements_v3_counts_by_label")
+        if isinstance(label_counts, dict):
+            for label, count in label_counts.items():
+                try:
+                    c = int(count or 0)
+                except (TypeError, ValueError):
+                    c = 0
+                entry["pe_by_label"][str(label)] = max(entry["pe_by_label"][str(label)], c)
+
+    pe_by_label_totals: dict[str, int] = defaultdict(int)
+    pe_total = ocr_table_total = ocr_chart_total = ocr_infographic_total = 0
+    for e in per_page.values():
+        pe_total += e["pe"]
+        ocr_table_total += e["ocr_table"]
+        ocr_chart_total += e["ocr_chart"]
+        ocr_infographic_total += e["ocr_infographic"]
+        for label, count in e["pe_by_label"].items():
+            pe_by_label_totals[label] += count
+
+    return {
+        "pages_seen": len(per_page),
+        "page_elements_v3_total_detections": pe_total,
+        "page_elements_v3_counts_by_label": dict(sorted(pe_by_label_totals.items())),
+        "ocr_table_total_detections": ocr_table_total,
+        "ocr_chart_total_detections": ocr_chart_total,
+        "ocr_infographic_total_detections": ocr_infographic_total,
+    }
+
+
+def _print_ingest_summary(results: list, elapsed_s: float) -> None:
+    """Print end-of-ingest summary matching batch pipeline output format."""
+    dfs = [r for r in results if isinstance(r, pd.DataFrame) and not r.empty]
+    if not dfs:
+        print(f"\nIngest time: {elapsed_s:.2f}s (no documents processed)")
+        return
+
+    combined = pd.concat(dfs, ignore_index=True) if len(dfs) > 1 else dfs[0]
+    summary = _collect_summary_from_df(combined)
+
+    print("\nDetection summary (deduped by source/page_number):")
+    print(f"  Pages seen: {summary['pages_seen']}")
+    print(f"  PageElements v3 total detections: {summary['page_elements_v3_total_detections']}")
+    print(f"  OCR table detections: {summary['ocr_table_total_detections']}")
+    print(f"  OCR chart detections: {summary['ocr_chart_total_detections']}")
+    print(f"  OCR infographic detections: {summary['ocr_infographic_total_detections']}")
+    print("  PageElements v3 counts by label:")
+    by_label = summary.get("page_elements_v3_counts_by_label", {})
+    if not by_label:
+        print("    (none)")
+    else:
+        for label, count in by_label.items():
+            print(f"    {label}: {count}")
+
+    pages = summary["pages_seen"]
+    if elapsed_s > 0 and pages > 0:
+        pps = pages / elapsed_s
+        print(f"Pages processed: {pages}")
+        print(f"Pages/sec: {pps:.2f}")
+    else:
+        print(f"\nIngest time: {elapsed_s:.2f}s")
+
+
+class InProcessIngestor(Ingestor):
+    RUN_MODE = "inprocess"
+
+    def __init__(self, documents: Optional[List[str]] = None) -> None:
+        super().__init__(documents=documents)
+
+        # Keep backwards-compatibility with code that inspects `Ingestor._documents`
+        # by ensuring both names refer to the same list.
+        self._input_documents: List[str] = self._documents
+
+        # Builder-style configuration recorded for later execution (TBD).
+        self._tasks: List[tuple[Callable[..., Any], dict[str, Any]]] = []
+
+        # Pipeline type: "pdf" (extract), "txt" (extract_txt), or "html" (extract_html). Loader dispatch in ingest().
+        self._pipeline_type: Literal["pdf", "txt", "html"] = "pdf"
+        self._extract_txt_kwargs: Dict[str, Any] = {}
+        self._extract_html_kwargs: Dict[str, Any] = {}
+
+    def files(self, documents: Union[str, List[str]]) -> "InProcessIngestor":
+        """
+        Add local files for in-process execution.
+
+        Mirrors `BatchIngestor.files()` path/glob resolution, but does not create
+        a Ray Data dataset.
+        """
+        if isinstance(documents, str):
+            documents = [documents]
+
+        for pattern in documents:
+            if not isinstance(pattern, str) or not pattern:
+                raise ValueError(f"Invalid document pattern: {pattern!r}")
+
+            # Expand globs (supports ** when recursive=True).
+            matches = glob.glob(pattern, recursive=True)
+            if matches:
+                files = [os.path.abspath(p) for p in matches if os.path.isfile(p)]
+                if not files:
+                    raise FileNotFoundError(f"Pattern resolved, but no files found: {pattern!r}")
+                self._input_documents.extend(files)
+                continue
+
+            # No glob matches: treat as explicit path.
+            if os.path.isfile(pattern):
+                self._input_documents.append(os.path.abspath(pattern))
+                continue
+
+            raise FileNotFoundError(f"No local files found for: {pattern!r}")
+
+        return self
+
+    def extract(self, params: ExtractParams | None = None, **kwargs: Any) -> "InProcessIngestor":
+        """
+        Configure extraction for in-process execution (skeleton).
+
+        TODO: implement actual local extraction (PDF split/extract, page elements,
+        table structure, chart detection, etc.). For now this records the
+        configuration so call sites can be wired up and chained.
+        """
+        # NOTE: `kwargs` passed to `.extract()` are intended primarily for PDF extraction
+        # (e.g. `extract_text`, `dpi`, etc). Downstream model stages do NOT necessarily
+        # accept the same keyword arguments. Keep per-stage kwargs isolated.
+
+        resolved = _coerce_params(params, ExtractParams, kwargs)
+        kwargs = resolved.model_dump(mode="python")
+        batch_tuning = kwargs.get("batch_tuning") if isinstance(kwargs.get("batch_tuning"), dict) else {}
+        nemotron_parse_workers = float(batch_tuning.get("nemotron_parse_workers", 0.0) or 0.0)
+        gpu_nemotron_parse = float(batch_tuning.get("gpu_nemotron_parse", 0.0) or 0.0)
+        nemotron_parse_batch_size = float(batch_tuning.get("nemotron_parse_batch_size", 0.0) or 0.0)
+        use_nemotron_parse_only = (
+            nemotron_parse_workers > 0.0 and gpu_nemotron_parse > 0.0 and nemotron_parse_batch_size > 0.0
+        )
+        extract_kwargs = dict(kwargs)
+        # Downstream in-process stages (page elements / table / chart / infographic) assume
+        # `page_image.image_b64` exists. Ensure PDF extraction emits a page image unless
+        # the caller explicitly disables it.
+        if "extract_page_as_image" not in extract_kwargs:
+            if any(
+                extract_kwargs.get(k) is True
+                for k in ("extract_text", "extract_images", "extract_tables", "extract_charts", "extract_infographics")
+            ):
+                extract_kwargs["extract_page_as_image"] = True
+        self._pipeline_type = "pdf"
+        self._tasks.append((pdf_extraction, extract_kwargs))
+
+        # Common, optional knobs shared by our detect_* helpers.
+        detect_passthrough_keys = {
+            "inference_batch_size",
+            "output_column",
+            "num_detections_column",
+            "counts_by_label_column",
+        }
+
+        def _stage_remote_kwargs(stage_name: str) -> dict[str, Any]:
+            stage_prefix = f"{stage_name}_"
+            out: dict[str, Any] = {}
+            invoke_url = kwargs.get(f"{stage_prefix}invoke_url", kwargs.get("invoke_url"))
+            if invoke_url:
+                out["invoke_url"] = invoke_url
+            api_key = kwargs.get(f"{stage_prefix}api_key", kwargs.get("api_key"))
+            if api_key:
+                out["api_key"] = api_key
+            timeout = kwargs.get(f"{stage_prefix}request_timeout_s", kwargs.get("request_timeout_s"))
+            if timeout is not None:
+                out["request_timeout_s"] = timeout
+            for k in ("remote_max_pool_workers", "remote_max_retries", "remote_max_429_retries"):
+                stage_key = f"{stage_prefix}{k}"
+                if stage_key in kwargs:
+                    out[k] = kwargs[stage_key]
+                elif k in kwargs:
+                    out[k] = kwargs[k]
+            return out
+
+        def _detect_kwargs_with_model(model_obj: Any, *, stage_name: str, allow_remote: bool) -> dict[str, Any]:
+            d: dict[str, Any] = {"model": model_obj}
+            for k in detect_passthrough_keys:
+                if k in kwargs:
+                    d[k] = kwargs[k]
+            if allow_remote:
+                d.update(_stage_remote_kwargs(stage_name))
+            return d
+
+        if use_nemotron_parse_only:
+            parse_flags: dict[str, Any] = {}
+            if kwargs.get("extract_tables") is True:
+                parse_flags["extract_tables"] = True
+            if kwargs.get("extract_charts") is True:
+                parse_flags["extract_charts"] = True
+            if kwargs.get("extract_infographics") is True:
+                parse_flags["extract_infographics"] = True
+            parse_flags["inference_batch_size"] = int(nemotron_parse_batch_size)
+            parse_flags.update(_stage_remote_kwargs("nemotron_parse"))
+            parse_invoke_url = kwargs.get(
+                "nemotron_parse_invoke_url", kwargs.get("ocr_invoke_url", kwargs.get("invoke_url", ""))
+            )
+            if parse_invoke_url:
+                parse_flags["invoke_url"] = parse_invoke_url
+                self._tasks.append((nemotron_parse_page_elements, {"model": None, **parse_flags}))
+            else:
+                self._tasks.append((nemotron_parse_page_elements, {"model": NemotronParseV12(), **parse_flags}))
+        else:
+            # NOTE: Page element detection is a common prerequisite for downstream
+            # structure stages (tables/charts/infographics). We enable it whenever
+            # any downstream extraction is requested.
+            if any(
+                kwargs.get(k) is True
+                for k in ("extract_text", "extract_tables", "extract_charts", "extract_infographics")
+            ):
+                print("Adding page elements task")
+                pe_invoke_url = kwargs.get("page_elements_invoke_url", kwargs.get("invoke_url", ""))
+                pe_model = None if pe_invoke_url else NemotronPageElementsV3()
+                self._tasks.append(
+                    (
+                        detect_page_elements_v3,
+                        _detect_kwargs_with_model(
+                            pe_model,
+                            stage_name="page_elements",
+                            allow_remote=True,
+                        ),
+                    )
+                )
+
+            # OCR-based extraction for tables/charts/infographics.
+            ocr_flags = {}
+            if kwargs.get("extract_tables") is True:
+                ocr_flags["extract_tables"] = True
+            if kwargs.get("extract_charts") is True:
+                ocr_flags["extract_charts"] = True
+            if kwargs.get("extract_infographics") is True:
+                ocr_flags["extract_infographics"] = True
+            ocr_flags.update(_stage_remote_kwargs("ocr"))
+
+            if ocr_flags:
+                print("Adding OCR extraction task")
+                ocr_invoke_url = kwargs.get("ocr_invoke_url", kwargs.get("invoke_url", ""))
+                if ocr_invoke_url:
+                    self._tasks.append((ocr_page_elements, {"model": None, **ocr_flags}))
+                else:
+                    ocr_model_dir = (
+                        kwargs.get("ocr_model_dir")
+                        or os.environ.get("RETRIEVER_NEMOTRON_OCR_MODEL_DIR", "").strip()
+                        or os.environ.get("NEMOTRON_OCR_MODEL_DIR", "").strip()
+                        or os.environ.get("NEMOTRON_OCR_V1_MODEL_DIR", "").strip()
+                    )
+                    model = NemotronOCRV1(model_dir=str(ocr_model_dir)) if ocr_model_dir else NemotronOCRV1()
+                    self._tasks.append((ocr_page_elements, {"model": model, **ocr_flags}))
+
+        return self
+
+    def extract_txt(self, params: TextChunkParams | None = None, **kwargs: Any) -> "InProcessIngestor":
+        """
+        Configure txt ingestion: tokenizer-based chunking only (no PDF extraction).
+
+        Use with .files("*.txt").extract_txt(...).embed().vdb_upload().ingest().
+        Do not call .extract() when using .extract_txt().
+        """
+        self._pipeline_type = "txt"
+        resolved = _coerce_params(params, TextChunkParams, kwargs)
+        self._extract_txt_kwargs = resolved.model_dump(mode="python")
+        return self
+
+    def extract_html(self, params: HtmlChunkParams | None = None, **kwargs: Any) -> "InProcessIngestor":
+        """
+        Configure HTML ingestion: markitdown -> markdown -> tokenizer chunking (no PDF extraction).
+
+        Use with .files("*.html").extract_html(...).embed().vdb_upload().ingest().
+        Do not call .extract() when using .extract_html().
+        """
+        self._pipeline_type = "html"
+        resolved = _coerce_params(params, HtmlChunkParams, kwargs)
+        self._extract_html_kwargs = resolved.model_dump(mode="python")
+        return self
+
+    def extract_audio(
+        self,
+        params: AudioChunkParams | None = None,
+        asr_params: ASRParams | None = None,
+        **kwargs: Any,
+    ) -> "InProcessIngestor":
+        """
+        Configure audio ingestion: media chunking (sync) -> ASR (Parakeet gRPC) -> same embed/vdb.
+
+        Use with .files("mp3/*.mp3").extract_audio(...).embed().vdb_upload().ingest().
+        Do not call .extract() when using .extract_audio(). ASR requires a remote Parakeet/Riva endpoint.
+        """
+        from nemo_retriever.audio.asr_actor import apply_asr_to_df
+
+        self._pipeline_type = "audio"
+        chunk_resolved = _coerce_params(params, AudioChunkParams, kwargs)
+        asr_resolved = _coerce_params(asr_params, ASRParams, kwargs)
+        self._extract_audio_chunk_kwargs = chunk_resolved.model_dump(mode="python")
+        self._extract_audio_asr_kwargs = asr_resolved.model_dump(mode="python")
+        self._tasks.append((apply_asr_to_df, {"asr_params": self._extract_audio_asr_kwargs}))
+        return self
+
+    def embed(self, params: EmbedParams | None = None, **kwargs: Any) -> "InProcessIngestor":
+        """
+        Configure embedding for in-process execution.
+
+        This records an embedding task so call sites can chain `.embed(...)`
+        after `.extract(...)`, `.extract_txt()`, or `.extract_html()`.
+
+        When ``embedding_endpoint`` (or ``embed_invoke_url``) is provided (e.g.
+        ``"http://embedding:8000/v1"``), a remote NIM endpoint is used for
+        embedding instead of the local HF model.
+        """
+        resolved = _coerce_params(params, EmbedParams, kwargs)
+        embed_modality = resolved.embed_modality
+        text_elements_modality = resolved.text_elements_modality or embed_modality
+        structured_elements_modality = resolved.structured_elements_modality or embed_modality
+
+        # Explode content rows before embedding so each table/chart/infographic
+        # gets its own embedding vector (mirrors nv-ingest per-element embeddings).
+        self._tasks.append(
+            (
+                explode_content_to_rows,
+                {
+                    "modality": embed_modality,
+                    "text_elements_modality": text_elements_modality,
+                    "structured_elements_modality": structured_elements_modality,
+                },
+            )
+        )
+
+        embed_kwargs = {
+            **resolved.model_dump(
+                mode="python", exclude={"runtime", "batch_tuning", "fused_tuning"}, exclude_none=True
+            ),
+            **resolved.runtime.model_dump(mode="python", exclude_none=True),
+        }
+        if "embedding_endpoint" not in embed_kwargs and embed_kwargs.get("embed_invoke_url"):
+            embed_kwargs["embedding_endpoint"] = embed_kwargs.get("embed_invoke_url")
+
+        # Ensure embed_modality is forwarded to the embedding function.
+        embed_kwargs["embed_modality"] = embed_modality
+
+        # If a remote NIM endpoint is configured, skip local model creation.
+        endpoint = (embed_kwargs.get("embedding_endpoint") or embed_kwargs.get("embed_invoke_url") or "").strip()
+        if endpoint:
+            embed_kwargs.setdefault("input_type", "passage")
+            self._tasks.append((embed_text_main_text_embed, embed_kwargs))
+            return self
+
+        # Local HF embedder path.
+        # Allow callers to control device / max_length to avoid OOMs.
+        device = embed_kwargs.pop("device", None)
+        hf_cache_dir = embed_kwargs.pop("hf_cache_dir", None)
+        normalize = bool(embed_kwargs.pop("normalize", True))
+        max_length = int(embed_kwargs.pop("max_length", 8192))
+
+        model_name_raw = embed_kwargs.pop("model_name", None)
+
+        from nemo_retriever.model import is_vl_embed_model, resolve_embed_model
+
+        model_id = resolve_embed_model(model_name_raw)
+
+        embed_kwargs.setdefault("input_type", "passage")
+
+        if is_vl_embed_model(model_name_raw):
+            from nemo_retriever.model.local.llama_nemotron_embed_vl_1b_v2_embedder import (
+                LlamaNemotronEmbedVL1BV2Embedder,
+            )
+
+            embed_kwargs["model"] = LlamaNemotronEmbedVL1BV2Embedder(
+                device=str(device) if device is not None else None,
+                hf_cache_dir=str(hf_cache_dir) if hf_cache_dir is not None else None,
+                model_id=model_id,
+            )
+        else:
+            embed_kwargs["model"] = LlamaNemotronEmbed1BV2Embedder(
+                device=str(device) if device is not None else None,
+                hf_cache_dir=str(hf_cache_dir) if hf_cache_dir is not None else None,
+                normalize=normalize,
+                max_length=max_length,
+                model_id=model_id,
+            )
+        self._tasks.append((embed_text_main_text_embed, embed_kwargs))
+        return self
+
+    def save_to_disk(
+        self,
+        output_directory: Optional[str] = None,
+        cleanup: bool = True,
+        compression: Optional[str] = "gzip",
+    ) -> "InProcessIngestor":
+        """
+        Persist the current per-document DataFrame to disk as JSON.
+
+        Writes one JSON file per input document under `output_directory`, using a
+        UTC timestamp in the filename.
+        """
+        _ = (cleanup, compression)  # reserved for future use (parity with interface)
+        if output_directory is None:
+            raise ValueError("output_directory is required for inprocess save_to_disk()")
+
+        self._tasks.append((save_dataframe_to_disk_json, {"output_directory": str(output_directory)}))
+        return self
+
+    def vdb_upload(self, params: VdbUploadParams | None = None, **kwargs: Any) -> "InProcessIngestor":
+        """
+        Upload the (embedding-enriched) results to a vector DB (LanceDB).
+
+        This is an in-process uploader intended to run after `.embed(...)`.
+        It reads embeddings from either:
+        - `metadata.embedding` (if present), or
+        - the embedding payload column produced by the embed stage (default: `text_embeddings_1b_v2`)
+
+        Configuration is passed via kwargs:
+        - **lancedb_uri**: str, default `"lancedb"`
+        - **table_name**: str, default `"nv-ingest"`
+        - **overwrite**: bool, default True (False appends)
+        - **create_index**: bool, default True
+        - **index_type**: str, default `"IVF_HNSW_SQ"`
+        - **metric**: str, default `"l2"`
+        - **num_partitions**: int, default 16
+        - **num_sub_vectors**: int, default 256
+        - **embedding_column**: str, default `"text_embeddings_1b_v2"`
+        - **embedding_key**: str, default `"embedding"`
+        - **include_text**: bool, default False
+        - **text_column**: str, default `"text"`
+
+        Notes:
+        - `purge_results_after_upload` is accepted for API parity but is not used in inprocess mode.
+        """
+        p = params or VdbUploadParams()
+        if kwargs:
+            lancedb_kwargs = {k: v for k, v in kwargs.items() if k != "purge_results_after_upload"}
+            if lancedb_kwargs:
+                p = p.model_copy(update={"lancedb": p.lancedb.model_copy(update=lancedb_kwargs)})
+            if "purge_results_after_upload" in kwargs:
+                p = p.model_copy(update={"purge_results_after_upload": bool(kwargs["purge_results_after_upload"])})
+        _ = p.purge_results_after_upload  # parity with interface; inprocess does not purge by default
+        self._tasks.append((upload_embeddings_to_lancedb_inprocess, p.lancedb.model_dump(mode="python")))
+        return self
+
+    # Tasks that run once on combined results (after all docs). All others run per-doc.
+    _POST_TASKS = (upload_embeddings_to_lancedb_inprocess, save_dataframe_to_disk_json)
+
+    def get_pipeline_tasks(
+        self,
+    ) -> Tuple[List[Tuple[Callable[..., Any], Dict[str, Any]]], List[Tuple[Callable[..., Any], Dict[str, Any]]]]:
+        """
+        Return (per_doc_tasks, post_tasks) for use by ingest() or by the online
+        serve deployment to run the same pipeline on a single document.
+        """
+        per_doc_tasks = [(f, k) for f, k in self._tasks if f not in self._POST_TASKS]
+        post_tasks = [(f, k) for f, k in self._tasks if f in self._POST_TASKS]
+        return per_doc_tasks, post_tasks
+
+    def ingest(self, params: IngestExecuteParams | None = None, **kwargs: Any) -> list[Any]:
+        run_params = _coerce_params(params, IngestExecuteParams, kwargs)
+        show_progress = run_params.show_progress
+        _ = (run_params.return_failures, run_params.save_to_disk, run_params.return_traces)
+        parallel = run_params.parallel
+        max_workers = run_params.max_workers
+        gpu_devices = list(run_params.gpu_devices) if run_params.gpu_devices else None
+        page_chunk_size = run_params.page_chunk_size
+
+        _start = time.perf_counter()
+
+        # -- Three-way task classification --------------------------------
+        _post_task_fns = (upload_embeddings_to_lancedb_inprocess, save_dataframe_to_disk_json)
+        _cpu_task_fns = (pdf_extraction,)
+
+        cpu_tasks = [(f, k) for f, k in self._tasks if f in _cpu_task_fns]
+        gpu_tasks = [(f, k) for f, k in self._tasks if f not in _cpu_task_fns and f not in _post_task_fns]
+        post_tasks = [(f, k) for f, k in self._tasks if f in _post_task_fns]
+
+        docs = list(self._documents)
+
+        # -- Parallel execution branch ------------------------------------
+        if parallel:
+            if gpu_devices and len(gpu_devices) >= 1 and gpu_tasks:
+                # Pipelined: GPU workers load models while CPU runs,
+                # each completed chunk goes to GPU immediately.
+                from .gpu_pool import GPUWorkerPool, gpu_tasks_to_descriptors
+
+                descriptors = gpu_tasks_to_descriptors(gpu_tasks)
+                errors: list[str] = []
+
+                with GPUWorkerPool(gpu_devices, descriptors) as gpu_pool:
+                    # Split all docs into page chunks (main thread, cheap PDF byte splitting)
+                    chunks: list[pd.DataFrame] = []
+                    chunk_to_doc: list[str] = []
+                    doc_chunk_total: dict[str, int] = defaultdict(int)
+                    for doc in docs:
+                        for chunk_df in _iter_page_chunks(doc, page_chunk_size):
+                            chunk_to_doc.append(doc)
+                            doc_chunk_total[doc] += 1
+                            chunks.append(chunk_df)
+
+                    shard_id = 0
+                    progress = None
+                    if show_progress and tqdm is not None:
+                        progress = tqdm(total=len(docs), desc="Processing files", unit="file")
+
+                    shard_to_doc: dict[int, str] = {}
+                    doc_done: dict[str, int] = defaultdict(int)
+
+                    def _check_file_done(doc_path: str) -> None:
+                        if doc_done[doc_path] >= doc_chunk_total[doc_path]:
+                            if progress is not None:
+                                progress.update(1)
+
+                    with ProcessPoolExecutor(
+                        max_workers=max_workers,
+                        mp_context=multiprocessing.get_context("spawn"),
+                    ) as cpu_pool:
+                        future_to_idx = {
+                            cpu_pool.submit(_process_chunk_cpu, chunk, cpu_tasks): i for i, chunk in enumerate(chunks)
+                        }
+
+                        for future in as_completed(future_to_idx):
+                            idx = future_to_idx[future]
+                            doc = chunk_to_doc[idx]
+                            try:
+                                result = future.result()
+                                if isinstance(result, pd.DataFrame) and not result.empty:
+                                    shard_to_doc[shard_id] = doc
+                                    gpu_pool.submit(shard_id, result)
+                                    shard_id += 1
+                                else:
+                                    doc_done[doc] += 1
+                                    _check_file_done(doc)
+                            except Exception as e:
+                                errors.append(f"chunk {idx}: {type(e).__name__}: {e}")
+                                print(f"Warning: failed to process chunk {idx}: {e}")
+                                doc_done[doc] += 1
+                                _check_file_done(doc)
+
+                    if errors:
+                        print(f"Warning: {len(errors)} chunk(s) failed CPU extraction")
+
+                    # All CPU done, collect remaining GPU results
+                    def _on_gpu_done(sid: int) -> None:
+                        d = shard_to_doc.get(sid, "")
+                        if d:
+                            doc_done[d] += 1
+                            _check_file_done(d)
+
+                    combined = gpu_pool.collect_all(on_shard_done=_on_gpu_done)
+
+                    if progress is not None:
+                        progress.close()
+
+                if combined.empty:
+                    results: list = []
+                    if show_progress:
+                        _print_ingest_summary(results, time.perf_counter() - _start)
+                    return results
+
+                for func, kwargs in post_tasks:
+                    combined = func(combined, **kwargs)
+
+                results = [combined]
+                if show_progress:
+                    _print_ingest_summary(results, time.perf_counter() - _start)
+                return results
+
+            else:
+                # Single-GPU or no-GPU path: CPU parallel on chunks, then sequential GPU
+                chunks: list[pd.DataFrame] = []
+                chunk_to_doc: list[str] = []
+                doc_chunk_total: dict[str, int] = defaultdict(int)
+                for doc in docs:
+                    for chunk_df in _iter_page_chunks(doc, page_chunk_size):
+                        chunk_to_doc.append(doc)
+                        doc_chunk_total[doc] += 1
+                        chunks.append(chunk_df)
+
+                cpu_results: list[pd.DataFrame] = []
+                errors: list[str] = []
+
+                progress = None
+                if show_progress and tqdm is not None:
+                    progress = tqdm(total=len(docs), desc="Processing files", unit="file")
+
+                doc_done: dict[str, int] = defaultdict(int)
+
+                with ProcessPoolExecutor(
+                    max_workers=max_workers,
+                    mp_context=multiprocessing.get_context("spawn"),
+                ) as pool:
+                    future_to_idx = {pool.submit(_process_chunk_cpu, c, cpu_tasks): i for i, c in enumerate(chunks)}
+
+                    for future in as_completed(future_to_idx):
+                        idx = future_to_idx[future]
+                        doc = chunk_to_doc[idx]
+                        try:
+                            result = future.result()
+                            if isinstance(result, pd.DataFrame) and not result.empty:
+                                cpu_results.append(result)
+                        except Exception as e:
+                            errors.append(f"chunk {idx}: {type(e).__name__}: {e}")
+                            print(f"Warning: failed to process chunk {idx}: {e}")
+                        doc_done[doc] += 1
+                        if doc_done[doc] >= doc_chunk_total[doc] and progress is not None:
+                            progress.update(1)
+
+                if progress is not None:
+                    progress.close()
+
+                if errors:
+                    print(f"Warning: {len(errors)} chunk(s) failed CPU extraction")
+
+                if not cpu_results:
+                    results = []
+                    if show_progress:
+                        _print_ingest_summary(results, time.perf_counter() - _start)
+                    return results
+
+                combined = pd.concat(cpu_results, ignore_index=True)
+                for func, kwargs in gpu_tasks:
+                    combined = func(combined, **kwargs)
+
+                for func, kwargs in post_tasks:
+                    combined = func(combined, **kwargs)
+
+                results = [combined]
+                if show_progress:
+                    _print_ingest_summary(results, time.perf_counter() - _start)
+                return results
+
+        # -- Sequential execution branch (default) ------------------------
+        use_multi_gpu_seq = gpu_devices and len(gpu_devices) >= 1 and gpu_tasks
+
+        if use_multi_gpu_seq:
+            # Pipelined: GPU workers process earlier chunks while CPU
+            # extracts later chunks of the same (or next) document.
+            cpu_and_extract = [(f, k) for f, k in self._tasks if f in _cpu_task_fns]
+
+            from .gpu_pool import GPUWorkerPool, gpu_tasks_to_descriptors
+
+            descriptors = gpu_tasks_to_descriptors(gpu_tasks)
+
+            with GPUWorkerPool(gpu_devices, descriptors) as gpu_pool:
+                shard_id = 0
+                shard_to_doc: dict[int, str] = {}
+                doc_chunk_total: dict[str, int] = defaultdict(int)
+                doc_done: dict[str, int] = defaultdict(int)
+
+                for doc_path in docs:
+                    for chunk_df in _iter_page_chunks(doc_path, page_chunk_size):
+                        doc_chunk_total[doc_path] += 1
+                        current: Any = chunk_df
+                        for func, kwargs in cpu_and_extract:
+                            if func is pdf_extraction:
+                                current = func(pdf_binary=current, **kwargs)
+                            else:
+                                current = func(current, **kwargs)
+                        if isinstance(current, pd.DataFrame) and not current.empty:
+                            shard_to_doc[shard_id] = doc_path
+                            gpu_pool.submit(shard_id, current)
+                            shard_id += 1
+                        else:
+                            doc_done[doc_path] += 1
+
+                progress = None
+                if show_progress and tqdm is not None:
+                    # Docs whose chunks all failed CPU are already done
+                    already_done = sum(
+                        1 for d in docs if d not in doc_chunk_total or doc_done.get(d, 0) >= doc_chunk_total[d]
+                    )
+                    progress = tqdm(total=len(docs), desc="Processing files", unit="file", initial=already_done)
+
+                def _on_gpu_done(sid: int) -> None:
+                    d = shard_to_doc.get(sid, "")
+                    if d:
+                        doc_done[d] += 1
+                        if doc_done[d] >= doc_chunk_total[d] and progress is not None:
+                            progress.update(1)
+
+                combined = gpu_pool.collect_all(on_shard_done=_on_gpu_done)
+
+                if progress is not None:
+                    progress.close()
+
+            if combined.empty:
+                results = []
+                if show_progress:
+                    _print_ingest_summary(results, time.perf_counter() - _start)
+                return results
+
+            for func, kwargs in post_tasks:
+                combined = func(combined, **kwargs)
+
+            results = [combined]
+            if show_progress:
+                _print_ingest_summary(results, time.perf_counter() - _start)
+            return results
+
+        # Fully sequential: per-document CPU + GPU + post tasks
+        per_doc_tasks = [(f, k) for f, k in self._tasks if f not in _post_task_fns]
+
+        results: list[Any] = []
+        doc_iter = docs
+        if show_progress and tqdm is not None:
+            doc_iter = tqdm(docs, desc="Processing documents", unit="doc")
+
+        if self._pipeline_type == "pdf":
+
+            def _loader(p: str) -> pd.DataFrame:
+                """
+                Load a document as a per-page DataFrame. For .pdf use pdf_path_to_pages_df.
+                For .docx/.pptx convert to PDF via LibreOffice then split (same schema).
+                """
+                abs_path = os.path.abspath(p)
+                ext = os.path.splitext(abs_path)[1].lower()
+                if ext in SUPPORTED_EXTENSIONS and ext != ".pdf":
+                    try:
+                        with open(abs_path, "rb") as f:
+                            file_bytes = f.read()
+                        pdf_bytes = convert_to_pdf_bytes(file_bytes, ext)
+                        pages = _split_pdf_to_single_page_bytes(pdf_bytes)
+                        out_rows = [{"bytes": b, "path": abs_path, "page_number": i + 1} for i, b in enumerate(pages)]
+                        return pd.DataFrame(out_rows)
+                    except BaseException as e:
+                        return pd.DataFrame([{"bytes": b"", "path": abs_path, "page_number": 0, "error": str(e)}])
+                return pdf_path_to_pages_df(p)
+
+        elif self._pipeline_type == "html":
+
+            def _loader(p: str) -> pd.DataFrame:
+                return html_file_to_chunks_df(p, params=HtmlChunkParams(**self._extract_html_kwargs))
+
+        elif self._pipeline_type == "audio":
+
+            def _loader(p: str) -> pd.DataFrame:
+                from nemo_retriever.audio.chunk_actor import audio_path_to_chunks_df
+
+                return audio_path_to_chunks_df(p, params=AudioChunkParams(**self._extract_audio_chunk_kwargs))
+
+        else:
+
+            def _loader(p: str) -> pd.DataFrame:
+                return txt_file_to_chunks_df(p, params=TextChunkParams(**self._extract_txt_kwargs))
+
+        for doc_path in doc_iter:
+            initial_df = _loader(doc_path)
+            current, _ = run_pipeline_tasks_on_df(initial_df, per_doc_tasks, None)
+            results.append(current)
+
+        # Run upload/save once on combined results so overwrite=True keeps full corpus.
+        if post_tasks and results and all(isinstance(r, pd.DataFrame) for r in results):
+            combined = pd.concat(results, ignore_index=True)
+            for func, kwargs in post_tasks:
+                combined = func(combined, **kwargs)
+
+        if show_progress:
+            _print_ingest_summary(results, time.perf_counter() - _start)
+        return results
diff --git a/nemo_retriever/src/nemo_retriever/ingest_modes/online.py b/nemo_retriever/src/nemo_retriever/ingest_modes/online.py
new file mode 100644
index 000000000..89f296885
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_modes/online.py
@@ -0,0 +1,253 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Online runmode.
+
+Low-latency request/response serving: documents are submitted to a Ray Serve
+REST API (see ingest_modes.serve) which runs the same pipeline as inprocess
+on a single document per request. This module provides the client-side
+Ingestor that delegates to that REST endpoint.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+from io import BytesIO
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from ..ingestor import Ingestor
+from ..params import EmbedParams
+from ..params import ExtractParams
+from ..params import IngestExecuteParams
+from ..params import VdbUploadParams
+
+# Extension -> MIME for online ingest (server may dispatch to audio pipeline by MIME or header).
+_EXTENSION_MIME = {
+    ".mp3": "audio/mpeg",
+    ".wav": "audio/wav",
+    ".m4a": "audio/mp4",
+    ".mp4": "video/mp4",
+    ".mov": "video/quicktime",
+    ".avi": "video/x-msvideo",
+    ".mkv": "video/x-matroska",
+}
+
+
+def _mime_for_path(path: str) -> str:
+    ext = os.path.splitext(path)[1].lower()
+    return _EXTENSION_MIME.get(ext, "application/pdf")
+
+
+class OnlineIngestor(Ingestor):
+    """
+    Client-side ingestor that submits documents to the online ingest REST API.
+
+    Use create_ingestor(run_mode="online", base_url="http://localhost:7670")
+    then .files(...).extract(...).embed(...).vdb_upload().ingest().
+    extract/embed/vdb_upload record configuration for compatibility; the
+    actual pipeline runs on the server. ingest() POSTs each file to the
+    /ingest endpoint and returns a list of response metrics per document.
+    """
+
+    RUN_MODE = "online"
+
+    def __init__(
+        self,
+        documents: Optional[List[str]] = None,
+        base_url: str = "http://localhost:7670",
+    ) -> None:
+        super().__init__(documents=documents)
+        self._base_url = base_url.rstrip("/")
+        self._input_documents: List[str] = self._documents
+
+    def files(self, documents: Union[str, List[str]]) -> "OnlineIngestor":
+        """Add local file paths or globs for submission to the online service."""
+        if isinstance(documents, str):
+            documents = [documents]
+
+        for pattern in documents:
+            if not isinstance(pattern, str) or not pattern:
+                raise ValueError(f"Invalid document pattern: {pattern!r}")
+
+            matches = glob.glob(pattern, recursive=True)
+            if matches:
+                files = [os.path.abspath(p) for p in matches if os.path.isfile(p)]
+                if not files:
+                    raise FileNotFoundError(f"Pattern resolved, but no files found: {pattern!r}")
+                self._input_documents.extend(files)
+                continue
+
+            if os.path.isfile(pattern):
+                self._input_documents.append(os.path.abspath(pattern))
+                continue
+
+            raise FileNotFoundError(f"No local files found for: {pattern!r}")
+
+        return self
+
+    def buffers(self, buffers: Union[Tuple[str, BytesIO], List[Tuple[str, BytesIO]]]) -> "OnlineIngestor":
+        """Add in-memory buffers for submission. Name is used as source_path."""
+        if isinstance(buffers, (list, tuple)) and len(buffers) == 2 and not isinstance(buffers[0], (list, tuple)):
+            buffers = [buffers]
+        for name, buf in buffers:
+            self._buffers.append((str(name), buf))
+        return self
+
+    def load(self) -> "OnlineIngestor":
+        """No-op for API compatibility."""
+        return self
+
+    def extract(self, params: ExtractParams | None = None, **kwargs: Any) -> "OnlineIngestor":
+        """Record extraction config (server uses its own config). API compatibility."""
+        _ = params or ExtractParams(**kwargs)
+        return self
+
+    def extract_txt(self, params: ExtractParams | None = None, **kwargs: Any) -> "OnlineIngestor":
+        """Record txt config. API compatibility. Online mode typically serves PDF only."""
+        _ = params or ExtractParams(**kwargs)
+        return self
+
+    def extract_audio(self, params: Any = None, asr_params: Any = None, **kwargs: Any) -> "OnlineIngestor":
+        """Record audio config. API compatibility. Server must accept audio MIME and run audio pipeline."""
+        _ = params
+        _ = asr_params
+        _ = kwargs
+        return self
+
+    def embed(self, params: EmbedParams | None = None, **kwargs: Any) -> "OnlineIngestor":
+        """Record embed config (server uses its own config). API compatibility."""
+        _ = params or EmbedParams(**kwargs)
+        return self
+
+    def vdb_upload(self, params: VdbUploadParams | None = None, **kwargs: Any) -> "OnlineIngestor":
+        """Record vdb config (server uses its own config). API compatibility."""
+        _ = params or VdbUploadParams(
+            purge_results_after_upload=bool(kwargs.get("purge_results_after_upload", True)),
+            lancedb={k: v for k, v in kwargs.items() if k != "purge_results_after_upload"},
+        )
+        return self
+
+    def ingest(self, params: IngestExecuteParams | None = None, **kwargs: Any) -> List[Dict[str, Any]]:
+        """
+        Submit each configured file (and buffer) to the online ingest REST API.
+
+        Returns a list of response dicts (one per document) with ok, total_duration_sec,
+        stages, rows_written, and optional error.
+        """
+        _ = params or IngestExecuteParams(**kwargs)
+        import httpx
+
+        ingest_url = f"{self._base_url}/ingest"
+        results: List[Dict[str, Any]] = []
+        docs = list(self._input_documents)
+        for path in docs:
+            try:
+                with open(path, "rb") as f:
+                    body = f.read()
+            except Exception as e:
+                results.append({"ok": False, "error": str(e), "source_path": path})
+                continue
+
+            mime = _mime_for_path(path)
+            headers = {"X-Source-Path": path}
+            if not mime.startswith("application/"):
+                headers["X-Document-Type"] = "audio" if "audio" in mime or "video" in mime else "binary"
+            try:
+                with httpx.Client(timeout=300.0) as client:
+                    resp = client.post(
+                        ingest_url,
+                        files={"file": (os.path.basename(path), body, mime)},
+                        headers=headers,
+                    )
+            except Exception as e:
+                results.append({"ok": False, "error": str(e), "source_path": path})
+                continue
+
+            try:
+                data = resp.json()
+            except Exception:
+                data = {"ok": False, "error": resp.text[:500], "source_path": path}
+            if resp.status_code != 200:
+                data["ok"] = False
+                data.setdefault("error", f"HTTP {resp.status_code}")
+            results.append(data)
+
+        for name, buf in self._buffers:
+            buf.seek(0)
+            body = buf.read()
+            mime = _mime_for_path(name)
+            headers = {"X-Source-Path": name}
+            if not mime.startswith("application/"):
+                headers["X-Document-Type"] = "audio" if "audio" in mime or "video" in mime else "binary"
+            try:
+                with httpx.Client(timeout=300.0) as client:
+                    resp = client.post(
+                        ingest_url,
+                        files={"file": (name, body, mime)},
+                        headers=headers,
+                    )
+            except Exception as e:
+                results.append({"ok": False, "error": str(e), "source_path": name})
+                continue
+            try:
+                data = resp.json()
+            except Exception:
+                data = {"ok": False, "error": resp.text[:500], "source_path": name}
+            if resp.status_code != 200:
+                data["ok"] = False
+                data.setdefault("error", f"HTTP {resp.status_code}")
+            results.append(data)
+
+        return results
+
+    def all_tasks(self) -> "OnlineIngestor":
+        return self
+
+    def dedup(self) -> "OnlineIngestor":
+        return self
+
+    def filter(self) -> "OnlineIngestor":
+        return self
+
+    def split(self) -> "OnlineIngestor":
+        return self
+
+    def store(self) -> "OnlineIngestor":
+        return self
+
+    def store_embed(self) -> "OnlineIngestor":
+        return self
+
+    def udf(self, *args: Any, **kwargs: Any) -> "OnlineIngestor":
+        return self
+
+    def save_intermediate_results(self, output_dir: str) -> "OnlineIngestor":
+        return self
+
+    def save_to_disk(self, *args: Any) -> "OnlineIngestor":
+        _ = args
+        return self
+
+    def caption(self) -> "OnlineIngestor":
+        return self
+
+    def pdf_split_config(self, pages_per_chunk: int = 32) -> "OnlineIngestor":
+        return self
+
+    def completed_jobs(self) -> int:
+        return 0
+
+    def failed_jobs(self) -> int:
+        return 0
+
+    def cancelled_jobs(self) -> int:
+        return 0
+
+    def remaining_jobs(self) -> int:
+        return 0
+
+    def get_status(self) -> Dict[str, str]:
+        return {}
diff --git a/nemo_retriever/src/nemo_retriever/ingest_modes/pipeline.py b/nemo_retriever/src/nemo_retriever/ingest_modes/pipeline.py
new file mode 100644
index 000000000..60dadd5ac
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_modes/pipeline.py
@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+app = typer.Typer(help="Ingest pipeline commands.")
+
+
+@app.command()
+def run(
+    input_path: Path = typer.Option(
+        ...,
+        "--input-dir",
+        exists=True,
+        file_okay=True,
+        dir_okay=True,
+        path_type=Path,
+        help="Input file or directory to ingest.",
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        path_type=Path,
+        help="Optional ingest config file.",
+    ),
+) -> None:
+    """
+    Skeleton entrypoint for the ingest pipeline CLI.
+    """
+    typer.echo("Ingest pipeline runner is not implemented yet. " f"Received input={input_path} config={config}.")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/ingest_modes/serve.py b/nemo_retriever/src/nemo_retriever/ingest_modes/serve.py
new file mode 100644
index 000000000..f5b90a5fe
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingest_modes/serve.py
@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.adapters.service.app import RetrieverAPIDeployment, app
+
+__all__ = ["RetrieverAPIDeployment", "app"]
diff --git a/nemo_retriever/src/nemo_retriever/ingestor.py b/nemo_retriever/src/nemo_retriever/ingestor.py
new file mode 100644
index 000000000..d4d34cfad
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ingestor.py
@@ -0,0 +1,206 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+System-facing ingestion interface.
+
+This module defines the public API surface for building and executing ingestion.
+Concrete implementations are provided by runmodes:
+
+- inprocess: local Python process, no framework assumptions
+- batch: large-scale batch execution
+- fused: low-latency single-actor GPU model fusion
+- online: low-latency, multi-request serving
+"""
+
+from __future__ import annotations
+
+from io import BytesIO
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+from nemo_retriever.application.modes.factory import create_runmode_ingestor
+from nemo_retriever.params import EmbedParams
+from nemo_retriever.params import ExtractParams
+from nemo_retriever.params import IngestExecuteParams
+from nemo_retriever.params import IngestorCreateParams
+from nemo_retriever.params import RunMode
+from nemo_retriever.params import VdbUploadParams
+
+
+def _merge_params[T](params: T | None, kwargs: dict[str, Any]) -> T:
+    if params is None:
+        return kwargs  # type: ignore[return-value]
+    if not kwargs:
+        return params
+    if hasattr(params, "model_copy"):
+        return params.model_copy(update=kwargs)  # type: ignore[return-value]
+    return params
+
+
+def create_ingestor(
+    *,
+    run_mode: RunMode = "inprocess",
+    params: IngestorCreateParams | None = None,
+    **kwargs: Any,
+) -> "Ingestor":
+    """
+    Factory for selecting an ingestion runmode implementation.
+    """
+    merged = _merge_params(params, kwargs)
+    if isinstance(merged, IngestorCreateParams):
+        parsed = merged
+    else:
+        parsed = IngestorCreateParams(**merged)
+    return create_runmode_ingestor(run_mode=run_mode, params=parsed)
+
+
+class ingestor:
+    """
+    Interface base class. All methods intentionally raise NotImplementedError.
+
+    Each runmode should subclass this and eventually provide working behavior.
+    """
+
+    RUN_MODE: str = "interface"
+
+    def __init__(self, documents: Optional[List[str]] = None) -> None:
+        self._documents: List[str] = list(documents or [])
+        self._buffers: List[Tuple[str, BytesIO]] = []
+
+    def _not_implemented(self, method_name: str) -> "None":
+        raise NotImplementedError(
+            f"{self.__class__.__name__}.{method_name}() is not implemented yet " f"(run_mode={self.RUN_MODE})."
+        )
+
+    def files(self, documents: Union[str, List[str]]) -> "ingestor":
+        """Add document paths/URIs for processing."""
+        self._not_implemented("files")
+
+    def buffers(self, buffers: Union[Tuple[str, BytesIO], List[Tuple[str, BytesIO]]]) -> "ingestor":
+        """Add in-memory buffers for processing."""
+        self._not_implemented("buffers")
+
+    def load(self) -> "ingestor":
+        """
+        Placeholder for remote fetch/localization.
+
+        The client-side Ingestor supports downloading remote URIs locally.
+        In this system, each runmode may handle remote inputs differently.
+        """
+        self._not_implemented("load")
+
+    def ingest(
+        self,
+        params: IngestExecuteParams | None = None,
+        **kwargs: Any,
+    ) -> Union[List[Any], Tuple[Any, ...]]:
+        """
+        Execute the configured ingestion pipeline (placeholder).
+        """
+        _ = _merge_params(params, kwargs)
+        self._not_implemented("ingest")
+
+    def ingest_async(self, *, return_failures: bool = False, return_traces: bool = False) -> Any:
+        """Asynchronously execute ingestion (placeholder)."""
+        self._not_implemented("ingest_async")
+
+    def all_tasks(self) -> "ingestor":
+        """Record the default task chain (placeholder)."""
+        self._not_implemented("all_tasks")
+
+    def dedup(self) -> "ingestor":
+        """Record a dedup task configuration."""
+        self._not_implemented("dedup")
+
+    def embed(self, params: EmbedParams | None = None, **kwargs: Any) -> "ingestor":
+        """Record an embedding task configuration."""
+        _ = _merge_params(params, kwargs)
+        self._not_implemented("embed")
+
+    def extract(self, params: ExtractParams | None = None, **kwargs: Any) -> "ingestor":
+        """Record an extract task configuration."""
+        _ = _merge_params(params, kwargs)
+        self._not_implemented("extract")
+
+    def filter(self) -> "ingestor":
+        """Record a filter task configuration."""
+        self._not_implemented("filter")
+
+    def split(self) -> "ingestor":
+        """Record a split task configuration."""
+        self._not_implemented("split")
+
+    def store(self) -> "ingestor":
+        """Record a store task configuration."""
+        self._not_implemented("store")
+
+    def store_embed(self) -> "ingestor":
+        """Record a store-embed task configuration."""
+        self._not_implemented("store_embed")
+
+    def udf(
+        self,
+        udf_function: str,
+        udf_function_name: Optional[str] = None,
+        phase: Optional[Union[int, str]] = None,
+        target_stage: Optional[str] = None,
+        run_before: bool = False,
+        run_after: bool = False,
+    ) -> "ingestor":
+        """Record a UDF task configuration."""
+        self._not_implemented("udf")
+
+    def vdb_upload(self, params: VdbUploadParams | None = None, **kwargs: Any) -> "ingestor":
+        """Record a vector DB upload configuration (execution TBD)."""
+        _ = _merge_params(params, kwargs)
+        self._not_implemented("vdb_upload")
+
+    def save_intermediate_results(self, output_dir: str) -> "ingestor":
+        """Record intermediate results persistence configuration."""
+        self._not_implemented("save_intermediate_results")
+
+    def save_to_disk(
+        self,
+        output_directory: Optional[str] = None,
+        cleanup: bool = True,
+        compression: Optional[str] = "gzip",
+    ) -> "ingestor":
+        """Record result persistence configuration (execution TBD)."""
+        self._not_implemented("save_to_disk")
+
+    def caption(self) -> "ingestor":
+        """Record a caption task configuration."""
+        self._not_implemented("caption")
+
+    def pdf_split_config(self, pages_per_chunk: int = 32) -> "ingestor":
+        """Record PDF split configuration (execution TBD)."""
+        self._not_implemented("pdf_split_config")
+
+    def completed_jobs(self) -> int:
+        """Return completed job count (placeholder until backend populates job state)."""
+        self._not_implemented("completed_jobs")
+
+    def failed_jobs(self) -> int:
+        """Return failed job count (placeholder until backend populates job state)."""
+        self._not_implemented("failed_jobs")
+
+    def cancelled_jobs(self) -> int:
+        """Return cancelled job count (placeholder until backend populates job state)."""
+        self._not_implemented("cancelled_jobs")
+
+    def remaining_jobs(self) -> int:
+        """Return remaining job count (placeholder until backend populates job state)."""
+        self._not_implemented("remaining_jobs")
+
+    def get_status(self) -> Dict[str, str]:
+        """
+        Return per-document status mapping (placeholder).
+
+        Once Ray execution is wired, this should reflect actual job/task state.
+        """
+        self._not_implemented("get_status")
+
+
+# Backward compatibility alias.
+Ingestor = ingestor
diff --git a/nemo_retriever/src/nemo_retriever/io/__init__.py b/nemo_retriever/src/nemo_retriever/io/__init__.py
new file mode 100644
index 000000000..3a5d08715
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/io/__init__.py
@@ -0,0 +1,14 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .dataframe import read_dataframe, validate_primitives_dataframe, write_dataframe
+from .stage_files import build_stage_output_path, find_stage_inputs
+
+__all__ = [
+    "build_stage_output_path",
+    "find_stage_inputs",
+    "read_dataframe",
+    "validate_primitives_dataframe",
+    "write_dataframe",
+]
diff --git a/nemo_retriever/src/nemo_retriever/io/dataframe.py b/nemo_retriever/src/nemo_retriever/io/dataframe.py
new file mode 100644
index 000000000..ff2e5d8f6
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/io/dataframe.py
@@ -0,0 +1,72 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pandas as pd
+
+
+def validate_primitives_dataframe(df: pd.DataFrame) -> None:
+    if "metadata" not in df.columns:
+        raise KeyError("Primitives DataFrame must include a 'metadata' column.")
+
+
+def read_dataframe(path: Path) -> pd.DataFrame:
+    suffix = path.suffix.lower()
+    if suffix == ".parquet":
+        return pd.read_parquet(path)
+    if suffix in {".jsonl", ".json"}:
+        text = path.read_text(encoding="utf-8")
+        if suffix == ".jsonl":
+            records = [json.loads(line) for line in text.splitlines() if line.strip()]
+        else:
+            obj = json.loads(text)
+            if isinstance(obj, dict):
+                records = _unwrap_records_from_mapping(obj)
+            else:
+                records = obj if isinstance(obj, list) else [obj]
+
+        # Some stage payloads are wrapped once more in jsonl.
+        if (
+            isinstance(records, list)
+            and len(records) == 1
+            and isinstance(records[0], dict)
+            and not ("metadata" in records[0] and "document_type" in records[0])
+        ):
+            records = _unwrap_records_from_mapping(records[0])
+
+        return pd.DataFrame(records)
+
+    raise ValueError(f"Unsupported DataFrame format: {path} (expected .parquet, .jsonl, or .json)")
+
+
+def write_dataframe(df: pd.DataFrame, path: Path) -> None:
+    suffix = path.suffix.lower()
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+    if suffix == ".parquet":
+        df.to_parquet(path, index=False)
+        return
+    if suffix == ".jsonl":
+        with path.open("w", encoding="utf-8") as file_handle:
+            for record in df.to_dict(orient="records"):
+                file_handle.write(json.dumps(record, ensure_ascii=False) + "\n")
+        return
+    if suffix == ".json":
+        payload = df.to_dict(orient="records")
+        path.write_text(json.dumps(payload, ensure_ascii=False, indent=2), encoding="utf-8")
+        return
+
+    raise ValueError(f"Unsupported DataFrame format: {path} (expected .parquet, .jsonl, or .json)")
+
+
+def _unwrap_records_from_mapping(obj: dict) -> list:
+    for key in ("extracted_df_records", "primitives"):
+        value = obj.get(key)
+        if isinstance(value, list) and (not value or isinstance(value[0], dict)):
+            return value
+    return [obj]
diff --git a/nemo_retriever/src/nemo_retriever/io/stage_files.py b/nemo_retriever/src/nemo_retriever/io/stage_files.py
new file mode 100644
index 000000000..e59fbbd54
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/io/stage_files.py
@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+
+
+def find_stage_inputs(input_dir: Path, *, suffix: str) -> list[Path]:
+    files = [path for path in input_dir.iterdir() if path.is_file() and path.name.endswith(suffix)]
+    return sorted(files)
+
+
+def build_stage_output_path(input_path: Path, *, stage_suffix: str, output_dir: Path | None) -> Path:
+    output_name = input_path.stem + stage_suffix + input_path.suffix
+    if output_dir is None:
+        return input_path.with_name(output_name)
+    return output_dir / output_name
diff --git a/nemo_retriever/src/nemo_retriever/local/__init__.py b/nemo_retriever/src/nemo_retriever/local/__init__.py
new file mode 100644
index 000000000..711bfce3a
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/__init__.py
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .__main__ import app
+
+__all__ = ["app"]
diff --git a/nemo_retriever/src/nemo_retriever/local/__main__.py b/nemo_retriever/src/nemo_retriever/local/__main__.py
new file mode 100644
index 000000000..7ceb865b0
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/__main__.py
@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from .stages import (
+    stage1_pdf_extraction,
+    stage2_infographic_extraction,
+    stage3_table_extractor,
+    stage4_chart_extractor,
+    stage5_text_embeddings,
+    stage6_vdb_upload,
+    stage7_vdb_query,
+    stage999_post_mortem_analysis,
+)
+
+app = typer.Typer(help="Simple non-distributed pipeline for local development, debugging, and research.")
+app.add_typer(stage1_pdf_extraction.app, name="stage1")
+app.add_typer(stage2_infographic_extraction.app, name="stage2")
+app.add_typer(stage3_table_extractor.app, name="stage3")
+app.add_typer(stage4_chart_extractor.app, name="stage4")
+app.add_typer(stage5_text_embeddings.app, name="stage5")
+app.add_typer(stage6_vdb_upload.app, name="stage6")
+app.add_typer(stage7_vdb_query.app, name="stage7")
+app.add_typer(stage999_post_mortem_analysis.app, name="stage999")
+
+
+def main():
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/__init__.py b/nemo_retriever/src/nemo_retriever/local/stages/__init__.py
new file mode 100644
index 000000000..62eb32190
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/__init__.py
@@ -0,0 +1,12 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Checkpointable local pipeline stages.
+
+Each stage is a standalone Typer CLI module intended to be run independently,
+reading previous artifacts from disk and writing new artifacts alongside inputs.
+"""
+
+# Intentionally empty: stages are imported explicitly in `nemo_retriever.local.__main__`.
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/stage1_pdf_extraction.py b/nemo_retriever/src/nemo_retriever/local/stages/stage1_pdf_extraction.py
new file mode 100644
index 000000000..06bc08a4a
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/stage1_pdf_extraction.py
@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+"""
+Local pipeline stage1: pass-through PDF extraction CLI.
+
+This module intentionally contains **no configuration logic**. It simply re-exports the
+`nemo_retriever.pdf.stage` Typer application so any arguments provided to:
+
+  `retriever local stage1 ...`
+
+are handled exactly the same as:
+
+  `retriever pdf ...`
+"""
+
+from nemo_retriever.pdf.stage import app as app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/stage2_infographic_extraction.py b/nemo_retriever/src/nemo_retriever/local/stages/stage2_infographic_extraction.py
new file mode 100644
index 000000000..a63c72166
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/stage2_infographic_extraction.py
@@ -0,0 +1,105 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Local pipeline stage: infographic extraction wrapper.
+
+This stage mostly delegates to `nemo_retriever.infographic.stage`, but adds a local-only
+convenience: `--input` may be either:
+
+- A single primitives DF file (e.g. `<pdf>.pdf_extraction.json`, `.jsonl`, `.parquet`)
+- A directory, in which case we iterate over all `*pdf_extraction.json` files in that
+  directory and run the extractor on each.
+
+This makes it easy to run stage2 across a whole folder of stage1 outputs.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from nemo_retriever.infographic import stage as infographic_stage
+from nemo_retriever.io.stage_files import build_stage_output_path, find_stage_inputs
+
+app = typer.Typer(help="Stage 2: infographic extractor (wrapper around `nemo_retriever.infographic.stage`).")
+
+
+def _iter_pdf_extraction_json_files(input_dir: Path) -> list[Path]:
+    return find_stage_inputs(input_dir, suffix="pdf_extraction.json")
+
+
+@app.command()
+def run(
+    input_path: Path = typer.Option(
+        ...,
+        "--input",
+        exists=True,
+        dir_okay=True,
+        file_okay=True,
+        help=(
+            "Input primitives DataFrame file (.parquet, .jsonl, or .json), or a directory. "
+            "If a directory, we process every `*pdf_extraction.json` file in it."
+        ),
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        dir_okay=False,
+        file_okay=True,
+        help="Output path for single-file input. Defaults to <input>.+infographic<ext>.",
+    ),
+    output_dir: Optional[Path] = typer.Option(
+        None,
+        "--output-dir",
+        dir_okay=True,
+        file_okay=False,
+        help=(
+            "Output directory for directory input. Defaults to the input directory. "
+            "Output filenames follow the single-file default naming."
+        ),
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="Optional YAML config for InfographicExtractorSchema.",
+    ),
+) -> None:
+    """
+    Run infographic enrichment on a single primitives file, or batch-run it across a directory of
+    stage1 outputs.
+    """
+    if input_path.is_file():
+        if output_dir is not None:
+            raise typer.BadParameter("--output-dir is only valid when --input is a directory.")
+        infographic_stage.run(input_path=input_path, output_path=output_path, config=config)
+        return
+
+    # Directory mode
+    if output_path is not None:
+        raise typer.BadParameter("--output is only valid when --input is a file.")
+
+    files = _iter_pdf_extraction_json_files(input_path)
+    if not files:
+        raise typer.BadParameter(f"No `*pdf_extraction.json` files found in directory: {input_path}")
+
+    out_dir = output_dir or input_path
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    for p in files:
+        out = build_stage_output_path(p, stage_suffix=".infographic", output_dir=out_dir)
+        infographic_stage.run(input_path=p, output_path=out, config=config)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/stage3_table_extractor.py b/nemo_retriever/src/nemo_retriever/local/stages/stage3_table_extractor.py
new file mode 100644
index 000000000..71d0b1c8d
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/stage3_table_extractor.py
@@ -0,0 +1,150 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Local pipeline stage: table extraction wrapper.
+
+Adds local-only conveniences (e.g. dumping OCR input images) while delegating
+the actual extraction to `nemo_retriever.table.stage`.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from nemo_retriever.table import stage as table_stage
+from nemo_retriever.io.stage_files import build_stage_output_path, find_stage_inputs
+
+app = typer.Typer(help="Stage 3: table extractor (wrapper around `nemo_retriever.table.stage`).")
+
+
+def _iter_pdf_extraction_infographics_json_files(input_dir: Path) -> list[Path]:
+    return find_stage_inputs(input_dir, suffix="pdf_extraction.infographic.json")
+
+
+def _run_one(
+    *,
+    input_path: Path,
+    output_path: Optional[Path],
+    config: Optional[Path],
+    output_ocr_input_images: bool,
+) -> None:
+    """
+    Run table enrichment for a single input file, optionally dumping OCR input images.
+    """
+    # Stage3 knows where the input DF file lives; communicate that to lower layers via env vars.
+    # This keeps the API extractors reusable across callsites (Typer, Ray, etc).
+    env_backup = {
+        "NV_INGEST_DUMP_OCR_INPUT_IMAGES": os.getenv("NV_INGEST_DUMP_OCR_INPUT_IMAGES"),
+        "NV_INGEST_DUMP_OCR_INPUT_IMAGES_DIR": os.getenv("NV_INGEST_DUMP_OCR_INPUT_IMAGES_DIR"),
+        "NV_INGEST_DUMP_OCR_INPUT_IMAGES_PREFIX": os.getenv("NV_INGEST_DUMP_OCR_INPUT_IMAGES_PREFIX"),
+    }
+    try:
+        if output_ocr_input_images:
+            os.environ["NV_INGEST_DUMP_OCR_INPUT_IMAGES"] = "1"
+            os.environ["NV_INGEST_DUMP_OCR_INPUT_IMAGES_DIR"] = str(input_path.parent)
+            os.environ["NV_INGEST_DUMP_OCR_INPUT_IMAGES_PREFIX"] = input_path.name
+
+        # Delegate to the canonical table stage implementation.
+        table_stage.run(input_path=input_path, output_path=output_path, config=config)
+    finally:
+        for k, v in env_backup.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+
+
+@app.command()
+def run(
+    input_path: Path = typer.Option(
+        ...,
+        "--input",
+        exists=True,
+        dir_okay=True,
+        file_okay=True,
+        help=(
+            "Input primitives as a DataFrame file (.parquet, .jsonl, or .json), or a directory. "
+            "If a directory, we process every `*pdf_extraction.infographics.json` file in it."
+        ),
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        dir_okay=False,
+        file_okay=True,
+        help="Output path for single-file input (.parquet, .jsonl, or .json). Defaults to <input>.+table<ext>.",
+    ),
+    output_dir: Optional[Path] = typer.Option(
+        None,
+        "--output-dir",
+        dir_okay=True,
+        file_okay=False,
+        help=(
+            "Output directory for directory input. Defaults to the input directory. "
+            "Output filenames follow the single-file default naming."
+        ),
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="Optional YAML config for TableExtractorSchema.",
+    ),
+    output_ocr_input_images: bool = typer.Option(
+        False,
+        "--output-ocr-input-images/--no-output-ocr-input-images",
+        help=(
+            "If enabled, writes every image passed to OCR into the input file's directory. "
+            "Filenames: <input_filename>.page_<PPPP>_<IIII>.(hf|nim).png"
+        ),
+    ),
+) -> None:
+    """
+    Run table enrichment and optionally dump OCR input images.
+    """
+    if input_path.is_file():
+        if output_dir is not None:
+            raise typer.BadParameter("--output-dir is only valid when --input is a directory.")
+        _run_one(
+            input_path=input_path,
+            output_path=output_path,
+            config=config,
+            output_ocr_input_images=output_ocr_input_images,
+        )
+        return
+
+    # Directory mode
+    if output_path is not None:
+        raise typer.BadParameter("--output is only valid when --input is a file.")
+
+    files = _iter_pdf_extraction_infographics_json_files(input_path)
+    if not files:
+        raise typer.BadParameter(f"No `*pdf_extraction.infographics.json` files found in directory: {input_path}")
+
+    out_dir = output_dir or input_path
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    for p in files:
+        out = build_stage_output_path(p, stage_suffix=".table", output_dir=out_dir) if output_dir is not None else None
+        _run_one(
+            input_path=p,
+            output_path=out,
+            config=config,
+            output_ocr_input_images=output_ocr_input_images,
+        )
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/stage4_chart_extractor.py b/nemo_retriever/src/nemo_retriever/local/stages/stage4_chart_extractor.py
new file mode 100644
index 000000000..a2ca5c0fc
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/stage4_chart_extractor.py
@@ -0,0 +1,109 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Local pipeline stage: chart extraction wrapper.
+
+This stage mostly delegates to `nemo_retriever.chart.stage`, but adds a local-only
+convenience: `--input` may be either:
+
+- A single primitives DF file (e.g. `*.pdf_extraction.infographics.table.json`, `.jsonl`, `.parquet`)
+- A directory, in which case we iterate over all stage3 table outputs in that
+  directory (files ending with `pdf_extraction.infographics.table.json`) and run
+  chart extraction on each.
+
+This makes it easy to run stage4 across a whole folder of stage3 outputs.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from nemo_retriever.chart import stage as chart_stage
+from nemo_retriever.io.stage_files import build_stage_output_path, find_stage_inputs
+
+app = typer.Typer(help="Stage 4: chart extractor (wrapper around `nemo_retriever.chart.stage`).")
+
+
+def _iter_stage3_table_outputs(input_dir: Path) -> list[Path]:
+    return find_stage_inputs(input_dir, suffix="pdf_extraction.infographic.table.json")
+
+
+@app.command()
+def run(
+    input_path: Path = typer.Option(
+        ...,
+        "--input",
+        exists=True,
+        dir_okay=True,
+        file_okay=True,
+        help=(
+            "Input primitives as a DataFrame file (.parquet, .jsonl, or .json), or a directory. "
+            "If a directory, we process every `*pdf_extraction.infographics.table.json` file in it."
+        ),
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        dir_okay=False,
+        file_okay=True,
+        help="Output path for single-file input (.parquet, .jsonl, or .json). Defaults to <input>.+chart<ext>.",
+    ),
+    output_dir: Optional[Path] = typer.Option(
+        None,
+        "--output-dir",
+        dir_okay=True,
+        file_okay=False,
+        help=(
+            "Output directory for directory input. Defaults to the input directory. "
+            "Output filenames follow the single-file default naming."
+        ),
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="Optional YAML config for ChartExtractorSchema.",
+    ),
+) -> None:
+    """
+    Run chart enrichment on a single primitives file, or batch-run it across a directory of stage3 outputs.
+    """
+    if input_path.is_file():
+        if output_dir is not None:
+            raise typer.BadParameter("--output-dir is only valid when --input is a directory.")
+        chart_stage.run(input_path=input_path, output_path=output_path, config=config)
+        return
+
+    # Directory mode
+    if output_path is not None:
+        raise typer.BadParameter("--output is only valid when --input is a file.")
+
+    files = _iter_stage3_table_outputs(input_path)
+    if not files:
+        raise typer.BadParameter(f"No `*pdf_extraction.infographics.table.json` files found in directory: {input_path}")
+
+    out_dir = output_dir or input_path
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    for p in files:
+        out = build_stage_output_path(p, stage_suffix=".chart", output_dir=out_dir) if output_dir is not None else None
+        chart_stage.run(input_path=p, output_path=out, config=config)
+
+
+# Preserve access to other chart-stage commands under local stage4 (e.g. `graphic-elements`).
+app.command("graphic-elements")(chart_stage.render_graphic_elements)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/stage5_text_embeddings.py b/nemo_retriever/src/nemo_retriever/local/stages/stage5_text_embeddings.py
new file mode 100644
index 000000000..3ea038f3d
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/stage5_text_embeddings.py
@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+"""
+Local pipeline stage5: thin proxy for text embedding CLI.
+
+This module intentionally contains no configuration logic. It re-exports the
+`nemo_retriever.text_embed.stage` Typer application so arguments provided to:
+
+  `retriever local stage5 ...`
+
+are handled by `nemo_retriever.text_embed.stage`, including local-HF fallback options
+when an embedding endpoint is not configured.
+"""
+
+from nemo_retriever.text_embed.stage import app as app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/stage6_vdb_upload.py b/nemo_retriever/src/nemo_retriever/local/stages/stage6_vdb_upload.py
new file mode 100644
index 000000000..17c18b45f
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/stage6_vdb_upload.py
@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+"""
+Local pipeline stage6: thin proxy for vector store upload CLI.
+
+This module intentionally contains no configuration logic. It re-exports the
+`nemo_retriever.vector_store.stage` Typer application so arguments provided to:
+
+  `retriever local stage6 ...`
+
+are handled by `nemo_retriever.vector_store.stage`.
+"""
+
+from nemo_retriever.vector_store.stage import app as app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/stage7_vdb_query.py b/nemo_retriever/src/nemo_retriever/local/stages/stage7_vdb_query.py
new file mode 100644
index 000000000..451befd0d
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/stage7_vdb_query.py
@@ -0,0 +1,27 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+"""
+Local pipeline stage7: thin proxy for vector DB query/recall CLI.
+
+This module intentionally contains no configuration logic. It re-exports the
+`nemo_retriever.recall.vdb_recall` Typer application so arguments provided to:
+
+  `retriever local stage7 ...`
+
+are handled by `nemo_retriever.recall.vdb_recall`, including a local-HF fallback path
+when embedding HTTP/gRPC endpoints are not configured.
+"""
+
+from nemo_retriever.recall.vdb_recall import app as app
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/local/stages/stage999_post_mortem_analysis.py b/nemo_retriever/src/nemo_retriever/local/stages/stage999_post_mortem_analysis.py
new file mode 100644
index 000000000..e4f6ba1ae
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/local/stages/stage999_post_mortem_analysis.py
@@ -0,0 +1,2223 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+# flake8: noqa
+
+import csv
+import json
+import textwrap
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+import typer
+from rich.console import Console
+
+
+console = Console()
+app = typer.Typer(
+    help=(
+        "Stage 999: Post-mortem analysis viewer for per-page artifacts.\n\n"
+        "Reads bo767_query_gt.csv (query -> pdf_page) and loads page images + adjacent stage sidecars:\n"
+        "  - <image>.+page_elements_v3.json\n"
+        "  - <image>.+graphic_elements_v1.json\n"
+        "  - <image>.+table_structure_v1.json\n"
+        "  - <image>.+nemotron_ocr_v1.json\n"
+        "  - <image_stem>.pdfium_text.txt\n"
+        "Optionally displays <image>.page_element_detections.png if present.\n\n"
+        "Provides an interactive UI (Tk) for browsing and a PDF report export mode."
+    )
+)
+
+
+IMAGE_EXTS = (".png", ".jpg", ".jpeg")
+
+
+@dataclass(frozen=True)
+class QueryRow:
+    query: str
+    pdf: str
+    page: Optional[int]  # CSV 'page' column (often 0-based in this dataset)
+    modality: Optional[str]
+    pdf_page: str  # e.g. "1102434_20"
+
+    @property
+    def pdf_page_pdf(self) -> str:
+        # "1102434_20" -> "1102434"
+        parts = self.pdf_page.split("_", 1)
+        return parts[0] if parts else self.pdf
+
+    @property
+    def pdf_page_page1(self) -> Optional[int]:
+        # "1102434_20" -> 20 (1-based)
+        parts = self.pdf_page.split("_", 1)
+        if len(parts) != 2:
+            return None
+        try:
+            return int(parts[1])
+        except Exception:
+            return None
+
+
+@dataclass(frozen=True)
+class RecallResult:
+    """Recall hit information for a query."""
+
+    hit_at_1: bool
+    hit_at_3: bool
+    hit_at_5: bool
+    hit_at_10: bool
+    rank_at_1: Optional[int]
+    rank_at_3: Optional[int]
+    rank_at_5: Optional[int]
+    rank_at_10: Optional[int]
+    top_10_retrieved: List[str]
+
+
+@dataclass(frozen=True)
+class ResolvedExample:
+    row: QueryRow
+    image_path: Optional[Path]
+    recall: Optional[RecallResult] = None
+
+
+def _read_json_best_effort(path: Path) -> Optional[Dict[str, Any]]:
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            obj = json.load(f)
+        return obj if isinstance(obj, dict) else None
+    except Exception:
+        return None
+
+
+def _read_text_best_effort(path: Path) -> str:
+    try:
+        return path.read_text(encoding="utf-8", errors="replace").strip()
+    except Exception:
+        return ""
+
+
+def _iter_images(input_dir: Path, recursive: bool) -> List[Path]:
+    it = input_dir.rglob("*") if recursive else input_dir.iterdir()
+    out: List[Path] = []
+    for p in it:
+        if p.is_file() and p.suffix.lower() in IMAGE_EXTS:
+            out.append(p)
+    return sorted(out)
+
+
+def _index_images(images: Sequence[Path]) -> Tuple[Dict[str, Path], Dict[str, Path]]:
+    """
+    Returns:
+      - by_name: filename -> path
+      - by_stem: stem -> path
+    If multiple paths collide, keeps the first in sorted order.
+    """
+    by_name: Dict[str, Path] = {}
+    by_stem: Dict[str, Path] = {}
+    for p in images:
+        by_name.setdefault(p.name, p)
+        by_stem.setdefault(p.stem, p)
+    return by_name, by_stem
+
+
+def _candidate_image_stems(row: QueryRow) -> List[str]:
+    """
+    Try to resolve dataset IDs to rendered image stems.
+
+    Primary convention from `nemo_retriever.utils.convert`:
+      <pdf_basename>_page<NNNN>.<ext> where NNNN is 1-based.
+
+    The bo767 CSV includes `pdf_page` like "<pdf>_<page1based>".
+    """
+    cands: List[str] = []
+
+    pdf = (row.pdf_page_pdf or row.pdf or "").strip()
+    page1 = row.pdf_page_page1
+    if pdf and page1 is not None and page1 > 0:
+        cands.append(f"{pdf}_page{int(page1):04d}")
+        cands.append(f"{pdf}_page{int(page1)}")
+
+    # Fallback: if CSV 'page' looks 0-based, try +1.
+    if pdf and row.page is not None:
+        try:
+            p0 = int(row.page)
+            if p0 >= 0:
+                cands.append(f"{pdf}_page{int(p0 + 1):04d}")
+                cands.append(f"{pdf}_page{int(p0 + 1)}")
+        except Exception:
+            pass
+
+    # Last resort: sometimes datasets store "<pdf>_<page>" images directly.
+    if row.pdf_page:
+        cands.append(row.pdf_page)
+
+    # De-dupe while preserving order
+    seen: set[str] = set()
+    out: List[str] = []
+    for s in cands:
+        if s and s not in seen:
+            seen.add(s)
+            out.append(s)
+    return out
+
+
+def _resolve_image_for_row(row: QueryRow, *, by_stem: Dict[str, Path], by_name: Dict[str, Path]) -> Optional[Path]:
+    # Try exact stems first
+    for stem in _candidate_image_stems(row):
+        p = by_stem.get(stem)
+        if p is not None:
+            return p
+
+    # Fallback: try filenames with extensions
+    for stem in _candidate_image_stems(row):
+        for ext in IMAGE_EXTS:
+            p = by_name.get(stem + ext)
+            if p is not None:
+                return p
+
+    return None
+
+
+def _load_csv_rows(csv_path: Path) -> List[QueryRow]:
+    rows: List[QueryRow] = []
+    with csv_path.open("r", encoding="utf-8", errors="replace", newline="") as f:
+        r = csv.DictReader(f)
+        for rec in r:
+            query = (rec.get("query") or "").strip()
+            pdf = (rec.get("pdf") or "").strip()
+            modality = (rec.get("modality") or "").strip() or None
+            pdf_page = (rec.get("pdf_page") or "").strip()
+            page_raw = rec.get("page")
+            page: Optional[int]
+            try:
+                page = int(page_raw) if page_raw is not None and str(page_raw).strip() != "" else None
+            except Exception:
+                page = None
+            if not pdf_page:
+                # if missing, attempt to synthesize
+                if pdf and page is not None:
+                    pdf_page = f"{pdf}_{int(page)}"
+            if not query and not pdf_page:
+                continue
+            rows.append(QueryRow(query=query, pdf=pdf, page=page, modality=modality, pdf_page=pdf_page))
+    return rows
+
+
+def _load_recall_results(recall_csv_path: Path) -> Dict[str, RecallResult]:
+    """
+    Load recall results from the CSV generated by stage8.
+    Returns a dict mapping golden_answer (pdf_page) to RecallResult.
+    """
+    recall_map: Dict[str, RecallResult] = {}
+
+    if not recall_csv_path.exists():
+        return recall_map
+
+    try:
+        import pandas as pd
+
+        df = pd.read_csv(recall_csv_path)
+
+        for _, row in df.iterrows():
+            golden = str(row.get("golden_answer", "")).strip()
+            if not golden:
+                continue
+
+            # Parse top_10_retrieved - it's stored as a string representation of a list
+            top_10_str = str(row.get("top_10_retrieved", "[]"))
+            try:
+                import ast
+
+                top_10 = ast.literal_eval(top_10_str)
+                if not isinstance(top_10, list):
+                    top_10 = []
+            except Exception:
+                top_10 = []
+
+            recall_map[golden] = RecallResult(
+                hit_at_1=bool(row.get("hit@1", False)),
+                hit_at_3=bool(row.get("hit@3", False)),
+                hit_at_5=bool(row.get("hit@5", False)),
+                hit_at_10=bool(row.get("hit@10", False)),
+                rank_at_1=int(row["rank@1"]) if pd.notna(row.get("rank@1")) else None,
+                rank_at_3=int(row["rank@3"]) if pd.notna(row.get("rank@3")) else None,
+                rank_at_5=int(row["rank@5"]) if pd.notna(row.get("rank@5")) else None,
+                rank_at_10=int(row["rank@10"]) if pd.notna(row.get("rank@10")) else None,
+                top_10_retrieved=[str(x) for x in top_10],
+            )
+    except Exception as e:
+        console.print(f"[yellow]Warning: Could not load recall results from {recall_csv_path}: {e}[/yellow]")
+
+    return recall_map
+
+
+def _paths_for_image(img_path: Path) -> Dict[str, Path]:
+    # Note: stage2-5 scripts use img_path.name + ".suffix.json" (double-extension).
+    return {
+        "img": img_path,
+        "img_overlay": img_path.with_name(img_path.name + ".page_element_detections.png"),
+        "pdfium_text": img_path.with_suffix(".pdfium_text.txt"),
+        "stage2": img_path.with_name(img_path.name + ".page_elements_v3.json"),
+        "stage3": img_path.with_name(img_path.name + ".graphic_elements_v1.json"),
+        "stage4": img_path.with_name(img_path.name + ".table_structure_v1.json"),
+        "stage5": img_path.with_name(img_path.name + ".nemotron_ocr_v1.json"),
+        # Stage6 writes this (see stage6_embeddings.py): <image>.+embedder-input.txt
+        "embedder_input": img_path.with_name(img_path.name + ".embedder-input.txt"),
+    }
+
+
+def _count_stage2(d: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    if not d:
+        return {"present": False}
+    dets = d.get("detections") or []
+    by_label: Dict[str, int] = {}
+    for det in dets if isinstance(dets, list) else []:
+        if not isinstance(det, dict):
+            continue
+        name = det.get("label_name")
+        if not isinstance(name, str) or not name.strip():
+            name = f"label_{det.get('label')}"
+        k = str(name)
+        by_label[k] = int(by_label.get(k, 0) + 1)
+    timing_s = None
+    t = d.get("timing")
+    if isinstance(t, dict):
+        try:
+            timing_s = float(t.get("seconds"))
+        except Exception:
+            timing_s = None
+    return {
+        "present": True,
+        "num_detections": int(len(dets)) if isinstance(dets, list) else 0,
+        "by_label": dict(sorted(by_label.items(), key=lambda kv: (-kv[1], kv[0]))),
+        "timing_s": timing_s,
+    }
+
+
+def _count_regions_model(d: Optional[Dict[str, Any]], *, regions_key: str = "regions") -> Dict[str, Any]:
+    if not d:
+        return {"present": False}
+    regions = d.get(regions_key) or []
+    n_regions = int(len(regions)) if isinstance(regions, list) else 0
+    n_dets = 0
+    for r in regions if isinstance(regions, list) else []:
+        if not isinstance(r, dict):
+            continue
+        dets = r.get("detections") or []
+        if isinstance(dets, list):
+            n_dets += int(len(dets))
+    timing_s = None
+    t = d.get("timing")
+    if isinstance(t, dict):
+        try:
+            timing_s = float(t.get("seconds"))
+        except Exception:
+            timing_s = None
+    return {"present": True, "num_regions": n_regions, "num_detections": int(n_dets), "timing_s": timing_s}
+
+
+def _count_stage5_ocr(d: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+    if not d:
+        return {"present": False}
+    regions = d.get("regions") or []
+    n_regions = int(len(regions)) if isinstance(regions, list) else 0
+    nonempty = 0
+    by_kind: Dict[str, int] = {}
+    sample_texts: List[str] = []
+    for r in regions if isinstance(regions, list) else []:
+        if not isinstance(r, dict):
+            continue
+        txt = (r.get("ocr_text") or "").strip()
+        if txt:
+            nonempty += 1
+            if len(sample_texts) < 8:
+                sample_texts.append(txt.replace("\n", " ").strip())
+        name = r.get("label_name")
+        if not isinstance(name, str) or not name.strip():
+            name = f"label_{r.get('label')}"
+        k = str(name)
+        by_kind[k] = int(by_kind.get(k, 0) + 1)
+    return {
+        "present": True,
+        "num_regions": n_regions,
+        "num_nonempty": int(nonempty),
+        "by_label_name": dict(sorted(by_kind.items(), key=lambda kv: (-kv[1], kv[0]))),
+        "sample_texts": sample_texts,
+    }
+
+
+def _format_summary_for_page(img_path: Path, row: QueryRow) -> Dict[str, Any]:
+    paths = _paths_for_image(img_path)
+    pdfium_text = _read_text_best_effort(paths["pdfium_text"]) if paths["pdfium_text"].exists() else ""
+
+    s2_raw = _read_json_best_effort(paths["stage2"]) if paths["stage2"].exists() else None
+    s3_raw = _read_json_best_effort(paths["stage3"]) if paths["stage3"].exists() else None
+    s4_raw = _read_json_best_effort(paths["stage4"]) if paths["stage4"].exists() else None
+    s5_raw = _read_json_best_effort(paths["stage5"]) if paths["stage5"].exists() else None
+
+    return {
+        "row": row,
+        "paths": paths,
+        "pdfium_text": pdfium_text,
+        "stage2": _count_stage2(s2_raw),
+        "stage3": _count_regions_model(s3_raw),
+        "stage4": _count_regions_model(s4_raw),
+        "stage5": _count_stage5_ocr(s5_raw),
+        "raw": {
+            "stage2": s2_raw,
+            "stage3": s3_raw,
+            "stage4": s4_raw,
+            "stage5": s5_raw,
+        },
+    }
+
+
+def _compute_global_metrics(examples: Sequence[ResolvedExample]) -> Dict[str, Any]:
+    # Aggregate across unique images referenced by the CSV (best-effort).
+    uniq_imgs: Dict[Path, QueryRow] = {}
+    for ex in examples:
+        if ex.image_path is not None and ex.image_path.exists():
+            uniq_imgs.setdefault(ex.image_path, ex.row)
+
+    totals = {
+        "unique_pages": int(len(uniq_imgs)),
+        "missing_images": int(sum(1 for ex in examples if ex.image_path is None)),
+        "present": {"stage2": 0, "stage3": 0, "stage4": 0, "stage5": 0, "pdfium_text": 0, "overlay": 0},
+        "counts": {"stage2_detections": 0, "stage3_detections": 0, "stage4_detections": 0, "stage5_regions": 0},
+    }
+
+    # Add recall metrics if available
+    recall_available = sum(1 for ex in examples if ex.recall is not None)
+    if recall_available > 0:
+        totals["recall"] = {
+            "total_queries": recall_available,
+            "hits_at_1": sum(1 for ex in examples if ex.recall and ex.recall.hit_at_1),
+            "hits_at_3": sum(1 for ex in examples if ex.recall and ex.recall.hit_at_3),
+            "hits_at_5": sum(1 for ex in examples if ex.recall and ex.recall.hit_at_5),
+            "hits_at_10": sum(1 for ex in examples if ex.recall and ex.recall.hit_at_10),
+        }
+        totals["recall"]["recall_at_1"] = totals["recall"]["hits_at_1"] / recall_available
+        totals["recall"]["recall_at_3"] = totals["recall"]["hits_at_3"] / recall_available
+        totals["recall"]["recall_at_5"] = totals["recall"]["hits_at_5"] / recall_available
+        totals["recall"]["recall_at_10"] = totals["recall"]["hits_at_10"] / recall_available
+
+    for img_path, row in uniq_imgs.items():
+        paths = _paths_for_image(img_path)
+        if paths["stage2"].exists():
+            totals["present"]["stage2"] += 1
+            s2 = _read_json_best_effort(paths["stage2"])
+            dets = (s2 or {}).get("detections") if isinstance(s2, dict) else None
+            if isinstance(dets, list):
+                totals["counts"]["stage2_detections"] += int(len(dets))
+        if paths["stage3"].exists():
+            totals["present"]["stage3"] += 1
+            s3 = _read_json_best_effort(paths["stage3"])
+            regions = (s3 or {}).get("regions") if isinstance(s3, dict) else None
+            if isinstance(regions, list):
+                for r in regions:
+                    if isinstance(r, dict) and isinstance(r.get("detections"), list):
+                        totals["counts"]["stage3_detections"] += int(len(r["detections"]))
+        if paths["stage4"].exists():
+            totals["present"]["stage4"] += 1
+            s4 = _read_json_best_effort(paths["stage4"])
+            regions = (s4 or {}).get("regions") if isinstance(s4, dict) else None
+            if isinstance(regions, list):
+                for r in regions:
+                    if isinstance(r, dict) and isinstance(r.get("detections"), list):
+                        totals["counts"]["stage4_detections"] += int(len(r["detections"]))
+        if paths["stage5"].exists():
+            totals["present"]["stage5"] += 1
+            s5 = _read_json_best_effort(paths["stage5"])
+            regions = (s5 or {}).get("regions") if isinstance(s5, dict) else None
+            if isinstance(regions, list):
+                totals["counts"]["stage5_regions"] += int(len(regions))
+        if paths["pdfium_text"].exists():
+            totals["present"]["pdfium_text"] += 1
+        if paths["img_overlay"].exists():
+            totals["present"]["overlay"] += 1
+
+    return totals
+
+
+def _export_report_pdf(
+    *,
+    examples: Sequence[ResolvedExample],
+    output_pdf: Path,
+    recursive: bool,
+    limit_unique_pages: Optional[int] = None,
+    include_overlay_if_present: bool = True,
+) -> None:
+    """
+    Create a PDF report where each PDF page is a rendered composite image.
+    Uses only existing dependencies (Pillow + img2pdf).
+    """
+    from PIL import Image, ImageDraw, ImageFont  # pillow is a project dependency
+    import img2pdf  # project dependency
+
+    # Build unique pages in stable order (by image name) for reproducibility.
+    uniq: Dict[Path, QueryRow] = {}
+    for ex in examples:
+        if ex.image_path is None or (not ex.image_path.exists()):
+            continue
+        uniq.setdefault(ex.image_path, ex.row)
+
+    page_items = sorted(uniq.items(), key=lambda kv: kv[0].name)
+    if limit_unique_pages is not None:
+        page_items = page_items[: int(limit_unique_pages)]
+
+    # Try a reasonable default font; fall back to PIL default.
+    def _load_font(size: int) -> ImageFont.ImageFont:
+        try:
+            # common on many Linux distros
+            return ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf", size=size)
+        except Exception:
+            return ImageFont.load_default()
+
+    font_title = _load_font(22)
+    font_body = _load_font(14)
+    font_small = _load_font(12)
+
+    # Report page layout (pixel-based). Keep it modest for speed.
+    W, H = 1654, 2339  # ~A4 @ 150 DPI
+    margin = 30
+    gutter = 20
+
+    def _fit(im: Image.Image, max_w: int, max_h: int) -> Image.Image:
+        im = im.convert("RGB")
+        w, h = im.size
+        scale = min(max_w / max(1, w), max_h / max(1, h))
+        nw = max(1, int(w * scale))
+        nh = max(1, int(h * scale))
+        return im.resize((nw, nh), Image.BILINEAR)
+
+    def _wrap(s: str, width: int) -> List[str]:
+        s = (s or "").replace("\r", "").strip()
+        if not s:
+            return []
+        return textwrap.wrap(s, width=width, break_long_words=False, replace_whitespace=False)
+
+    def _draw_block(draw: ImageDraw.ImageDraw, x: int, y: int, lines: Sequence[str], font, line_h: int) -> int:
+        yy = y
+        for ln in lines:
+            draw.text((x, yy), ln, fill=(0, 0, 0), font=font)
+            yy += line_h
+        return yy
+
+    rendered_pages: List[bytes] = []
+    for img_path, row in page_items:
+        summary = _format_summary_for_page(img_path, row)
+        paths = summary["paths"]
+
+        canvas = Image.new("RGB", (W, H), (255, 255, 255))
+        draw = ImageDraw.Draw(canvas)
+
+        # Title
+        y = margin
+        title = f"{row.pdf_page}  |  {img_path.name}"
+        draw.text((margin, y), title, fill=(0, 0, 0), font=font_title)
+        y += 34
+
+        # Query
+        q_lines = _wrap(f"Query: {row.query}", width=110)
+        y = _draw_block(draw, margin, y, q_lines[:6], font=font_body, line_h=18) + 10
+
+        # Images region (two columns: original + overlay if present)
+        img_area_h = 820
+        col_w = (W - 2 * margin - gutter) // 2
+
+        with Image.open(paths["img"]) as im:
+            left = _fit(im, col_w, img_area_h)
+        canvas.paste(left, (margin, y))
+
+        if include_overlay_if_present and paths["img_overlay"].exists():
+            with Image.open(paths["img_overlay"]) as im2:
+                right = _fit(im2, col_w, img_area_h)
+            canvas.paste(right, (margin + col_w + gutter, y))
+            draw.text(
+                (margin + col_w + gutter, y + right.size[1] + 6),
+                "page_element_detections",
+                fill=(0, 0, 0),
+                font=font_small,
+            )
+        else:
+            draw.text((margin + col_w + gutter, y), "(no overlay image found)", fill=(120, 120, 120), font=font_small)
+
+        y = y + img_area_h + 25
+
+        # Metrics summary
+        s2 = summary["stage2"]
+        s3 = summary["stage3"]
+        s4 = summary["stage4"]
+        s5 = summary["stage5"]
+        metrics_lines = [
+            "Model / stage presence & counts:",
+            f"- pdfium_text: {'present' if bool(summary['pdfium_text']) else 'missing/empty'} (file: {'yes' if paths['pdfium_text'].exists() else 'no'})",
+            f"- stage2 page_elements_v3: present={s2.get('present')} dets={s2.get('num_detections', 0)} timing_s={s2.get('timing_s')}",
+            f"- stage3 graphic_elements_v1: present={s3.get('present')} regions={s3.get('num_regions', 0)} dets={s3.get('num_detections', 0)} timing_s={s3.get('timing_s')}",
+            f"- stage4 table_structure_v1: present={s4.get('present')} regions={s4.get('num_regions', 0)} dets={s4.get('num_detections', 0)} timing_s={s4.get('timing_s')}",
+            f"- stage5 nemotron_ocr_v1: present={s5.get('present')} regions={s5.get('num_regions', 0)} nonempty={s5.get('num_nonempty', 0)}",
+            "",
+        ]
+        y = _draw_block(draw, margin, y, metrics_lines, font=font_small, line_h=16) + 8
+
+        # PDFium + OCR samples (truncate)
+        pdfium_lines = _wrap("PDFium text: " + (summary["pdfium_text"] or ""), width=120)[:18]
+        ocr_samples = summary["stage5"].get("sample_texts") or []
+        ocr_lines: List[str] = []
+        if ocr_samples:
+            ocr_lines.append("OCR sample texts:")
+            for t in ocr_samples[:6]:
+                for ln in _wrap("- " + t, width=120)[:2]:
+                    ocr_lines.append(ln)
+        else:
+            ocr_lines = ["OCR sample texts: (none)"]
+
+        y = _draw_block(draw, margin, y, pdfium_lines, font=font_small, line_h=16) + 8
+        y = _draw_block(draw, margin, y, ocr_lines, font=font_small, line_h=16) + 8
+
+        # Render to PNG bytes (then img2pdf will embed as a PDF page).
+        import io
+
+        buf = io.BytesIO()
+        canvas.save(buf, format="PNG", optimize=True)
+        rendered_pages.append(buf.getvalue())
+
+    if not rendered_pages:
+        raise typer.BadParameter("No pages could be resolved to images; nothing to export.")
+
+    output_pdf.parent.mkdir(parents=True, exist_ok=True)
+    pdf_bytes = img2pdf.convert(rendered_pages)
+    output_pdf.write_bytes(pdf_bytes)
+
+
+def _gather_results_zip(
+    *,
+    examples: Sequence[ResolvedExample],
+    input_dir: Path,
+    csv_path: Path,
+    zip_path: Path,
+    recursive: bool,
+    limit_unique_pages: Optional[int] = None,
+) -> None:
+    """
+    Gather the artifacts used by the UI into a single shareable zip:
+      - the CSV
+      - resolved page images + adjacent artifacts (if present)
+      - a manifest.json with pointers + basic stats
+    """
+    import time
+    import zipfile
+
+    input_dir = Path(input_dir)
+    zip_path = Path(zip_path)
+    zip_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Unique pages in stable order.
+    uniq: Dict[Path, QueryRow] = {}
+    for ex in examples:
+        if ex.image_path is None or (not ex.image_path.exists()):
+            continue
+        uniq.setdefault(ex.image_path, ex.row)
+    page_items = sorted(uniq.items(), key=lambda kv: kv[0].name)
+    if limit_unique_pages is not None:
+        page_items = page_items[: int(limit_unique_pages)]
+
+    # Helper to store files under a stable namespace.
+    def _arc_for(p: Path) -> str:
+        try:
+            rel = p.resolve().relative_to(input_dir.resolve())
+            return str(Path("pages") / rel)
+        except Exception:
+            # Not under input_dir (or resolve fails); fall back to basename.
+            return str(Path("pages") / p.name)
+
+    manifest: Dict[str, Any] = {
+        "schema_version": 1,
+        "created_unix_s": int(time.time()),
+        "input_dir": str(input_dir),
+        "recursive": bool(recursive),
+        "csv_path": str(csv_path),
+        "counts": {
+            "csv_rows": int(len(examples)),
+            "unique_pages_resolved": int(len(page_items)),
+            "unique_pages_limit": int(limit_unique_pages) if limit_unique_pages is not None else None,
+        },
+        "entries": [],
+    }
+
+    with zipfile.ZipFile(zip_path, mode="w", compression=zipfile.ZIP_DEFLATED, compresslevel=6) as zf:
+        # Include the CSV verbatim.
+        try:
+            zf.write(csv_path, arcname="bo767_query_gt.csv")
+        except Exception:
+            # still allow zip creation even if CSV isn't readable for some reason
+            pass
+
+        # Include a small readme to guide recipients.
+        readme = (
+            "retriever stage999 gathered results\n"
+            "\n"
+            "Contents:\n"
+            "- bo767_query_gt.csv: original query->pdf_page mapping\n"
+            "- pages/: resolved page images and adjacent artifacts (sidecar JSON, pdfium text, overlay, embedder input)\n"
+            "- manifest.json: what was included and how it maps to the CSV\n"
+        )
+        zf.writestr("README.txt", readme)
+
+        # Add per-page artifacts
+        for img_path, row in page_items:
+            paths = _paths_for_image(img_path)
+            files: List[Tuple[str, Path]] = []
+            for k in ("img", "img_overlay", "pdfium_text", "stage2", "stage3", "stage4", "stage5", "embedder_input"):
+                p = paths.get(k)
+                if isinstance(p, Path) and p.exists():
+                    files.append((k, p))
+
+            # Write files into zip
+            included: Dict[str, str] = {}
+            for kind, p in files:
+                arc = _arc_for(p)
+                # Avoid overwriting if collisions happen; disambiguate with a prefix.
+                if arc in zf.namelist():
+                    arc = str(Path("pages") / f"{img_path.stem}__{p.name}")
+                zf.write(p, arcname=arc)
+                included[kind] = arc
+
+            manifest["entries"].append(
+                {
+                    "pdf_page": row.pdf_page,
+                    "query": row.query,
+                    "modality": row.modality,
+                    "image_name": img_path.name,
+                    "included": included,
+                }
+            )
+
+        # Always write manifest at end.
+        zf.writestr("manifest.json", json.dumps(manifest, ensure_ascii=False, indent=2))
+
+
+def _run_headless(*, examples: Sequence[ResolvedExample], global_metrics: Dict[str, Any]) -> None:
+    """
+    Display analysis results in a rich CLI format without requiring a display/GUI.
+    """
+    from rich.table import Table
+    from rich.panel import Panel
+    from rich import box
+
+    # Display global metrics
+    console.print("\n[bold cyan]═══ Global Metrics ═══[/bold cyan]\n")
+
+    metrics_table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED)
+    metrics_table.add_column("Metric", style="cyan")
+    metrics_table.add_column("Value", style="green")
+
+    metrics_table.add_row("Total CSV Rows", str(len(examples)))
+    metrics_table.add_row("Unique Pages", str(global_metrics.get("unique_pages", 0)))
+    metrics_table.add_row("Missing Images", str(global_metrics.get("missing_images", 0)))
+
+    present = global_metrics.get("present", {})
+    metrics_table.add_row("", "")  # separator
+    metrics_table.add_row("Stage 2 (page_elements_v3)", str(present.get("stage2", 0)))
+    metrics_table.add_row("Stage 3 (graphic_elements_v1)", str(present.get("stage3", 0)))
+    metrics_table.add_row("Stage 4 (table_structure_v1)", str(present.get("stage4", 0)))
+    metrics_table.add_row("Stage 5 (nemotron_ocr_v1)", str(present.get("stage5", 0)))
+    metrics_table.add_row("PDFium Text Files", str(present.get("pdfium_text", 0)))
+    metrics_table.add_row("Overlay Images", str(present.get("overlay", 0)))
+
+    counts = global_metrics.get("counts", {})
+    if counts:
+        metrics_table.add_row("", "")  # separator
+        metrics_table.add_row("Stage 2 Detections", str(counts.get("stage2_detections", 0)))
+        metrics_table.add_row("Stage 3 Detections", str(counts.get("stage3_detections", 0)))
+        metrics_table.add_row("Stage 4 Detections", str(counts.get("stage4_detections", 0)))
+        metrics_table.add_row("Stage 5 Regions", str(counts.get("stage5_regions", 0)))
+
+    # Add recall metrics if available
+    recall = global_metrics.get("recall")
+    if recall:
+        metrics_table.add_row("", "")  # separator
+        metrics_table.add_row("[bold yellow]Recall Metrics[/bold yellow]", "")
+        metrics_table.add_row("Total Queries with Recall", str(recall.get("total_queries", 0)))
+        metrics_table.add_row(
+            "Recall@1",
+            f"{recall.get('recall_at_1', 0):.4f} ({recall.get('hits_at_1', 0)}/{recall.get('total_queries', 0)})",
+        )
+        metrics_table.add_row(
+            "Recall@3",
+            f"{recall.get('recall_at_3', 0):.4f} ({recall.get('hits_at_3', 0)}/{recall.get('total_queries', 0)})",
+        )
+        metrics_table.add_row(
+            "Recall@5",
+            f"{recall.get('recall_at_5', 0):.4f} ({recall.get('hits_at_5', 0)}/{recall.get('total_queries', 0)})",
+        )
+        metrics_table.add_row(
+            "Recall@10",
+            f"{recall.get('recall_at_10', 0):.4f} ({recall.get('hits_at_10', 0)}/{recall.get('total_queries', 0)})",
+        )
+
+    console.print(metrics_table)
+
+    # Display sample of resolved examples
+    console.print("\n[bold cyan]═══ Sample Pages (first 20) ═══[/bold cyan]\n")
+
+    samples_table = Table(show_header=True, header_style="bold magenta", box=box.ROUNDED, show_lines=True)
+    samples_table.add_column("PDF Page", style="cyan", width=18)
+    samples_table.add_column("Status", style="yellow", width=12)
+    samples_table.add_column("Query", style="white", width=60)
+    samples_table.add_column("Stages", style="green", width=15)
+
+    for i, ex in enumerate(examples[:20]):
+        row = ex.row
+
+        # Determine status based on recall results if available
+        if ex.recall is not None:
+            if ex.recall.hit_at_10:
+                if ex.recall.hit_at_1:
+                    status = f"[green]✓ Hit@1[/green]"
+                elif ex.recall.hit_at_3:
+                    status = f"[yellow]✓ Hit@3[/yellow]"
+                else:
+                    status = f"[yellow]✓ Hit@10[/yellow]"
+            else:
+                status = "[red]✗ Miss[/red]"
+        else:
+            # Fallback to image existence check
+            status = "[green]✓ OK[/green]" if ex.image_path is not None else "[red]✗ MISS[/red]"
+
+        query = row.query[:57] + "..." if len(row.query) > 60 else row.query
+
+        if ex.image_path is not None and ex.image_path.exists():
+            paths = _paths_for_image(ex.image_path)
+            stages = []
+            if paths["stage2"].exists():
+                stages.append("2")
+            if paths["stage3"].exists():
+                stages.append("3")
+            if paths["stage4"].exists():
+                stages.append("4")
+            if paths["stage5"].exists():
+                stages.append("5")
+            stages_str = ",".join(stages) if stages else "none"
+        else:
+            stages_str = "n/a"
+
+        samples_table.add_row(row.pdf_page, status, query, stages_str)
+
+    if len(examples) > 20:
+        console.print(samples_table)
+        console.print(f"\n[dim]... and {len(examples) - 20} more entries[/dim]\n")
+    else:
+        console.print(samples_table)
+        console.print()
+
+    # Display detailed stats for a few random pages
+    console.print("[bold cyan]═══ Detailed Analysis (3 random pages) ═══[/bold cyan]\n")
+
+    import random
+
+    # Filter to pages that actually exist
+    existing_examples = [ex for ex in examples if ex.image_path is not None and ex.image_path.exists()]
+
+    if existing_examples:
+        sample_count = min(3, len(existing_examples))
+        sampled = random.sample(existing_examples, sample_count)
+
+        for ex in sampled:
+            summary = _format_summary_for_page(ex.image_path, ex.row)
+
+            # Create a panel for each page
+            details_lines = []
+            details_lines.append(f"[bold]PDF Page:[/bold] {ex.row.pdf_page}")
+            details_lines.append(f"[bold]Query:[/bold] {ex.row.query}")
+            details_lines.append(f"[bold]Image:[/bold] {ex.image_path}")
+
+            # Add recall information if available
+            if ex.recall:
+                details_lines.append("")
+                details_lines.append("[bold]Recall Results:[/bold]")
+                hit1 = "✓" if ex.recall.hit_at_1 else "✗"
+                hit3 = "✓" if ex.recall.hit_at_3 else "✗"
+                hit5 = "✓" if ex.recall.hit_at_5 else "✗"
+                hit10 = "✓" if ex.recall.hit_at_10 else "✗"
+                details_lines.append(f"  • Hit@1: {hit1} (rank: {ex.recall.rank_at_1 or 'N/A'})")
+                details_lines.append(f"  • Hit@3: {hit3} (rank: {ex.recall.rank_at_3 or 'N/A'})")
+                details_lines.append(f"  • Hit@5: {hit5} (rank: {ex.recall.rank_at_5 or 'N/A'})")
+                details_lines.append(f"  • Hit@10: {hit10} (rank: {ex.recall.rank_at_10 or 'N/A'})")
+                if ex.recall.top_10_retrieved:
+                    details_lines.append(f"  • Top 3 Retrieved: {', '.join(ex.recall.top_10_retrieved[:3])}")
+
+            details_lines.append("")
+
+            s2 = summary["stage2"]
+            s3 = summary["stage3"]
+            s4 = summary["stage4"]
+            s5 = summary["stage5"]
+
+            details_lines.append("[bold]Stage Presence:[/bold]")
+            details_lines.append(
+                f"  • Stage 2: {'✓' if s2.get('present') else '✗'} ({s2.get('num_detections', 0)} detections)"
+            )
+            details_lines.append(
+                f"  • Stage 3: {'✓' if s3.get('present') else '✗'} ({s3.get('num_regions', 0)} regions, {s3.get('num_detections', 0)} detections)"
+            )
+            details_lines.append(
+                f"  • Stage 4: {'✓' if s4.get('present') else '✗'} ({s4.get('num_regions', 0)} regions, {s4.get('num_detections', 0)} detections)"
+            )
+            details_lines.append(
+                f"  • Stage 5: {'✓' if s5.get('present') else '✗'} ({s5.get('num_regions', 0)} regions, {s5.get('num_nonempty', 0)} with text)"
+            )
+
+            if s5.get("sample_texts"):
+                details_lines.append("")
+                details_lines.append("[bold]OCR Sample Texts:[/bold]")
+                for t in s5["sample_texts"][:3]:
+                    truncated = t[:80] + "..." if len(t) > 80 else t
+                    details_lines.append(f"  • {truncated}")
+
+            pdfium = summary.get("pdfium_text", "")
+            if pdfium:
+                details_lines.append("")
+                details_lines.append("[bold]PDFium Text (preview):[/bold]")
+                preview = pdfium[:200] + "..." if len(pdfium) > 200 else pdfium
+                details_lines.append(f"  {preview}")
+
+            panel = Panel(
+                "\n".join(details_lines), title=f"[bold yellow]{ex.row.pdf_page}[/bold yellow]", border_style="blue"
+            )
+            console.print(panel)
+            console.print()
+    else:
+        console.print("[yellow]No existing pages found to analyze in detail.[/yellow]\n")
+
+    # Summary at the end
+    console.print("[bold green]═══ Analysis Complete ═══[/bold green]\n")
+    console.print(f"Processed {len(examples)} rows from CSV")
+    console.print(f"Successfully resolved {len(existing_examples)} pages with images")
+
+    if global_metrics.get("recall"):
+        recall = global_metrics["recall"]
+        console.print(f"\n[bold cyan]Recall Summary:[/bold cyan]")
+        console.print(f"  Recall@1:  {recall['recall_at_1']:.2%}")
+        console.print(f"  Recall@3:  {recall['recall_at_3']:.2%}")
+        console.print(f"  Recall@5:  {recall['recall_at_5']:.2%}")
+        console.print(f"  Recall@10: {recall['recall_at_10']:.2%}")
+    console.print()
+
+
+def _run_web_ui(*, examples: Sequence[ResolvedExample], global_metrics: Dict[str, Any], port: int = 8888) -> None:
+    """
+    Start a FastAPI web server to display the analysis in a browser.
+    """
+    try:
+        from fastapi import FastAPI, HTTPException
+        from fastapi.responses import HTMLResponse, FileResponse, JSONResponse
+        from fastapi.staticfiles import StaticFiles
+        import uvicorn
+        import base64
+    except ImportError:
+        console.print(
+            "[red]Error:[/red] FastAPI and uvicorn are required for --web-ui. Install with: pip install fastapi uvicorn"
+        )
+        raise typer.Exit(1)
+
+    app_fastapi = FastAPI(title="Retriever Stage999 Post-Mortem Analysis")
+
+    # Helper to get summary data for a specific index
+    def _get_example_data(idx: int) -> Dict[str, Any]:
+        if idx < 0 or idx >= len(examples):
+            return None
+
+        ex = examples[idx]
+        row = ex.row
+
+        result = {
+            "index": idx,
+            "pdf_page": row.pdf_page,
+            "query": row.query,
+            "modality": row.modality,
+            "status": "ok" if ex.image_path is not None else "missing",
+        }
+
+        # Add recall information if available
+        if ex.recall:
+            result["recall"] = {
+                "hit_at_1": ex.recall.hit_at_1,
+                "hit_at_3": ex.recall.hit_at_3,
+                "hit_at_5": ex.recall.hit_at_5,
+                "hit_at_10": ex.recall.hit_at_10,
+                "rank_at_1": ex.recall.rank_at_1,
+                "rank_at_3": ex.recall.rank_at_3,
+                "rank_at_5": ex.recall.rank_at_5,
+                "rank_at_10": ex.recall.rank_at_10,
+                "top_10_retrieved": ex.recall.top_10_retrieved,
+            }
+
+        if ex.image_path is None or not ex.image_path.exists():
+            return result
+
+        summary = _format_summary_for_page(ex.image_path, row)
+        paths = summary["paths"]
+
+        result.update(
+            {
+                "image_path": str(ex.image_path),
+                "has_overlay": paths["img_overlay"].exists(),
+                "has_pdfium": paths["pdfium_text"].exists(),
+                "pdfium_text": summary.get("pdfium_text", ""),
+                "embedder_input": (
+                    _read_text_best_effort(paths["embedder_input"]) if paths["embedder_input"].exists() else ""
+                ),
+                "stage2": summary["stage2"],
+                "stage3": summary["stage3"],
+                "stage4": summary["stage4"],
+                "stage5": summary["stage5"],
+                "raw": summary["raw"],
+            }
+        )
+
+        return result
+
+    @app_fastapi.get("/", response_class=HTMLResponse)
+    async def index():
+        html = """
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Retriever Stage999 Post-Mortem Analysis</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+            background: #f5f5f5;
+            display: flex;
+            height: 100vh;
+            overflow: hidden;
+        }
+
+        .sidebar {
+            width: 450px;
+            background: white;
+            border-right: 1px solid #ddd;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+
+        .sidebar-header {
+            padding: 20px;
+            border-bottom: 1px solid #ddd;
+        }
+
+        .sidebar-header h1 {
+            font-size: 18px;
+            margin-bottom: 15px;
+            color: #333;
+        }
+
+        .search-box {
+            width: 100%;
+            padding: 10px;
+            border: 1px solid #ddd;
+            border-radius: 4px;
+            font-size: 14px;
+        }
+
+        .metrics {
+            padding: 15px 20px;
+            background: #f9f9f9;
+            border-bottom: 1px solid #ddd;
+            font-size: 12px;
+            color: #666;
+        }
+
+        .metrics-grid {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 8px;
+        }
+
+        .metric-item {
+            display: flex;
+            justify-content: space-between;
+        }
+
+        .list-container {
+            flex: 1;
+            overflow-y: auto;
+        }
+
+        .list-item {
+            padding: 12px 20px;
+            border-bottom: 1px solid #eee;
+            cursor: pointer;
+            transition: background 0.2s;
+        }
+
+        .list-item:hover {
+            background: #f9f9f9;
+        }
+
+        .list-item.selected {
+            background: #e3f2fd;
+            border-left: 3px solid #2196F3;
+        }
+
+        .list-item-title {
+            font-size: 13px;
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 4px;
+        }
+
+        .list-item-query {
+            font-size: 12px;
+            color: #666;
+            overflow: hidden;
+            text-overflow: ellipsis;
+            white-space: nowrap;
+        }
+
+        .list-item-status {
+            display: inline-block;
+            padding: 2px 6px;
+            border-radius: 3px;
+            font-size: 11px;
+            font-weight: 600;
+            margin-left: 8px;
+        }
+
+        .list-item-status.ok {
+            background: #c8e6c9;
+            color: #2e7d32;
+        }
+
+        .list-item-status.missing {
+            background: #ffcdd2;
+            color: #c62828;
+        }
+
+        .main-content {
+            flex: 1;
+            display: flex;
+            flex-direction: column;
+            overflow: hidden;
+        }
+
+        .content-header {
+            padding: 20px;
+            background: white;
+            border-bottom: 1px solid #ddd;
+        }
+
+        .content-title {
+            font-size: 16px;
+            font-weight: 600;
+            color: #333;
+            margin-bottom: 8px;
+        }
+
+        .content-subtitle {
+            font-size: 13px;
+            color: #666;
+        }
+
+        .content-body {
+            flex: 1;
+            overflow-y: auto;
+            padding: 20px;
+        }
+
+        .images-row {
+            display: grid;
+            grid-template-columns: 1fr 1fr;
+            gap: 20px;
+            margin-bottom: 20px;
+        }
+
+        .image-container {
+            background: white;
+            padding: 15px;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+        }
+
+        .image-container img {
+            width: 100%;
+            height: auto;
+            border-radius: 4px;
+        }
+
+        .image-label {
+            font-size: 12px;
+            color: #666;
+            margin-top: 8px;
+            text-align: center;
+        }
+
+        .tabs {
+            background: white;
+            border-radius: 8px;
+            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+            overflow: hidden;
+        }
+
+        .tab-header {
+            display: flex;
+            border-bottom: 1px solid #ddd;
+        }
+
+        .tab-btn {
+            padding: 12px 20px;
+            border: none;
+            background: none;
+            cursor: pointer;
+            font-size: 13px;
+            font-weight: 500;
+            color: #666;
+            border-bottom: 3px solid transparent;
+            transition: all 0.2s;
+        }
+
+        .tab-btn:hover {
+            background: #f9f9f9;
+        }
+
+        .tab-btn.active {
+            color: #2196F3;
+            border-bottom-color: #2196F3;
+        }
+
+        .tab-content {
+            display: none;
+            padding: 20px;
+            max-height: 400px;
+            overflow-y: auto;
+        }
+
+        .tab-content.active {
+            display: block;
+        }
+
+        .tab-content pre {
+            font-size: 12px;
+            line-height: 1.5;
+            white-space: pre-wrap;
+            word-wrap: break-word;
+            color: #333;
+        }
+
+        .stage-summary {
+            font-size: 13px;
+            line-height: 1.8;
+            color: #333;
+        }
+
+        .stage-summary strong {
+            color: #2196F3;
+        }
+
+        .empty-state {
+            text-align: center;
+            padding: 60px 20px;
+            color: #999;
+        }
+
+        .empty-state-icon {
+            font-size: 48px;
+            margin-bottom: 16px;
+        }
+    </style>
+</head>
+<body>
+    <div class="sidebar">
+        <div class="sidebar-header">
+            <h1>📊 Post-Mortem Analysis</h1>
+            <input type="text" class="search-box" id="searchBox" placeholder="Search by query or pdf_page...">
+        </div>
+        <div class="metrics">
+            <div class="metrics-grid" id="metricsGrid">
+                <!-- Metrics will be populated here -->
+            </div>
+        </div>
+        <div class="list-container" id="listContainer">
+            <!-- List items will be populated here -->
+        </div>
+    </div>
+
+    <div class="main-content">
+        <div class="content-header">
+            <div class="content-title" id="contentTitle">Select an item to view details</div>
+            <div class="content-subtitle" id="contentSubtitle"></div>
+        </div>
+        <div class="content-body" id="contentBody">
+            <div class="empty-state">
+                <div class="empty-state-icon">📄</div>
+                <p>Select a page from the list to view its analysis</p>
+            </div>
+        </div>
+    </div>
+
+    <script>
+        let allExamples = [];
+        let filteredExamples = [];
+        let selectedIndex = -1;
+
+        async function init() {
+            try {
+                const response = await fetch('/api/list');
+                const data = await response.json();
+                allExamples = data.examples;
+                filteredExamples = [...allExamples];
+
+                renderMetrics(data.global_metrics);
+                renderList();
+
+                if (filteredExamples.length > 0) {
+                    selectItem(0);
+                }
+            } catch (error) {
+                console.error('Failed to load data:', error);
+            }
+        }
+
+        function renderMetrics(metrics) {
+            const grid = document.getElementById('metricsGrid');
+            const present = metrics.present || {};
+            const counts = metrics.counts || {};
+            const recall = metrics.recall || null;
+
+            let metricsHTML = `
+                <div class="metric-item"><span>Total Rows:</span><strong>${allExamples.length}</strong></div>
+                <div class="metric-item"><span>Unique Pages:</span><strong>${metrics.unique_pages}</strong></div>
+                <div class="metric-item"><span>Stage 2:</span><strong>${present.stage2 || 0}</strong></div>
+                <div class="metric-item"><span>Stage 3:</span><strong>${present.stage3 || 0}</strong></div>
+                <div class="metric-item"><span>Stage 4:</span><strong>${present.stage4 || 0}</strong></div>
+                <div class="metric-item"><span>Stage 5:</span><strong>${present.stage5 || 0}</strong></div>
+            `;
+
+            if (recall) {
+                metricsHTML += `
+                    <div class="metric-item" style="grid-column: 1 / -1; margin-top: 10px; padding-top: 10px; border-top: 1px solid #ddd;">
+                        <span style="font-weight: 600; color: #333;">Recall Metrics (${recall.total_queries} queries)</span>
+                    </div>
+                    <div class="metric-item"><span>Recall@1:</span><strong>${(recall.recall_at_1 * 100).toFixed(1)}%</strong></div>
+                    <div class="metric-item"><span>Recall@3:</span><strong>${(recall.recall_at_3 * 100).toFixed(1)}%</strong></div>
+                    <div class="metric-item"><span>Recall@5:</span><strong>${(recall.recall_at_5 * 100).toFixed(1)}%</strong></div>
+                    <div class="metric-item"><span>Recall@10:</span><strong>${(recall.recall_at_10 * 100).toFixed(1)}%</strong></div>
+                `;
+            }
+
+            grid.innerHTML = metricsHTML;
+        }
+
+        function renderList() {
+            const container = document.getElementById('listContainer');
+            container.innerHTML = '';
+
+            filteredExamples.forEach((ex, i) => {
+                const item = document.createElement('div');
+                item.className = 'list-item' + (i === selectedIndex ? ' selected' : '');
+                item.onclick = () => selectItem(i);
+
+                // Determine status based on recall if available
+                let statusClass, statusText;
+                if (ex.recall) {
+                    if (ex.recall.hit_at_10) {
+                        if (ex.recall.hit_at_1) {
+                            statusClass = 'ok';
+                            statusText = '✓ Hit@1';
+                        } else if (ex.recall.hit_at_3) {
+                            statusClass = 'ok';
+                            statusText = '✓ Hit@3';
+                        } else {
+                            statusClass = 'ok';
+                            statusText = '✓ Hit@10';
+                        }
+                    } else {
+                        statusClass = 'missing';
+                        statusText = '✗ Miss';
+                    }
+                } else {
+                    // Fallback to image existence
+                    statusClass = ex.status === 'ok' ? 'ok' : 'missing';
+                    statusText = ex.status === 'ok' ? 'OK' : 'MISS';
+                }
+
+                item.innerHTML = `
+                    <div class="list-item-title">
+                        ${ex.pdf_page}
+                        <span class="list-item-status ${statusClass}">${statusText}</span>
+                    </div>
+                    <div class="list-item-query">${ex.query}</div>
+                `;
+
+                container.appendChild(item);
+            });
+        }
+
+        async function selectItem(index) {
+            selectedIndex = index;
+            renderList();
+
+            const ex = filteredExamples[index];
+
+            document.getElementById('contentTitle').textContent = ex.query;
+            document.getElementById('contentSubtitle').textContent = `${ex.pdf_page}`;
+
+            if (ex.status !== 'ok') {
+                document.getElementById('contentBody').innerHTML = `
+                    <div class="empty-state">
+                        <div class="empty-state-icon">❌</div>
+                        <p>Image not found for this page</p>
+                    </div>
+                `;
+                return;
+            }
+
+            try {
+                const response = await fetch(`/api/details/${ex.index}`);
+                const data = await response.json();
+
+                renderDetails(data);
+            } catch (error) {
+                console.error('Failed to load details:', error);
+            }
+        }
+
+        function renderDetails(data) {
+            const body = document.getElementById('contentBody');
+
+            const imagesHTML = `
+                <div class="images-row">
+                    <div class="image-container">
+                        <img src="/api/image/${data.index}/main" alt="Page image">
+                        <div class="image-label">Original Page</div>
+                    </div>
+                    ${data.has_overlay ? `
+                        <div class="image-container">
+                            <img src="/api/image/${data.index}/overlay" alt="Overlay image">
+                            <div class="image-label">Detection Overlay</div>
+                        </div>
+                    ` : `
+                        <div class="image-container">
+                            <div class="empty-state">
+                                <div class="empty-state-icon">🖼️</div>
+                                <p>No overlay image</p>
+                            </div>
+                        </div>
+                    `}
+                </div>
+            `;
+
+            const s2 = data.stage2 || {};
+            const s3 = data.stage3 || {};
+            const s4 = data.stage4 || {};
+            const s5 = data.stage5 || {};
+
+            const summaryHTML = `
+                <div class="stage-summary">
+                    ${data.recall ? `
+                        <div style="margin-bottom: 15px; padding: 10px; background: #f0f7ff; border-left: 3px solid #2196F3; border-radius: 4px;">
+                            <strong style="color: #1976d2;">Recall Results:</strong><br>
+                            <span style="margin-left: 10px;">Hit@1: ${data.recall.hit_at_1 ? '✓' : '✗'} ${data.recall.rank_at_1 ? `(rank ${data.recall.rank_at_1})` : ''}</span><br>
+                            <span style="margin-left: 10px;">Hit@3: ${data.recall.hit_at_3 ? '✓' : '✗'} ${data.recall.rank_at_3 ? `(rank ${data.recall.rank_at_3})` : ''}</span><br>
+                            <span style="margin-left: 10px;">Hit@5: ${data.recall.hit_at_5 ? '✓' : '✗'} ${data.recall.rank_at_5 ? `(rank ${data.recall.rank_at_5})` : ''}</span><br>
+                            <span style="margin-left: 10px;">Hit@10: ${data.recall.hit_at_10 ? '✓' : '✗'} ${data.recall.rank_at_10 ? `(rank ${data.recall.rank_at_10})` : ''}</span><br>
+                            ${data.recall.top_10_retrieved && data.recall.top_10_retrieved.length > 0 ? `
+                                <span style="margin-left: 10px; margin-top: 5px; display: block;">
+                                    <strong>Top 3 Retrieved:</strong> ${data.recall.top_10_retrieved.slice(0, 3).join(', ')}
+                                </span>
+                            ` : ''}
+                        </div>
+                    ` : ''}
+
+                    <strong>Stage 2 (page_elements_v3):</strong>
+                    ${s2.present ? '✓' : '✗'}
+                    ${s2.num_detections || 0} detections
+                    ${s2.timing_s ? ` (${s2.timing_s.toFixed(2)}s)` : ''}<br>
+
+                    <strong>Stage 3 (graphic_elements_v1):</strong>
+                    ${s3.present ? '✓' : '✗'}
+                    ${s3.num_regions || 0} regions,
+                    ${s3.num_detections || 0} detections
+                    ${s3.timing_s ? ` (${s3.timing_s.toFixed(2)}s)` : ''}<br>
+
+                    <strong>Stage 4 (table_structure_v1):</strong>
+                    ${s4.present ? '✓' : '✗'}
+                    ${s4.num_regions || 0} regions,
+                    ${s4.num_detections || 0} detections
+                    ${s4.timing_s ? ` (${s4.timing_s.toFixed(2)}s)` : ''}<br>
+
+                    <strong>Stage 5 (nemotron_ocr_v1):</strong>
+                    ${s5.present ? '✓' : '✗'}
+                    ${s5.num_regions || 0} regions,
+                    ${s5.num_nonempty || 0} with text<br>
+
+                    ${s5.sample_texts && s5.sample_texts.length > 0 ? `
+                        <br><strong>OCR Samples:</strong><br>
+                        ${s5.sample_texts.map(t => `• ${t}`).join('<br>')}
+                    ` : ''}
+                </div>
+            `;
+
+            // Build recall HTML
+            const recallHTML = data.recall ? `
+                <div style="padding: 15px; font-family: monospace; line-height: 1.6;">
+                    <div style="margin-bottom: 20px;">
+                        <strong style="font-size: 16px;">PDF Page:</strong> ${data.pdf_page}<br>
+                        <strong style="font-size: 16px;">Query:</strong> ${data.query}
+                    </div>
+
+                    <div style="border-top: 2px solid #333; padding-top: 15px; margin-bottom: 15px;">
+                        <strong style="font-size: 18px; display: block; margin-bottom: 10px;">RECALL RESULTS</strong>
+                    </div>
+
+                    <div style="margin-bottom: 20px;">
+                        <strong style="display: block; margin-bottom: 8px;">Hit Status:</strong>
+                        <div style="margin-left: 20px;">
+                            • Hit@1:  <strong style="color: ${data.recall.hit_at_1 ? '#2e7d32' : '#c62828'};">${data.recall.hit_at_1 ? '✓ YES' : '✗ NO'}</strong>
+                            (Rank: ${data.recall.rank_at_1 || 'N/A'})<br>
+                            • Hit@3:  <strong style="color: ${data.recall.hit_at_3 ? '#2e7d32' : '#c62828'};">${data.recall.hit_at_3 ? '✓ YES' : '✗ NO'}</strong>
+                            (Rank: ${data.recall.rank_at_3 || 'N/A'})<br>
+                            • Hit@5:  <strong style="color: ${data.recall.hit_at_5 ? '#2e7d32' : '#c62828'};">${data.recall.hit_at_5 ? '✓ YES' : '✗ NO'}</strong>
+                            (Rank: ${data.recall.rank_at_5 || 'N/A'})<br>
+                            • Hit@10: <strong style="color: ${data.recall.hit_at_10 ? '#2e7d32' : '#c62828'};">${data.recall.hit_at_10 ? '✓ YES' : '✗ NO'}</strong>
+                            (Rank: ${data.recall.rank_at_10 || 'N/A'})
+                        </div>
+                    </div>
+
+                    <div style="padding: 12px; background: ${data.recall.hit_at_1 ? '#c8e6c9' : data.recall.hit_at_10 ? '#fff3cd' : '#ffcdd2'};
+                                border-radius: 4px; margin-bottom: 20px; border-left: 4px solid ${data.recall.hit_at_1 ? '#2e7d32' : data.recall.hit_at_10 ? '#f57c00' : '#c62828'};">
+                        <strong>VERDICT:</strong>
+                        ${data.recall.hit_at_1 ? '✓ Perfect hit at rank 1' :
+                          data.recall.hit_at_3 ? '⚠ Good hit in top 3' :
+                          data.recall.hit_at_5 ? '⚠ Acceptable hit in top 5' :
+                          data.recall.hit_at_10 ? '⚠ Weak hit in top 10' :
+                          '✗ MISS - Not found in top 10 results'}
+                    </div>
+
+                    ${data.recall.top_10_retrieved && data.recall.top_10_retrieved.length > 0 ? `
+                        <div style="border-top: 2px solid #333; padding-top: 15px; margin-bottom: 15px;">
+                            <strong style="font-size: 18px; display: block; margin-bottom: 10px;">TOP 10 RETRIEVED PAGES</strong>
+                        </div>
+                        <div style="margin-left: 20px;">
+                            ${data.recall.top_10_retrieved.slice(0, 10).map((page, i) => `
+                                <div style="margin-bottom: 4px; ${page === data.pdf_page ? 'background: #ffffcc; padding: 4px; border-left: 3px solid #f57c00;' : ''}">
+                                    ${page === data.pdf_page ? '→' : ' '} Rank ${String(i + 1).padStart(2)}: ${page}
+                                </div>
+                            `).join('')}
+                        </div>
+                        <div style="margin-top: 15px; padding: 10px; background: #f5f5f5; border-radius: 4px;">
+                            ${data.pdf_page && data.recall.top_10_retrieved.includes(data.pdf_page) ?
+                                `Correct answer '<strong>${data.pdf_page}</strong>' found at rank <strong>${data.recall.top_10_retrieved.indexOf(data.pdf_page) + 1}</strong>` :
+                                `Correct answer '<strong>${data.pdf_page}</strong>' <span style="color: #c62828;">NOT in top 10</span>`
+                            }
+                        </div>
+                    ` : ''}
+                </div>
+            ` : `
+                <div style="padding: 20px; text-align: center; color: #666;">
+                    <p>No recall results available for this query.</p>
+                    <p style="margin-top: 10px; font-size: 14px;">Provide a recall results CSV file using --recall-results-csv option to see recall analysis.</p>
+                </div>
+            `;
+
+            const tabsHTML = `
+                <div class="tabs">
+                    <div class="tab-header">
+                        <button class="tab-btn active" onclick="switchTab(0)">Summary</button>
+                        <button class="tab-btn" onclick="switchTab(1)">Recall</button>
+                        <button class="tab-btn" onclick="switchTab(2)">PDFium Text</button>
+                        <button class="tab-btn" onclick="switchTab(3)">Embedder Input</button>
+                        <button class="tab-btn" onclick="switchTab(4)">Raw JSON</button>
+                    </div>
+                    <div class="tab-content active">${summaryHTML}</div>
+                    <div class="tab-content">${recallHTML}</div>
+                    <div class="tab-content"><pre>${data.pdfium_text || '(empty)'}</pre></div>
+                    <div class="tab-content"><pre>${data.embedder_input || '(empty)'}</pre></div>
+                    <div class="tab-content"><pre>${JSON.stringify(data.raw, null, 2)}</pre></div>
+                </div>
+            `;
+
+            body.innerHTML = imagesHTML + tabsHTML;
+        }
+
+        function switchTab(index) {
+            const btns = document.querySelectorAll('.tab-btn');
+            const contents = document.querySelectorAll('.tab-content');
+
+            btns.forEach((btn, i) => {
+                btn.classList.toggle('active', i === index);
+            });
+
+            contents.forEach((content, i) => {
+                content.classList.toggle('active', i === index);
+            });
+        }
+
+        function filterList() {
+            const query = document.getElementById('searchBox').value.toLowerCase();
+
+            if (!query) {
+                filteredExamples = [...allExamples];
+            } else {
+                filteredExamples = allExamples.filter(ex =>
+                    ex.pdf_page.toLowerCase().includes(query) ||
+                    ex.query.toLowerCase().includes(query)
+                );
+            }
+
+            selectedIndex = -1;
+            renderList();
+
+            if (filteredExamples.length > 0) {
+                selectItem(0);
+            } else {
+                document.getElementById('contentBody').innerHTML = `
+                    <div class="empty-state">
+                        <div class="empty-state-icon">🔍</div>
+                        <p>No results found</p>
+                    </div>
+                `;
+            }
+        }
+
+        document.getElementById('searchBox').addEventListener('input', filterList);
+
+        init();
+    </script>
+</body>
+</html>
+        """
+        return HTMLResponse(content=html)
+
+    @app_fastapi.get("/api/list")
+    async def api_list():
+        """Return list of all examples with basic info"""
+        examples_list = []
+        for i, ex in enumerate(examples):
+            examples_list.append(
+                {
+                    "index": i,
+                    "pdf_page": ex.row.pdf_page,
+                    "query": ex.row.query,
+                    "status": "ok" if ex.image_path is not None else "missing",
+                }
+            )
+
+        return JSONResponse(
+            {
+                "examples": examples_list,
+                "global_metrics": global_metrics,
+            }
+        )
+
+    @app_fastapi.get("/api/details/{index}")
+    async def api_details(index: int):
+        """Return detailed data for a specific example"""
+        data = _get_example_data(index)
+        if data is None:
+            raise HTTPException(status_code=404, detail="Example not found")
+        return JSONResponse(data)
+
+    @app_fastapi.get("/api/image/{index}/{image_type}")
+    async def api_image(index: int, image_type: str):
+        """Serve the image file for a specific example"""
+        if index < 0 or index >= len(examples):
+            raise HTTPException(status_code=404, detail="Example not found")
+
+        ex = examples[index]
+        if ex.image_path is None or not ex.image_path.exists():
+            raise HTTPException(status_code=404, detail="Image not found")
+
+        paths = _paths_for_image(ex.image_path)
+
+        if image_type == "main":
+            image_path = paths["img"]
+        elif image_type == "overlay":
+            image_path = paths["img_overlay"]
+        else:
+            raise HTTPException(status_code=400, detail="Invalid image type")
+
+        if not image_path.exists():
+            raise HTTPException(status_code=404, detail="Image file not found")
+
+        return FileResponse(image_path)
+
+    console.print(f"[bold green]Starting web UI server on port {port}...[/bold green]")
+    console.print(f"[cyan]Open your browser to: http://localhost:{port}[/cyan]")
+    console.print("[yellow]Press Ctrl+C to stop the server[/yellow]\n")
+
+    uvicorn.run(app_fastapi, host="0.0.0.0", port=port, log_level="info")
+
+
+def _run_ui(*, examples: Sequence[ResolvedExample], global_metrics: Dict[str, Any]) -> None:
+    # Tk is stdlib; pillow is project dependency.
+    import tkinter as tk
+    from tkinter import ttk
+
+    from PIL import Image, ImageTk
+
+    def _short(s: str, n: int = 90) -> str:
+        s = (s or "").replace("\n", " ").strip()
+        return (s[: n - 1] + "…") if len(s) > n else s
+
+    # Precompute list entries text (stable indices).
+    list_labels: List[str] = []
+    for ex in examples:
+        row = ex.row
+        # Use recall status if available, otherwise fallback to image existence
+        if ex.recall is not None:
+            if ex.recall.hit_at_10:
+                if ex.recall.hit_at_1:
+                    status = "✓ Hit@1"
+                elif ex.recall.hit_at_3:
+                    status = "✓ Hit@3"
+                else:
+                    status = "✓ Hit@10"
+            else:
+                status = "✗ Miss"
+        else:
+            status = "OK" if ex.image_path is not None else "MISSING"
+        list_labels.append(f"{row.pdf_page} [{status}]  |  {_short(row.query)}")
+
+    # Cache for loaded page summaries to keep UI snappy.
+    summary_cache: Dict[int, Dict[str, Any]] = {}
+
+    root = tk.Tk()
+    root.title("retriever stage999 post-mortem analysis")
+
+    # Layout: left search+list, right detail panel.
+    root.columnconfigure(0, weight=0)
+    root.columnconfigure(1, weight=1)
+    root.rowconfigure(0, weight=1)
+
+    left = ttk.Frame(root, padding=8)
+    left.grid(row=0, column=0, sticky="nsw")
+    left.rowconfigure(2, weight=1)
+
+    right = ttk.Frame(root, padding=8)
+    right.grid(row=0, column=1, sticky="nsew")
+    right.columnconfigure(0, weight=1)
+    right.rowconfigure(2, weight=1)
+
+    # Search + global metrics
+    ttk.Label(left, text="Search (query or pdf_page):").grid(row=0, column=0, sticky="w")
+    search_var = tk.StringVar()
+    search_entry = ttk.Entry(left, textvariable=search_var, width=42)
+    search_entry.grid(row=1, column=0, sticky="ew", pady=(0, 8))
+
+    gm = global_metrics
+    gm_text = (
+        f"unique_pages={gm.get('unique_pages')} missing_images={gm.get('missing_images')}\n"
+        f"present: s2={gm.get('present', {}).get('stage2')} s3={gm.get('present', {}).get('stage3')} "
+        f"s4={gm.get('present', {}).get('stage4')} s5={gm.get('present', {}).get('stage5')} "
+        f"pdfium={gm.get('present', {}).get('pdfium_text')} overlay={gm.get('present', {}).get('overlay')}"
+    )
+
+    # Add recall metrics if available
+    recall = gm.get("recall")
+    if recall:
+        gm_text += (
+            f"\n\nRecall Metrics ({recall.get('total_queries')} queries):\n"
+            f"R@1={recall.get('recall_at_1', 0):.3f} R@3={recall.get('recall_at_3', 0):.3f} "
+            f"R@5={recall.get('recall_at_5', 0):.3f} R@10={recall.get('recall_at_10', 0):.3f}"
+        )
+
+    ttk.Label(left, text=gm_text, justify="left").grid(row=3, column=0, sticky="ew", pady=(8, 0))
+
+    # Listbox with scrollbar
+    list_frame = ttk.Frame(left)
+    list_frame.grid(row=2, column=0, sticky="nsew")
+    list_frame.rowconfigure(0, weight=1)
+    list_frame.columnconfigure(0, weight=1)
+
+    lb = tk.Listbox(list_frame, width=54, height=28, activestyle="dotbox")
+    sb = ttk.Scrollbar(list_frame, orient="vertical", command=lb.yview)
+    lb.configure(yscrollcommand=sb.set)
+    lb.grid(row=0, column=0, sticky="nsew")
+    sb.grid(row=0, column=1, sticky="ns")
+
+    # Right panel widgets
+    query_lbl = ttk.Label(right, text="", wraplength=820, justify="left")
+    query_lbl.grid(row=0, column=0, sticky="ew")
+
+    path_lbl = ttk.Label(right, text="", justify="left")
+    path_lbl.grid(row=1, column=0, sticky="ew", pady=(2, 8))
+
+    # Images row
+    img_row = ttk.Frame(right)
+    img_row.grid(row=2, column=0, sticky="nsew")
+    img_row.columnconfigure(0, weight=1)
+    img_row.columnconfigure(1, weight=1)
+    img_row.rowconfigure(0, weight=1)
+
+    img_lbl = ttk.Label(img_row)
+    img_lbl.grid(row=0, column=0, sticky="nsew", padx=(0, 6))
+    overlay_lbl = ttk.Label(img_row)
+    overlay_lbl.grid(row=0, column=1, sticky="nsew", padx=(6, 0))
+
+    # Text notebook
+    nb = ttk.Notebook(right)
+    nb.grid(row=3, column=0, sticky="nsew", pady=(8, 0))
+    right.rowconfigure(3, weight=1)
+
+    def _make_text_tab(title: str) -> tk.Text:
+        frame = ttk.Frame(nb)
+        frame.rowconfigure(0, weight=1)
+        frame.columnconfigure(0, weight=1)
+        t = tk.Text(frame, wrap="word")
+        s = ttk.Scrollbar(frame, orient="vertical", command=t.yview)
+        t.configure(yscrollcommand=s.set)
+        t.grid(row=0, column=0, sticky="nsew")
+        s.grid(row=0, column=1, sticky="ns")
+        nb.add(frame, text=title)
+        return t
+
+    pdfium_text = _make_text_tab("PDFium text")
+    det_text = _make_text_tab("Detections / OCR / metrics")
+    recall_text = _make_text_tab("Recall Results")
+    embedder_input_text = _make_text_tab("Embedder input")
+    raw_text = _make_text_tab("Raw JSON")
+
+    # Keep references to images to prevent GC.
+    img_refs: Dict[str, Any] = {"img": None, "overlay": None}
+
+    def _set_text(widget: tk.Text, content: str) -> None:
+        widget.configure(state="normal")
+        widget.delete("1.0", "end")
+        widget.insert("1.0", content or "")
+        widget.configure(state="disabled")
+
+    def _pretty_json(obj: Any, *, limit_chars: int = 250_000) -> str:
+        if obj is None:
+            return ""
+        try:
+            s = json.dumps(obj, ensure_ascii=False, indent=2, sort_keys=True)
+        except Exception:
+            s = str(obj)
+        if len(s) > int(limit_chars):
+            s = s[: int(limit_chars)] + "\n... (truncated) ...\n"
+        return s
+
+    def _render_image_to_label(label: ttk.Label, path: Optional[Path]) -> None:
+        if path is None or (not path.exists()):
+            label.configure(image="", text="(missing)", anchor="center")
+            return
+        try:
+            with Image.open(path) as im:
+                im = im.convert("RGB")
+                # Fit to a reasonable UI size
+                max_w, max_h = 520, 520
+                w, h = im.size
+                scale = min(max_w / max(1, w), max_h / max(1, h), 1.0)
+                nw, nh = max(1, int(w * scale)), max(1, int(h * scale))
+                im = im.resize((nw, nh), Image.BILINEAR)
+                photo = ImageTk.PhotoImage(im)
+        except Exception:
+            label.configure(image="", text="(failed to load image)", anchor="center")
+            return
+        label.configure(image=photo, text="")
+        # Store reference
+        if label is img_lbl:
+            img_refs["img"] = photo
+        else:
+            img_refs["overlay"] = photo
+
+    def _summary_text(summary: Dict[str, Any], ex: ResolvedExample) -> str:
+        row: QueryRow = summary["row"]
+        paths: Dict[str, Path] = summary["paths"]
+        lines: List[str] = []
+        lines.append(f"pdf_page: {row.pdf_page}")
+        lines.append(f"image: {paths['img']}")
+        lines.append(f"overlay present: {paths['img_overlay'].exists()}")
+        lines.append(f"pdfium_text file: {paths['pdfium_text']} (exists={paths['pdfium_text'].exists()})")
+
+        # Add recall information if available
+        if ex.recall:
+            lines.append("")
+            lines.append("Recall Results:")
+            hit1 = "✓" if ex.recall.hit_at_1 else "✗"
+            hit3 = "✓" if ex.recall.hit_at_3 else "✗"
+            hit5 = "✓" if ex.recall.hit_at_5 else "✗"
+            hit10 = "✓" if ex.recall.hit_at_10 else "✗"
+            lines.append(f"- Hit@1: {hit1} (rank: {ex.recall.rank_at_1 or 'N/A'})")
+            lines.append(f"- Hit@3: {hit3} (rank: {ex.recall.rank_at_3 or 'N/A'})")
+            lines.append(f"- Hit@5: {hit5} (rank: {ex.recall.rank_at_5 or 'N/A'})")
+            lines.append(f"- Hit@10: {hit10} (rank: {ex.recall.rank_at_10 or 'N/A'})")
+            if ex.recall.top_10_retrieved:
+                lines.append(f"- Top 3 Retrieved: {', '.join(ex.recall.top_10_retrieved[:3])}")
+
+        lines.append("")
+
+        s2 = summary["stage2"]
+        s3 = summary["stage3"]
+        s4 = summary["stage4"]
+        s5 = summary["stage5"]
+        lines.append("Model / stage summary:")
+        lines.append(
+            f"- stage2 page_elements_v3: present={s2.get('present')} dets={s2.get('num_detections', 0)} timing_s={s2.get('timing_s')}"
+        )
+        if s2.get("by_label"):
+            lines.append("  label counts: " + ", ".join([f"{k}={v}" for k, v in list(s2["by_label"].items())[:12]]))
+        lines.append(
+            f"- stage3 graphic_elements_v1: present={s3.get('present')} regions={s3.get('num_regions', 0)} dets={s3.get('num_detections', 0)} timing_s={s3.get('timing_s')}"
+        )
+        lines.append(
+            f"- stage4 table_structure_v1: present={s4.get('present')} regions={s4.get('num_regions', 0)} dets={s4.get('num_detections', 0)} timing_s={s4.get('timing_s')}"
+        )
+        lines.append(
+            f"- stage5 nemotron_ocr_v1: present={s5.get('present')} regions={s5.get('num_regions', 0)} nonempty={s5.get('num_nonempty', 0)}"
+        )
+        if s5.get("by_label_name"):
+            lines.append(
+                "  region kinds: " + ", ".join([f"{k}={v}" for k, v in list(s5["by_label_name"].items())[:12]])
+            )
+        if s5.get("sample_texts"):
+            lines.append("")
+            lines.append("OCR sample texts:")
+            for t in s5["sample_texts"]:
+                lines.append(f"- {t}")
+        return "\n".join(lines).strip() + "\n"
+
+    def _get_summary_for_index(idx: int) -> Optional[Dict[str, Any]]:
+        if idx in summary_cache:
+            return summary_cache[idx]
+        ex = examples[idx]
+        if ex.image_path is None or (not ex.image_path.exists()):
+            return None
+        summary = _format_summary_for_page(ex.image_path, ex.row)
+        summary_cache[idx] = summary
+        return summary
+
+    # Filtering state: listbox shows only indices in `visible`.
+    visible: List[int] = list(range(len(examples)))
+
+    def _apply_filter() -> None:
+        nonlocal visible
+        q = (search_var.get() or "").strip().lower()
+        if not q:
+            visible = list(range(len(examples)))
+        else:
+            out: List[int] = []
+            for i, ex in enumerate(examples):
+                hay = f"{ex.row.pdf_page} {ex.row.query}".lower()
+                if q in hay:
+                    out.append(i)
+            visible = out
+
+        lb.delete(0, "end")
+        for i in visible:
+            lb.insert("end", list_labels[i])
+        if visible:
+            lb.selection_clear(0, "end")
+            lb.selection_set(0)
+            lb.event_generate("<<ListboxSelect>>")
+
+    def _on_select(_evt=None) -> None:
+        sel = lb.curselection()
+        if not sel:
+            return
+        vis_pos = int(sel[0])
+        idx = visible[vis_pos]
+        ex = examples[idx]
+        row = ex.row
+        query_lbl.configure(text=f"Query: {row.query}")
+        if ex.image_path is None:
+            path_lbl.configure(text=f"{row.pdf_page}  |  (image not found in input_dir)")
+            _render_image_to_label(img_lbl, None)
+            _render_image_to_label(overlay_lbl, None)
+            _set_text(pdfium_text, "")
+            _set_text(det_text, "")
+            _set_text(recall_text, "")
+            _set_text(embedder_input_text, "")
+            _set_text(raw_text, "")
+            return
+
+        paths = _paths_for_image(ex.image_path)
+        path_lbl.configure(text=f"{row.pdf_page}  |  {ex.image_path}")
+
+        _render_image_to_label(img_lbl, paths["img"])
+        _render_image_to_label(overlay_lbl, paths["img_overlay"] if paths["img_overlay"].exists() else None)
+
+        s = _get_summary_for_index(idx)
+        if s is None:
+            _set_text(pdfium_text, "")
+            _set_text(det_text, "")
+            _set_text(recall_text, "")
+            _set_text(embedder_input_text, "")
+            _set_text(raw_text, "")
+            return
+        _set_text(pdfium_text, s.get("pdfium_text") or "")
+        _set_text(det_text, _summary_text(s, ex))
+
+        # Populate recall tab
+        if ex.recall:
+            recall_lines = []
+            recall_lines.append(f"PDF Page: {ex.row.pdf_page}")
+            recall_lines.append(f"Query: {ex.row.query}")
+            recall_lines.append("")
+            recall_lines.append("=" * 80)
+            recall_lines.append("RECALL RESULTS")
+            recall_lines.append("=" * 80)
+            recall_lines.append("")
+
+            # Hit status with visual indicators
+            recall_lines.append("Hit Status:")
+            recall_lines.append(
+                f"  • Hit@1:  {'✓ YES' if ex.recall.hit_at_1 else '✗ NO':10}  (Rank: {ex.recall.rank_at_1 if ex.recall.rank_at_1 else 'N/A'})"
+            )
+            recall_lines.append(
+                f"  • Hit@3:  {'✓ YES' if ex.recall.hit_at_3 else '✗ NO':10}  (Rank: {ex.recall.rank_at_3 if ex.recall.rank_at_3 else 'N/A'})"
+            )
+            recall_lines.append(
+                f"  • Hit@5:  {'✓ YES' if ex.recall.hit_at_5 else '✗ NO':10}  (Rank: {ex.recall.rank_at_5 if ex.recall.rank_at_5 else 'N/A'})"
+            )
+            recall_lines.append(
+                f"  • Hit@10: {'✓ YES' if ex.recall.hit_at_10 else '✗ NO':10}  (Rank: {ex.recall.rank_at_10 if ex.recall.rank_at_10 else 'N/A'})"
+            )
+            recall_lines.append("")
+
+            # Summary verdict
+            if ex.recall.hit_at_1:
+                recall_lines.append("✓ VERDICT: Perfect hit at rank 1")
+            elif ex.recall.hit_at_3:
+                recall_lines.append("⚠ VERDICT: Good hit in top 3")
+            elif ex.recall.hit_at_5:
+                recall_lines.append("⚠ VERDICT: Acceptable hit in top 5")
+            elif ex.recall.hit_at_10:
+                recall_lines.append("⚠ VERDICT: Weak hit in top 10")
+            else:
+                recall_lines.append("✗ VERDICT: MISS - Not found in top 10 results")
+            recall_lines.append("")
+
+            # Top 10 retrieved pages
+            if ex.recall.top_10_retrieved:
+                recall_lines.append("=" * 80)
+                recall_lines.append("TOP 10 RETRIEVED PAGES")
+                recall_lines.append("=" * 80)
+                recall_lines.append("")
+                for i, page in enumerate(ex.recall.top_10_retrieved[:10], 1):
+                    marker = "→" if page == ex.row.pdf_page else " "
+                    recall_lines.append(f"  {marker} Rank {i:2d}: {page}")
+                recall_lines.append("")
+
+                # Highlight where the correct answer is
+                if ex.row.pdf_page in ex.recall.top_10_retrieved:
+                    rank = ex.recall.top_10_retrieved.index(ex.row.pdf_page) + 1
+                    recall_lines.append(f"Correct answer '{ex.row.pdf_page}' found at rank {rank}")
+                else:
+                    recall_lines.append(f"Correct answer '{ex.row.pdf_page}' NOT in top 10")
+
+            _set_text(recall_text, "\n".join(recall_lines))
+        else:
+            _set_text(
+                recall_text,
+                "No recall results available for this query.\n\nProvide a recall results CSV file using --recall-results-csv option to see recall analysis.",
+            )
+
+        embed_path = paths.get("embedder_input")
+        if isinstance(embed_path, Path) and embed_path.exists():
+            _set_text(embedder_input_text, _read_text_best_effort(embed_path) + "\n")
+        else:
+            _set_text(embedder_input_text, "")
+        raw = s.get("raw") or {}
+        raw_blob = "\n\n".join(
+            [
+                f"## stage2: {paths['stage2']} (exists={paths['stage2'].exists()})\n{_pretty_json(raw.get('stage2'))}",
+                f"## stage3: {paths['stage3']} (exists={paths['stage3'].exists()})\n{_pretty_json(raw.get('stage3'))}",
+                f"## stage4: {paths['stage4']} (exists={paths['stage4'].exists()})\n{_pretty_json(raw.get('stage4'))}",
+                f"## stage5: {paths['stage5']} (exists={paths['stage5'].exists()})\n{_pretty_json(raw.get('stage5'))}",
+            ]
+        ).strip()
+        _set_text(raw_text, raw_blob + ("\n" if raw_blob else ""))
+
+    def _export_current_to_pdf() -> None:
+        # Minimal UX: export the currently selected page only to a PDF adjacent to input_dir.
+        sel = lb.curselection()
+        if not sel:
+            return
+        idx = visible[int(sel[0])]
+        ex = examples[idx]
+        if ex.image_path is None:
+            return
+        out = ex.image_path.parent / f"{ex.row.pdf_page}.post_mortem.pdf"
+        _export_report_pdf(examples=[ex], output_pdf=out, recursive=recursive)
+        console.print(f"[green]Exported[/green] {out}")
+
+    btns = ttk.Frame(left)
+    btns.grid(row=4, column=0, sticky="ew", pady=(10, 0))
+    ttk.Button(btns, text="Export selected PDF", command=_export_current_to_pdf).grid(row=0, column=0, sticky="ew")
+
+    search_var.trace_add("write", lambda *_: _apply_filter())
+    lb.bind("<<ListboxSelect>>", _on_select)
+
+    _apply_filter()
+    search_entry.focus_set()
+    root.mainloop()
+
+
+@app.command()
+def run(
+    input_dir: Path = typer.Option(..., "--input-dir", exists=True, file_okay=False, dir_okay=True),
+    csv_path: Path = typer.Option(
+        Path("./bo767_query_gt.csv"),
+        "--csv-path",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        help="CSV containing query -> pdf_page mappings (expects columns like query,pdf,page,pdf_page).",
+    ),
+    recursive: bool = typer.Option(True, "--recursive/--no-recursive", help="Scan subdirectories for images."),
+    export_pdf: Optional[Path] = typer.Option(
+        None,
+        "--export-pdf",
+        help="If set, exports a multi-page PDF report (one PDF page per unique resolved page) and exits unless --also-ui is set.",
+    ),
+    export_limit_unique_pages: Optional[int] = typer.Option(
+        None,
+        "--export-limit-unique-pages",
+        min=1,
+        help="Optional limit on number of unique pages included in the exported report.",
+    ),
+    gather_results: Optional[Path] = typer.Option(
+        None,
+        "--gather-results",
+        help="If set, writes a .zip containing all artifacts used by the UI (images, sidecars, text, overlays, embedder-input) plus a manifest.",
+    ),
+    gather_limit_unique_pages: Optional[int] = typer.Option(
+        None,
+        "--gather-limit-unique-pages",
+        min=1,
+        help="Optional limit on number of unique pages included in the gathered .zip.",
+    ),
+    also_ui: bool = typer.Option(False, "--also-ui", help="If --export-pdf is set, still open the UI after exporting."),
+    recall_results_csv: Optional[Path] = typer.Option(
+        None,
+        "--recall-results-csv",
+        help="Path to recall results CSV file from stage8. If provided, displays recall hit/miss status for each query.",
+    ),
+    headless: bool = typer.Option(
+        False,
+        "--headless",
+        help="Run in headless mode without GUI. Displays analysis in rich CLI format instead of opening interactive UI. If not set, automatically enables headless mode when no DISPLAY is available.",
+    ),
+    web_ui: bool = typer.Option(
+        False,
+        "--web-ui",
+        help="Start a web UI server (FastAPI) instead of the desktop UI. Access at http://localhost:8888",
+    ),
+    port: int = typer.Option(
+        8888,
+        "--port",
+        help="Port for the web UI server (only used with --web-ui).",
+    ),
+):
+    """
+    Default behavior: open an interactive UI viewer over pages referenced in the CSV.
+
+    If --export-pdf is provided, creates a shareable report PDF containing the same information.
+
+    If --headless is provided, runs without GUI and displays analysis in CLI format.
+
+    If --web-ui is provided, starts a FastAPI web server for browser-based viewing.
+    """
+    input_dir = Path(input_dir)
+    csv_path = Path(csv_path)
+
+    rows = _load_csv_rows(csv_path)
+    if not rows:
+        raise typer.BadParameter(f"No rows parsed from csv_path={csv_path}")
+
+    images = _iter_images(input_dir, recursive=recursive)
+    if not images:
+        console.print(f"[yellow]warning[/yellow] No images found under input_dir={input_dir} (recursive={recursive})")
+    by_name, by_stem = _index_images(images)
+
+    # Load recall results if provided
+    recall_map: Dict[str, RecallResult] = {}
+    if recall_results_csv is not None:
+        recall_results_csv = Path(recall_results_csv)
+        console.print(f"[cyan]Loading recall results from:[/cyan] {recall_results_csv}")
+        recall_map = _load_recall_results(recall_results_csv)
+        console.print(f"[green]Loaded recall data for {len(recall_map)} queries[/green]")
+
+    resolved: List[ResolvedExample] = []
+    for row in rows:
+        img = _resolve_image_for_row(row, by_stem=by_stem, by_name=by_name)
+        # Attach recall result if available
+        recall_result = recall_map.get(row.pdf_page)
+        resolved.append(ResolvedExample(row=row, image_path=img, recall=recall_result))
+
+    global_metrics = _compute_global_metrics(resolved)
+    console.print(
+        f"[bold cyan]Stage999[/bold cyan] rows={len(rows)} unique_pages={global_metrics.get('unique_pages')} "
+        f"missing_images={global_metrics.get('missing_images')} input_dir={input_dir} recursive={recursive}"
+    )
+
+    if export_pdf is not None:
+        out = Path(export_pdf)
+        console.print(f"[cyan]Exporting report[/cyan] output={out}")
+        _export_report_pdf(
+            examples=resolved,
+            output_pdf=out,
+            recursive=recursive,
+            limit_unique_pages=export_limit_unique_pages,
+        )
+        console.print(f"[green]Export complete[/green] output={out}")
+        if not also_ui:
+            return
+
+    if gather_results is not None:
+        out_zip = Path(gather_results)
+        if out_zip.suffix.lower() != ".zip":
+            out_zip = out_zip.with_suffix(out_zip.suffix + ".zip") if out_zip.suffix else out_zip.with_suffix(".zip")
+        console.print(f"[cyan]Gathering results[/cyan] output={out_zip}")
+        _gather_results_zip(
+            examples=resolved,
+            input_dir=input_dir,
+            csv_path=csv_path,
+            zip_path=out_zip,
+            recursive=recursive,
+            limit_unique_pages=gather_limit_unique_pages,
+        )
+        console.print(f"[green]Gather complete[/green] output={out_zip}")
+
+    # Choose display mode: headless CLI or interactive GUI
+    # Auto-detect headless environment if not explicitly set
+    if web_ui:
+        # Web UI mode takes precedence
+        _run_web_ui(examples=resolved, global_metrics=global_metrics, port=port)
+    elif not headless:
+        import os
+
+        # If no DISPLAY variable is set and headless not explicitly requested,
+        # automatically use headless mode
+        if not os.environ.get("DISPLAY"):
+            console.print("[yellow]No DISPLAY detected - automatically using headless mode[/yellow]")
+            headless = True
+
+    if headless and not web_ui:
+        _run_headless(examples=resolved, global_metrics=global_metrics)
+    elif not web_ui:
+        _run_ui(examples=resolved, global_metrics=global_metrics)
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/model/__init__.py b/nemo_retriever/src/nemo_retriever/model/__init__.py
new file mode 100644
index 000000000..dc763d548
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/__init__.py
@@ -0,0 +1,35 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+_VL_EMBED_MODEL_IDS = frozenset(
+    {
+        "nvidia/llama-nemotron-embed-vl-1b-v2",
+        "llama-nemotron-embed-vl-1b-v2",
+    }
+)
+
+# Short name → full HF repo ID.
+_EMBED_MODEL_ALIASES: dict[str, str] = {
+    "nemo_retriever_v1": "nvidia/llama-3.2-nv-embedqa-1b-v2",
+    "llama-nemotron-embed-vl-1b-v2": "nvidia/llama-nemotron-embed-vl-1b-v2",
+}
+
+_DEFAULT_EMBED_MODEL = "nvidia/llama-3.2-nv-embedqa-1b-v2"
+
+
+def resolve_embed_model(model_name: str | None) -> str:
+    """Resolve a model name/alias to a full HF repo ID.
+
+    Returns ``_DEFAULT_EMBED_MODEL`` when *model_name* is ``None`` or empty.
+    """
+    if not model_name:
+        return _DEFAULT_EMBED_MODEL
+    return _EMBED_MODEL_ALIASES.get(model_name, model_name)
+
+
+def is_vl_embed_model(model_name: str | None) -> bool:
+    """Return True if *model_name* refers to the VL embedding model."""
+    return resolve_embed_model(model_name) in _VL_EMBED_MODEL_IDS
diff --git a/nemo_retriever/src/nemo_retriever/model/local/__init__.py b/nemo_retriever/src/nemo_retriever/model/local/__init__.py
new file mode 100644
index 000000000..7fa66d3f7
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/__init__.py
@@ -0,0 +1,49 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Local model implementations for slim-gest.
+
+This module contains implementations of locally-runnable models that extend
+the BaseModel abstract class. Exports are lazy-loaded so that importing a
+single submodule (e.g. parakeet_ctc_1_1b_asr) does not pull in torch-dependent
+modules, allowing unit tests with minimal deps to run.
+"""
+
+__all__ = [
+    "NemotronPageElementsV3",
+    "NemotronOCRV1",
+    "NemotronTableStructureV1",
+    "NemotronGraphicElementsV1",
+    "NemotronParseV12",
+    "ParakeetCTC1B1ASR",
+]
+
+
+def __getattr__(name: str):
+    if name == "NemotronPageElementsV3":
+        from .nemotron_page_elements_v3 import NemotronPageElementsV3
+
+        return NemotronPageElementsV3
+    if name == "NemotronOCRV1":
+        from .nemotron_ocr_v1 import NemotronOCRV1
+
+        return NemotronOCRV1
+    if name == "NemotronTableStructureV1":
+        from .nemotron_table_structure_v1 import NemotronTableStructureV1
+
+        return NemotronTableStructureV1
+    if name == "NemotronGraphicElementsV1":
+        from .nemotron_graphic_elements_v1 import NemotronGraphicElementsV1
+
+        return NemotronGraphicElementsV1
+    if name == "NemotronParseV12":
+        from .nemotron_parse_v1_2 import NemotronParseV12
+
+        return NemotronParseV12
+    if name == "ParakeetCTC1B1ASR":
+        from .parakeet_ctc_1_1b_asr import ParakeetCTC1B1ASR
+
+        return ParakeetCTC1B1ASR
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
diff --git a/nemo_retriever/src/nemo_retriever/model/local/llama_nemotron_embed_1b_v2_embedder.py b/nemo_retriever/src/nemo_retriever/model/local/llama_nemotron_embed_1b_v2_embedder.py
new file mode 100644
index 000000000..dfd5a2a3a
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/llama_nemotron_embed_1b_v2_embedder.py
@@ -0,0 +1,111 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, Sequence
+
+import torch
+
+
+def _l2_normalize(x: torch.Tensor, eps: float = 1e-12) -> torch.Tensor:
+    x = x.float()
+    denom = x.norm(p=2, dim=-1, keepdim=True).clamp_min(eps)
+    return x / denom
+
+
+@dataclass
+class LlamaNemotronEmbed1BV2Embedder:
+    """
+    Minimal embedder wrapper for local-only HuggingFace execution.
+
+    This intentionally contains **no remote invocation logic**.
+    """
+
+    device: Optional[str] = None
+    hf_cache_dir: Optional[str] = None
+    normalize: bool = True
+    # IMPORTANT: Some HF tokenizers set an effectively "infinite" model_max_length.
+    # If we rely on that, `truncation=True` may still allow extremely long sequences,
+    # which can explode attention-mask memory (O(seq_len^2)) and OOM the GPU.
+    # max_length: int = 4096
+    max_length: int = 8192
+    model_id: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        self._tokenizer = None
+        self._model = None
+        self._device = None
+
+        from transformers import AutoModel, AutoTokenizer
+
+        MODEL_ID = self.model_id or "nvidia/llama-3.2-nv-embedqa-1b-v2"
+        dev = torch.device(self.device or ("cuda" if torch.cuda.is_available() else "cpu"))
+        hf_cache_dir = self.hf_cache_dir or str(Path.home() / ".cache" / "huggingface")
+        self._tokenizer = AutoTokenizer.from_pretrained(MODEL_ID, cache_dir=hf_cache_dir)
+        self._model = AutoModel.from_pretrained(MODEL_ID, trust_remote_code=True, cache_dir=hf_cache_dir)
+        self._model = self._model.to(dev)
+        self._model.eval()
+        self._device = dev
+
+    @property
+    def is_remote(self) -> bool:
+        return False
+
+    def embed(self, texts: Sequence[str], *, batch_size: int = 64) -> torch.Tensor:
+        """
+        Returns a CPU tensor of shape [N, D].
+        """
+        texts_list = [str(t) for t in texts if str(t).strip()]
+        if not texts_list:
+            return torch.empty((0, 0), dtype=torch.float32)
+
+        return self._embed_local(texts_list, batch_size=batch_size)
+
+    def _embed_local(self, texts: List[str], *, batch_size: int) -> torch.Tensor:
+        if self._tokenizer is None or self._model is None or self._device is None:
+            raise RuntimeError("Local embedder was not initialized.")
+        dev = self._device
+
+        outs: List[torch.Tensor] = []
+        with torch.inference_mode():
+            with torch.autocast(device_type="cuda"):
+                for i in range(0, len(texts), max(1, int(batch_size))):
+                    chunk = texts[i : i + max(1, int(batch_size))]
+                    batch = self._tokenizer(
+                        chunk,
+                        padding=True,
+                        truncation=True,
+                        max_length=max(1, int(self.max_length)),
+                        return_tensors="pt",
+                    ).to(dev)
+                    out = self._model(**batch, output_hidden_states=True)
+                    # The bidirectional model returns BaseModelOutputWithPast
+                    # (last_hidden_state), but some transformers versions or
+                    # model revisions return CausalLMOutputWithPast (hidden_states).
+                    lhs = getattr(out, "last_hidden_state", None)
+                    if lhs is None:
+                        # CausalLMOutputWithPast: use the last layer's hidden state.
+                        hs = getattr(out, "hidden_states", None)
+                        if hs is not None:
+                            lhs = hs[-1]
+                        else:
+                            raise AttributeError(
+                                f"Model output ({type(out).__name__}) has neither "
+                                "'last_hidden_state' nor 'hidden_states'. "
+                                "Ensure the model is loaded with trust_remote_code=True."
+                            )
+                    # lhs shape: [B, S, D]
+                    mask = batch["attention_mask"].unsqueeze(-1)  # [B, S, 1]
+                    vec = (lhs * mask).sum(dim=1) / mask.sum(dim=1)  # [B, D]
+                    vec = vec.detach().to("cpu")
+                    if self.normalize:
+                        vec = _l2_normalize(vec)
+                    outs.append(vec)
+
+        return torch.cat(outs, dim=0) if outs else torch.empty((0, 0), dtype=torch.float32)
+
+    # Intentionally no remote embedding method.
diff --git a/nemo_retriever/src/nemo_retriever/model/local/llama_nemotron_embed_vl_1b_v2_embedder.py b/nemo_retriever/src/nemo_retriever/model/local/llama_nemotron_embed_vl_1b_v2_embedder.py
new file mode 100644
index 000000000..3e6c35fe7
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/llama_nemotron_embed_vl_1b_v2_embedder.py
@@ -0,0 +1,142 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional, Sequence
+
+import torch
+
+
+def _l2_normalize(x: torch.Tensor, eps: float = 1e-12) -> torch.Tensor:
+    x = x.float()
+    denom = x.norm(p=2, dim=-1, keepdim=True).clamp_min(eps)
+    return x / denom
+
+
+@dataclass
+class LlamaNemotronEmbedVL1BV2Embedder:
+    """
+    Multimodal embedder wrapper for ``nvidia/llama-nemotron-embed-vl-1b-v2``.
+
+    The VL model exposes ``encode_queries()`` and ``encode_documents()``
+    instead of the standard tokenizer + forward pass used by the embedqa
+    model.  This class supports text, image, and text+image modalities.
+    """
+
+    device: Optional[str] = None
+    hf_cache_dir: Optional[str] = None
+    model_id: Optional[str] = None
+
+    # Populated in __post_init__
+    _model: Any = field(default=None, init=False, repr=False)
+    _device: Any = field(default=None, init=False, repr=False)
+
+    def __post_init__(self) -> None:
+        from transformers import AutoModel
+
+        model_id = self.model_id or "nvidia/llama-nemotron-embed-vl-1b-v2"
+        dev = torch.device(self.device or ("cuda" if torch.cuda.is_available() else "cpu"))
+        hf_cache_dir = self.hf_cache_dir or str(Path.home() / ".cache" / "huggingface")
+
+        # flash_attention_2 requires the model on GPU at init time, so use
+        # device_map when requesting it.  Fall back to sdpa/eager on CPU or
+        # when flash-attn is not installed.
+        use_gpu = dev.type == "cuda"
+        for attn_impl in ("flash_attention_2", "sdpa", "eager"):
+            try:
+                kwargs: dict[str, Any] = {
+                    "trust_remote_code": True,
+                    "torch_dtype": torch.bfloat16,
+                    "attn_implementation": attn_impl,
+                    "cache_dir": hf_cache_dir,
+                }
+                if attn_impl == "flash_attention_2" and use_gpu:
+                    kwargs["device_map"] = dev
+                self._model = AutoModel.from_pretrained(model_id, **kwargs)
+                break
+            except (ValueError, ImportError):
+                if attn_impl == "eager":
+                    raise
+                continue
+
+        if not hasattr(self._model, "device_map"):
+            self._model = self._model.to(dev)
+        self._model.eval()
+        self._device = dev
+
+    @property
+    def is_remote(self) -> bool:
+        return False
+
+    def _set_p_max_length(self, modality: str) -> None:
+        _RECOMMENDED = {"text": 8192, "image": 2048, "text_image": 10240}
+        p = _RECOMMENDED.get(modality)
+        if p is not None and hasattr(self._model, "processor"):
+            self._model.processor.p_max_length = p
+
+    def embed(self, texts: Sequence[str], *, batch_size: int = 64) -> torch.Tensor:
+        """Embed document texts. Returns CPU tensor ``[N, 2048]``."""
+        texts_list = [str(t) for t in texts if str(t).strip()]
+        if not texts_list:
+            return torch.empty((0, 2048), dtype=torch.float32)
+        with torch.inference_mode():
+            self._set_p_max_length("text")
+            out = self._model.encode_documents(texts=texts_list)
+        if isinstance(out, torch.Tensor):
+            return _l2_normalize(out.detach().cpu())
+        return _l2_normalize(torch.as_tensor(out, dtype=torch.float32).cpu())
+
+    def embed_queries(self, texts: Sequence[str], *, batch_size: int = 64) -> torch.Tensor:
+        """Embed query strings. Returns CPU tensor ``[N, 2048]``."""
+        texts_list = [str(t) for t in texts]
+        if not texts_list:
+            return torch.empty((0, 2048), dtype=torch.float32)
+        with torch.inference_mode():
+            out = self._model.encode_queries(texts_list)
+        if isinstance(out, torch.Tensor):
+            return _l2_normalize(out.detach().cpu())
+        return _l2_normalize(torch.as_tensor(out, dtype=torch.float32).cpu())
+
+    def embed_images(self, images_b64: Sequence[str], *, batch_size: int = 64) -> torch.Tensor:
+        """Embed images (base64-encoded). Returns CPU tensor ``[N, 2048]``.
+
+        Entries where the image is None/empty are skipped; the returned tensor
+        only contains embeddings for valid images.
+        """
+        image_dicts = [{"base64": b64} for b64 in images_b64 if b64]
+        if not image_dicts:
+            return torch.empty((0, 2048), dtype=torch.float32)
+        with torch.inference_mode():
+            self._set_p_max_length("image")
+            out = self._model.encode_documents(images=image_dicts)
+        if isinstance(out, torch.Tensor):
+            return _l2_normalize(out.detach().cpu())
+        return _l2_normalize(torch.as_tensor(out, dtype=torch.float32).cpu())
+
+    def embed_text_image(
+        self, texts: Sequence[str], images_b64: Sequence[str], *, batch_size: int = 64
+    ) -> torch.Tensor:
+        """Embed paired text+image inputs. Returns CPU tensor ``[N, 2048]``.
+
+        *texts* and *images_b64* must be the same length.  Entries where the
+        image is None/empty are skipped; the returned tensor only contains
+        embeddings for valid pairs.
+        """
+        paired_texts: list[str] = []
+        paired_images: list[dict[str, str]] = []
+        for t, b64 in zip(texts, images_b64):
+            if b64:
+                paired_texts.append(str(t))
+                paired_images.append({"base64": b64})
+        if not paired_images:
+            return torch.empty((0, 2048), dtype=torch.float32)
+        with torch.inference_mode():
+            self._set_p_max_length("text_image")
+            out = self._model.encode_documents(texts=paired_texts, images=paired_images)
+        if isinstance(out, torch.Tensor):
+            return _l2_normalize(out.detach().cpu())
+        return _l2_normalize(torch.as_tensor(out, dtype=torch.float32).cpu())
diff --git a/nemo_retriever/src/nemo_retriever/model/local/nemotron_graphic_elements_v1.py b/nemo_retriever/src/nemo_retriever/model/local/nemotron_graphic_elements_v1.py
new file mode 100644
index 000000000..a22f2caa9
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/nemotron_graphic_elements_v1.py
@@ -0,0 +1,155 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Tuple, Union
+
+import torch
+from ..model import BaseModel, RunMode
+
+from nemotron_graphic_elements_v1.model import define_model as define_model_graphic_elements
+from nemotron_graphic_elements_v1.model import resize_pad as resize_pad_graphic_elements
+
+
+class NemotronGraphicElementsV1(BaseModel):
+    """
+    Nemotron Graphic Elements v1 model for detecting chart and graph elements.
+
+    Detects and extracts key elements from charts and graphs including:
+    - Chart titles
+    - X/Y axis titles and labels
+    - Legend titles and labels
+    - Marker labels
+    - Value labels
+    - Other text components
+
+    Note: Input should be a cropped chart image, typically obtained using
+    Nemotron Page Elements v3 model.
+    """
+
+    def __init__(
+        self,
+    ) -> None:
+        super().__init__()
+        self._model = define_model_graphic_elements(self.model_name)
+        self._graphic_elements_input_shape = (1024, 1024)
+
+    def preprocess(self, tensor: torch.Tensor) -> torch.Tensor:
+        """Preprocess the input tensor."""
+        # Upstream `nemotron_graphic_elements_v1.model.resize_pad` expects CHW.
+        # Our pipeline helpers often pass BCHW (typically B=1), so normalize here.
+        if not isinstance(tensor, torch.Tensor):
+            raise TypeError(f"Expected torch.Tensor, got {type(tensor)!r}")
+
+        x = tensor
+        if x.ndim == 4:
+            b = int(x.shape[0])
+            if b == 1:
+                y = resize_pad_graphic_elements(x[0], self.input_shape)
+                if not isinstance(y, torch.Tensor) or y.ndim != 3:
+                    raise ValueError(f"resize_pad produced unexpected output: {type(y)!r}")
+                return y.unsqueeze(0)
+            outs = []
+            for i in range(b):
+                y = resize_pad_graphic_elements(x[i], self.input_shape)
+                if not isinstance(y, torch.Tensor) or y.ndim != 3:
+                    raise ValueError(f"resize_pad produced unexpected output for batch item {i}: {type(y)!r}")
+                outs.append(y)
+            return torch.stack(outs, dim=0)
+
+        if x.ndim == 3:
+            y = resize_pad_graphic_elements(x, self.input_shape)
+            if not isinstance(y, torch.Tensor) or y.ndim != 3:
+                raise ValueError(f"resize_pad produced unexpected output: {type(y)!r}")
+            return y.unsqueeze(0)
+
+        raise ValueError(f"Expected CHW or BCHW tensor, got shape {tuple(x.shape)}")
+
+    def invoke(
+        self, input_data: torch.Tensor, orig_shape: Tuple[int, int]
+    ) -> Union[List[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]:
+        if self._model is None:
+            raise RuntimeError("Local graphic_elements_v1 model was not initialized.")
+
+        # Conditionally check and make sure the input data is on the correct device and shape
+        return self._model(input_data, orig_shape)[0]
+
+    @property
+    def model_name(self) -> str:
+        """Human-readable model name."""
+        return "Nemotron Graphic Elements v1"
+
+    @property
+    def model_type(self) -> str:
+        """Model category/type."""
+        return "object-detection"
+
+    @property
+    def model_runmode(self) -> RunMode:
+        """Execution mode: local, NIM, or build-endpoint."""
+        return "local"
+
+    @property
+    def input(self) -> Any:
+        """
+        Input schema for the model.
+
+        Returns:
+            dict: Schema describing RGB chart image input
+        """
+        return {
+            "type": "image",
+            "format": "RGB",
+            "dimensions": "(1024, 1024)",
+            "expected_content": "chart_or_graph",
+            "description": "Chart/graph image in RGB format, resized to 1024x1024. Should be cropped from document using page element detection.",  # noqa: E501
+            "preprocessing_recommendation": "Use Nemotron Page Elements v3 to detect and crop chart regions",
+        }
+
+    @property
+    def output(self) -> Any:
+        """
+        Output schema for the model.
+
+        Returns:
+            dict: Schema describing detection output format
+        """
+        return {
+            "type": "detection",
+            "format": "dict",
+            "structure": {
+                "boxes": "np.ndarray[N, 4] - normalized (x_min, y_min, x_max, y_max)",
+                "labels": "List[str] - class names",
+                "scores": "np.ndarray[N] - confidence scores",
+            },
+            "classes": [
+                "chart_title",
+                "x_title",
+                "y_title",
+                "xlabel",
+                "ylabel",
+                "legend_title",
+                "legend_label",
+                "mark_label",
+                "value_label",
+                "other",
+            ],
+            "post_processing": {"conf_thresh": 0.01, "iou_thresh": 0.25},
+            "use_cases": [
+                "Chart-to-text conversion",
+                "Data extraction from visualizations",
+                "Automated chart understanding",
+                "Multimodal RAG workflows",
+            ],
+            "supported_chart_types": ["bar_charts", "line_charts", "pie_charts", "scientific_plots"],
+        }
+
+    @property
+    def input_batch_size(self) -> int:
+        """Maximum or default input batch size."""
+        return 1
+
+    @property
+    def input_shape(self) -> Tuple[int, int]:
+        """Input shape."""
+        return self._graphic_elements_input_shape
diff --git a/nemo_retriever/src/nemo_retriever/model/local/nemotron_ocr_v1.py b/nemo_retriever/src/nemo_retriever/model/local/nemotron_ocr_v1.py
new file mode 100644
index 000000000..3bbf41e9e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/nemotron_ocr_v1.py
@@ -0,0 +1,266 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Optional, Tuple, Union  # noqa: F401
+
+import base64
+import io
+import os
+from pathlib import Path  # noqa: F401
+
+import numpy as np
+import torch
+from ..model import BaseModel, RunMode
+
+from PIL import Image
+
+
+class NemotronOCRV1(BaseModel):
+    """
+    Nemotron OCR v1 model for optical character recognition.
+
+    End-to-end OCR model that integrates:
+    - Text detector for region localization
+    - Text recognizer for transcription
+    - Relational model for layout and reading order analysis
+    """
+
+    def __init__(
+        self,
+        model_dir: Optional[str] = None,
+    ) -> None:
+        super().__init__()
+        from nemotron_ocr.inference.pipeline import NemotronOCR  # local-only import
+
+        if model_dir:
+            self._model = NemotronOCR(model_dir=model_dir)
+        else:
+            self._model = NemotronOCR()
+        # NemotronOCR is a high-level pipeline (not an nn.Module). We can optionally
+        # TensorRT-compile individual submodules (e.g. the detector backbone) but
+        # must keep post-processing (NMS, box decoding, etc.) in eager PyTorch/C++.
+        self._enable_trt = os.getenv("RETRIEVER_ENABLE_TORCH_TRT", "").strip().lower() in {"1", "true", "yes", "on"}
+        if self._enable_trt and self._model is not None:
+            self._maybe_compile_submodules()
+
+    def _maybe_compile_submodules(self) -> None:
+        """
+        Best-effort TensorRT compilation of internal nn.Modules.
+        Any failure falls back to eager PyTorch without breaking initialization.
+        """
+        try:
+            import torch_tensorrt  # type: ignore
+        except Exception:
+            return
+
+        # Detector is the safest candidate: input is a BCHW image tensor.
+        if self._model is None:
+            return
+
+        detector = getattr(self._model, "detector", None)
+        if not isinstance(detector, torch.nn.Module):
+            return
+
+        # NemotronOCR internally resizes/pads to 1024 and runs B=1 (see upstream FIXME);
+        # keep the TRT input shape fixed to avoid accidental batching issues.
+        try:
+            trt_input = torch_tensorrt.Input((1, 3, 1024, 1024), dtype=torch.float16)
+        except TypeError:
+            # Older/newer API variants: fall back to named arg.
+            trt_input = torch_tensorrt.Input(shape=(1, 3, 1024, 1024), dtype=torch.float16)
+
+        # If any torchvision NMS makes it into a compiled graph elsewhere, forcing
+        # that op to run in Torch avoids hard failures.
+        compile_kwargs: Dict[str, Any] = {
+            "inputs": [trt_input],
+            "enabled_precisions": {torch.float16},
+        }
+        if hasattr(torch_tensorrt, "compile"):
+            for k in ("torch_executed_ops", "torch_executed_modules"):
+                if k == "torch_executed_ops":
+                    compile_kwargs[k] = {"torchvision::nms"}
+                elif k == "torch_executed_modules":
+                    compile_kwargs[k] = set()
+            try:
+                self._model.detector = torch_tensorrt.compile(detector, **compile_kwargs)
+            except Exception:
+                # Leave detector as-is on any failure.
+                return
+
+    def preprocess(self, tensor: torch.Tensor) -> torch.Tensor:
+        """Preprocess the input tensor."""
+        # no-op for now
+        return tensor
+
+    @staticmethod
+    def _tensor_to_png_b64(img: torch.Tensor) -> str:
+        """
+        Convert a CHW/BCHW tensor into a base64-encoded PNG.
+
+        Accepts:
+          - CHW (3,H,W) or (1,H,W)
+        Returns:
+          - base64 string (no data: prefix)
+        """
+        if not isinstance(img, torch.Tensor):
+            raise TypeError(f"Expected torch.Tensor, got {type(img)}")
+        if img.ndim != 3:
+            raise ValueError(f"Expected CHW tensor, got shape {tuple(img.shape)}")
+
+        x = img.detach()
+        if x.device.type != "cpu":
+            x = x.cpu()
+
+        # Convert to uint8 in [0,255]
+        if x.dtype.is_floating_point:
+            maxv = float(x.max().item()) if x.numel() else 1.0
+            # Heuristic: treat [0,1] images as normalized.
+            if maxv <= 1.5:
+                x = x * 255.0
+            x = x.clamp(0, 255).to(dtype=torch.uint8)
+        else:
+            x = x.clamp(0, 255).to(dtype=torch.uint8)
+
+        c, h, w = int(x.shape[0]), int(x.shape[1]), int(x.shape[2])  # noqa: F841
+        if c == 1:
+            arr = x.squeeze(0).numpy()
+            pil = Image.fromarray(arr, mode="L").convert("RGB")
+        elif c == 3:
+            arr = x.permute(1, 2, 0).contiguous().numpy()
+            pil = Image.fromarray(arr, mode="RGB")
+        else:
+            raise ValueError(f"Expected 1 or 3 channels, got {c}")
+
+        buf = io.BytesIO()
+        pil.save(buf, format="PNG")
+        return base64.b64encode(buf.getvalue()).decode("utf-8")
+
+    @staticmethod
+    def _extract_text(obj: Any) -> str:
+        if obj is None:
+            return ""
+        if isinstance(obj, str):
+            return obj.strip()
+        if isinstance(obj, dict):
+            for k in ("text", "output_text", "generated_text", "ocr_text"):
+                v = obj.get(k)
+                if isinstance(v, str) and v.strip():
+                    return v.strip()
+            # Some APIs return nested structures; best-effort flatten common shapes.
+            if "words" in obj and isinstance(obj["words"], list):
+                parts: List[str] = []
+                for w in obj["words"]:
+                    if isinstance(w, dict) and isinstance(w.get("text"), str):
+                        parts.append(w["text"])
+                if parts:
+                    return " ".join(parts).strip()
+        return str(obj).strip()
+
+    def invoke(
+        self,
+        input_data: Union[torch.Tensor, str, bytes, np.ndarray, io.BytesIO],
+        merge_level: str = "paragraph",
+    ) -> Any:
+        """
+        Invoke OCR locally.
+
+        Supports:
+          - file path (str) **only if it exists**
+          - base64 (str/bytes) (str is treated as base64 unless it is an existing file path)
+          - NumPy array (HWC)
+          - io.BytesIO
+          - torch.Tensor (CHW/BCHW): converted to base64 PNG internally for compatibility
+        """
+        if self._model is None:
+            raise RuntimeError("Local OCR model was not initialized.")
+
+        # Convert torch tensors to base64 bytes (NemotronOCR expects file path/base64/ndarray/BytesIO).
+        if isinstance(input_data, torch.Tensor):
+            if input_data.ndim == 4:
+                out: List[Any] = []
+                for i in range(int(input_data.shape[0])):
+                    b64 = self._tensor_to_png_b64(input_data[i])
+                    out.extend(self._model(b64.encode("utf-8"), merge_level=merge_level))
+                return out
+            if input_data.ndim == 3:
+                b64 = self._tensor_to_png_b64(input_data)
+                return self._model(b64.encode("utf-8"), merge_level=merge_level)
+            raise ValueError(f"Unsupported torch tensor shape for OCR: {tuple(input_data.shape)}")
+
+        # Disambiguate str: existing file path vs base64 string.
+        if isinstance(input_data, str):
+            # s = input_data.strip()
+            # breakpoint()
+            # if s and Path(s).is_file():
+            #     return self._model(s, merge_level=merge_level)
+            # Treat as base64 string (nemotron_ocr expects bytes for base64).
+            return self._model(input_data.encode("utf-8"), merge_level=merge_level)
+
+        # bytes / ndarray / BytesIO are supported directly by nemotron_ocr.
+        return self._model(input_data, merge_level=merge_level)
+
+    @property
+    def model_name(self) -> str:
+        """Human-readable model name."""
+        return "Nemotron OCR v1"
+
+    @property
+    def model_type(self) -> str:
+        """Model category/type."""
+        return "ocr"
+
+    @property
+    def model_runmode(self) -> RunMode:
+        """Execution mode: local, NIM, or build-endpoint."""
+        return "local"
+
+    @property
+    def input(self) -> Any:
+        """
+        Input schema for the model.
+
+        Returns:
+            dict: Schema describing RGB image input with variable dimensions
+        """
+        return {
+            "type": "image",
+            "format": "RGB",
+            "supported_formats": ["PNG", "JPEG"],
+            "data_types": ["float32", "uint8"],
+            "dimensions": "variable (H x W)",
+            "batch_support": True,
+            "value_range": {"float32": "[0, 1]", "uint8": "[0, 255] (auto-converted)"},
+            "aggregation_levels": ["word", "sentence", "paragraph"],
+            "description": "Document or scene image in RGB format with automatic multi-scale resizing",
+        }
+
+    @property
+    def output(self) -> Any:
+        """
+        Output schema for the model.
+
+        Returns:
+            dict: Schema describing OCR output format
+        """
+        return {
+            "type": "ocr_results",
+            "format": "structured",
+            "structure": {
+                "boxes": "List[List[List[float]]] - quadrilateral bounding box coordinates [[x1,y1], [x2,y2], [x3,y3], [x4,y4]]",  # noqa: E501
+                "texts": "List[str] - recognized text strings",
+                "confidences": "List[float] - confidence scores per detection",
+            },
+            "properties": {
+                "reading_order": True,
+                "layout_analysis": True,
+                "multi_line_support": True,
+                "multi_block_support": True,
+            },
+            "description": "Structured OCR results with bounding boxes, recognized text, and confidence scores",
+        }
+
+    @property
+    def input_batch_size(self) -> int:
+        """Maximum or default input batch size."""
+        return 8
diff --git a/nemo_retriever/src/nemo_retriever/model/local/nemotron_page_elements_v3.py b/nemo_retriever/src/nemo_retriever/model/local/nemotron_page_elements_v3.py
new file mode 100644
index 000000000..aeabe6086
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/nemotron_page_elements_v3.py
@@ -0,0 +1,225 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Sequence, Tuple, Union, cast  # noqa: F401
+
+from torch import nn
+import torch
+import numpy as np
+from ..model import HuggingFaceModel, RunMode
+
+from nemotron_page_elements_v3.model import define_model as define_model_page_elements
+from nemotron_page_elements_v3.model import resize_pad as resize_pad_page_elements
+from nemotron_page_elements_v3.utils import postprocess_preds_page_element as postprocess_preds_page_element
+
+
+class NemotronPageElementsV3(HuggingFaceModel):
+    """
+    Nemotron Page Elements v3 model for detecting document page elements.
+
+    Detects and extracts structural elements from document pages including:
+    - Tables
+    - Charts
+    - Infographics
+    - Titles
+    - Headers/Footers
+    - Text regions
+    """
+
+    def __init__(self) -> None:
+        super().__init__(self.model_name)
+        self._model = define_model_page_elements(self.model_name)
+        self._page_elements_input_shape = (1024, 1024)
+
+    def preprocess(self, tensor: Union[torch.Tensor, np.ndarray]) -> torch.Tensor:
+        """Preprocess the input tensor."""
+        # Upstream `nemotron_page_elements_v3.model.resize_pad` expects a CHW tensor.
+        # Our pipeline helpers often pass BCHW (typically B=1), so normalize here.
+        if isinstance(tensor, torch.Tensor):
+            x = tensor
+        elif isinstance(tensor, np.ndarray):
+            arr = tensor
+            # Normalize to CHW tensor.
+            if arr.ndim == 4 and int(arr.shape[0]) == 1:
+                arr = arr[0]
+            if arr.ndim != 3:
+                raise ValueError(f"Expected 3D image array, got shape {getattr(arr, 'shape', None)}")
+            # Heuristic: HWC (RGB) -> CHW; otherwise assume CHW-like.
+            if int(arr.shape[-1]) == 3 and int(arr.shape[0]) != 3:
+                x = torch.from_numpy(np.ascontiguousarray(arr)).permute(2, 0, 1)
+            else:
+                x = torch.from_numpy(np.ascontiguousarray(arr))
+            # Keep 0-255 range: resize_pad pads with 114.0 (designed for 0-255),
+            # and YoloXWrapper.forward() handles the 0-255 → model-input conversion.
+            x = x.to(dtype=torch.float32)
+        else:
+            raise TypeError(f"Expected torch.Tensor or np.ndarray, got {type(tensor)!r}")
+
+        if x.ndim == 4:
+            b = int(x.shape[0])
+            if b == 1:
+                x_chw = x[0]
+                y = resize_pad_page_elements(x_chw, self.input_shape)
+                if not isinstance(y, torch.Tensor):
+                    raise TypeError(f"resize_pad returned non-tensor: {type(y)!r}")
+                if y.ndim != 3:
+                    raise ValueError(f"Expected CHW from resize_pad, got {tuple(y.shape)}")
+                return y.unsqueeze(0)
+
+            outs: List[torch.Tensor] = []
+            for i in range(b):
+                y = resize_pad_page_elements(x[i], self.input_shape)
+                if not isinstance(y, torch.Tensor) or y.ndim != 3:
+                    raise ValueError(f"resize_pad produced unexpected output for batch item {i}: {type(y)!r}")
+                outs.append(y)
+            return torch.stack(outs, dim=0)
+
+        if x.ndim == 3:
+            y = resize_pad_page_elements(x, self.input_shape)
+            if not isinstance(y, torch.Tensor):
+                raise TypeError(f"resize_pad returned non-tensor: {type(y)!r}")
+            if y.ndim != 3:
+                raise ValueError(f"Expected CHW from resize_pad, got {tuple(y.shape)}")
+            return y.unsqueeze(0)
+
+        raise ValueError(f"Expected CHW or BCHW tensor, got shape {tuple(x.shape)}")
+
+    def __call__(
+        self, input_data: torch.Tensor, orig_shape: Union[Tuple[int, int], Sequence[Tuple[int, int]]]
+    ) -> Union[List[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]:
+        return self.invoke(input_data, orig_shape)
+
+    def invoke(
+        self, input_data: torch.Tensor, orig_shape: Union[Tuple[int, int], Sequence[Tuple[int, int]]]
+    ) -> Union[List[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]:
+        if self._model is None:
+            raise RuntimeError("Local page_elements_v3 model was not initialized.")
+
+        # The upstream model returns a container where index [0] is the predictions.
+        with torch.inference_mode():
+            with torch.autocast(device_type="cuda"):
+                out = self._model(input_data, orig_shape)
+                return out
+        # preds0: Any
+        # if isinstance(out, (list, tuple)) and len(out) > 0:
+        #     preds0 = out[0]
+        # else:
+        #     preds0 = out
+
+        # # If we got per-image preds, return them as-is so pipeline code can
+        # # avoid slow per-image fallback.
+        # if isinstance(preds0, list):
+        #     # If caller passed a batch, keep list; if single-item batch, unwrap to dict for back-compat.
+        #     if isinstance(orig_shape, (list, tuple)) and len(orig_shape) == 1:
+        #         one = preds0[0] if preds0 else {}
+        #         return cast(Dict[str, torch.Tensor], one)
+        #     return cast(List[Dict[str, torch.Tensor]], preds0)
+
+        # return cast(Dict[str, torch.Tensor], preds0)
+
+    def postprocess(self, preds: Union[Dict[str, torch.Tensor], Sequence[Dict[str, torch.Tensor]]]) -> Tuple[
+        Union[torch.Tensor, List[torch.Tensor]],
+        Union[torch.Tensor, List[torch.Tensor]],
+        Union[torch.Tensor, List[torch.Tensor]],
+    ]:
+        if self._model is None:
+            raise RuntimeError("Local page_elements_v3 model was not initialized.")
+
+        # Upstream `nemotron_page_elements_v3.utils.postprocess_preds_page_element` expects a
+        # single prediction dict (with torch tensors) and returns numpy arrays. Our pipeline
+        # may pass a *list* of per-image preds for batched inference, so handle both cases
+        # and always return torch tensors (or lists of torch tensors).
+
+        def _one(p: Dict[str, torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor, torch.Tensor]:
+            b_np, l_np, s_np = postprocess_preds_page_element(p, self._model.thresholds_per_class, self._model.labels)
+            b = torch.as_tensor(b_np, dtype=torch.float32)
+            l = torch.as_tensor(l_np, dtype=torch.int64)  # noqa: E741
+            s = torch.as_tensor(s_np, dtype=torch.float32)
+            return b, l, s
+
+        if isinstance(preds, dict):
+            return _one(preds)
+
+        boxes_list: List[torch.Tensor] = []
+        labels_list: List[torch.Tensor] = []
+        scores_list: List[torch.Tensor] = []
+        for p in preds:
+            b, l, s = _one(p)
+            boxes_list.append(b)
+            labels_list.append(l)
+            scores_list.append(s)
+
+        return boxes_list, labels_list, scores_list
+
+    @property
+    def model_dir(self) -> str:
+        """Model directory."""
+        return self.model_name
+
+    @property
+    def model(self) -> nn.Module:
+        """Model instance."""
+        if self._model is None:
+            raise RuntimeError("Local page_elements_v3 model was not initialized.")
+        return self._model
+
+    @property
+    def model_name(self) -> str:
+        """Human-readable model name."""
+        return "page_element_v3"
+
+    @property
+    def model_type(self) -> str:
+        """Model category/type."""
+        return "object-detection"
+
+    @property
+    def model_runmode(self) -> RunMode:
+        """Execution mode: local, NIM, or build-endpoint."""
+        return "local"
+
+    @property
+    def input(self) -> Any:
+        """
+        Input schema for the model.
+
+        Returns:
+            dict: Schema describing RGB image input with dimensions (1024, 1024)
+        """
+        return {
+            "type": "image",
+            "format": "RGB",
+            "dimensions": "(1024, 1024)",
+            "description": "Document page image in RGB format, resized to 1024x1024",
+        }
+
+    @property
+    def output(self) -> Any:
+        """
+        Output schema for the model.
+
+        Returns:
+            dict: Schema describing detection output format
+        """
+        return {
+            "type": "detection",
+            "format": "dict",
+            "structure": {
+                "boxes": "np.ndarray[N, 4] - normalized (x_min, y_min, x_max, y_max)",
+                "labels": "List[str] - class names",
+                "scores": "np.ndarray[N] - confidence scores",
+            },
+            "classes": ["table", "chart", "infographic", "title", "text", "header_footer"],
+            "post_processing": {"conf_thresh": 0.01, "iou_thresh": 0.5},
+        }
+
+    @property
+    def input_batch_size(self) -> int:
+        """Maximum or default input batch size."""
+        return 1
+
+    @property
+    def input_shape(self) -> Tuple[int, int]:
+        """Input shape."""
+        return self._page_elements_input_shape
diff --git a/nemo_retriever/src/nemo_retriever/model/local/nemotron_parse_v1_2.py b/nemo_retriever/src/nemo_retriever/model/local/nemotron_parse_v1_2.py
new file mode 100644
index 000000000..1d762c6d0
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/nemotron_parse_v1_2.py
@@ -0,0 +1,175 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional, Union
+
+import numpy as np
+import torch
+from PIL import Image
+
+from ..model import BaseModel, RunMode
+
+
+class NemotronParseV12(BaseModel):
+    """
+    NVIDIA Nemotron Parse v1.2 local wrapper.
+
+    This wrapper loads `nvidia/NVIDIA-Nemotron-Parse-v1.2` from Hugging Face and
+    runs image-to-structured-text generation for document parsing.
+    """
+
+    def __init__(
+        self,
+        model_path: str = "nvidia/NVIDIA-Nemotron-Parse-v1.2",
+        device: Optional[str] = None,
+        hf_cache_dir: Optional[str] = None,
+        task_prompt: str = "</s><s><predict_bbox><predict_classes><output_markdown><predict_no_text_in_pic>",
+    ) -> None:
+        super().__init__()
+
+        from transformers import AutoModel, AutoProcessor, AutoTokenizer, GenerationConfig
+
+        self._model_path = model_path
+        self._task_prompt = task_prompt
+        self._device = torch.device(device or ("cuda:0" if torch.cuda.is_available() else "cpu"))
+        self._dtype = torch.bfloat16 if self._device.type == "cuda" else torch.float32
+
+        self._model = AutoModel.from_pretrained(
+            self._model_path,
+            trust_remote_code=True,
+            torch_dtype=self._dtype,
+            cache_dir=hf_cache_dir,
+        ).to(self._device)
+        self._model.eval()
+
+        self._tokenizer = AutoTokenizer.from_pretrained(self._model_path, cache_dir=hf_cache_dir)
+        self._processor = AutoProcessor.from_pretrained(
+            self._model_path, trust_remote_code=True, cache_dir=hf_cache_dir
+        )
+        self._generation_config = GenerationConfig.from_pretrained(
+            self._model_path, trust_remote_code=True, cache_dir=hf_cache_dir
+        )
+
+    def preprocess(self, input_data: Union[torch.Tensor, np.ndarray, Image.Image, str, Path]) -> Image.Image:
+        """
+        Normalize supported input formats to a RGB PIL image.
+        """
+        if isinstance(input_data, Image.Image):
+            return input_data.convert("RGB")
+
+        if isinstance(input_data, (str, Path)):
+            return Image.open(Path(input_data)).convert("RGB")
+
+        if isinstance(input_data, torch.Tensor):
+            x = input_data.detach().cpu()
+            if x.ndim == 4:
+                if int(x.shape[0]) != 1:
+                    raise ValueError(f"Expected batch size 1 tensor, got shape {tuple(x.shape)}")
+                x = x[0]
+            if x.ndim != 3:
+                raise ValueError(f"Expected CHW/HWC tensor, got shape {tuple(x.shape)}")
+            if int(x.shape[0]) in (1, 3):
+                x = x.permute(1, 2, 0).contiguous()
+            if x.dtype.is_floating_point:
+                max_v = float(x.max().item()) if x.numel() else 1.0
+                if max_v <= 1.5:
+                    x = x * 255.0
+            arr = x.clamp(0, 255).to(torch.uint8).numpy()
+            return Image.fromarray(arr).convert("RGB")
+
+        if isinstance(input_data, np.ndarray):
+            arr = input_data
+            if arr.ndim == 4:
+                if int(arr.shape[0]) != 1:
+                    raise ValueError(f"Expected batch size 1 array, got shape {arr.shape}")
+                arr = arr[0]
+            if arr.ndim != 3:
+                raise ValueError(f"Expected HWC/CHW array, got shape {arr.shape}")
+            if int(arr.shape[0]) in (1, 3) and int(arr.shape[-1]) not in (1, 3):
+                arr = np.transpose(arr, (1, 2, 0))
+            if np.issubdtype(arr.dtype, np.floating):
+                max_v = float(arr.max()) if arr.size else 1.0
+                if max_v <= 1.5:
+                    arr = arr * 255.0
+            arr = np.clip(arr, 0, 255).astype(np.uint8)
+            return Image.fromarray(arr).convert("RGB")
+
+        raise TypeError(f"Unsupported input type for Nemotron Parse: {type(input_data)!r}")
+
+    def invoke(
+        self,
+        input_data: Union[torch.Tensor, np.ndarray, Image.Image, str, Path],
+        task_prompt: Optional[str] = None,
+    ) -> str:
+        """
+        Run local Nemotron Parse inference and return decoded model text.
+        """
+        image = self.preprocess(input_data)
+        prompt = task_prompt or self._task_prompt
+
+        inputs = self._processor(
+            images=[image],
+            text=prompt,
+            return_tensors="pt",
+            add_special_tokens=False,
+        ).to(self._device)
+
+        with torch.inference_mode():
+            outputs = self._model.generate(**inputs, generation_config=self._generation_config)
+
+        decoded = self._processor.batch_decode(outputs, skip_special_tokens=True)
+        return decoded[0] if decoded else ""
+
+    def __call__(
+        self,
+        input_data: Union[torch.Tensor, np.ndarray, Image.Image, str, Path],
+        task_prompt: Optional[str] = None,
+    ) -> str:
+        return self.invoke(input_data, task_prompt=task_prompt)
+
+    @property
+    def model_name(self) -> str:
+        """Human-readable model name."""
+        return "NVIDIA-Nemotron-Parse-v1.2"
+
+    @property
+    def model_type(self) -> str:
+        """Model category/type."""
+        return "document-parse"
+
+    @property
+    def model_runmode(self) -> RunMode:
+        """Execution mode: local, NIM, or build-endpoint."""
+        return "local"
+
+    @property
+    def input(self) -> Any:
+        """
+        Input schema for the model.
+        """
+        return {
+            "type": "image",
+            "format": "RGB",
+            "supported_inputs": ["PIL.Image", "path", "torch.Tensor", "np.ndarray"],
+            "description": "Document image for parsing into markdown text with structural tags.",
+        }
+
+    @property
+    def output(self) -> Any:
+        """
+        Output schema for the model.
+        """
+        return {
+            "type": "text",
+            "format": "string",
+            "description": "Generated structured parse text from Nemotron Parse v1.2.",
+        }
+
+    @property
+    def input_batch_size(self) -> int:
+        """Maximum or default input batch size."""
+        return 1
diff --git a/nemo_retriever/src/nemo_retriever/model/local/nemotron_table_structure_v1.py b/nemo_retriever/src/nemo_retriever/model/local/nemotron_table_structure_v1.py
new file mode 100644
index 000000000..7cac9b91f
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/nemotron_table_structure_v1.py
@@ -0,0 +1,141 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from typing import Any, Dict, List, Tuple, Union
+
+import torch
+from ..model import BaseModel, RunMode
+
+from nemotron_table_structure_v1.model import define_model as define_model_table_structure
+from nemotron_table_structure_v1.model import resize_pad as resize_pad_table_structure
+
+
+class NemotronTableStructureV1(BaseModel):
+    """
+    Nemotron Table Structure v1 model for detecting table structure elements.
+
+    Detects and extracts structural components from table images:
+    - Individual cells (including merged cells)
+    - Rows
+    - Columns
+
+    Note: Input should be a cropped table image, typically obtained using
+    Nemotron Page Elements v3 model.
+    """
+
+    def __init__(self) -> None:
+        super().__init__()
+        # table_structure_model = define_model_table_structure("table_structure_v1")
+        self._model = define_model_table_structure(self.model_name)
+        self._table_structure_input_shape = (1024, 1024)
+
+    def preprocess(self, input_tensor: torch.Tensor, orig_shape: Tuple[int, int]) -> torch.Tensor:
+        """Preprocess the input tensor.
+
+        Upstream `nemotron_table_structure_v1.model.resize_pad` expects CHW.
+        The pipeline often passes BCHW (typically B=1); normalize here.
+        """
+        if not isinstance(input_tensor, torch.Tensor):
+            raise TypeError(f"Expected torch.Tensor, got {type(input_tensor)!r}")
+
+        x = input_tensor
+        if x.ndim == 4:
+            b = int(x.shape[0])
+            if b == 1:
+                y = resize_pad_table_structure(x[0], self.input_shape)
+                if not isinstance(y, torch.Tensor) or y.ndim != 3:
+                    raise ValueError(f"resize_pad produced unexpected output: {type(y)!r}")
+                return y.unsqueeze(0)
+            outs = []
+            for i in range(b):
+                y = resize_pad_table_structure(x[i], self.input_shape)
+                if not isinstance(y, torch.Tensor) or y.ndim != 3:
+                    raise ValueError(f"resize_pad produced unexpected output for batch item {i}: {type(y)!r}")
+                outs.append(y)
+            return torch.stack(outs, dim=0)
+
+        if x.ndim == 3:
+            y = resize_pad_table_structure(x, self.input_shape)
+            if not isinstance(y, torch.Tensor) or y.ndim != 3:
+                raise ValueError(f"resize_pad produced unexpected output: {type(y)!r}")
+            return y.unsqueeze(0)
+
+        raise ValueError(f"Expected CHW or BCHW tensor, got shape {tuple(x.shape)}")
+
+    def invoke(
+        self, input_tensor: torch.Tensor, orig_shape: Tuple[int, int]
+    ) -> Union[List[Dict[str, torch.Tensor]], Dict[str, torch.Tensor]]:
+        if self._model is None:
+            raise RuntimeError("Local table_structure_v1 model was not initialized.")
+
+        table_preds = self._model(input_tensor, orig_shape)[0]
+        return table_preds
+
+    @property
+    def model_name(self) -> str:
+        """Human-readable model name."""
+        return "table_structure_v1"
+
+    @property
+    def model_type(self) -> str:
+        """Model category/type."""
+        return "object-detection"
+
+    @property
+    def model_runmode(self) -> RunMode:
+        """Execution mode: local, NIM, or build-endpoint."""
+        return "local"
+
+    @property
+    def input(self) -> Any:
+        """
+        Input schema for the model.
+
+        Returns:
+            dict: Schema describing RGB table image input
+        """
+        return {
+            "type": "image",
+            "format": "RGB",
+            "dimensions": "(1024, 1024)",
+            "expected_content": "table",
+            "description": "Table image in RGB format, resized to 1024x1024. Should be cropped from document using page element detection.",  # noqa: E501
+            "preprocessing_recommendation": "Use Nemotron Page Elements v3 to detect and crop table regions",
+        }
+
+    @property
+    def output(self) -> Any:
+        """
+        Output schema for the model.
+
+        Returns:
+            dict: Schema describing detection output format
+        """
+        return {
+            "type": "detection",
+            "format": "dict",
+            "structure": {
+                "boxes": "np.ndarray[N, 4] - normalized (x_min, y_min, x_max, y_max)",
+                "labels": "List[str] - class names",
+                "scores": "np.ndarray[N] - confidence scores",
+            },
+            "classes": ["cell", "row", "column"],
+            "post_processing": {"conf_thresh": 0.01, "iou_thresh": 0.25},
+            "use_cases": ["Table-to-markdown conversion", "Structured data extraction", "Table analysis"],
+            "known_limitations": [
+                "Less confident in detecting cells at bottom of table",
+                "Not robust to rotated tables",
+                "No support for non full-page tables",
+            ],
+        }
+
+    @property
+    def input_batch_size(self) -> int:
+        """Maximum or default input batch size."""
+        return 1
+
+    @property
+    def input_shape(self) -> Tuple[int, int]:
+        """Input shape."""
+        return self._table_structure_input_shape
diff --git a/nemo_retriever/src/nemo_retriever/model/local/parakeet_ctc_1_1b_asr.py b/nemo_retriever/src/nemo_retriever/model/local/parakeet_ctc_1_1b_asr.py
new file mode 100644
index 000000000..1227e06da
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/local/parakeet_ctc_1_1b_asr.py
@@ -0,0 +1,173 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Local ASR using nvidia/parakeet-ctc-1.1b via Hugging Face Transformers.
+
+Uses AutoModelForCTC + AutoProcessor with batch_decode(skip_special_tokens=True)
+to avoid <pad> tokens in output; falls back to post-processing to strip any remaining.
+Requires transformers>=5. Model expects 16 kHz mono input.
+"""
+
+from __future__ import annotations
+
+import logging
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+MODEL_ID = "nvidia/parakeet-ctc-1.1b"
+SAMPLING_RATE = 16000
+
+
+def _strip_pad_from_transcript(text: str) -> str:
+    """Remove <pad> tokens and normalize spaces (fallback when decode doesn't skip them)."""
+    if not text:
+        return ""
+    t = text.replace("<pad>", "").strip()
+    return " ".join(t.split()) if t else ""
+
+
+def _load_audio_16k(path: str) -> Optional[np.ndarray]:
+    """Load audio from path and return mono 16 kHz float32 array, or None on failure."""
+    try:
+        import soundfile as sf
+    except ImportError:
+        logger.warning("soundfile not installed; cannot load audio for local ASR.")
+        return None
+
+    try:
+        data, sr = sf.read(path, dtype="float32")
+    except Exception:
+        # Unsupported format (e.g. mp3); try ffmpeg to 16k mono wav
+        try:
+            import subprocess
+
+            with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+                wav_path = f.name
+            try:
+                subprocess.run(
+                    [
+                        "ffmpeg",
+                        "-y",
+                        "-i",
+                        path,
+                        "-ar",
+                        str(SAMPLING_RATE),
+                        "-ac",
+                        "1",
+                        "-f",
+                        "wav",
+                        wav_path,
+                    ],
+                    check=True,
+                    capture_output=True,
+                )
+                data, sr = sf.read(wav_path, dtype="float32")
+            finally:
+                Path(wav_path).unlink(missing_ok=True)
+        except Exception as e:
+            logger.warning("Failed to load or convert audio %s: %s", path, e)
+            return None
+
+    if data.ndim > 1:
+        data = data.mean(axis=1)
+    if sr != SAMPLING_RATE:
+        from scipy.signal import resample
+
+        n = int(len(data) * SAMPLING_RATE / sr)
+        data = resample(data, n).astype(np.float32)
+    return data
+
+
+def _load_model_and_processor(model_id: str, hf_cache_dir: Optional[str] = None):
+    """Load Parakeet ASR via AutoModelForCTC + AutoProcessor (explicit decode control)."""
+    import torch
+    from transformers import AutoModelForCTC, AutoProcessor
+
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    kwargs = {}
+    if hf_cache_dir:
+        kwargs["cache_dir"] = hf_cache_dir
+    processor = AutoProcessor.from_pretrained(model_id, **kwargs)
+    model = AutoModelForCTC.from_pretrained(model_id, torch_dtype="auto", device_map=device, **kwargs)
+    return model, processor
+
+
+class ParakeetCTC1B1ASR:
+    """
+    Local ASR using nvidia/parakeet-ctc-1.1b via Hugging Face Transformers.
+
+    Uses AutoModelForCTC + AutoProcessor with batch_decode(skip_special_tokens=True)
+    and post-processes to remove any remaining <pad> tokens. Requires transformers>=5.
+    """
+
+    def __init__(
+        self,
+        device: Optional[str] = None,
+        hf_cache_dir: Optional[str] = None,
+        model_id: Optional[str] = None,
+    ) -> None:
+        self._device = device
+        self._hf_cache_dir = hf_cache_dir
+        self._model_id = model_id or MODEL_ID
+        self._model = None
+        self._processor = None
+
+    def _ensure_loaded(self) -> None:
+        if self._model is not None and self._processor is not None:
+            return
+        self._model, self._processor = _load_model_and_processor(self._model_id, self._hf_cache_dir)
+        logger.info(
+            "ParakeetCTC1B1ASR: loaded %s via Transformers (AutoModelForCTC + AutoProcessor)",
+            self._model_id,
+        )
+
+    def transcribe(self, paths: List[str]) -> List[str]:
+        """
+        Transcribe one or more audio files to text.
+
+        Each path is loaded and resampled to 16 kHz mono as required by the model.
+        Returns one string per path; empty string on load/transcribe failure.
+        <pad> tokens are removed via skip_special_tokens and/or post-processing.
+        """
+        self._ensure_loaded()
+        results: List[str] = []
+        for path in paths:
+            audio = _load_audio_16k(path)
+            if audio is None:
+                results.append("")
+                continue
+            results.append(self._transcribe_audio(audio) or "")
+        return results
+
+    def _transcribe_audio(self, audio: np.ndarray) -> str:
+        if self._model is None or self._processor is None:
+            return ""
+        try:
+            import torch
+
+            # Single sample: wrap in list for processor
+            speech = [audio]
+            inputs = self._processor(
+                speech,
+                sampling_rate=self._processor.feature_extractor.sampling_rate,
+                return_tensors="pt",
+                padding=True,
+            )
+            inputs = inputs.to(self._model.device, dtype=self._model.dtype)
+            with torch.no_grad():
+                outputs = self._model.generate(**inputs)
+            # batch_decode with skip_special_tokens to drop pad tokens
+            decoded = self._processor.batch_decode(outputs, skip_special_tokens=True)
+            text = decoded[0] if decoded else ""
+            # Fallback: strip any remaining <pad> and normalize spaces
+            return _strip_pad_from_transcript(text.strip())
+        except Exception as e:
+            logger.warning("ASR (transformers) failed: %s", e)
+            return ""
diff --git a/nemo_retriever/src/nemo_retriever/model/model.py b/nemo_retriever/src/nemo_retriever/model/model.py
new file mode 100644
index 000000000..1158142b2
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/model/model.py
@@ -0,0 +1,104 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from abc import ABC, abstractmethod
+from typing import Any, Literal, Tuple
+import torch.nn as nn
+
+
+RunMode = Literal["local", "NIM", "build-endpoint"]
+
+
+class BaseModel(ABC):
+    """
+    Abstract base class for all models.
+
+    This class must never be instantiated directly.
+    """
+
+    def __init__(self) -> None:
+        if type(self) is BaseModel:
+            raise TypeError("BaseModel is abstract and cannot be instantiated directly")
+
+    # ---- Required metadata ----
+
+    @property
+    @abstractmethod
+    def model_name(self) -> str:
+        """Human-readable model name."""
+        pass
+
+    @property
+    @abstractmethod
+    def model_type(self) -> str:
+        """Model category/type (e.g. llm, vision, embedding)."""
+        pass
+
+    @property
+    @abstractmethod
+    def model_runmode(self) -> RunMode:
+        """Execution mode: local, NIM, or build-endpoint."""
+        pass
+
+    # ---- I/O contract ----
+
+    @property
+    @abstractmethod
+    def input(self) -> Any:
+        """Input schema or object."""
+        pass
+
+    @property
+    @abstractmethod
+    def output(self) -> Any:
+        """Output schema or object."""
+        pass
+
+    @property
+    @abstractmethod
+    def input_batch_size(self) -> int:
+        """Maximum or default input batch size."""
+        pass
+
+
+class HuggingFaceModel(BaseModel):
+    """
+    Abstract base class for all HuggingFace models.
+    """
+
+    def __init__(self, model_id: str) -> None:
+        super().__init__()
+
+    @property
+    @abstractmethod
+    def model_dir(self) -> str:
+        """Model directory."""
+        pass
+
+    @property
+    @abstractmethod
+    def model(self) -> nn.Module:
+        """Model instance."""
+        pass
+
+    @property
+    @abstractmethod
+    def input_shape(self) -> Tuple[int, int]:
+        """Input shape."""
+        pass
+
+
+class NvidiaNIMModel(BaseModel):
+    """
+    Abstract base class for all Nvidia NIM models.
+    """
+
+    def __init__(self, model_id: str) -> None:
+        super().__init__()
+
+    @property
+    @abstractmethod
+    def model_dir(self) -> str:
+        """Model directory."""
+        pass
diff --git a/nemo_retriever/src/nemo_retriever/nim/__init__.py b/nemo_retriever/src/nemo_retriever/nim/__init__.py
new file mode 100644
index 000000000..d46c93264
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/nim/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""NIM helpers for retriever inference paths."""
diff --git a/nemo_retriever/src/nemo_retriever/nim/nim.py b/nemo_retriever/src/nemo_retriever/nim/nim.py
new file mode 100644
index 000000000..6bcde5d36
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/nim/nim.py
@@ -0,0 +1,211 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+import requests
+
+
+def _chunk_ranges(total: int, chunk_size: int) -> List[Tuple[int, int]]:
+    if chunk_size <= 0:
+        raise ValueError("chunk_size must be > 0")
+    return [(i, min(i + chunk_size, total)) for i in range(0, total, chunk_size)]
+
+
+def _parse_invoke_urls(invoke_url: str) -> List[str]:
+    parts = [p.strip() for p in str(invoke_url or "").split(",")]
+    urls = [p for p in parts if p]
+    if not urls:
+        raise ValueError("invoke_url is required")
+    return urls
+
+
+def _normalize_batch_response(response_json: Any, expected_count: int) -> List[Any]:
+    """
+    Normalize common NIM HTTP response shapes to one item per input image.
+    """
+    if isinstance(response_json, list):
+        items = response_json
+    elif isinstance(response_json, dict):
+        data = response_json.get("data")
+        output = response_json.get("output")
+        predictions = response_json.get("predictions")
+        if isinstance(data, list):
+            items = data
+        elif isinstance(output, list):
+            items = output
+        elif isinstance(predictions, list):
+            items = predictions
+        else:
+            items = [response_json]
+    else:
+        raise RuntimeError(f"Unexpected response type: {type(response_json)!r}")
+
+    out: List[Any] = []
+    for item in items:
+        out.append(item)
+
+    if len(out) != int(expected_count):
+        raise RuntimeError(f"Remote response count mismatch: expected {expected_count}, got {len(out)}")
+    return out
+
+
+def _post_with_retries(
+    *,
+    invoke_url: str,
+    payload: Dict[str, Any],
+    headers: Dict[str, str],
+    timeout_s: float,
+    max_retries: int,
+    max_429_retries: int,
+) -> Any:
+    base_delay = 2.0
+    attempt = 0
+    retries_429 = 0
+
+    while attempt < int(max_retries):
+        try:
+            response = requests.post(invoke_url, headers=headers, json=payload, timeout=float(timeout_s))
+            status_code = response.status_code
+
+            if status_code == 429:
+                retries_429 += 1
+                if retries_429 >= int(max_429_retries):
+                    response.raise_for_status()
+                backoff_time = base_delay * (2**retries_429)
+                time.sleep(backoff_time)
+                continue
+
+            if status_code == 503 or (500 <= status_code < 600):
+                if attempt == int(max_retries) - 1:
+                    response.raise_for_status()
+                backoff_time = base_delay * (2**attempt)
+                time.sleep(backoff_time)
+                attempt += 1
+                continue
+
+            response.raise_for_status()
+            return response.json()
+
+        except requests.Timeout as exc:
+            if attempt == int(max_retries) - 1:
+                raise TimeoutError(f"Request timed out after {attempt + 1} attempts.") from exc
+            backoff_time = base_delay * (2**attempt)
+            time.sleep(backoff_time)
+            attempt += 1
+        except requests.RequestException:
+            if attempt == int(max_retries) - 1:
+                raise
+            backoff_time = base_delay * (2**attempt)
+            time.sleep(backoff_time)
+            attempt += 1
+
+    raise RuntimeError(f"Failed to get a successful response after {max_retries} retries.")
+
+
+def invoke_image_inference_batches(
+    *,
+    invoke_url: str,
+    image_b64_list: Sequence[str],
+    api_key: Optional[str] = None,
+    timeout_s: float = 120.0,
+    max_batch_size: int = 8,
+    max_pool_workers: int = 16,
+    max_retries: int = 10,
+    max_429_retries: int = 5,
+) -> List[Any]:
+    """
+    Invoke one or more image NIM HTTP endpoints with batched concurrent requests.
+
+    `invoke_url` may be a single URL or a comma-separated URL list.
+    When multiple URLs are provided, batches are distributed round-robin.
+
+    Returns one response item per input image, in the same order.
+    """
+    invoke_urls = _parse_invoke_urls(invoke_url)
+
+    token = (api_key or "").strip()
+    headers: Dict[str, str] = {"Accept": "application/json", "Content-Type": "application/json"}
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    n = len(image_b64_list)
+    if n == 0:
+        return []
+
+    ranges = _chunk_ranges(n, int(max_batch_size))
+    flattened: List[Optional[Any]] = [None] * n
+
+    def _invoke_one_batch(start: int, end: int, endpoint_url: str) -> Tuple[int, int, List[Any]]:
+        inputs = [
+            {
+                "type": "image_url",
+                "url": f"data:image/png;base64,{b64}",
+            }
+            for b64 in image_b64_list[start:end]
+        ]
+        payload = {"input": inputs}
+        response_json = _post_with_retries(
+            invoke_url=endpoint_url,
+            payload=payload,
+            headers=headers,
+            timeout_s=float(timeout_s),
+            max_retries=int(max_retries),
+            max_429_retries=int(max_429_retries),
+        )
+        per_image = _normalize_batch_response(response_json, end - start)
+        return start, end, per_image
+
+    with ThreadPoolExecutor(max_workers=max(1, int(max_pool_workers))) as executor:
+        futures = {
+            executor.submit(
+                _invoke_one_batch,
+                start,
+                end,
+                invoke_urls[idx % len(invoke_urls)],
+            ): (start, end)
+            for idx, (start, end) in enumerate(ranges)
+        }
+        for future in as_completed(futures):
+            start, end = futures[future]
+            _s, _e, per_image = future.result()
+            if _s != start or _e != end:
+                raise RuntimeError("Internal batch ordering mismatch.")
+            for i, item in enumerate(per_image):
+                flattened[start + i] = item
+
+    out: List[Any] = []
+    for idx, item in enumerate(flattened):
+        if item is None:
+            raise RuntimeError(f"Missing response for item index {idx}")
+        out.append(item)
+    return out
+
+
+def invoke_page_elements_batches(
+    *,
+    invoke_url: str,
+    image_b64_list: Sequence[str],
+    api_key: Optional[str] = None,
+    timeout_s: float = 120.0,
+    max_batch_size: int = 8,
+    max_pool_workers: int = 16,
+    max_retries: int = 10,
+    max_429_retries: int = 5,
+) -> List[Any]:
+    """Backward-compatible alias for page-elements callers."""
+    return invoke_image_inference_batches(
+        invoke_url=invoke_url,
+        image_b64_list=image_b64_list,
+        api_key=api_key,
+        timeout_s=timeout_s,
+        max_batch_size=max_batch_size,
+        max_pool_workers=max_pool_workers,
+        max_retries=max_retries,
+        max_429_retries=max_429_retries,
+    )
diff --git a/nemo_retriever/src/nemo_retriever/ocr/__init__.py b/nemo_retriever/src/nemo_retriever/ocr/__init__.py
new file mode 100644
index 000000000..49e6be1a4
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ocr/__init__.py
@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .ocr import OCRActor, ocr_page_elements
+
+__all__ = ["OCRActor", "ocr_page_elements"]
diff --git a/nemo_retriever/src/nemo_retriever/ocr/ocr.py b/nemo_retriever/src/nemo_retriever/ocr/ocr.py
new file mode 100644
index 000000000..a0071369c
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ocr/ocr.py
@@ -0,0 +1,935 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+"""
+Crop-based OCR stage.
+
+Runs Nemotron OCR v1 on table / chart / infographic regions detected by
+PageElements v3. Text extraction for the full page is handled upstream
+by PDFium in the PDF extraction stage.
+"""
+
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+import base64
+import io
+import time
+import traceback
+
+import numpy as np
+import pandas as pd
+from nemo_retriever.params import RemoteRetryParams
+from nemo_retriever.nim.nim import invoke_image_inference_batches
+
+try:
+    from PIL import Image
+except Exception:  # pragma: no cover
+    Image = None  # type: ignore[assignment]
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _error_payload(*, stage: str, exc: BaseException) -> Dict[str, Any]:
+    return {
+        "timing": None,
+        "error": {
+            "stage": str(stage),
+            "type": exc.__class__.__name__,
+            "message": str(exc),
+            "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+        },
+    }
+
+
+def _crop_b64_image_by_norm_bbox(
+    page_image_b64: str,
+    *,
+    bbox_xyxy_norm: Sequence[float],
+    image_format: str = "png",
+) -> Tuple[Optional[str], Optional[Tuple[int, int]]]:
+    """
+    Crop a base64-encoded RGB image by a normalized xyxy bbox.
+
+    Returns
+    -------
+    cropped_image_b64 : str | None
+        Base64-encoded cropped image (PNG), or *None* on failure.
+    cropped_shape_hw : tuple[int, int] | None
+        (H, W) of the crop, or *None* on failure.
+    """
+    if Image is None:  # pragma: no cover
+        raise ImportError("Cropping requires pillow.")
+
+    if not isinstance(page_image_b64, str) or not page_image_b64:
+        return None, None
+    try:
+        x1n, y1n, x2n, y2n = [float(x) for x in bbox_xyxy_norm]
+    except Exception:
+        return None, None
+
+    try:
+        raw = base64.b64decode(page_image_b64)
+        with Image.open(io.BytesIO(raw)) as im0:
+            im = im0.convert("RGB")
+            w, h = im.size
+            if w <= 1 or h <= 1:
+                return None, None
+
+            def _clamp_int(v: float, lo: int, hi: int) -> int:
+                if v != v:  # NaN
+                    return lo
+                return int(min(max(v, float(lo)), float(hi)))
+
+            x1 = _clamp_int(x1n * w, 0, w)
+            x2 = _clamp_int(x2n * w, 0, w)
+            y1 = _clamp_int(y1n * h, 0, h)
+            y2 = _clamp_int(y2n * h, 0, h)
+
+            if x2 <= x1 or y2 <= y1:
+                return None, None
+
+            crop = im.crop((x1, y1, x2, y2))
+            cw, ch = crop.size
+            if cw <= 1 or ch <= 1:
+                return None, None
+
+            buf = io.BytesIO()
+            fmt = str(image_format or "png").lower()
+            if fmt not in {"png"}:
+                fmt = "png"
+            crop.save(buf, format=fmt.upper())
+            return base64.b64encode(buf.getvalue()).decode("ascii"), (int(ch), int(cw))
+    except Exception:
+        return None, None
+
+
+def _crop_all_from_page(
+    page_image_b64: str,
+    detections: List[Dict[str, Any]],
+    wanted_labels: set,
+) -> List[Tuple[str, List[float], np.ndarray]]:
+    """
+    Decode the page image **once** and crop all matching detections.
+
+    Returns a list of ``(label_name, bbox_xyxy_norm, crop_array)`` tuples for
+    detections whose ``label_name`` is in *wanted_labels* and whose crop is
+    valid.  Skips detections that fail to crop (bad bbox, tiny region, etc.).
+
+    Crops are returned as HWC uint8 numpy arrays so they can be passed
+    directly to ``NemotronOCRV1.invoke()`` without a PNG/base64 round-trip.
+    """
+    if Image is None:  # pragma: no cover
+        raise ImportError("Cropping requires pillow.")
+
+    if not isinstance(page_image_b64, str) or not page_image_b64:
+        return []
+
+    try:
+        raw = base64.b64decode(page_image_b64)
+        im0 = Image.open(io.BytesIO(raw))
+        im = im0.convert("RGB")
+        im0.close()
+    except Exception:
+        return []
+
+    w, h = im.size
+    if w <= 1 or h <= 1:
+        im.close()
+        return []
+
+    def _clamp_int(v: float, lo: int, hi: int) -> int:
+        if v != v:  # NaN
+            return lo
+        return int(min(max(v, float(lo)), float(hi)))
+
+    results: List[Tuple[str, List[float], np.ndarray]] = []
+    for det in detections:
+        if not isinstance(det, dict):
+            continue
+        label_name = str(det.get("label_name") or "").strip()
+        if label_name not in wanted_labels:
+            continue
+
+        bbox = det.get("bbox_xyxy_norm")
+        if not isinstance(bbox, (list, tuple)) or len(bbox) != 4:
+            continue
+
+        try:
+            x1n, y1n, x2n, y2n = [float(x) for x in bbox]
+        except Exception:
+            continue
+
+        x1 = _clamp_int(x1n * w, 0, w)
+        x2 = _clamp_int(x2n * w, 0, w)
+        y1 = _clamp_int(y1n * h, 0, h)
+        y2 = _clamp_int(y2n * h, 0, h)
+
+        if x2 <= x1 or y2 <= y1:
+            continue
+
+        crop = im.crop((x1, y1, x2, y2))
+        cw, ch = crop.size
+        if cw <= 1 or ch <= 1:
+            crop.close()
+            continue
+
+        crop_array = np.asarray(crop, dtype=np.uint8).copy()
+        crop.close()
+        results.append((label_name, [float(x) for x in bbox], crop_array))
+
+    im.close()
+    return results
+
+
+def _np_rgb_to_b64_png(crop_array: np.ndarray) -> str:
+    if Image is None:  # pragma: no cover
+        raise ImportError("Pillow is required for image encoding.")
+    img = Image.fromarray(crop_array.astype(np.uint8), mode="RGB")
+    buf = io.BytesIO()
+    img.save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode("ascii")
+
+
+def _extract_remote_ocr_item(response_item: Any) -> Any:
+    if isinstance(response_item, dict):
+        # NIM text_detections format: return full list (not v[0])
+        td = response_item.get("text_detections")
+        if isinstance(td, list) and td:
+            return td
+        for k in ("prediction", "predictions", "output", "outputs", "data"):
+            v = response_item.get(k)
+            if isinstance(v, list) and v:
+                return v[0]
+            if v is not None:
+                return v
+    return response_item
+
+
+def _parse_ocr_result(preds: Any) -> List[Dict[str, Any]]:
+    """
+    Parse the output of ``NemotronOCRV1.invoke()`` into a flat list of
+    ``{"text": str, "sort_y": float, "sort_x": float}`` blocks.
+
+    The model may return:
+    * ``dict`` with ``boxes`` / ``texts`` keys (packed form), or
+    * ``list[dict]`` with ``left``/``right``/``upper``/``lower``/``text`` keys
+      (Nemotron OCR normalized-coord form), or
+    * ``list[dict]`` with generic ``text`` + ``box``/``bbox`` keys.
+    """
+    blocks: List[Dict[str, Any]] = []
+
+    # ---- dict form: {"boxes": [...], "texts": [...]} ----
+    if isinstance(preds, dict):
+        pb = preds.get("boxes") or preds.get("bboxes") or preds.get("bounding_boxes")
+        pt = preds.get("texts") or preds.get("text_predictions") or preds.get("text")
+        if isinstance(pb, list) and isinstance(pt, list):
+            for b, txt in zip(pb, pt):
+                if not isinstance(txt, str) or not txt.strip():
+                    continue
+                sort_y, sort_x = 0.0, 0.0
+                if isinstance(b, list):
+                    if len(b) == 4 and all(isinstance(p, (list, tuple)) and len(p) == 2 for p in b):
+                        # quadrilateral [[x1,y1], ...]
+                        sort_y = float(b[0][1])
+                        sort_x = float(b[0][0])
+                    elif len(b) == 4 and all(isinstance(v, (int, float)) for v in b):
+                        # xyxy [x1, y1, x2, y2]
+                        sort_y = float(b[1])
+                        sort_x = float(b[0])
+                blocks.append({"text": txt.strip(), "sort_y": sort_y, "sort_x": sort_x})
+        return blocks
+
+    # ---- list form: list[dict] with various key conventions ----
+    if isinstance(preds, list):
+        for item in preds:
+            if isinstance(item, str):
+                if item.strip():
+                    blocks.append({"text": item.strip(), "sort_y": 0.0, "sort_x": 0.0})
+                continue
+            if not isinstance(item, dict):
+                continue
+
+            # NIM text_detections format:
+            # {"text_prediction": {"text": "...", "confidence": ...},
+            #  "bounding_box": {"points": [{"x": ..., "y": ...}, ...]}}
+            tp = item.get("text_prediction")
+            if isinstance(tp, dict):
+                txt0 = str(tp.get("text") or "").strip()
+                if txt0 and txt0 != "nan":
+                    sort_y, sort_x = 0.0, 0.0
+                    bb = item.get("bounding_box")
+                    if isinstance(bb, dict):
+                        pts = bb.get("points")
+                        if isinstance(pts, list) and pts:
+                            try:
+                                sort_x = float(pts[0].get("x", 0.0))
+                                sort_y = float(pts[0].get("y", 0.0))
+                            except Exception:
+                                pass
+                    blocks.append({"text": txt0, "sort_y": sort_y, "sort_x": sort_x})
+                continue
+
+            # Nemotron OCR normalized-coord form
+            if all(k in item for k in ("left", "right", "upper", "lower")) and isinstance(item.get("text"), str):
+                txt0 = str(item.get("text") or "").strip()
+                if not txt0 or txt0 == "nan":
+                    continue
+                try:
+                    sort_x = float(item["left"])
+                    sort_y = float(item["lower"])
+                except Exception:
+                    sort_x, sort_y = 0.0, 0.0
+                blocks.append({"text": txt0, "sort_y": sort_y, "sort_x": sort_x})
+                continue
+
+            # Generic text + box fallback
+            txt = item.get("text") or item.get("ocr_text") or item.get("generated_text") or item.get("output_text")
+            if not isinstance(txt, str) or not txt.strip():
+                continue
+            sort_y, sort_x = 0.0, 0.0
+            b = item.get("box") or item.get("bbox") or item.get("bounding_box") or item.get("bbox_points")
+            if isinstance(b, list):
+                if len(b) == 4 and all(isinstance(p, (list, tuple)) and len(p) == 2 for p in b):
+                    sort_y = float(b[0][1])
+                    sort_x = float(b[0][0])
+                elif len(b) == 4 and all(isinstance(v, (int, float)) for v in b):
+                    sort_y = float(b[1])
+                    sort_x = float(b[0])
+            blocks.append({"text": txt.strip(), "sort_y": sort_y, "sort_x": sort_x})
+
+    # ---- last-resort stringify ----
+    if not blocks and preds is not None:
+        s = ""
+        try:
+            s = str(preds).strip()
+        except Exception:
+            s = ""
+        if s and s.lower() not in {"none", "null", "[]", "{}"}:
+            blocks.append({"text": s, "sort_y": 0.0, "sort_x": 0.0})
+
+    return blocks
+
+
+def _blocks_to_text(blocks: List[Dict[str, Any]]) -> str:
+    """Sort text blocks by reading order (y then x) and join with newlines."""
+    blocks.sort(key=lambda b: (b.get("sort_y", 0.0), b.get("sort_x", 0.0)))
+    return "\n".join(b["text"] for b in blocks if b.get("text"))
+
+
+def _blocks_to_pseudo_markdown(blocks: List[Dict[str, Any]]) -> str:
+    """Convert OCR text blocks into pseudo-markdown table format.
+
+    Uses DBSCAN clustering on y-coordinates to identify rows, then
+    sorts within each row by x-coordinate and joins with pipe separators.
+    """
+    if not blocks:
+        return ""
+
+    valid = [b for b in blocks if b.get("text")]
+    if not valid:
+        return ""
+
+    from sklearn.cluster import DBSCAN
+
+    df = pd.DataFrame(valid)
+
+    # Normalize y-coordinates to [0,1] for scale-invariant clustering.
+    y_vals = df["sort_y"].values
+    y_range = y_vals.max() - y_vals.min()
+    if y_range > 0:
+        y_norm = (y_vals - y_vals.min()) / y_range
+        eps = 0.03  # ~3% of bbox height ≈ one text line
+    else:
+        y_norm = y_vals
+        eps = 0.1
+
+    dbscan = DBSCAN(eps=eps, min_samples=1)
+    dbscan.fit(y_norm.reshape(-1, 1))
+    df["cluster"] = dbscan.labels_
+
+    df = df.sort_values(["cluster", "sort_x"])
+
+    rows = []
+    for _, grp in df.groupby("cluster", sort=True):
+        rows.append("| " + " | ".join(grp["text"].tolist()) + " |")
+    return "\n".join(rows)
+
+
+# ---------------------------------------------------------------------------
+# Core function
+# ---------------------------------------------------------------------------
+
+
+def ocr_page_elements(
+    batch_df: Any,
+    *,
+    model: Any = None,
+    invoke_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    request_timeout_s: float = 120.0,
+    extract_tables: bool = False,
+    extract_charts: bool = False,
+    extract_infographics: bool = False,
+    remote_retry: RemoteRetryParams | None = None,
+    **kwargs: Any,
+) -> Any:
+    retry = remote_retry or RemoteRetryParams(
+        remote_max_pool_workers=int(kwargs.get("remote_max_pool_workers", 16)),
+        remote_max_retries=int(kwargs.get("remote_max_retries", 10)),
+        remote_max_429_retries=int(kwargs.get("remote_max_429_retries", 5)),
+    )
+    """
+    Run Nemotron OCR v1 on cropped regions detected by PageElements v3.
+
+    For each row (page) in ``batch_df``:
+    1. Read ``page_elements_v3`` detections and ``page_image["image_b64"]``.
+    2. For each detection whose ``label_name`` is a requested type, crop the
+       page image, invoke OCR, parse the result, and collect text.
+    3. Write per-type content lists and timing metadata to output columns.
+
+    Parameters
+    ----------
+    batch_df : pandas.DataFrame
+        Ray Data batch with ``page_elements_v3`` and ``page_image`` columns.
+    model : NemotronOCRV1
+        Initialised OCR model.
+    extract_tables, extract_charts, extract_infographics : bool
+        Which element types to OCR.
+
+    Returns
+    -------
+    pandas.DataFrame
+        Original columns plus ``table``, ``chart``,
+        ``infographic``, and ``ocr_v1``.
+    """
+    if not isinstance(batch_df, pd.DataFrame):
+        raise NotImplementedError("ocr_page_elements currently only supports pandas.DataFrame input.")
+    invoke_url = (invoke_url or kwargs.get("ocr_invoke_url") or "").strip()
+    use_remote = bool(invoke_url)
+    if not use_remote and model is None:
+        raise ValueError("A local `model` is required when `invoke_url` is not provided.")
+
+    # Determine which labels we need to process.
+    wanted_labels: set[str] = set()
+    if extract_tables:
+        wanted_labels.add("table")
+    if extract_charts:
+        wanted_labels.add("chart")
+    if extract_infographics:
+        wanted_labels.add("infographic")
+
+    # Per-row accumulators.
+    all_table: List[List[Dict[str, Any]]] = []
+    all_chart: List[List[Dict[str, Any]]] = []
+    all_infographic: List[List[Dict[str, Any]]] = []
+    all_ocr_meta: List[Dict[str, Any]] = []
+
+    t0_total = time.perf_counter()
+
+    for row in batch_df.itertuples(index=False):
+        table_items: List[Dict[str, Any]] = []
+        chart_items: List[Dict[str, Any]] = []
+        infographic_items: List[Dict[str, Any]] = []
+        row_error: Any = None
+
+        try:
+            # --- get page elements detections ---
+            pe = getattr(row, "page_elements_v3", None)
+            dets: List[Dict[str, Any]] = []
+            if isinstance(pe, dict):
+                dets = pe.get("detections") or []
+            if not isinstance(dets, list):
+                dets = []
+
+            # --- get page image ---
+            page_image = getattr(row, "page_image", None) or {}
+            page_image_b64 = page_image.get("image_b64") if isinstance(page_image, dict) else None
+
+            if not isinstance(page_image_b64, str) or not page_image_b64:
+                # No image available — nothing to crop/OCR.
+                all_table.append(table_items)
+                all_chart.append(chart_items)
+                all_infographic.append(infographic_items)
+                all_ocr_meta.append({"timing": None, "error": None})
+                continue
+
+            # --- decode page image once, crop all matching detections ---
+            crops = _crop_all_from_page(page_image_b64, dets, wanted_labels)
+
+            if use_remote:
+                crop_b64s: List[str] = []
+                crop_meta: List[Tuple[str, List[float]]] = []
+                for label_name, bbox, crop_array in crops:
+                    crop_b64s.append(_np_rgb_to_b64_png(crop_array))
+                    crop_meta.append((label_name, bbox))
+
+                if crop_b64s:
+                    response_items = invoke_image_inference_batches(
+                        invoke_url=invoke_url,
+                        image_b64_list=crop_b64s,
+                        api_key=api_key,
+                        timeout_s=float(request_timeout_s),
+                        max_batch_size=int(kwargs.get("inference_batch_size", 8)),
+                        max_pool_workers=int(retry.remote_max_pool_workers),
+                        max_retries=int(retry.remote_max_retries),
+                        max_429_retries=int(retry.remote_max_429_retries),
+                    )
+                    if len(response_items) != len(crop_meta):
+                        raise RuntimeError(f"Expected {len(crop_meta)} OCR responses, got {len(response_items)}")
+
+                    for i, (label_name, bbox) in enumerate(crop_meta):
+                        preds = _extract_remote_ocr_item(response_items[i])
+                        blocks = _parse_ocr_result(preds)
+                        if label_name == "table":
+                            text = _blocks_to_pseudo_markdown(blocks) or _blocks_to_text(blocks)
+                        else:
+                            text = _blocks_to_text(blocks)
+                        entry = {"bbox_xyxy_norm": bbox, "text": text}
+                        if label_name == "table":
+                            table_items.append(entry)
+                        elif label_name == "chart":
+                            chart_items.append(entry)
+                        elif label_name == "infographic":
+                            infographic_items.append(entry)
+            else:
+                for label_name, bbox, crop_array in crops:
+                    # Use word-level merging for tables to preserve cell boundaries;
+                    # paragraph-level for charts/infographics where structure matters less.
+                    ml = "word" if label_name == "table" else "paragraph"
+                    preds = model.invoke(crop_array, merge_level=ml)
+
+                    # Parse and assemble text.
+                    blocks = _parse_ocr_result(preds)
+                    if label_name == "table":
+                        text = _blocks_to_pseudo_markdown(blocks)
+                        if not text:
+                            text = _blocks_to_text(blocks)  # fallback
+                    else:
+                        text = _blocks_to_text(blocks)
+
+                    entry = {
+                        "bbox_xyxy_norm": bbox,
+                        "text": text,
+                    }
+
+                    if label_name == "table":
+                        table_items.append(entry)
+                    elif label_name == "chart":
+                        chart_items.append(entry)
+                    elif label_name == "infographic":
+                        infographic_items.append(entry)
+
+        except BaseException as e:
+            print(f"Warning: OCR failed: {type(e).__name__}: {e}")
+            row_error = {
+                "stage": "ocr_page_elements",
+                "type": e.__class__.__name__,
+                "message": str(e),
+                "traceback": "".join(traceback.format_exception(type(e), e, e.__traceback__)),
+            }
+
+        all_table.append(table_items)
+        all_chart.append(chart_items)
+        all_infographic.append(infographic_items)
+        all_ocr_meta.append({"timing": None, "error": row_error})
+
+    elapsed = time.perf_counter() - t0_total
+
+    # Fill timing into metadata.
+    for meta in all_ocr_meta:
+        meta["timing"] = {"seconds": float(elapsed)}
+
+    out = batch_df.copy()
+    out["table"] = all_table
+    out["chart"] = all_chart
+    out["infographic"] = all_infographic
+    out["ocr_v1"] = all_ocr_meta
+    return out
+
+
+# ---------------------------------------------------------------------------
+# Ray Actor
+# ---------------------------------------------------------------------------
+
+
+class OCRActor:
+    """
+    Ray-friendly callable that initializes Nemotron OCR v1 once per actor.
+
+    Usage with Ray Data::
+
+        ds = ds.map_batches(
+            OCRActor,
+            batch_size=16, batch_format="pandas", num_cpus=4, num_gpus=1,
+            compute=ray.data.ActorPoolStrategy(size=8),
+            fn_constructor_kwargs={
+                "extract_tables": True,
+                "extract_charts": True,
+                "extract_infographics": False,
+            },
+        )
+    """
+
+    __slots__ = (
+        "_model",
+        "_extract_tables",
+        "_extract_charts",
+        "_extract_infographics",
+        "_invoke_url",
+        "_api_key",
+        "_request_timeout_s",
+        "_remote_retry",
+    )
+
+    def __init__(
+        self,
+        *,
+        extract_tables: bool = False,
+        extract_charts: bool = False,
+        extract_infographics: bool = False,
+        ocr_invoke_url: Optional[str] = None,
+        invoke_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        request_timeout_s: float = 120.0,
+        remote_max_pool_workers: int = 16,
+        remote_max_retries: int = 10,
+        remote_max_429_retries: int = 5,
+    ) -> None:
+        self._invoke_url = (ocr_invoke_url or invoke_url or "").strip()
+        self._api_key = api_key
+        self._request_timeout_s = float(request_timeout_s)
+        self._remote_retry = RemoteRetryParams(
+            remote_max_pool_workers=int(remote_max_pool_workers),
+            remote_max_retries=int(remote_max_retries),
+            remote_max_429_retries=int(remote_max_429_retries),
+        )
+        if self._invoke_url:
+            self._model = None
+        else:
+            from nemo_retriever.model.local import NemotronOCRV1
+
+            self._model = NemotronOCRV1()
+        self._extract_tables = bool(extract_tables)
+        self._extract_charts = bool(extract_charts)
+        self._extract_infographics = bool(extract_infographics)
+
+    def __call__(self, batch_df: Any, **override_kwargs: Any) -> Any:
+        try:
+            return ocr_page_elements(
+                batch_df,
+                model=self._model,
+                invoke_url=self._invoke_url,
+                api_key=self._api_key,
+                request_timeout_s=self._request_timeout_s,
+                extract_tables=self._extract_tables,
+                extract_charts=self._extract_charts,
+                extract_infographics=self._extract_infographics,
+                remote_retry=self._remote_retry,
+                **override_kwargs,
+            )
+        except BaseException as e:
+            # Never let the Ray UDF raise — return a DataFrame with error metadata.
+            if isinstance(batch_df, pd.DataFrame):
+                out = batch_df.copy()
+                payload = _error_payload(stage="actor_call", exc=e)
+                n = len(out.index)
+                out["table"] = [[] for _ in range(n)]
+                out["chart"] = [[] for _ in range(n)]
+                out["infographic"] = [[] for _ in range(n)]
+                out["ocr_v1"] = [payload for _ in range(n)]
+                return out
+            return [{"ocr_v1": _error_payload(stage="actor_call", exc=e)}]
+
+
+# ---------------------------------------------------------------------------
+# Nemotron Parse v1.2
+# ---------------------------------------------------------------------------
+
+
+def _extract_parse_text(response_item: Any) -> str:
+    if response_item is None:
+        return ""
+    if isinstance(response_item, str):
+        return response_item.strip()
+    if isinstance(response_item, dict):
+        for key in ("generated_text", "text", "output_text", "prediction", "output", "data"):
+            value = response_item.get(key)
+            if isinstance(value, str) and value.strip():
+                return value.strip()
+            if isinstance(value, list) and value:
+                first = value[0]
+                if isinstance(first, str) and first.strip():
+                    return first.strip()
+                if isinstance(first, dict):
+                    inner = _extract_parse_text(first)
+                    if inner:
+                        return inner
+    if isinstance(response_item, list):
+        for item in response_item:
+            text = _extract_parse_text(item)
+            if text:
+                return text
+    try:
+        return str(response_item).strip()
+    except Exception:
+        return ""
+
+
+def nemotron_parse_page_elements(
+    batch_df: Any,
+    *,
+    model: Any = None,
+    invoke_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    request_timeout_s: float = 120.0,
+    extract_tables: bool = False,
+    extract_charts: bool = False,
+    extract_infographics: bool = False,
+    task_prompt: str = "</s><s><predict_bbox><predict_classes><output_markdown><predict_no_text_in_pic>",
+    remote_retry: RemoteRetryParams | None = None,
+    **kwargs: Any,
+) -> Any:
+    """
+    Run Nemotron Parse v1.2 on cropped page elements.
+
+    Emits OCR-compatible content columns (``table``, ``chart``, ``infographic``)
+    so this stage can replace the page-elements + OCR pair in pipeline wiring.
+    """
+    retry = remote_retry or RemoteRetryParams(
+        remote_max_pool_workers=int(kwargs.get("remote_max_pool_workers", 16)),
+        remote_max_retries=int(kwargs.get("remote_max_retries", 10)),
+        remote_max_429_retries=int(kwargs.get("remote_max_429_retries", 5)),
+    )
+    if not isinstance(batch_df, pd.DataFrame):
+        raise NotImplementedError("nemotron_parse_page_elements currently only supports pandas.DataFrame input.")
+
+    invoke_url = (invoke_url or kwargs.get("nemotron_parse_invoke_url") or "").strip()
+    use_remote = bool(invoke_url)
+    if not use_remote and model is None:
+        raise ValueError("A local `model` is required when `invoke_url` is not provided.")
+
+    wanted_labels: set[str] = set()
+    if extract_tables:
+        wanted_labels.add("table")
+    if extract_charts:
+        wanted_labels.add("chart")
+    if extract_infographics:
+        wanted_labels.add("infographic")
+
+    all_table: List[List[Dict[str, Any]]] = []
+    all_chart: List[List[Dict[str, Any]]] = []
+    all_infographic: List[List[Dict[str, Any]]] = []
+    all_meta: List[Dict[str, Any]] = []
+
+    t0_total = time.perf_counter()
+
+    for row in batch_df.itertuples(index=False):
+        table_items: List[Dict[str, Any]] = []
+        chart_items: List[Dict[str, Any]] = []
+        infographic_items: List[Dict[str, Any]] = []
+        row_error: Any = None
+
+        try:
+            pe = getattr(row, "page_elements_v3", None)
+            dets: List[Dict[str, Any]] = []
+            if isinstance(pe, dict):
+                dets = pe.get("detections") or []
+            if not isinstance(dets, list):
+                dets = []
+
+            page_image = getattr(row, "page_image", None) or {}
+            page_image_b64 = page_image.get("image_b64") if isinstance(page_image, dict) else None
+            if not isinstance(page_image_b64, str) or not page_image_b64:
+                all_table.append(table_items)
+                all_chart.append(chart_items)
+                all_infographic.append(infographic_items)
+                all_meta.append({"timing": None, "error": None})
+                continue
+
+            crops = _crop_all_from_page(page_image_b64, dets, wanted_labels)
+            # Parse-only mode may skip page-elements detection entirely. In that
+            # case, parse the full page once and fan out the text to enabled
+            # content channels.
+            if not crops and wanted_labels:
+                try:
+                    raw = base64.b64decode(page_image_b64)
+                    with Image.open(io.BytesIO(raw)) as im0:
+                        full_crop = np.asarray(im0.convert("RGB"), dtype=np.uint8).copy()
+                    crops = [("full_page", [0.0, 0.0, 1.0, 1.0], full_crop)]
+                except Exception:
+                    crops = []
+
+            if use_remote:
+                crop_b64s: List[str] = []
+                crop_meta: List[Tuple[str, List[float]]] = []
+                for label_name, bbox, crop_array in crops:
+                    crop_b64s.append(_np_rgb_to_b64_png(crop_array))
+                    crop_meta.append((label_name, bbox))
+
+                if crop_b64s:
+                    response_items = invoke_image_inference_batches(
+                        invoke_url=invoke_url,
+                        image_b64_list=crop_b64s,
+                        api_key=api_key,
+                        timeout_s=float(request_timeout_s),
+                        max_batch_size=int(kwargs.get("inference_batch_size", 8)),
+                        max_pool_workers=int(retry.remote_max_pool_workers),
+                        max_retries=int(retry.remote_max_retries),
+                        max_429_retries=int(retry.remote_max_429_retries),
+                    )
+                    if len(response_items) != len(crop_meta):
+                        raise RuntimeError(f"Expected {len(crop_meta)} Parse responses, got {len(response_items)}")
+
+                    for i, (label_name, bbox) in enumerate(crop_meta):
+                        text = _extract_parse_text(response_items[i])
+                        entry = {"bbox_xyxy_norm": bbox, "text": text}
+                        if label_name == "table":
+                            table_items.append(entry)
+                        elif label_name == "chart":
+                            chart_items.append(entry)
+                        elif label_name == "infographic":
+                            infographic_items.append(entry)
+                        elif label_name == "full_page":
+                            if extract_tables:
+                                table_items.append(dict(entry))
+                            if extract_charts:
+                                chart_items.append(dict(entry))
+                            if extract_infographics:
+                                infographic_items.append(dict(entry))
+            else:
+                for label_name, bbox, crop_array in crops:
+                    text = str(model.invoke(crop_array, task_prompt=task_prompt) or "").strip()
+                    entry = {"bbox_xyxy_norm": bbox, "text": text}
+                    if label_name == "table":
+                        table_items.append(entry)
+                    elif label_name == "chart":
+                        chart_items.append(entry)
+                    elif label_name == "infographic":
+                        infographic_items.append(entry)
+                    elif label_name == "full_page":
+                        if extract_tables:
+                            table_items.append(dict(entry))
+                        if extract_charts:
+                            chart_items.append(dict(entry))
+                        if extract_infographics:
+                            infographic_items.append(dict(entry))
+
+        except BaseException as e:
+            print(f"Warning: Nemotron Parse failed: {type(e).__name__}: {e}")
+            row_error = {
+                "stage": "nemotron_parse_page_elements",
+                "type": e.__class__.__name__,
+                "message": str(e),
+                "traceback": "".join(traceback.format_exception(type(e), e, e.__traceback__)),
+            }
+
+        all_table.append(table_items)
+        all_chart.append(chart_items)
+        all_infographic.append(infographic_items)
+        all_meta.append({"timing": None, "error": row_error})
+
+    elapsed = time.perf_counter() - t0_total
+    for meta in all_meta:
+        meta["timing"] = {"seconds": float(elapsed)}
+
+    out = batch_df.copy()
+    out["table"] = all_table
+    out["chart"] = all_chart
+    out["infographic"] = all_infographic
+    # Aliases retained for experiments that read parse-specific columns.
+    out["table_parse"] = all_table
+    out["chart_parse"] = all_chart
+    out["infographic_parse"] = all_infographic
+    out["nemotron_parse_v1_2"] = all_meta
+    return out
+
+
+class NemotronParseActor:
+    """
+    Ray-friendly callable that initializes Nemotron Parse v1.2 once per actor.
+
+    This actor is a drop-in map-batches stage intended for future pipeline
+    wiring in batch/inprocess ingest modes.
+    """
+
+    __slots__ = (
+        "_model",
+        "_extract_tables",
+        "_extract_charts",
+        "_extract_infographics",
+        "_invoke_url",
+        "_api_key",
+        "_request_timeout_s",
+        "_task_prompt",
+        "_remote_retry",
+    )
+
+    def __init__(
+        self,
+        *,
+        extract_tables: bool = False,
+        extract_charts: bool = False,
+        extract_infographics: bool = False,
+        nemotron_parse_invoke_url: Optional[str] = None,
+        invoke_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+        request_timeout_s: float = 120.0,
+        task_prompt: str = "</s><s><predict_bbox><predict_classes><output_markdown><predict_no_text_in_pic>",
+        remote_max_pool_workers: int = 16,
+        remote_max_retries: int = 10,
+        remote_max_429_retries: int = 5,
+    ) -> None:
+        self._invoke_url = (nemotron_parse_invoke_url or invoke_url or "").strip()
+        self._api_key = api_key
+        self._request_timeout_s = float(request_timeout_s)
+        self._task_prompt = str(task_prompt)
+        self._remote_retry = RemoteRetryParams(
+            remote_max_pool_workers=int(remote_max_pool_workers),
+            remote_max_retries=int(remote_max_retries),
+            remote_max_429_retries=int(remote_max_429_retries),
+        )
+        if self._invoke_url:
+            self._model = None
+        else:
+            from nemo_retriever.model.local import NemotronParseV12
+
+            self._model = NemotronParseV12(task_prompt=self._task_prompt)
+        self._extract_tables = bool(extract_tables)
+        self._extract_charts = bool(extract_charts)
+        self._extract_infographics = bool(extract_infographics)
+
+    def __call__(self, batch_df: Any, **override_kwargs: Any) -> Any:
+        try:
+            return nemotron_parse_page_elements(
+                batch_df,
+                model=self._model,
+                invoke_url=self._invoke_url,
+                api_key=self._api_key,
+                request_timeout_s=self._request_timeout_s,
+                task_prompt=self._task_prompt,
+                extract_tables=self._extract_tables,
+                extract_charts=self._extract_charts,
+                extract_infographics=self._extract_infographics,
+                remote_retry=self._remote_retry,
+                **override_kwargs,
+            )
+        except BaseException as e:
+            if isinstance(batch_df, pd.DataFrame):
+                out = batch_df.copy()
+                payload = _error_payload(stage="nemotron_parse_actor_call", exc=e)
+                n = len(out.index)
+                out["table"] = [[] for _ in range(n)]
+                out["chart"] = [[] for _ in range(n)]
+                out["infographic"] = [[] for _ in range(n)]
+                out["table_parse"] = [[] for _ in range(n)]
+                out["chart_parse"] = [[] for _ in range(n)]
+                out["infographic_parse"] = [[] for _ in range(n)]
+                out["nemotron_parse_v1_2"] = [payload for _ in range(n)]
+                return out
+            return [{"nemotron_parse_v1_2": _error_payload(stage="nemotron_parse_actor_call", exc=e)}]
diff --git a/nemo_retriever/src/nemo_retriever/online/__init__.py b/nemo_retriever/src/nemo_retriever/online/__init__.py
new file mode 100644
index 000000000..f53774dcc
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/online/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Online ingest: Ray Serve REST API and CLI for submitting documents."""
diff --git a/nemo_retriever/src/nemo_retriever/online/__main__.py b/nemo_retriever/src/nemo_retriever/online/__main__.py
new file mode 100644
index 000000000..154ef2737
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/online/__main__.py
@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.adapters.service.cli import app, main, serve_cmd, stream_pdf_cmd, submit_cmd
+
+__all__ = ["app", "main", "serve_cmd", "stream_pdf_cmd", "submit_cmd"]
diff --git a/nemo_retriever/src/nemo_retriever/page_elements/__init__.py b/nemo_retriever/src/nemo_retriever/page_elements/__init__.py
new file mode 100644
index 000000000..592ba25b5
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/page_elements/__init__.py
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Page element detection stage (Nemotron Page Elements v3).
+
+This package provides:
+- `detect_page_elements_v3`: pure-Python batch function (pandas.DataFrame in/out)
+- `PageElementDetectionActor`: Ray-friendly callable that initializes the model once
+"""
+
+from .page_elements import PageElementDetectionActor, detect_page_elements_v3
+
+__all__ = [
+    "detect_page_elements_v3",
+    "PageElementDetectionActor",
+]
diff --git a/nemo_retriever/src/nemo_retriever/page_elements/page_elements.py b/nemo_retriever/src/nemo_retriever/page_elements/page_elements.py
new file mode 100644
index 000000000..fc9052ddf
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/page_elements/page_elements.py
@@ -0,0 +1,749 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
+
+import base64
+import io
+import time
+import traceback
+
+from nemotron_page_elements_v3.utils import postprocess_preds_page_element
+import pandas as pd
+from nemo_retriever.params import RemoteRetryParams
+
+try:
+    import numpy as np
+except Exception:  # pragma: no cover
+    np = None  # type: ignore[assignment]
+
+try:
+    import torch
+except Exception:  # pragma: no cover
+    torch = None  # type: ignore[assignment]
+
+try:
+    from PIL import Image
+except Exception:  # pragma: no cover
+    Image = None  # type: ignore[assignment]
+
+try:
+    from nv_ingest_api.internal.primitives.nim.model_interface.yolox import (
+        postprocess_page_elements_v3,
+        YOLOX_PAGE_V3_CLASS_LABELS,
+    )
+except ImportError:
+    postprocess_page_elements_v3 = None  # type: ignore[assignment,misc]
+    YOLOX_PAGE_V3_CLASS_LABELS = None  # type: ignore[assignment]
+
+from nemo_retriever.nim.nim import invoke_page_elements_batches
+
+
+TensorOrArray = Union["torch.Tensor", "np.ndarray"]
+
+
+def _ensure_chw_float_tensor(x: TensorOrArray) -> "torch.Tensor":
+    """
+    Normalize a single image into a CHW float32 torch.Tensor suitable for batching.
+
+    Accepts either:
+    - torch.Tensor in CHW or 1xCHW (or CHW-like) formats
+    - np.ndarray in CHW or HWC (RGB) formats (optionally with leading batch dim=1)
+    """
+    if torch is None or np is None:  # pragma: no cover
+        raise ImportError("page element detection requires torch and numpy.")
+
+    if isinstance(x, torch.Tensor):
+        t = x
+    elif isinstance(x, np.ndarray):
+        arr = x
+        # Squeeze trivial batch dimension if present.
+        if arr.ndim == 4 and int(arr.shape[0]) == 1:
+            arr = arr[0]
+        if arr.ndim != 3:
+            raise ValueError(f"Expected 3D image array, got shape {getattr(arr, 'shape', None)}")
+
+        # Heuristic: HWC (RGB) -> CHW; otherwise assume already CHW-like.
+        if int(arr.shape[-1]) == 3 and int(arr.shape[0]) != 3:
+            t = torch.from_numpy(np.ascontiguousarray(arr)).permute(2, 0, 1)
+        else:
+            t = torch.from_numpy(np.ascontiguousarray(arr))
+    else:
+        raise TypeError(f"Expected torch.Tensor or np.ndarray, got {type(x)!r}")
+
+    # Squeeze trivial batch dimension if present.
+    if t.ndim == 4 and int(t.shape[0]) == 1:
+        t = t[0]
+    if t.ndim != 3:
+        raise ValueError(f"Expected CHW tensor, got shape {tuple(t.shape)}")
+
+    # Keep 0-255 range: resize_pad pads with 114.0 (designed for 0-255),
+    # and YoloXWrapper.forward() handles the 0-255 → model-input conversion.
+    t = t.to(dtype=torch.float32)
+
+    return t.contiguous()
+
+
+def _error_payload(*, stage: str, exc: BaseException) -> Dict[str, Any]:
+    return {
+        "detections": [],
+        "error": {
+            "stage": str(stage),
+            "type": exc.__class__.__name__,
+            "message": str(exc),
+            "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+        },
+    }
+
+
+def _decode_b64_image_to_chw_tensor(image_b64: str) -> Tuple["torch.Tensor", Tuple[int, int]]:
+    if torch is None or Image is None or np is None:  # pragma: no cover
+        raise ImportError("page element detection requires torch, pillow, and numpy.")
+
+    raw = base64.b64decode(image_b64)
+    with Image.open(io.BytesIO(raw)) as im0:
+        im = im0.convert("RGB")
+        w, h = im.size
+        arr = np.array(im)  # (H,W,3)
+
+    t = torch.from_numpy(arr).permute(2, 0, 1).contiguous()  # (3,H,W) uint8
+    t = t.to(dtype=torch.float32) / 255.0
+    return t, (int(h), int(w))
+
+
+def _decode_b64_image_to_np_array(image_b64: str) -> Tuple["np.array", Tuple[int, int]]:
+    if torch is None or Image is None or np is None:  # pragma: no cover
+        raise ImportError("page element detection requires torch, pillow, and numpy.")
+
+    raw = base64.b64decode(image_b64)
+    with Image.open(io.BytesIO(raw)) as im0:
+        im = im0.convert("RGB")
+        w, h = im.size
+        arr = np.array(im)
+
+    return arr, (int(h), int(w))
+
+
+def _labels_from_model(_model: Any) -> List[str]:
+    return [
+        "table",
+        "chart",
+        "title",
+        "infographic",
+        "text",
+        "header_footer",
+    ]
+
+
+def _counts_by_label(detections: Sequence[Dict[str, Any]]) -> Dict[str, int]:
+    out: Dict[str, int] = {}
+    for d in detections:
+        if not isinstance(d, dict):
+            continue
+        name = d.get("label_name")
+        if not isinstance(name, str) or not name.strip():
+            name = f"label_{d.get('label')}"
+        k = str(name)
+        out[k] = int(out.get(k, 0) + 1)
+    return out
+
+
+def _postprocess_to_per_image_detections(
+    *,
+    boxes: Any,
+    labels: Any,
+    scores: Any,
+    batch_size: int,
+    label_names: List[str],
+) -> List[List[Dict[str, Any]]]:
+    """
+    Convert model postprocess outputs into a list of per-image detection dicts.
+
+    Expected detection format matches the "stage2 page_elements_v3 json" used by `nemo_retriever.utils.image.render`.
+    """
+    if torch is None:  # pragma: no cover
+        raise ImportError("torch is required for page element detection postprocess.")
+
+    # Normalize to per-image tensors.
+    def _as_list(x: Any) -> List[Any]:
+        if isinstance(x, list):
+            return x
+        return [x]
+
+    # If tensors include a batch dimension, split them.
+    if isinstance(boxes, torch.Tensor) and boxes.ndim == 3:
+        boxes_list = [boxes[i] for i in range(int(boxes.shape[0]))]
+    else:
+        boxes_list = _as_list(boxes)
+
+    if isinstance(labels, torch.Tensor) and labels.ndim == 2:
+        labels_list = [labels[i] for i in range(int(labels.shape[0]))]
+    else:
+        labels_list = _as_list(labels)
+
+    if isinstance(scores, torch.Tensor) and scores.ndim == 2:
+        scores_list = [scores[i] for i in range(int(scores.shape[0]))]
+    else:
+        scores_list = _as_list(scores)
+
+    n = min(len(boxes_list), len(labels_list), len(scores_list), int(batch_size))
+    out: List[List[Dict[str, Any]]] = []
+    for i in range(n):
+        bi = boxes_list[i]
+        li = labels_list[i]
+        si = scores_list[i]
+
+        if not isinstance(bi, torch.Tensor) or not isinstance(li, torch.Tensor) or not isinstance(si, torch.Tensor):
+            out.append([])
+            continue
+
+        # Move to CPU for safe conversion.
+        bi = bi.detach().cpu()
+        li = li.detach().cpu()
+        si = si.detach().cpu()
+
+        # Common shapes:
+        # - boxes: (N,4)
+        # - labels: (N,)
+        # - scores: (N,)
+        if bi.ndim != 2 or bi.shape[-1] != 4:
+            out.append([])
+            continue
+
+        n_det = int(bi.shape[0])
+        dets: List[Dict[str, Any]] = []
+        for j in range(n_det):
+            try:
+                x1, y1, x2, y2 = [float(x) for x in bi[j].tolist()]
+            except Exception:
+                continue
+
+            label_i: Optional[int]
+            try:
+                label_i = int(li[j].item())
+            except Exception:
+                label_i = None
+
+            score_f: Optional[float]
+            try:
+                score_f = float(si[j].item())
+            except Exception:
+                score_f = None
+
+            label_name = None
+            if label_i is not None and 0 <= label_i < len(label_names):
+                label_name = label_names[label_i]
+            if not label_name:
+                label_name = f"label_{label_i}" if label_i is not None else "unknown"
+
+            dets.append(
+                {
+                    "bbox_xyxy_norm": [x1, y1, x2, y2],
+                    "label": label_i,
+                    "label_name": str(label_name),
+                    "score": score_f,
+                }
+            )
+        out.append(dets)
+
+    # If model returned fewer splits than requested, pad.
+    while len(out) < int(batch_size):
+        out.append([])
+    return out[: int(batch_size)]
+
+
+# -- Label mapping between retriever ("text") and API ("paragraph") --
+_RETRIEVER_LABEL_NAMES = ["table", "chart", "title", "infographic", "text", "header_footer"]
+_RETRIEVER_TO_API = {"text": "paragraph"}
+_API_TO_RETRIEVER = {"paragraph": "text"}
+
+
+def _detections_to_annotation_dict(
+    dets: List[Dict[str, Any]],
+) -> Dict[str, List[List[float]]]:
+    """Convert a list of detection dicts into the annotation_dict format expected by
+    ``postprocess_page_elements_v3``.
+
+    Each detection dict has keys ``bbox_xyxy_norm``, ``label_name``, ``score``.
+    The annotation_dict maps label names (using API naming, i.e. "paragraph") to
+    ``[[x0, y0, x1, y1, confidence], ...]``.
+    """
+    ann: Dict[str, List[List[float]]] = {}
+    for d in dets:
+        name = _RETRIEVER_TO_API.get(d["label_name"], d["label_name"])
+        bbox = list(d["bbox_xyxy_norm"])  # [x0, y0, x1, y1]
+        bbox.append(float(d["score"]) if d["score"] is not None else 0.0)
+        ann.setdefault(name, []).append(bbox)
+    return ann
+
+
+def _annotation_dict_to_detections(
+    ann_dict: Dict[str, Any],
+) -> List[Dict[str, Any]]:
+    """Convert an annotation_dict back into a list of detection dicts.
+
+    Maps API label names back to retriever names (e.g. "paragraph" -> "text")
+    and assigns integer label IDs from the retriever label order.
+    """
+    dets: List[Dict[str, Any]] = []
+    for api_name, entries in ann_dict.items():
+        retriever_name = _API_TO_RETRIEVER.get(api_name, api_name)
+        try:
+            label_id = _RETRIEVER_LABEL_NAMES.index(retriever_name)
+        except ValueError:
+            label_id = None
+        for entry in entries:
+            # entry is [x0, y0, x1, y1, confidence]
+            dets.append(
+                {
+                    "bbox_xyxy_norm": list(entry[:4]),
+                    "label": label_id,
+                    "label_name": retriever_name,
+                    "score": float(entry[4]) if len(entry) > 4 else 0.0,
+                }
+            )
+    return dets
+
+
+def _bounding_boxes_to_detections(
+    bb_dict: Dict[str, Any],
+) -> List[Dict[str, Any]]:
+    """Convert a bounding_boxes dict (NIM API format) to detection dicts.
+
+    Input format: {"label": [{"x_min": ..., "y_min": ..., "x_max": ..., "y_max": ..., "confidence": ...}, ...]}
+    """
+    dets: List[Dict[str, Any]] = []
+    for api_name, entries in bb_dict.items():
+        retriever_name = _API_TO_RETRIEVER.get(api_name, api_name)
+        try:
+            label_id = _RETRIEVER_LABEL_NAMES.index(retriever_name)
+        except ValueError:
+            label_id = None
+        for entry in entries:
+            dets.append(
+                {
+                    "bbox_xyxy_norm": [
+                        float(entry["x_min"]),
+                        float(entry["y_min"]),
+                        float(entry["x_max"]),
+                        float(entry["y_max"]),
+                    ],
+                    "label": label_id,
+                    "label_name": retriever_name,
+                    "score": float(entry.get("confidence", 0.0)),
+                }
+            )
+    return dets
+
+
+def _apply_page_elements_v3_postprocess(
+    dets: List[Dict[str, Any]],
+) -> List[Dict[str, Any]]:
+    """Apply ``postprocess_page_elements_v3`` (box fusion, title matching,
+    expansion, overlap removal) to a single image's detection list.
+
+    Returns the original detections unchanged if the API function is unavailable.
+    """
+    if postprocess_page_elements_v3 is None or not dets:
+        return dets
+    try:
+        ann_dict = _detections_to_annotation_dict(dets)
+        labels = YOLOX_PAGE_V3_CLASS_LABELS if YOLOX_PAGE_V3_CLASS_LABELS is not None else list(ann_dict.keys())
+        result = postprocess_page_elements_v3(ann_dict, labels=labels)
+        return _annotation_dict_to_detections(result)
+    except Exception:
+        return dets
+
+
+def _remote_response_to_detections(
+    *,
+    response_json: Dict[str, Any],
+    label_names: List[str],
+    thresholds_per_class: Sequence[float],
+) -> List[Dict[str, Any]]:
+    # Try direct model-pred style payload first (or common wrappers around it).
+    candidates: List[Any] = [response_json]
+    data_list = response_json.get("data")
+    if isinstance(data_list, list) and data_list:
+        candidates.append(data_list[0])
+    output_list = response_json.get("output")
+    if isinstance(output_list, list) and output_list:
+        candidates.append(output_list[0])
+    pred_list = response_json.get("predictions")
+    if isinstance(pred_list, list) and pred_list:
+        candidates.append(pred_list[0])
+
+    for cand in candidates:
+        if not isinstance(cand, dict):
+            continue
+        try:
+            boxes, labels, scores = postprocess_preds_page_element(cand, list(thresholds_per_class), label_names)
+            dets = _postprocess_to_per_image_detections(
+                boxes=[boxes],
+                labels=[labels],
+                scores=[scores],
+                batch_size=1,
+                label_names=label_names,
+            )[0]
+            return _apply_page_elements_v3_postprocess(dets)
+        except Exception:
+            pass
+
+    # NIM bounding_boxes format:
+    # {"index": 0, "bounding_boxes": {"title": [{"x_min": ..., "y_min": ..., ...}]}}
+    for cand in candidates:
+        if not isinstance(cand, dict):
+            continue
+        bb = cand.get("bounding_boxes")
+        if isinstance(bb, dict):
+            try:
+                dets = _bounding_boxes_to_detections(bb)
+                return _apply_page_elements_v3_postprocess(dets)
+            except Exception:
+                pass
+
+    # Fall back to API-style annotation dict:
+    # {"table": [[x0,y0,x1,y1,conf], ...], "paragraph": [...]}
+    for cand in candidates:
+        if not isinstance(cand, dict) or not cand:
+            continue
+        if all(isinstance(v, list) for v in cand.values()):
+            try:
+                dets = _annotation_dict_to_detections(cand)  # type: ignore[arg-type]
+                return _apply_page_elements_v3_postprocess(dets)
+            except Exception:
+                pass
+
+    raise RuntimeError(f"Unsupported remote response format (keys={list(response_json.keys())!r})")
+
+
+def detect_page_elements_v3(
+    pages_df: Any,
+    *,
+    model: Any = None,
+    invoke_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    request_timeout_s: float = 120.0,
+    inference_batch_size: int = 8,
+    output_column: str = "page_elements_v3",
+    num_detections_column: str = "page_elements_v3_num_detections",
+    counts_by_label_column: str = "page_elements_v3_counts_by_label",
+    remote_retry: RemoteRetryParams | None = None,
+    **kwargs: Any,
+) -> Any:
+    retry = remote_retry or RemoteRetryParams(
+        remote_max_pool_workers=int(kwargs.get("remote_max_pool_workers", 16)),
+        remote_max_retries=int(kwargs.get("remote_max_retries", 10)),
+        remote_max_429_retries=int(kwargs.get("remote_max_429_retries", 5)),
+    )
+    """
+    Run Nemotron Page Elements v3 on a pandas batch.
+
+    Input:
+      - `pages_df`: pandas.DataFrame (typical Ray Data `batch_format="pandas"`)
+        Must contain an image base64 source either in `image_b64` or one of
+        `images`/`tables`/`charts`/`infographics` (each as list[{"image_b64": ...}]).
+
+    Output:
+      - returns a pandas.DataFrame with original columns preserved, plus:
+        - `output_column`: dict payload {"detections": [...], "timing": {...}, "error": {...?}}
+        - `num_detections_column`: int
+        - `counts_by_label_column`: dict[str,int]
+
+    Notes:
+      - This function internally batches model invocations in chunks of `inference_batch_size`
+        to enforce batch=8 even if Ray provides larger `map_batches` frames.
+    """
+    if not isinstance(pages_df, pd.DataFrame):
+        raise NotImplementedError("detect_page_elements_v3 currently only supports pandas.DataFrame input.")
+
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+
+    # Working snippet for single image inference and debugging
+    # breakpoint()
+    # first_page = pages_df.iloc[0]
+    # b64 = first_page.get("page_image")["image_b64"]
+
+    # t, orig_shape = _decode_b64_image_to_np_array(b64)
+
+    # # Inference
+    # with torch.inference_mode():
+    #     x = model.preprocess(t)
+    #     preds = model(x, orig_shape)[0]
+
+    # print(preds)
+    # breakpoint()
+
+    invoke_url = (invoke_url or kwargs.get("page_elements_invoke_url") or "").strip()
+    use_remote = bool(invoke_url)
+
+    if not use_remote and model is None:
+        raise ValueError("A local `model` is required when `invoke_url` is not provided.")
+
+    # Prepare per-row decode artifacts (local mode), raw base64 (remote mode),
+    # and placeholders for missing/errored rows.
+    row_tensors: List[Optional[TensorOrArray]] = []
+    row_shapes: List[Optional[Tuple[int, int]]] = []
+    row_b64: List[Optional[str]] = []
+    row_payloads: List[Dict[str, Any]] = []
+
+    label_names = _labels_from_model(model) if model is not None else list(_RETRIEVER_LABEL_NAMES)
+    if model is not None and hasattr(model, "thresholds_per_class"):
+        thresholds_per_class = getattr(model, "thresholds_per_class")
+    else:
+        thresholds_per_class = [0.0 for _ in label_names]
+
+    for _, row in pages_df.iterrows():
+        try:
+            b64 = row.get("page_image")["image_b64"]
+            if not b64:
+                raise ValueError("No usable image_b64 found in row.")
+            row_b64.append(b64)
+            if use_remote:
+                row_tensors.append(None)
+                row_shapes.append(None)
+            else:
+                t, orig_shape = _decode_b64_image_to_np_array(b64)
+                row_tensors.append(t)
+                row_shapes.append(orig_shape)
+            row_payloads.append({"detections": []})
+        except BaseException as e:
+            row_tensors.append(None)
+            row_shapes.append(None)
+            row_b64.append(None)
+            row_payloads.append(_error_payload(stage="decode_image", exc=e))
+
+    # Run inference over only valid rows, but write results back in original order.
+    if use_remote:
+        valid_indices = [i for i, b64 in enumerate(row_b64) if b64]
+    else:
+        valid_indices = [i for i, t in enumerate(row_tensors) if t is not None and row_shapes[i] is not None]
+
+    if (not use_remote) and valid_indices and torch is None:  # pragma: no cover
+        raise ImportError("torch is required for page element detection.")
+
+    if use_remote and valid_indices:
+        valid_b64: List[str] = []
+        for row_i in valid_indices:
+            b64 = row_b64[row_i]
+            if b64:
+                valid_b64.append(b64)
+
+        t0 = time.perf_counter()
+        try:
+            response_items = invoke_page_elements_batches(
+                invoke_url=invoke_url,
+                image_b64_list=valid_b64,
+                api_key=api_key,
+                timeout_s=float(request_timeout_s),
+                max_batch_size=int(inference_batch_size),
+                max_pool_workers=int(retry.remote_max_pool_workers),
+                max_retries=int(retry.remote_max_retries),
+                max_429_retries=int(retry.remote_max_429_retries),
+            )
+            elapsed = time.perf_counter() - t0
+
+            if len(response_items) != len(valid_indices):
+                raise RuntimeError(
+                    "Remote response count mismatch: " f"expected {len(valid_indices)}, got {len(response_items)}"
+                )
+
+            for local_i, row_i in enumerate(valid_indices):
+                dets = _remote_response_to_detections(
+                    response_json=response_items[local_i],
+                    label_names=label_names,
+                    thresholds_per_class=thresholds_per_class,
+                )
+                row_payloads[row_i] = {
+                    "detections": dets,
+                    "timing": {"seconds": float(elapsed)},
+                    "error": None,
+                }
+        except BaseException as e:
+            elapsed = time.perf_counter() - t0
+            print(f"Warning: page_elements remote inference failed: {type(e).__name__}: {e}")
+            for row_i in valid_indices:
+                row_payloads[row_i] = _error_payload(stage="remote_inference", exc=e) | {
+                    "timing": {"seconds": float(elapsed)}
+                }
+
+    for chunk_start in range(0, len(valid_indices), int(inference_batch_size)):
+        chunk_idx = valid_indices[chunk_start : chunk_start + int(inference_batch_size)]
+        if not chunk_idx:
+            continue
+
+        if use_remote:
+            continue
+
+        # Preprocess each image to a fixed shape so we can stack.
+        pre_list: List[TensorOrArray] = []
+        orig_shapes: List[Tuple[int, int]] = []
+        for i in chunk_idx:
+            t = row_tensors[i]
+            sh = row_shapes[i]
+            if t is None or sh is None:
+                continue
+            orig_shapes.append(sh)
+            try:
+                # `preprocess` may accept/return torch.Tensor or np.ndarray.
+                pre = model.preprocess(t)  # type: ignore[arg-type]
+
+                # Normalize to a single-image CHW-like item (torch or numpy); we'll convert to torch at stack time.
+                if isinstance(pre, torch.Tensor):
+                    if pre.ndim == 4 and int(pre.shape[0]) == 1:
+                        pre_list.append(pre[0])
+                    elif pre.ndim == 3:
+                        pre_list.append(pre)
+                    else:
+                        pre_list.append(pre)
+                elif isinstance(pre, np.ndarray):
+                    if pre.ndim == 4 and int(pre.shape[0]) == 1:
+                        pre_list.append(pre[0])
+                    else:
+                        pre_list.append(pre)
+                else:
+                    pre_list.append(t)
+            except Exception:
+                pre_list.append(t)
+
+        if not pre_list:
+            continue
+
+        batch = torch.stack([_ensure_chw_float_tensor(x) for x in pre_list], dim=0)
+
+        t0 = time.perf_counter()
+        try:
+            # Best-effort: pass list of shapes for batching; fall back to per-image if unsupported.
+            with torch.inference_mode():
+                with torch.autocast(device_type="cuda"):
+                    preds = model(batch, orig_shapes) if len(pre_list) > 1 else model(batch, orig_shapes[0])
+            # Some local wrappers return only the first prediction dict even for batched inputs.
+            # Detect that and force per-image invocation so every row gets its own detections.
+            if len(pre_list) > 1:
+                if isinstance(preds, dict):
+                    raise RuntimeError("Model returned a single pred dict for batched input.")
+                if isinstance(preds, list) and len(preds) != len(pre_list):
+                    raise RuntimeError(
+                        f"Model returned {len(preds)} preds for batch size {len(pre_list)}; falling back to per-image."
+                    )
+        except Exception as ex:
+            print(f"Error invoking model: {ex}")
+            preds_list: List[Any] = []
+            for j in range(int(batch.shape[0])):
+                preds_list.append(model(batch[j : j + 1], orig_shapes[j]))
+            preds = preds_list
+        elapsed = time.perf_counter() - t0
+
+        # Normalize preds into a list of per-image prediction dicts.
+        if isinstance(preds, dict):
+            preds_list2 = [preds]
+        elif isinstance(preds, list):
+            preds_list2 = preds
+        else:
+            preds_list2 = [preds]  # type: ignore[list-item]
+
+        try:
+            # Preferred: allow model wrapper to handle batched postprocess.
+            if hasattr(model, "postprocess"):
+                boxes, labels, scores = model.postprocess(preds_list2)  # type: ignore[attr-defined]
+            else:
+                # Fallback: run upstream util per-image.
+                # `postprocess_preds_page_element` expects a single pred dict and returns numpy arrays.
+                boxes_list: List["torch.Tensor"] = []
+                labels_list: List["torch.Tensor"] = []
+                scores_list: List["torch.Tensor"] = []
+                for p in preds_list2:
+                    if not isinstance(p, dict):
+                        boxes_list.append(torch.empty((0, 4), dtype=torch.float32))
+                        labels_list.append(torch.empty((0,), dtype=torch.int64))
+                        scores_list.append(torch.empty((0,), dtype=torch.float32))
+                        continue
+                    b_np, l_np, s_np = postprocess_preds_page_element(
+                        p,
+                        thresholds_per_class,
+                        label_names,
+                    )
+                    boxes_list.append(torch.as_tensor(b_np, dtype=torch.float32))
+                    labels_list.append(torch.as_tensor(l_np, dtype=torch.int64))
+                    scores_list.append(torch.as_tensor(s_np, dtype=torch.float32))
+                boxes, labels, scores = boxes_list, labels_list, scores_list
+            per_image_dets = _postprocess_to_per_image_detections(
+                boxes=boxes,
+                labels=labels,
+                scores=scores,
+                batch_size=len(pre_list),
+                label_names=label_names,
+            )
+            # Apply v3 postprocessing (box fusion, title matching, expansion, overlap removal)
+            per_image_dets = [_apply_page_elements_v3_postprocess(dets) for dets in per_image_dets]
+            for local_i, row_i in enumerate(chunk_idx):
+                dets = per_image_dets[local_i] if local_i < len(per_image_dets) else []
+                row_payloads[row_i] = {
+                    "detections": dets,
+                    "timing": {"seconds": float(elapsed)},
+                    "error": None,
+                }
+        except BaseException as e:
+            # If postprocess fails, attach an error but keep job alive.
+            for row_i in chunk_idx:
+                row_payloads[row_i] = _error_payload(stage="postprocess", exc=e) | {
+                    "timing": {"seconds": float(elapsed)}
+                }
+
+    out = pages_df.copy()
+    out[output_column] = row_payloads
+    out[num_detections_column] = [
+        int(len(p.get("detections") or [])) if isinstance(p, dict) else 0 for p in row_payloads
+    ]
+    out[counts_by_label_column] = [
+        _counts_by_label(p.get("detections") or []) if isinstance(p, dict) else {} for p in row_payloads
+    ]
+    return out
+
+
+class PageElementDetectionActor:
+    """
+    Ray-friendly callable that initializes Nemotron Page Elements v3 once.
+
+    Use with Ray Data:
+      ds = ds.map_batches(PageElementDetectionActor, fn_constructor_kwargs={...}, batch_format="pandas")
+    """
+
+    __slots__ = ("detect_kwargs", "_model")
+
+    def __init__(self, **detect_kwargs: Any) -> None:
+        self.detect_kwargs = dict(detect_kwargs)
+        invoke_url = str(
+            self.detect_kwargs.get("page_elements_invoke_url") or self.detect_kwargs.get("invoke_url") or ""
+        ).strip()
+        if invoke_url and "invoke_url" not in self.detect_kwargs:
+            self.detect_kwargs["invoke_url"] = invoke_url
+        if invoke_url:
+            self._model = None
+        else:
+            from nemo_retriever.model.local import NemotronPageElementsV3
+
+            self._model = NemotronPageElementsV3()
+
+    def __call__(self, pages_df: Any, **override_kwargs: Any) -> Any:
+        try:
+            return detect_page_elements_v3(
+                pages_df,
+                model=self._model,
+                **self.detect_kwargs,
+                **override_kwargs,
+            )
+        except Exception as e:
+            # As a last line of defense, never let the Ray UDF raise.
+            if isinstance(pages_df, pd.DataFrame):
+                out = pages_df.copy()
+                payload = _error_payload(stage="actor_call", exc=e)
+                out["page_elements_v3"] = [payload for _ in range(len(out.index))]
+                out["page_elements_v3_num_detections"] = [0 for _ in range(len(out.index))]
+                out["page_elements_v3_counts_by_label"] = [{} for _ in range(len(out.index))]
+                return out
+            return [{"page_elements_v3": _error_payload(stage="actor_call", exc=e)}]
diff --git a/nemo_retriever/src/nemo_retriever/params/__init__.py b/nemo_retriever/src/nemo_retriever/params/__init__.py
new file mode 100644
index 000000000..5f4eef723
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/params/__init__.py
@@ -0,0 +1,53 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .models import ASRParams
+from .models import AudioChunkParams
+from .models import BatchTuningParams
+from .models import ChartParams
+from .models import EmbedParams
+from .models import ExtractParams
+from .models import FusedTuningParams
+from .models import GpuAllocationParams
+from .models import HtmlChunkParams
+from .models import InfographicParams
+from .models import IngestExecuteParams
+from .models import IngestorCreateParams
+from .models import LanceDbParams
+from .models import ModelRuntimeParams
+from .models import OcrParams
+from .models import PageElementsParams
+from .models import PdfSplitParams
+from .models import RemoteInvokeParams
+from .models import RemoteRetryParams
+from .models import RunMode
+from .models import TableParams
+from .models import TextChunkParams
+from .models import VdbUploadParams
+
+__all__ = [
+    "ASRParams",
+    "AudioChunkParams",
+    "BatchTuningParams",
+    "ChartParams",
+    "EmbedParams",
+    "ExtractParams",
+    "FusedTuningParams",
+    "GpuAllocationParams",
+    "HtmlChunkParams",
+    "InfographicParams",
+    "IngestExecuteParams",
+    "IngestorCreateParams",
+    "LanceDbParams",
+    "ModelRuntimeParams",
+    "OcrParams",
+    "PageElementsParams",
+    "PdfSplitParams",
+    "RemoteInvokeParams",
+    "RemoteRetryParams",
+    "RunMode",
+    "TableParams",
+    "TextChunkParams",
+    "VdbUploadParams",
+]
diff --git a/nemo_retriever/src/nemo_retriever/params/models.py b/nemo_retriever/src/nemo_retriever/params/models.py
new file mode 100644
index 000000000..14462a414
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/params/models.py
@@ -0,0 +1,253 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from typing import Literal, Optional, Sequence, Tuple
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+RunMode = Literal["inprocess", "batch", "fused", "online"]
+
+
+class _ParamsModel(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+class RemoteRetryParams(_ParamsModel):
+    remote_max_pool_workers: int = 16
+    remote_max_retries: int = 10
+    remote_max_429_retries: int = 5
+
+
+class RemoteInvokeParams(_ParamsModel):
+    invoke_url: Optional[str] = None
+    api_key: Optional[str] = None
+    request_timeout_s: float = 120.0
+
+
+class ModelRuntimeParams(_ParamsModel):
+    device: Optional[str] = None
+    hf_cache_dir: Optional[str] = None
+    normalize: bool = True
+    max_length: int = 8192
+    model_name: Optional[str] = None
+
+
+class IngestorCreateParams(_ParamsModel):
+    documents: list[str] = Field(default_factory=list)
+    ray_address: Optional[str] = None
+    ray_log_to_driver: bool = True
+    base_url: str = "http://localhost:7670"
+
+
+class IngestExecuteParams(_ParamsModel):
+    show_progress: bool = False
+    return_failures: bool = False
+    save_to_disk: bool = False
+    return_traces: bool = False
+    parallel: bool = False
+    max_workers: Optional[int] = None
+    gpu_devices: list[str] = Field(default_factory=list)
+    page_chunk_size: int = 32
+    runtime_metrics_dir: Optional[str] = None
+    runtime_metrics_prefix: Optional[str] = None
+
+
+class PdfSplitParams(_ParamsModel):
+    start_page: Optional[int] = None
+    end_page: Optional[int] = None
+
+
+class TextChunkParams(_ParamsModel):
+    max_tokens: int = 512
+    overlap_tokens: int = 0
+    tokenizer_model_id: Optional[str] = None
+    encoding: str = "utf-8"
+    tokenizer_cache_dir: Optional[str] = None
+
+
+class HtmlChunkParams(TextChunkParams):
+    pass
+
+
+class AudioChunkParams(_ParamsModel):
+    """Params for media chunking (audio/video split). Aligned with nv-ingest-api dataloader."""
+
+    split_type: Literal["size", "time", "frame"] = "size"
+    split_interval: int = 450
+    audio_only: bool = False
+    video_audio_separate: bool = False
+
+
+class ASRParams(_ParamsModel):
+    """Params for ASR (Parakeet/Riva gRPC or local transformers backend)."""
+
+    audio_endpoints: Tuple[Optional[str], Optional[str]] = (None, None)
+    audio_infer_protocol: str = "grpc"
+    function_id: Optional[str] = None
+    auth_token: Optional[str] = None
+    segment_audio: bool = False
+
+
+class LanceDbParams(_ParamsModel):
+    lancedb_uri: str = "lancedb"
+    table_name: str = "nv-ingest"
+    overwrite: bool = True
+    create_index: bool = True
+    index_type: str = "IVF_HNSW_SQ"
+    metric: str = "l2"
+    num_partitions: int = 16
+    num_sub_vectors: int = 256
+    embedding_column: str = "text_embeddings_1b_v2"
+    embedding_key: str = "embedding"
+    include_text: bool = True
+    text_column: str = "text"
+    hybrid: bool = False
+    fts_language: str = "English"
+
+
+class BatchTuningParams(_ParamsModel):
+    debug_run_id: str = "unknown"
+    pdf_split_batch_size: int = 1
+    pdf_extract_batch_size: int = 4
+    pdf_extract_num_cpus: float = 2
+    pdf_extract_workers: Optional[int] = None
+    page_elements_batch_size: int = 24
+    detect_batch_size: int = 24
+    page_elements_workers: int = 1
+    ocr_workers: int = 1
+    detect_workers: Optional[int] = None
+    page_elements_cpus_per_actor: float = 1
+    ocr_cpus_per_actor: float = 1
+    embed_workers: int = 1
+    embed_batch_size: int = 256
+    embed_cpus_per_actor: float = 1
+    gpu_page_elements: Optional[float] = None
+    gpu_ocr: Optional[float] = None
+    gpu_embed: Optional[float] = None
+    nemotron_parse_workers: float = 0.0
+    gpu_nemotron_parse: float = 0.0
+    nemotron_parse_batch_size: float = 0.0
+
+
+class FusedTuningParams(_ParamsModel):
+    fused_workers: int = 1
+    fused_batch_size: int = 64
+    fused_cpus_per_actor: float = 1
+    fused_gpus_per_actor: float = 1.0
+
+
+class GpuAllocationParams(_ParamsModel):
+    gpu_devices: list[str] = Field(default_factory=list)
+    startup_timeout: float = 600.0
+
+
+class ExtractParams(_ParamsModel):
+    method: Optional[str] = None
+    extract_text: bool = False
+    extract_images: bool = False
+    extract_tables: bool = False
+    extract_charts: bool = False
+    extract_infographics: bool = False
+    extract_page_as_image: Optional[bool] = None
+    dpi: int = 200
+
+    invoke_url: Optional[str] = None
+    api_key: Optional[str] = None
+    request_timeout_s: float = 120.0
+    page_elements_invoke_url: Optional[str] = None
+    page_elements_api_key: Optional[str] = None
+    page_elements_request_timeout_s: Optional[float] = None
+    ocr_invoke_url: Optional[str] = None
+    ocr_api_key: Optional[str] = None
+    ocr_request_timeout_s: Optional[float] = None
+
+    inference_batch_size: int = 8
+    output_column: str = "page_elements_v3"
+    num_detections_column: str = "page_elements_v3_num_detections"
+    counts_by_label_column: str = "page_elements_v3_counts_by_label"
+    ocr_model_dir: Optional[str] = None
+
+    remote_retry: RemoteRetryParams = Field(default_factory=RemoteRetryParams)
+    batch_tuning: BatchTuningParams = Field(default_factory=BatchTuningParams)
+
+
+IMAGE_MODALITIES: frozenset[str] = frozenset({"image", "text_image", "image_text"})
+
+
+class EmbedParams(_ParamsModel):
+    model_name: Optional[str] = None
+    embedding_endpoint: Optional[str] = None
+    embed_invoke_url: Optional[str] = None
+    input_type: str = "passage"
+    embed_modality: str = "text"  # "text", "image", or "text_image" — default for all element types
+    text_elements_modality: Optional[str] = None  # per-type override for page-text rows
+    structured_elements_modality: Optional[str] = None  # per-type override for table/chart/infographic rows
+    text_column: str = "text"
+    inference_batch_size: int = 32
+    output_column: str = "text_embeddings_1b_v2"
+    embedding_dim_column: str = "text_embeddings_1b_v2_dim"
+    has_embedding_column: str = "text_embeddings_1b_v2_has_embedding"
+    embed_output_column: str = "text_embeddings_1b_v2"
+    embed_inference_batch_size: int = 16
+
+    runtime: ModelRuntimeParams = Field(default_factory=ModelRuntimeParams)
+    batch_tuning: BatchTuningParams = Field(default_factory=BatchTuningParams)
+    fused_tuning: FusedTuningParams = Field(default_factory=FusedTuningParams)
+
+    @field_validator("embed_modality", "text_elements_modality", "structured_elements_modality", mode="before")
+    @classmethod
+    def _normalize_modality(cls, v: str | None) -> str | None:
+        if v == "image_text":
+            return "text_image"
+        return v
+
+
+class VdbUploadParams(_ParamsModel):
+    purge_results_after_upload: bool = True
+    lancedb: LanceDbParams = Field(default_factory=LanceDbParams)
+
+
+class PageElementsParams(_ParamsModel):
+    remote: RemoteInvokeParams = Field(default_factory=RemoteInvokeParams)
+    remote_retry: RemoteRetryParams = Field(default_factory=RemoteRetryParams)
+    inference_batch_size: int = 8
+    output_column: str = "page_elements_v3"
+    num_detections_column: str = "page_elements_v3_num_detections"
+    counts_by_label_column: str = "page_elements_v3_counts_by_label"
+
+
+class OcrParams(_ParamsModel):
+    remote: RemoteInvokeParams = Field(default_factory=RemoteInvokeParams)
+    remote_retry: RemoteRetryParams = Field(default_factory=RemoteRetryParams)
+    inference_batch_size: int = 8
+    extract_tables: bool = False
+    extract_charts: bool = False
+    extract_infographics: bool = False
+
+
+class TableParams(_ParamsModel):
+    remote: RemoteInvokeParams = Field(default_factory=RemoteInvokeParams)
+    remote_retry: RemoteRetryParams = Field(default_factory=RemoteRetryParams)
+    inference_batch_size: int = 8
+    output_column: str = "table_structure_v1"
+    num_detections_column: str = "table_structure_v1_num_detections"
+    counts_by_label_column: str = "table_structure_v1_counts_by_label"
+
+
+class ChartParams(_ParamsModel):
+    remote: RemoteInvokeParams = Field(default_factory=RemoteInvokeParams)
+    remote_retry: RemoteRetryParams = Field(default_factory=RemoteRetryParams)
+    inference_batch_size: int = 8
+
+
+class InfographicParams(_ParamsModel):
+    remote: RemoteInvokeParams = Field(default_factory=RemoteInvokeParams)
+    remote_retry: RemoteRetryParams = Field(default_factory=RemoteRetryParams)
+    inference_batch_size: int = 8
+    allowed_page_element_labels: Sequence[str] = ("infographic", "title")
+    output_column: str = "infographic_elements_v1"
+    num_detections_column: str = "infographic_elements_v1_num_detections"
+    counts_by_label_column: str = "infographic_elements_v1_counts_by_label"
diff --git a/nemo_retriever/src/nemo_retriever/pdf/__init__.py b/nemo_retriever/src/nemo_retriever/pdf/__init__.py
new file mode 100644
index 000000000..5cbde6646
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/pdf/__init__.py
@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+PDF extraction stage (pure Python + Ray Data adapters).
+
+This package intentionally reuses the core extraction logic from `nv-ingest-api`
+and only provides thin orchestration wrappers.
+"""
+
+from .__main__ import app
+from .config import PDFExtractionStageConfig, load_pdf_extractor_schema_from_dict
+from .io import pdf_files_to_ledger_df
+from .stage import extract_pdf_primitives_from_ledger_df, make_pdf_task_config
+
+__all__ = [
+    "app",
+    "PDFExtractionStageConfig",
+    "extract_pdf_primitives_from_ledger_df",
+    "load_pdf_extractor_schema_from_dict",
+    "make_pdf_task_config",
+    "pdf_files_to_ledger_df",
+]
diff --git a/nemo_retriever/src/nemo_retriever/pdf/__main__.py b/nemo_retriever/src/nemo_retriever/pdf/__main__.py
new file mode 100644
index 000000000..45b792d34
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/pdf/__main__.py
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from . import stage
+
+app = typer.Typer(help="PDF Extraction")
+app.add_typer(stage.app, name="stage")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/pdf/config.py b/nemo_retriever/src/nemo_retriever/pdf/config.py
new file mode 100644
index 000000000..f91b0a685
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/pdf/config.py
@@ -0,0 +1,46 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from nemo_retriever.config_utils import endpoints_from_yaml
+
+from nv_ingest_api.internal.schemas.extract.extract_pdf_schema import PDFExtractorSchema
+
+
+def load_pdf_extractor_schema_from_dict(cfg: Dict[str, Any]) -> PDFExtractorSchema:
+    """Build `PDFExtractorSchema` from a pipeline-like config dict.
+
+    `config/default_pipeline.yaml` uses list form for endpoints; `PDFExtractorSchema` uses tuples.
+    """
+    cfg = dict(cfg or {})
+
+    pdfium = cfg.get("pdfium_config")
+    if isinstance(pdfium, dict) and "yolox_endpoints" in pdfium:
+        pdfium = dict(pdfium)
+        pdfium["yolox_endpoints"] = endpoints_from_yaml(pdfium.get("yolox_endpoints"))
+        cfg["pdfium_config"] = pdfium
+
+    nemotron = cfg.get("nemotron_parse_config")
+    if isinstance(nemotron, dict):
+        nemotron = dict(nemotron)
+        if "yolox_endpoints" in nemotron:
+            nemotron["yolox_endpoints"] = endpoints_from_yaml(nemotron.get("yolox_endpoints"))
+        if "nemotron_parse_endpoints" in nemotron:
+            nemotron["nemotron_parse_endpoints"] = endpoints_from_yaml(nemotron.get("nemotron_parse_endpoints"))
+        cfg["nemotron_parse_config"] = nemotron
+
+    return PDFExtractorSchema(**cfg)
+
+
+@dataclass(frozen=True)
+class PDFExtractionStageConfig:
+    """Stage-level knobs for running PDF extraction via pure Python or Ray Data."""
+
+    batch_size: int = 16
+    # How we label metrics/spans for this stage.
+    stage_name: str = "pdf_extraction"
diff --git a/nemo_retriever/src/nemo_retriever/pdf/extract.py b/nemo_retriever/src/nemo_retriever/pdf/extract.py
new file mode 100644
index 000000000..3a5727aaa
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/pdf/extract.py
@@ -0,0 +1,357 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from io import BytesIO
+from typing import Any, Dict, List, Optional
+
+import base64
+import traceback
+import pypdfium2.raw as pdfium_c
+
+import pandas as pd
+
+try:
+    import pypdfium2 as pdfium
+except Exception as e:  # pragma: no cover
+    pdfium = None  # type: ignore[assignment]
+    _PDFIUM_IMPORT_ERROR = e
+else:  # pragma: no cover
+    _PDFIUM_IMPORT_ERROR = None
+
+try:
+    import numpy as np
+except Exception:  # pragma: no cover
+    np = None  # type: ignore[assignment]
+
+try:
+    from PIL import Image
+except Exception:  # pragma: no cover
+    Image = None  # type: ignore[assignment]
+
+
+def _render_page_to_base64(page: Any, *, dpi: int = 200, image_format: str = "png") -> Dict[str, Any]:
+    """
+    Render a page to an image and return base64 plus minimal metadata.
+
+    Returns dict with:
+    - image_b64: str
+    - encoding: str ("png" or "raw")
+    - orig_shape_hw: tuple[int,int] (H,W) of the rendered raster
+    - shape/dtype: optional (for raw)
+    """
+    scale = max(float(dpi) / 72.0, 0.01)
+    bitmap = page.render(scale=scale)
+
+    # Prefer numpy output when available.
+    arr = None
+    if hasattr(bitmap, "to_numpy"):
+        try:
+            arr = bitmap.to_numpy()
+        except Exception:
+            arr = None
+
+    if arr is None and hasattr(bitmap, "to_pil"):
+        try:
+            pil_img = bitmap.to_pil()
+        except Exception:
+            pil_img = None
+        if pil_img is not None:
+            w, h = pil_img.size
+            buf = BytesIO()
+            pil_img.save(buf, format=image_format.upper())
+            return {
+                "image_b64": base64.b64encode(buf.getvalue()).decode("ascii"),
+                "encoding": image_format.lower(),
+                "orig_shape_hw": (int(h), int(w)),
+            }
+
+    # Fallback: if we got a numpy-like array, try encoding with Pillow; else raw bytes.
+    if arr is not None and Image is not None:
+        try:
+            # Expect typical image layouts like (H,W,C) or (H,W).
+            h = int(arr.shape[0]) if hasattr(arr, "shape") and len(arr.shape) >= 2 else 0
+            w = int(arr.shape[1]) if hasattr(arr, "shape") and len(arr.shape) >= 2 else 0
+            pil = Image.fromarray(arr)
+            buf = BytesIO()
+            pil.save(buf, format=image_format.upper())
+            return {
+                "image_b64": base64.b64encode(buf.getvalue()).decode("ascii"),
+                "encoding": image_format.lower(),
+                "orig_shape_hw": (int(h), int(w)),
+            }
+        except Exception:
+            pass
+
+    if arr is not None:
+        # Last resort: raw bytes base64 (still a base64 string, but not a standard image container).
+        raw = arr.tobytes()
+        meta: Dict[str, Any] = {"image_b64": base64.b64encode(raw).decode("ascii"), "encoding": "raw"}
+        if hasattr(arr, "shape"):
+            meta["shape"] = tuple(arr.shape)
+            try:
+                if len(arr.shape) >= 2:
+                    meta["orig_shape_hw"] = (int(arr.shape[0]), int(arr.shape[1]))
+            except Exception:
+                pass
+        if hasattr(arr, "dtype"):
+            meta["dtype"] = str(arr.dtype)
+        return meta
+
+    raise RuntimeError("Failed to render page to an image representation.")
+
+
+def _error_record(
+    *,
+    source_path: Optional[str],
+    stage: str,
+    exc: BaseException,
+    page_number: int = 0,
+    dpi: int = 200,
+) -> Dict[str, Any]:
+    """
+    Return a single output record with the same shape as a normal page record,
+    but with error details in metadata.
+
+    This is used to prevent one PDF/page failure from aborting an entire Ray job.
+    """
+    return {
+        "path": source_path,
+        "page_number": int(page_number),
+        "text": "",
+        "page_image": None,
+        "images": [],
+        "tables": [],
+        "charts": [],
+        "infographics": [],
+        "metadata": {
+            "has_text": False,
+            "needs_ocr": False,
+            "dpi": int(dpi),
+            "source_path": source_path,
+            "error": {
+                "stage": str(stage),
+                "type": exc.__class__.__name__,
+                "message": str(exc),
+                # Keep traceback as a string for debugging; consumers can drop it.
+                "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+            },
+        },
+    }
+
+
+def _is_scanned_page(page) -> bool:
+    tp = page.get_textpage()
+    text = tp.get_text_bounded() or ""
+    num_chars = len(text.strip())
+    num_images = sum(1 for obj in page.get_objects() if obj.type == pdfium_c.FPDF_PAGEOBJ_IMAGE)
+
+    return num_chars == 0 and num_images > 0
+
+
+def _extract_page_text(page) -> str:
+    """
+    Always extract text from the given page and return it as a raw string.
+    The caller decides whether to use per-page or doc-level logic.
+    """
+    textpage = page.get_textpage()
+    return textpage.get_text_bounded()
+
+
+def pdf_extraction(
+    pdf_binary: Any,
+    extract_text: bool = False,
+    extract_images: bool = False,
+    extract_tables: bool = False,
+    extract_charts: bool = False,
+    extract_infographics: bool = False,
+    dpi: int = 200,
+    image_format: str = "png",
+    text_extraction_method: str = "pdfium_hybrid",
+    text_depth: str = "page",
+    **kwargs: Any,
+) -> Any:
+    """
+    Here are the steps for pdf extraction that should be implemented:
+    1. Load the pdf from the binary data using pypdfium2
+    2. Iterate through each page of the pdf using pypdfium2
+    3. Extract the text from each page and save each page's text to a list of strings if extract_text is True
+    4. If extract_images, extract_tables, extract_charts, or extract_infographics are True, convert the page to a numpy array using pypdfium2 and convert it to a base64 string and save it to a list of strings.  # noqa: E501, W505
+    5. IF extract_text is True but pypdfium2 does not detect text on the page also convert the page to a numpy array using pypdfium2 so that it can later be passed to a OCR model and indicate this in the metadata.  # noqa: E501, W505
+    6. Return a list of dictionaries containing the text, images, tables, charts, infographics, and page numbers.
+    """
+
+    # Assumption: PDF splitting ran earlier and produced a dataset where each row
+    # contains a *single-page* PDF in the `"bytes"` column. We therefore open the
+    # document and only process page 0 for each row.
+    if isinstance(pdf_binary, pd.DataFrame):
+        if pdfium is None:  # pragma: no cover
+            # Best-effort: return error records for the whole batch rather than raising.
+            outputs: List[Dict[str, Any]] = []
+            for _, row in pdf_binary.iterrows():
+                pdf_path = row["path"] if "path" in pdf_binary.columns else None
+                outputs.append(
+                    _error_record(
+                        source_path=str(pdf_path) if pdf_path is not None else None,
+                        stage="import_pypdfium2",
+                        exc=(
+                            _PDFIUM_IMPORT_ERROR
+                            if _PDFIUM_IMPORT_ERROR is not None
+                            else RuntimeError("pypdfium2 unavailable")
+                        ),
+                        page_number=0,
+                        dpi=dpi,
+                    )
+                )
+            return outputs
+
+        outputs: List[Dict[str, Any]] = []
+
+        for _, row in pdf_binary.iterrows():
+            pdf_bytes = row["bytes"] if "bytes" in pdf_binary.columns else None
+            pdf_path = row["path"] if "path" in pdf_binary.columns else None
+            page_number = int(row["page_number"]) if "page_number" in pdf_binary.columns else 1
+
+            try:
+                if not isinstance(pdf_bytes, (bytes, bytearray, memoryview)):
+                    raise RuntimeError(f"Unsupported bytes payload type: {type(pdf_bytes)!r}")
+
+                # Step 1: load the *single-page* PDF bytes.
+                try:
+                    doc = pdfium.PdfDocument(pdf_bytes)
+                except Exception:
+                    doc = pdfium.PdfDocument(BytesIO(bytes(pdf_bytes)))
+
+                # TODO: Extend to support more image formats
+                if image_format not in {"png"}:
+                    raise ValueError(f"Unsupported image_format: {image_format!r}")
+
+                # Step 2: process only the first page (single-page doc).
+                page = None
+                try:
+                    # we can safely assume page[0] only because pre-splitting has already occurred.
+                    page = doc.get_page(0)
+                    is_scanned_page = _is_scanned_page(page)
+
+                    ocr_extraction_needed_for_text = extract_text and (
+                        (text_extraction_method == "pdfium_hybrid" and is_scanned_page)
+                        or text_extraction_method == "ocr"
+                    )
+
+                    # extraction_needed_for_structured = (
+                    #     extract_tables or extract_charts or extract_infographics
+                    # )  # noqa: F841
+
+                    # Default to empty so scanned/OCR pages don't hit a NameError below.
+                    text = ""
+
+                    # Text extraction
+                    if extract_text and not ocr_extraction_needed_for_text:
+                        page_text = _extract_page_text(page)
+                        # TODO: Tiddy up logic here for document depth option
+                        if text_depth == "page":
+                            text = page_text
+                        else:
+                            text = page_text
+
+                    has_text = bool(text.strip()) if extract_text else False
+
+                    want_any_raster = bool(
+                        extract_images
+                        or extract_tables
+                        or extract_charts
+                        or extract_infographics
+                        or ocr_extraction_needed_for_text
+                    )
+                    render_info: Optional[Dict[str, Any]] = None
+                    if want_any_raster:
+                        render_info = _render_page_to_base64(page, dpi=dpi, image_format=image_format)
+
+                    page_record: Dict[str, Any] = {
+                        "path": pdf_path,
+                        "page_number": page_number,
+                        "text": text if extract_text else "",
+                        "page_image": None,
+                        "images": [],
+                        "tables": [],
+                        "charts": [],
+                        "infographics": [],
+                        "metadata": {
+                            "has_text": has_text,
+                            "needs_ocr_for_text": ocr_extraction_needed_for_text,
+                            "dpi": dpi,
+                            "source_path": pdf_path,
+                            "error": None,
+                        },
+                    }
+
+                    if want_any_raster and render_info is not None:
+                        # Store the rendered page raster only here; leave the other
+                        # fields empty so downstream stages have a single canonical
+                        # place to find the page image.
+                        page_record["page_image"] = render_info
+
+                    outputs.append(page_record)
+                finally:
+                    try:
+                        if page is not None and hasattr(page, "close"):
+                            page.close()
+                    except Exception:
+                        pass
+                    try:
+                        doc.close()
+                    except Exception:
+                        pass
+            except BaseException as e:
+                outputs.append(
+                    _error_record(
+                        source_path=str(pdf_path) if pdf_path is not None else None,
+                        stage="page_processing",
+                        exc=e,
+                        page_number=page_number,
+                        dpi=dpi,
+                    )
+                )
+
+        # Return a batch-shaped dataframe so Ray Data produces one output row per input page.
+        return pd.DataFrame(outputs)
+    else:
+        raise NotImplementedError("pdf_extraction currently only supports pandas.DataFrame input.")
+
+
+@dataclass(slots=True)
+class PDFExtractionActor:
+    """
+    Skeleton PDF extraction callable.
+
+    `__call__` uses `pdf_extract_config_from_kwargs()` to normalize configuration
+    before running the (not yet implemented) extraction logic.
+    """
+
+    extract_kwargs: Dict[str, Any]
+
+    def __init__(self, **extract_kwargs: Any) -> None:
+        self.extract_kwargs = dict(extract_kwargs)
+
+    def __call__(self, pdf: Any, **override_kwargs: Any) -> Optional[Any]:
+        try:
+            return pdf_extraction(pdf, **self.extract_kwargs, **override_kwargs)
+        except BaseException as e:
+            # As a last line of defense, never let the Ray UDF raise.
+            source_path = None
+            try:
+                if isinstance(pdf, pd.DataFrame) and "path" in pdf.columns and len(pdf.index) > 0:
+                    source_path = str(pdf.iloc[0]["path"])
+            except Exception:
+                source_path = None
+            return [
+                _error_record(
+                    source_path=source_path,
+                    stage="actor_call",
+                    exc=e,
+                    page_number=0,
+                )
+            ]
diff --git a/nemo_retriever/src/nemo_retriever/pdf/io.py b/nemo_retriever/src/nemo_retriever/pdf/io.py
new file mode 100644
index 000000000..9d389d754
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/pdf/io.py
@@ -0,0 +1,43 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional
+
+import pandas as pd
+
+
+def pdf_files_to_ledger_df(
+    pdf_paths: Iterable[str | Path],
+    *,
+    source_id_prefix: str = "pdf",
+    start_index: int = 0,
+    extra_metadata: Optional[Dict[str, Any]] = None,
+) -> pd.DataFrame:
+    """Create an nv-ingest-style ledger DataFrame from local PDF files.
+
+    The extraction functions in `nv-ingest-api` expect a ledger with a base64 `content`
+    column plus identifying metadata.
+    """
+    extra_metadata = dict(extra_metadata or {})
+    rows: List[Dict[str, Any]] = []
+
+    for i, p in enumerate(pdf_paths, start=start_index):
+        path = Path(p)
+        raw = path.read_bytes()
+        b64 = base64.b64encode(raw).decode("utf-8")
+        rows.append(
+            {
+                "source_id": str(path),
+                "source_name": str(path),
+                "content": b64,
+                "document_type": "pdf",
+                "metadata": {"custom_content": {"path": str(path), **extra_metadata}},
+            }
+        )
+
+    return pd.DataFrame(rows)
diff --git a/nemo_retriever/src/nemo_retriever/pdf/split.py b/nemo_retriever/src/nemo_retriever/pdf/split.py
new file mode 100644
index 000000000..75bfcdb02
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/pdf/split.py
@@ -0,0 +1,196 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from io import BytesIO
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import traceback
+
+import pandas as pd
+from nemo_retriever.params import PdfSplitParams
+
+try:
+    import pypdfium2 as pdfium
+except Exception as e:  # pragma: no cover
+    pdfium = None  # type: ignore[assignment]
+    _PDFIUM_IMPORT_ERROR = e
+else:  # pragma: no cover
+    _PDFIUM_IMPORT_ERROR = None
+
+
+def _error_record(
+    *,
+    source_path: Optional[str],
+    stage: str,
+    exc: BaseException,
+    page_number: int = 0,
+) -> Dict[str, Any]:
+    return {
+        "page_number": int(page_number),
+        "bytes": b"",
+        "path": source_path,
+        "metadata": {
+            "source_path": source_path,
+            "error": {
+                "stage": str(stage),
+                "type": exc.__class__.__name__,
+                "message": str(exc),
+                "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+            },
+        },
+    }
+
+
+def _split_pdf_to_single_page_bytes(pdf_binary: Any) -> List[bytes]:
+    """
+    Split a PDF into single-page PDFs (raw bytes) using pypdfium2.
+    """
+    if pdfium is None:  # pragma: no cover
+        raise ImportError(
+            "pypdfium2 is required for PDF splitting but could not be imported."
+        ) from _PDFIUM_IMPORT_ERROR
+
+    try:
+        doc = pdfium.PdfDocument(pdf_binary)
+    except Exception:
+        if isinstance(pdf_binary, (bytes, bytearray, memoryview)):
+            doc = pdfium.PdfDocument(BytesIO(bytes(pdf_binary)))
+        else:
+            raise
+
+    out: List[bytes] = []
+    try:
+        for page_idx in range(len(doc)):
+            single = pdfium.PdfDocument.new()
+            try:
+                single.import_pages(doc, pages=[page_idx])
+                buf = BytesIO()
+                single.save(buf)
+                out.append(buf.getvalue())
+            finally:
+                try:
+                    single.close()
+                except Exception:
+                    pass
+    finally:
+        try:
+            doc.close()
+        except Exception:
+            pass
+
+    return out
+
+
+def pdf_path_to_pages_df(path: str) -> pd.DataFrame:
+    """
+    Convert a multi-page PDF at `path` into a DataFrame where each row
+    contains a single-page PDF's raw bytes.
+
+    Columns: bytes, path, page_number (1-indexed).
+    Compatible with pdf_extraction and downstream inprocess/batch stages.
+    """
+    if pdfium is None:  # pragma: no cover
+        raise ImportError(
+            "pypdfium2 is required for PDF splitting but could not be imported."
+        ) from _PDFIUM_IMPORT_ERROR
+
+    abs_path = str(Path(path).resolve())
+    out_rows: List[Dict[str, Any]] = []
+    try:
+        raw_bytes = Path(abs_path).read_bytes()
+        pages = _split_pdf_to_single_page_bytes(raw_bytes)
+        for page_idx, page_bytes in enumerate(pages):
+            out_rows.append(
+                {
+                    "bytes": page_bytes,
+                    "path": abs_path,
+                    "page_number": page_idx + 1,
+                }
+            )
+    except BaseException as e:
+        out_rows.append({"bytes": b"", "path": abs_path, "page_number": 0, "error": str(e)})
+    return pd.DataFrame(out_rows)
+
+
+def split_pdf_batch(pdf_batch: Any, params: PdfSplitParams | None = None) -> pd.DataFrame:
+    """
+    Split a batch of PDFs into per-page single-page PDFs (bytes), without rendering.
+
+    Expected input is a pandas DataFrame batch containing at least a bytes-like
+    column `"bytes"` (and optionally `"path"`).
+    """
+    if not isinstance(pdf_batch, pd.DataFrame):
+        raise NotImplementedError("split_pdf_batch currently only supports pandas.DataFrame input.")
+
+    # Optional bounds (1-indexed inclusive).
+    split_params = params or PdfSplitParams()
+    start_page = split_params.start_page
+    end_page = split_params.end_page
+
+    out_rows: List[Dict[str, Any]] = []
+    for _, row in pdf_batch.iterrows():
+        pdf_path = row["path"] if "path" in pdf_batch.columns else None
+        pdf_bytes = row["bytes"] if "bytes" in pdf_batch.columns else None
+
+        try:
+            if not isinstance(pdf_bytes, (bytes, bytearray, memoryview)):
+                raise ValueError(f"Unsupported bytes payload type: {type(pdf_bytes)!r}")
+
+            pages = _split_pdf_to_single_page_bytes(pdf_bytes)
+            start_idx = 0 if start_page is None else max(int(start_page) - 1, 0)
+            end_idx = (len(pages) - 1) if end_page is None else min(int(end_page) - 1, len(pages) - 1)
+            if len(pages) == 0 or start_idx > end_idx:
+                continue
+
+            for page_idx in range(start_idx, end_idx + 1):
+                out_rows.append(
+                    {
+                        "bytes": pages[page_idx],
+                        "path": pdf_path,
+                        "page_number": page_idx + 1,
+                        "metadata": {"source_path": pdf_path},
+                    }
+                )
+        except BaseException as e:
+            out_rows.append(
+                _error_record(
+                    source_path=str(pdf_path) if pdf_path is not None else None,
+                    stage="split_pdf",
+                    exc=e,
+                    page_number=0,
+                )
+            )
+
+    return pd.DataFrame(out_rows)
+
+
+@dataclass(slots=True)
+class PDFSplitActor:
+    split_params: PdfSplitParams
+
+    def __init__(self, split_params: PdfSplitParams | None = None) -> None:
+        self.split_params = split_params or PdfSplitParams()
+
+    def __call__(self, pdf_batch: Any) -> Any:
+        return split_pdf_batch(pdf_batch, params=self.split_params)
+
+
+def split_pdf(pdf_ds: Any, params: PdfSplitParams | None = None) -> Any:
+    """
+    Dataset-level splitter.
+
+    Takes a Ray Dataset of PDFs (rows with `"bytes"` and optionally `"path"`) and
+    returns a new Ray Dataset with one row per page (single-page PDF bytes).
+    """
+    try:
+        import ray.data as rd  # noqa: F401
+    except Exception as e:  # pragma: no cover
+        raise ImportError("split_pdf() requires Ray Data (`ray`).") from e
+
+    # Note: returning a Dataset here creates the new dataset representing pages.
+    return pdf_ds.map_batches(PDFSplitActor(split_params=params), batch_format="pandas")
diff --git a/nemo_retriever/src/nemo_retriever/pdf/stage.py b/nemo_retriever/src/nemo_retriever/pdf/stage.py
new file mode 100644
index 000000000..d34313697
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/pdf/stage.py
@@ -0,0 +1,693 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Tuple
+
+import pandas as pd
+import yaml
+
+from nemo_retriever.ingest_config import load_ingest_config_section
+from nemo_retriever.pdf.config import load_pdf_extractor_schema_from_dict
+from nemo_retriever.pdf.io import pdf_files_to_ledger_df
+from rich.console import Console
+from tqdm import tqdm
+import typer
+
+from nv_ingest_api.internal.extract.pdf.pdf_extractor import extract_primitives_from_pdf_internal
+from nv_ingest_api.internal.schemas.extract.extract_pdf_schema import PDFExtractorSchema
+from nv_ingest_api.internal.primitives.tracing.tagging import traceable_func
+
+logger = logging.getLogger(__name__)
+
+
+console = Console()
+app = typer.Typer(help="Extract PDF primitives from PDF files.")
+
+
+def _argv_has_any(flags: Iterable[str]) -> bool:
+    """
+    Return True if any of the given flags appear in sys.argv.
+
+    Supports `--flag value` and `--flag=value` forms.
+    """
+    argv = sys.argv[1:]
+    for f in flags:
+        if f in argv:
+            return True
+        prefix = f + "="
+        if any(a.startswith(prefix) for a in argv):
+            return True
+    return False
+
+
+def _read_yaml_config(path: Path) -> Dict[str, Any]:
+    try:
+        text = path.read_text(encoding="utf-8")
+        data = yaml.safe_load(text)
+    except Exception as e:
+        raise typer.BadParameter(f"Failed reading YAML config {path}: {e}") from e
+    if data is None:
+        return {}
+    if not isinstance(data, dict):
+        raise typer.BadParameter(f"YAML config must be a mapping/object at top-level: {path}")
+    return data
+
+
+def _cfg_get(raw: Dict[str, Any], *keys: str) -> Any:
+    """
+    Return the first present key among `keys` from raw, else None.
+    """
+    for k in keys:
+        if k in raw:
+            return raw.get(k)
+    return None
+
+
+def _normalize_page_elements_config(raw: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Normalize YAML config into flat keys matching CLI parameter names.
+
+    Supports either flat keys (e.g. `yolox_grpc_endpoint`) or nested keys under:
+      endpoints.yolox.{grpc,http}
+      endpoints.nemotron_parse.{grpc,http,model_name}
+      extract.{text,images,tables,charts,infographics,page_as_image,text_depth}
+      outputs.{write_json,json_output_dir}
+    """
+    raw = dict(raw or {})
+
+    endpoints = raw.get("endpoints") if isinstance(raw.get("endpoints"), dict) else {}
+    yolox = endpoints.get("yolox") if isinstance(endpoints.get("yolox"), dict) else {}
+    nemo = endpoints.get("nemotron_parse") if isinstance(endpoints.get("nemotron_parse"), dict) else {}
+
+    extract = raw.get("extract") if isinstance(raw.get("extract"), dict) else {}
+    outputs = raw.get("outputs") if isinstance(raw.get("outputs"), dict) else {}
+
+    out: Dict[str, Any] = {}
+    out["input_dir"] = _cfg_get(raw, "input_dir", "input-dir")
+    out["method"] = _cfg_get(raw, "method")
+    out["auth_token"] = _cfg_get(raw, "auth_token", "auth-token")
+
+    out["yolox_grpc_endpoint"] = _cfg_get(raw, "yolox_grpc_endpoint", "yolox-grpc-endpoint") or _cfg_get(
+        yolox, "grpc", "grpc_endpoint", "grpc-endpoint"
+    )
+    out["yolox_http_endpoint"] = _cfg_get(raw, "yolox_http_endpoint", "yolox-http-endpoint") or _cfg_get(
+        yolox, "http", "http_endpoint", "http-endpoint"
+    )
+
+    out["nemotron_parse_grpc_endpoint"] = _cfg_get(
+        raw, "nemotron_parse_grpc_endpoint", "nemotron-parse-grpc-endpoint"
+    ) or _cfg_get(nemo, "grpc", "grpc_endpoint", "grpc-endpoint")
+    out["nemotron_parse_http_endpoint"] = _cfg_get(
+        raw, "nemotron_parse_http_endpoint", "nemotron-parse-http-endpoint"
+    ) or _cfg_get(nemo, "http", "http_endpoint", "http-endpoint")
+    out["nemotron_parse_model_name"] = _cfg_get(
+        raw, "nemotron_parse_model_name", "nemotron-parse-model-name"
+    ) or _cfg_get(nemo, "model_name", "model-name")
+
+    out["extract_text"] = (
+        _cfg_get(raw, "extract_text", "extract-text") if "extract_text" in raw else _cfg_get(extract, "text")
+    )
+    out["extract_images"] = (
+        _cfg_get(raw, "extract_images", "extract-images") if "extract_images" in raw else _cfg_get(extract, "images")
+    )
+    out["extract_tables"] = (
+        _cfg_get(raw, "extract_tables", "extract-tables") if "extract_tables" in raw else _cfg_get(extract, "tables")
+    )
+    out["extract_charts"] = (
+        _cfg_get(raw, "extract_charts", "extract-charts") if "extract_charts" in raw else _cfg_get(extract, "charts")
+    )
+    out["extract_infographics"] = (
+        _cfg_get(raw, "extract_infographics", "extract-infographics")
+        if "extract_infographics" in raw
+        else _cfg_get(extract, "infographics")
+    )
+    out["extract_page_as_image"] = (
+        _cfg_get(raw, "extract_page_as_image", "extract-page-as-image")
+        if "extract_page_as_image" in raw
+        else _cfg_get(extract, "page_as_image", "page-as-image", "page_as_image")
+    )
+    out["text_depth"] = _cfg_get(raw, "text_depth", "text-depth") or _cfg_get(extract, "text_depth", "text-depth")
+
+    out["write_json_outputs"] = (
+        _cfg_get(raw, "write_json_outputs", "write-json-outputs")
+        if "write_json_outputs" in raw
+        else _cfg_get(outputs, "write_json", "write-json", "write_json_outputs")
+    )
+    out["json_output_dir"] = _cfg_get(raw, "json_output_dir", "json-output-dir") or _cfg_get(
+        outputs, "json_output_dir", "json-output-dir"
+    )
+    out["limit"] = _cfg_get(raw, "limit")
+
+    # Drop Nones so "not specified" stays not specified.
+    return {k: v for k, v in out.items() if v is not None}
+
+
+def _atomic_write_json(path: Path, obj: Any) -> None:
+    """
+    Atomically write JSON to disk (write temp file then replace).
+
+    Kept local to the PDF stage to avoid importing heavier stage utilities.
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp_path = path.with_name(path.name + ".tmp")
+    with tmp_path.open("w", encoding="utf-8") as f:
+        json.dump(obj, f, ensure_ascii=False, indent=2)
+        f.flush()
+        try:
+            import os
+
+            os.fsync(f.fileno())
+        except Exception:
+            pass
+    tmp_path.replace(path)
+
+
+def _to_jsonable(obj: Any) -> Any:
+    """
+    Best-effort conversion to JSON-serializable builtins.
+
+    PDF primitive metadata can contain numpy/pandas scalar-like objects depending on backend;
+    this sanitizes them without pulling in optional heavy deps.
+    """
+    if obj is None or isinstance(obj, (str, int, float, bool)):
+        return obj
+
+    if isinstance(obj, dict):
+        return {str(k): _to_jsonable(v) for k, v in obj.items()}
+
+    if isinstance(obj, (list, tuple)):
+        return [_to_jsonable(v) for v in obj]
+
+    # numpy scalar / pandas scalar-like
+    item = getattr(obj, "item", None)
+    if callable(item):
+        try:
+            return _to_jsonable(item())
+        except Exception:
+            pass
+
+    tolist = getattr(obj, "tolist", None)
+    if callable(tolist):
+        try:
+            return _to_jsonable(tolist())
+        except Exception:
+            pass
+
+    # fallback
+    return str(obj)
+
+
+def _pdf_json_out_path(pdf_path: Path) -> Path:
+    # Mirror stage2 naming: append suffix to the full filename.
+    return pdf_path.with_name(pdf_path.name + ".pdf_extraction.json")
+
+
+def _safe_pdf_page_count(path: str) -> int:
+    """
+    Best-effort page count for a PDF path.
+
+    Used only for progress reporting; failures should not fail extraction.
+    """
+    try:
+        import pypdfium2 as pdfium  # type: ignore
+
+        doc = pdfium.PdfDocument(path)
+        try:
+            n = int(len(doc))
+        except Exception:
+            n = int(doc.get_page_count())  # type: ignore[attr-defined]
+        try:
+            doc.close()
+        except Exception:
+            pass
+        return max(n, 0)
+    except Exception:
+        # If we can't read page count, fall back to 0 (still shows PDF progress).
+        return 0
+
+
+def _iter_ledger_pdf_paths(df_ledger: pd.DataFrame) -> Iterable[Tuple[str, str, Optional[str]]]:
+    """
+    Yield (source_id, source_name, pdf_path_str_or_none) from the input ledger.
+    """
+    for _, row in df_ledger.iterrows():
+        source_id = str(row.get("source_id", ""))
+        source_name = str(row.get("source_name", ""))
+        meta = row.get("metadata") if isinstance(row.get("metadata"), dict) else {}
+        custom = meta.get("custom_content") if isinstance(meta.get("custom_content"), dict) else {}
+        path = custom.get("path")
+        path_str = str(path) if isinstance(path, (str, Path)) and str(path) else None
+        yield source_id, source_name, path_str
+
+
+def _primitive_source_id(meta: Any) -> Optional[str]:
+    if not isinstance(meta, dict):
+        return None
+    source = meta.get("source_metadata") if isinstance(meta.get("source_metadata"), dict) else {}
+    sid = source.get("source_id") or meta.get("source_id")
+    return str(sid) if sid is not None else None
+
+
+def _primitive_pdf_path(meta: Any) -> Optional[str]:
+    if not isinstance(meta, dict):
+        return None
+    custom = meta.get("custom_content") if isinstance(meta.get("custom_content"), dict) else {}
+    path = custom.get("path")
+    return str(path) if isinstance(path, str) and path else None
+
+
+def _write_pdf_extraction_json_outputs(
+    *,
+    df_ledger: pd.DataFrame,
+    extracted_df: pd.DataFrame,
+    task_config: Dict[str, Any],
+    elapsed_seconds: float,
+    output_dir: Optional[str | Path] = None,
+) -> List[Path]:
+    """
+    Write one JSON per input PDF (sidecar) summarizing extracted primitives.
+
+    The JSON payload mirrors the stage2 family shape:
+      {schema_version, stage, model, <input>, <outputs>, timing}
+
+    Additionally, it includes `extracted_df_records`, a JSON-friendly list of dicts
+    with the same columns as the raw `extracted_df` output:
+      [{"document_type": ..., "metadata": ..., "uuid": ...}, ...]
+    so downstream stages can reconstruct a `pandas.DataFrame` directly.
+    """
+    out_paths: List[Path] = []
+
+    # Pre-bucket primitives by best-effort identifiers.
+    prims_by_source_id: Dict[str, List[Dict[str, Any]]] = {}
+    prims_by_pdf_path: Dict[str, List[Dict[str, Any]]] = {}
+
+    for i, row in extracted_df.iterrows():
+        meta = row.get("metadata")
+        uuid = None
+        if isinstance(meta, dict):
+            uuid = meta.get("uuid")
+        if uuid is None:
+            uuid = row.get("uuid") or f"row:{i}"
+
+        # Keep a DataFrame-shaped record so downstream stages can do:
+        #   df = pd.DataFrame(payload["extracted_df_records"])
+        record = {
+            "uuid": str(uuid),
+            "document_type": row.get("document_type"),
+            "metadata": _to_jsonable(meta),
+        }
+
+        sid = _primitive_source_id(meta)
+        if sid:
+            prims_by_source_id.setdefault(sid, []).append(record)
+
+        p = _primitive_pdf_path(meta)
+        if p:
+            prims_by_pdf_path.setdefault(p, []).append(record)
+
+    out_base_dir: Optional[Path] = None
+    if output_dir is not None:
+        out_base_dir = Path(output_dir)
+
+    method = str(task_config.get("method") or "pdf_extraction")
+    params = task_config.get("params") if isinstance(task_config.get("params"), dict) else {}
+
+    for source_id, source_name, pdf_path_str in _iter_ledger_pdf_paths(df_ledger):
+        if not pdf_path_str:
+            # No stable path to write next to; skip.
+            continue
+
+        # Prefer source_id mapping; fall back to path mapping.
+        records = prims_by_source_id.get(source_id) or prims_by_pdf_path.get(pdf_path_str) or []
+
+        pdf_path = Path(pdf_path_str)
+        out_path = (
+            (out_base_dir / _pdf_json_out_path(pdf_path).name)
+            if out_base_dir is not None
+            else _pdf_json_out_path(pdf_path)
+        )
+
+        payload: Dict[str, Any] = {
+            "schema_version": 1,
+            "stage": 1,
+            "model": method,
+            "pdf": {"path": str(pdf_path), "source_id": source_id, "source_name": source_name},
+            "task": {"method": method, "params": _to_jsonable(params)},
+            # Back-compat: keep the old key.
+            "primitives": records,
+            # New: explicitly labeled as the raw extracted_df rows.
+            "extracted_df_records": records,
+            "timing": {"seconds": float(elapsed_seconds)},
+        }
+        _atomic_write_json(out_path, payload)
+        out_paths.append(out_path)
+
+    return out_paths
+
+
+def make_pdf_task_config(
+    *,
+    method: str = "pdfium",
+    extract_text: bool = True,
+    extract_images: bool = True,
+    extract_tables: bool = True,
+    extract_charts: bool = True,
+    extract_infographics: bool = True,
+    extract_page_as_image: bool = False,
+    text_depth: str = "page",
+    extract_method: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Build the `task_config` dict expected by `nv-ingest-api` PDF extraction internals."""
+    params: Dict[str, Any] = {
+        "extract_text": extract_text,
+        "extract_images": extract_images,
+        "extract_tables": extract_tables,
+        "extract_charts": extract_charts,
+        "extract_infographics": extract_infographics,
+        "extract_page_as_image": extract_page_as_image,
+        "text_depth": text_depth,
+    }
+    if extract_method is not None:
+        # Some callsites use params["extract_method"] while others use task_config["method"].
+        params["extract_method"] = extract_method
+
+    return {"method": method, "params": params}
+
+
+def _validate_pdf_ledger_df(df: pd.DataFrame) -> None:
+    required = {"content", "source_id", "source_name", "document_type", "metadata"}
+    missing = sorted(required.difference(df.columns))
+    if missing:
+        raise KeyError(f"PDF ledger DataFrame is missing required columns: {missing}")
+
+
+@traceable_func(trace_name="retriever::pdf_extraction")
+def extract_pdf_primitives_from_ledger_df(
+    df_ledger: pd.DataFrame,
+    *,
+    task_config: Dict[str, Any],
+    extractor_config: PDFExtractorSchema,
+    write_json_outputs: bool = True,
+    json_output_dir: Optional[str | Path] = None,
+    trace_info: Optional[Dict[str, Any]] = None,
+) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    """Pure-Python PDF extraction (no Ray required).
+
+    Returns:
+      - extracted_df: columns ["document_type", "metadata", "uuid"]
+      - info: includes `execution_trace_log`
+    """
+    _validate_pdf_ledger_df(df_ledger)
+
+    # `nv-ingest-api` engines treat this as a string-keyed mapping of trace timestamps.
+    # The Ray pipeline stage uses `{}` as well; using a list can trigger
+    # "list indices must be integers or slices, not str".
+    execution_trace_log: Dict[str, Any] = {}
+    try:
+        t0 = time.perf_counter()
+        extracted_df, info = extract_primitives_from_pdf_internal(
+            df_extraction_ledger=df_ledger,
+            task_config=task_config,
+            extractor_config=extractor_config,
+            execution_trace_log=execution_trace_log,
+        )
+        elapsed = time.perf_counter() - t0
+    except Exception:
+        logger.exception("PDF extraction failed")
+        raise
+
+    info = dict(info or {})
+    info.setdefault("execution_trace_log", execution_trace_log)
+
+    if write_json_outputs:
+        try:
+            written = _write_pdf_extraction_json_outputs(
+                df_ledger=df_ledger,
+                extracted_df=extracted_df,
+                task_config=task_config,
+                elapsed_seconds=float(elapsed),
+                output_dir=json_output_dir,
+            )
+            info["json_outputs"] = [str(p) for p in written]
+        except Exception:
+            # JSON output is best-effort; don't fail extraction if serialization/IO fails.
+            logger.exception("Failed writing PDF extraction JSON outputs")
+            info["json_outputs_error"] = "failed_writing_json_outputs"
+
+    return extracted_df, info
+
+
+@app.command("page-elements")
+def render_page_elements(
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help=(
+            "Optional ingest YAML config file. If omitted, we auto-discover ./ingest-config.yaml then "
+            "$HOME/.ingest-config.yaml. Explicitly passed CLI flags override YAML."
+        ),
+    ),
+    input_dir: Optional[Path] = typer.Option(
+        None,
+        "--input-dir",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to scan recursively for *.pdf (can be provided via --config).",
+    ),
+    method: str = typer.Option(
+        "pdfium",
+        "--method",
+        help="PDF extraction method (e.g. 'pdfium', 'pdfium_hybrid', 'ocr', 'nemotron_parse', 'tika').",
+    ),
+    auth_token: Optional[str] = typer.Option(
+        None,
+        "--auth-token",
+        help="Auth token for NIM-backed services (e.g. YOLOX / Nemotron Parse).",
+    ),
+    yolox_grpc_endpoint: Optional[str] = typer.Option(
+        None,
+        "--yolox-grpc-endpoint",
+        help="YOLOX gRPC endpoint (e.g. 'page-elements:8001'). Required for method 'pdfium' family.",
+    ),
+    yolox_http_endpoint: Optional[str] = typer.Option(
+        None,
+        "--yolox-http-endpoint",
+        help="YOLOX HTTP endpoint (e.g. 'http://page-elements:8000/v1/infer'). Required for method 'pdfium' family.",
+    ),
+    nemotron_parse_grpc_endpoint: Optional[str] = typer.Option(
+        None,
+        "--nemotron-parse-grpc-endpoint",
+        help="Nemotron Parse gRPC endpoint (required for method 'nemotron_parse').",
+    ),
+    nemotron_parse_http_endpoint: Optional[str] = typer.Option(
+        None,
+        "--nemotron-parse-http-endpoint",
+        help="Nemotron Parse HTTP endpoint (required for method 'nemotron_parse').",
+    ),
+    nemotron_parse_model_name: Optional[str] = typer.Option(
+        None,
+        "--nemotron-parse-model-name",
+        help="Nemotron Parse model name (optional; defaults to schema default).",
+    ),
+    extract_text: bool = typer.Option(True, "--extract-text/--no-extract-text", help="Extract text primitives."),
+    extract_images: bool = typer.Option(
+        False, "--extract-images/--no-extract-images", help="Extract image primitives."
+    ),
+    extract_tables: bool = typer.Option(
+        False, "--extract-tables/--no-extract-tables", help="Extract table primitives."
+    ),
+    extract_charts: bool = typer.Option(
+        False, "--extract-charts/--no-extract-charts", help="Extract chart primitives."
+    ),
+    extract_infographics: bool = typer.Option(
+        False, "--extract-infographics/--no-extract-infographics", help="Extract infographic primitives."
+    ),
+    extract_page_as_image: bool = typer.Option(
+        False, "--extract-page-as-image/--no-extract-page-as-image", help="Extract full page images as primitives."
+    ),
+    text_depth: str = typer.Option(
+        "page",
+        "--text-depth",
+        help="Text depth for extracted text primitives: 'page' or 'document'.",
+    ),
+    write_json_outputs: bool = typer.Option(
+        True,
+        "--write-json-outputs/--no-write-json-outputs",
+        help="Write one <pdf>.pdf_extraction.json sidecar per input PDF.",
+    ),
+    json_output_dir: Optional[Path] = typer.Option(
+        None,
+        "--json-output-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Optional directory to write JSON outputs into (instead of next to PDFs).",
+    ),
+    limit: Optional[int] = typer.Option(None, "--limit", help="Optionally limit number of PDFs processed."),
+) -> None:
+    """
+    Scan `input_dir` for PDFs and run nv-ingest-api PDF extraction, writing primitives JSON sidecars.
+
+    This command is intentionally "directory-first" so you can point it at a folder of PDFs
+    and get per-PDF outputs without having to build a ledger by hand.
+    """
+    # Load consolidated ingest config (section: pdf).
+    cfg_raw = _normalize_page_elements_config(load_ingest_config_section(config, section="pdf"))
+
+    # Merge: YAML provides defaults; explicit CLI flags override YAML.
+    if not _argv_has_any(["--input-dir"]):
+        if "input_dir" in cfg_raw:
+            input_dir = Path(str(cfg_raw["input_dir"]))
+
+    if not _argv_has_any(["--method"]):
+        method = str(cfg_raw.get("method", method))
+    if not _argv_has_any(["--auth-token"]):
+        auth_token = cfg_raw.get("auth_token", auth_token)
+
+    if not _argv_has_any(["--yolox-grpc-endpoint"]):
+        yolox_grpc_endpoint = cfg_raw.get("yolox_grpc_endpoint", yolox_grpc_endpoint)
+    if not _argv_has_any(["--yolox-http-endpoint"]):
+        yolox_http_endpoint = cfg_raw.get("yolox_http_endpoint", yolox_http_endpoint)
+
+    if not _argv_has_any(["--nemotron-parse-grpc-endpoint"]):
+        nemotron_parse_grpc_endpoint = cfg_raw.get("nemotron_parse_grpc_endpoint", nemotron_parse_grpc_endpoint)
+    if not _argv_has_any(["--nemotron-parse-http-endpoint"]):
+        nemotron_parse_http_endpoint = cfg_raw.get("nemotron_parse_http_endpoint", nemotron_parse_http_endpoint)
+    if not _argv_has_any(["--nemotron-parse-model-name"]):
+        nemotron_parse_model_name = cfg_raw.get("nemotron_parse_model_name", nemotron_parse_model_name)
+
+    if not _argv_has_any(["--extract-text", "--no-extract-text"]):
+        extract_text = bool(cfg_raw.get("extract_text", extract_text))
+    if not _argv_has_any(["--extract-images", "--no-extract-images"]):
+        extract_images = bool(cfg_raw.get("extract_images", extract_images))
+    if not _argv_has_any(["--extract-tables", "--no-extract-tables"]):
+        extract_tables = bool(cfg_raw.get("extract_tables", extract_tables))
+    if not _argv_has_any(["--extract-charts", "--no-extract-charts"]):
+        extract_charts = bool(cfg_raw.get("extract_charts", extract_charts))
+    if not _argv_has_any(["--extract-infographics", "--no-extract-infographics"]):
+        extract_infographics = bool(cfg_raw.get("extract_infographics", extract_infographics))
+    if not _argv_has_any(["--extract-page-as-image", "--no-extract-page-as-image"]):
+        extract_page_as_image = bool(cfg_raw.get("extract_page_as_image", extract_page_as_image))
+
+    if not _argv_has_any(["--text-depth"]):
+        text_depth = str(cfg_raw.get("text_depth", text_depth))
+
+    if not _argv_has_any(["--write-json-outputs", "--no-write-json-outputs"]):
+        write_json_outputs = bool(cfg_raw.get("write_json_outputs", write_json_outputs))
+    if not _argv_has_any(["--json-output-dir"]):
+        if "json_output_dir" in cfg_raw and cfg_raw["json_output_dir"] is not None:
+            json_output_dir = Path(str(cfg_raw["json_output_dir"]))
+
+    if not _argv_has_any(["--limit"]):
+        limit = cfg_raw.get("limit", limit)
+
+    if input_dir is None:
+        raise typer.BadParameter("Missing --input-dir (or set input_dir in --config YAML).")
+
+    pdfs = sorted(str(p) for p in input_dir.rglob("*.pdf"))
+    if not pdfs:
+        console.print(f"[red]No PDFs found[/red] under: {input_dir}")
+        raise typer.Exit(code=2)
+
+    if limit is not None:
+        pdfs = pdfs[: int(limit)]
+
+    method = str(method or "pdfium")
+
+    extractor_cfg: Dict[str, Any] = {}
+    if method in {"pdfium", "pdfium_hybrid", "ocr"}:
+        if not (yolox_grpc_endpoint or yolox_http_endpoint):
+            print("YOLOX NIM endpoints not set, using HuggingFace model instead.")
+
+        extractor_cfg["pdfium_config"] = {
+            "auth_token": auth_token,
+            "yolox_endpoints": [yolox_grpc_endpoint, yolox_http_endpoint],
+        }
+    elif method == "nemotron_parse":
+        if not (nemotron_parse_grpc_endpoint or nemotron_parse_http_endpoint):
+            raise typer.BadParameter(
+                "Nemotron Parse endpoint required for method 'nemotron_parse'. "
+                "Set --nemotron-parse-grpc-endpoint or --nemotron-parse-http-endpoint."
+            )
+        extractor_cfg["nemotron_parse_config"] = {
+            "auth_token": auth_token,
+            # Nemotron Parse may still rely on YOLOX for region proposals depending on config.
+            "yolox_endpoints": [yolox_grpc_endpoint, yolox_http_endpoint],
+            "nemotron_parse_endpoints": [nemotron_parse_grpc_endpoint, nemotron_parse_http_endpoint],
+            "nemotron_parse_model_name": nemotron_parse_model_name,
+        }
+
+    extractor_schema = load_pdf_extractor_schema_from_dict(extractor_cfg)
+    task_cfg = make_pdf_task_config(
+        method=method,
+        extract_text=extract_text,
+        extract_images=extract_images,
+        extract_tables=extract_tables,
+        extract_charts=extract_charts,
+        extract_infographics=extract_infographics,
+        extract_page_as_image=extract_page_as_image,
+        text_depth=text_depth,
+    )
+
+    # Progress reporting:
+    # - PDF progress: updates per completed PDF.
+    # - Page progress: updates by page-count *after* each PDF completes (best-effort).
+    page_counts = [_safe_pdf_page_count(p) for p in tqdm(pdfs, desc="Counting pages", unit="pdf")]
+    total_pages = sum(int(n) for n in page_counts)
+
+    extracted_chunks: List[pd.DataFrame] = []
+    all_json_outputs: List[str] = []
+    info_last: Dict[str, Any] = {}
+
+    pdf_bar = tqdm(total=len(pdfs), desc="PDFs", unit="pdf")
+    page_bar = tqdm(total=total_pages, desc="Pages", unit="page")
+    try:
+        for i, (pdf_path, n_pages) in enumerate(zip(pdfs, page_counts)):
+            pdf_bar.set_postfix_str(Path(pdf_path).name)
+
+            df_ledger = pdf_files_to_ledger_df([pdf_path], start_index=i)
+            df_one, info_one = extract_pdf_primitives_from_ledger_df(
+                df_ledger,
+                task_config=task_cfg,
+                extractor_config=extractor_schema,
+                write_json_outputs=bool(write_json_outputs),
+                json_output_dir=json_output_dir,
+            )
+            info_last = dict(info_one or {})
+
+            if not df_one.empty:
+                extracted_chunks.append(df_one)
+
+            wrote = info_last.get("json_outputs")
+            if isinstance(wrote, list):
+                all_json_outputs.extend(str(x) for x in wrote)
+
+            pdf_bar.update(1)
+            page_bar.update(int(n_pages))
+    finally:
+        pdf_bar.close()
+        page_bar.close()
+
+    extracted_df = (
+        pd.concat(extracted_chunks, ignore_index=True)
+        if extracted_chunks
+        else pd.DataFrame({"document_type": [], "metadata": [], "uuid": []})
+    )
+    info = dict(info_last or {})
+    if all_json_outputs:
+        info["json_outputs"] = all_json_outputs
+
+    wrote = info.get("json_outputs")
+    wrote_n = len(wrote) if isinstance(wrote, list) else 0
+    console.print(f"[green]Done[/green] pdfs={len(pdfs)} primitives={len(extracted_df)} wrote_json={wrote_n}")
diff --git a/nemo_retriever/src/nemo_retriever/ray_balance_dag.py b/nemo_retriever/src/nemo_retriever/ray_balance_dag.py
new file mode 100644
index 000000000..2cab6d0a8
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/ray_balance_dag.py
@@ -0,0 +1,945 @@
+#!/usr/bin/env python3
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import argparse
+import csv
+import itertools
+import json
+import os
+import re
+import shlex
+import shutil
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+DONE_RE = re.compile(r"\[done\]\s+(?P<files>\d+)\s+files,\s+(?P<pages>\d+)\s+pages\s+in\s+(?P<secs>[0-9.]+)s")
+RECALL_LINE_RE = re.compile(r"^\s{2}(?P<key>[^:]+):\s*(?P<val>-?\d+(?:\.\d+)?)\s*$", re.MULTILINE)
+
+
+@dataclass
+class Variant:
+    run_id: str
+    # Matrix input metadata columns
+    pdf_workers: int
+    pdf_num_cpus: float
+    pdf_split_bs: int
+    pdf_bs: int
+    page_elements_bs: int
+    page_elements_workers: int
+    ocr_workers: int
+    ocr_bs: int
+    embed_workers: int
+    embed_bs: int
+    page_elements_cpus_per_actor: float
+    ocr_cpus_per_actor: float
+    embed_cpus_per_actor: float
+    gpu_page_elements: float
+    gpu_ocr: float
+    gpu_embed: float
+    # Supported by batch_pipeline.py today
+    ray_address: str | None = None
+    start_ray: bool = False
+
+
+MATRIX_FIELDS = [
+    "run_id",
+    "pdf_workers",
+    "pdf_num_cpus",
+    "pdf_split_bs",
+    "pdf_bs",
+    "page_elements_bs",
+    "page_elements_workers",
+    "ocr_workers",
+    "ocr_bs",
+    "embed_workers",
+    "embed_bs",
+    "page_elements_cpus_per_actor",
+    "ocr_cpus_per_actor",
+    "embed_cpus_per_actor",
+    "gpu_page_elements",
+    "gpu_ocr",
+    "gpu_embed",
+    "ray_address",
+    "start_ray",
+]
+
+TUNABLE_KNOBS = [
+    "pdf_workers",
+    "pdf_num_cpus",
+    "pdf_split_bs",
+    "pdf_bs",
+    "page_elements_bs",
+    "page_elements_workers",
+    "ocr_workers",
+    "ocr_bs",
+    "embed_workers",
+    "embed_bs",
+    "page_elements_cpus_per_actor",
+    "ocr_cpus_per_actor",
+    "embed_cpus_per_actor",
+    "gpu_page_elements",
+    "gpu_ocr",
+    "gpu_embed",
+]
+
+KNOB_TO_ACTOR = {
+    "pdf_workers": "pdf_extraction_taskpool",
+    "pdf_num_cpus": "pdf_extraction_taskpool",
+    "pdf_split_bs": "pdf_split_taskpool",
+    "pdf_bs": "pdf_extraction_taskpool",
+    "page_elements_bs": "page_elements_actor",
+    "page_elements_workers": "page_elements_actor",
+    "ocr_workers": "ocr_actor",
+    "ocr_bs": "ocr_actor",
+    "embed_workers": "embed_actor",
+    "embed_bs": "embed_actor",
+    "page_elements_cpus_per_actor": "page_elements_actor",
+    "ocr_cpus_per_actor": "ocr_actor",
+    "embed_cpus_per_actor": "embed_actor",
+    "gpu_page_elements": "page_elements_actor",
+    "gpu_ocr": "ocr_actor",
+    "gpu_embed": "embed_actor",
+}
+
+
+def parse_done_metrics(stdout: str) -> dict[str, Any]:
+    match = DONE_RE.search(stdout)
+    if not match:
+        return {"files": None, "pages": None, "ingest_secs": None}
+    return {
+        "files": int(match.group("files")),
+        "pages": int(match.group("pages")),
+        "ingest_secs": float(match.group("secs")),
+    }
+
+
+def _sanitize_metric_key(raw: str) -> str:
+    s = raw.strip().lower()
+    s = re.sub(r"[^a-z0-9]+", "_", s)
+    s = s.strip("_")
+    return f"recall_{s}" if s else "recall_metric"
+
+
+def parse_recall_metrics(stdout: str) -> dict[str, float]:
+    out: dict[str, float] = {}
+    if "Recall metrics (matching nemo_retriever.recall.core):" not in stdout:
+        return out
+    for m in RECALL_LINE_RE.finditer(stdout):
+        key = _sanitize_metric_key(m.group("key"))
+        try:
+            out[key] = float(m.group("val"))
+        except ValueError:
+            continue
+    return out
+
+
+def _parse_bool(raw: Any, default: bool = False) -> bool:
+    if raw is None:
+        return default
+    s = str(raw).strip().lower()
+    if s in {"1", "true", "yes", "y", "on"}:
+        return True
+    if s in {"0", "false", "no", "n", "off"}:
+        return False
+    return default
+
+
+def _is_valid_variant(v: Variant) -> bool:
+    # Reject invalid fractional GPU requests above 1.0 (e.g. 1.25), which many
+    # Ray clusters do not accept per actor.
+    for gpu in (v.gpu_page_elements, v.gpu_ocr, v.gpu_embed):
+        if gpu < 0:
+            return False
+        if gpu > 1.0 and abs(gpu - round(gpu)) > 1e-9:
+            return False
+    return True
+
+
+def build_default_variants() -> list[Variant]:
+    # Compact DOE-style matrix (< 1000 rows):
+    # 1) baseline
+    # 2) one-factor sweeps around baseline
+    # 3) targeted interaction grids for likely bottlenecks
+    baseline = {
+        "pdf_workers": 8,
+        "pdf_num_cpus": 2.0,
+        "pdf_split_bs": 1,
+        "pdf_bs": 16,
+        "page_elements_bs": 16,
+        "page_elements_workers": 1,
+        "ocr_workers": 2,
+        "ocr_bs": 16,
+        "embed_workers": 1,
+        "embed_bs": 256,
+        "page_elements_cpus_per_actor": 1.0,
+        "ocr_cpus_per_actor": 2.0,
+        "embed_cpus_per_actor": 1.0,
+        "gpu_page_elements": 0.5,
+        "gpu_ocr": 1.0,
+        "gpu_embed": 0.5,
+    }
+
+    variants: list[Variant] = []
+    seen: set[tuple[Any, ...]] = set()
+
+    def _key(v: dict[str, Any]) -> tuple[Any, ...]:
+        return (
+            v["pdf_workers"],
+            v["pdf_num_cpus"],
+            v["pdf_split_bs"],
+            v["pdf_bs"],
+            v["page_elements_bs"],
+            v["page_elements_workers"],
+            v["ocr_workers"],
+            v["ocr_bs"],
+            v["embed_workers"],
+            v["embed_bs"],
+            v["page_elements_cpus_per_actor"],
+            v["ocr_cpus_per_actor"],
+            v["embed_cpus_per_actor"],
+            v["gpu_page_elements"],
+            v["gpu_ocr"],
+            v["gpu_embed"],
+        )
+
+    def add_variant(**overrides: Any) -> None:
+        cfg = dict(baseline)
+        cfg.update(overrides)
+        k = _key(cfg)
+        if k in seen:
+            return
+        seen.add(k)
+        v = Variant(
+            run_id=f"V{len(variants) + 1:05d}",
+            pdf_workers=int(cfg["pdf_workers"]),
+            pdf_num_cpus=float(cfg["pdf_num_cpus"]),
+            pdf_split_bs=int(cfg["pdf_split_bs"]),
+            pdf_bs=int(cfg["pdf_bs"]),
+            page_elements_bs=int(cfg["page_elements_bs"]),
+            page_elements_workers=int(cfg["page_elements_workers"]),
+            ocr_workers=int(cfg["ocr_workers"]),
+            ocr_bs=int(cfg["ocr_bs"]),
+            embed_workers=int(cfg["embed_workers"]),
+            embed_bs=int(cfg["embed_bs"]),
+            page_elements_cpus_per_actor=float(cfg["page_elements_cpus_per_actor"]),
+            ocr_cpus_per_actor=float(cfg["ocr_cpus_per_actor"]),
+            embed_cpus_per_actor=float(cfg["embed_cpus_per_actor"]),
+            gpu_page_elements=float(cfg["gpu_page_elements"]),
+            gpu_ocr=float(cfg["gpu_ocr"]),
+            gpu_embed=float(cfg["gpu_embed"]),
+        )
+        if _is_valid_variant(v):
+            variants.append(v)
+
+    # 1) Baseline
+    add_variant()
+
+    # 2) One-factor sweeps
+    for x in [4, 8, 12, 16]:
+        add_variant(pdf_workers=x)
+    for x in [1.0, 2.0, 3.0, 4.0]:
+        add_variant(pdf_num_cpus=x)
+    for x in [1, 4, 8]:
+        add_variant(pdf_split_bs=x)
+    for x in [8, 16, 24, 32]:
+        add_variant(pdf_bs=x)
+    for x in [8, 16, 24, 32]:
+        add_variant(page_elements_bs=x)
+    for x in [1, 2, 3]:
+        add_variant(page_elements_workers=x)
+    for x in [1, 2, 3]:
+        add_variant(ocr_workers=x)
+    for x in [8, 16, 24, 32]:
+        add_variant(ocr_bs=x)
+    for x in [1, 2, 3]:
+        add_variant(embed_workers=x)
+    for x in [128, 256, 512, 768]:
+        add_variant(embed_bs=x)
+    for x in [1.0, 2.0, 4.0]:
+        add_variant(page_elements_cpus_per_actor=x)
+    for x in [1.0, 2.0, 4.0]:
+        add_variant(ocr_cpus_per_actor=x)
+    for x in [1.0, 2.0, 4.0]:
+        add_variant(embed_cpus_per_actor=x)
+    for x in [0.25, 0.5, 0.75]:
+        add_variant(gpu_page_elements=x)
+    for x in [0.75, 1.0]:
+        add_variant(gpu_ocr=x)
+    for x in [0.25, 0.5, 0.75]:
+        add_variant(gpu_embed=x)
+
+    # 3) Targeted interactions
+    for ocr_bs, ocr_workers, gpu_ocr in itertools.product([8, 16, 24, 32], [1, 2, 3], [0.75, 1.0]):
+        add_variant(ocr_bs=ocr_bs, ocr_workers=ocr_workers, gpu_ocr=gpu_ocr)
+
+    for embed_bs, embed_workers, gpu_embed in itertools.product([128, 256, 512, 768], [1, 2, 3], [0.25, 0.5, 0.75]):
+        add_variant(embed_bs=embed_bs, embed_workers=embed_workers, gpu_embed=gpu_embed)
+
+    for page_elements_bs, page_elements_workers, gpu_page_elements in itertools.product(
+        [8, 16, 24, 32], [1, 2, 3], [0.25, 0.5, 0.75]
+    ):
+        add_variant(
+            page_elements_bs=page_elements_bs,
+            page_elements_workers=page_elements_workers,
+            gpu_page_elements=gpu_page_elements,
+        )
+
+    for pdf_workers, pdf_num_cpus, pdf_bs in itertools.product([4, 8, 12, 16], [1.0, 2.0, 3.0, 4.0], [8, 16, 24, 32]):
+        add_variant(pdf_workers=pdf_workers, pdf_num_cpus=pdf_num_cpus, pdf_bs=pdf_bs)
+
+    for pe_cpu, ocr_cpu, embed_cpu in itertools.product([1.0, 2.0, 4.0], [1.0, 2.0, 4.0], [1.0, 2.0, 4.0]):
+        add_variant(
+            page_elements_cpus_per_actor=pe_cpu,
+            ocr_cpus_per_actor=ocr_cpu,
+            embed_cpus_per_actor=embed_cpu,
+        )
+
+    for pdf_bs, ocr_bs, embed_bs in itertools.product([8, 16, 24, 32], [8, 16, 24, 32], [128, 256, 512, 768]):
+        add_variant(pdf_bs=pdf_bs, ocr_bs=ocr_bs, embed_bs=embed_bs)
+
+    return variants
+
+
+def write_matrix_csv(variants: list[Variant], path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    valid_variants = [v for v in variants if _is_valid_variant(v)]
+    with path.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=MATRIX_FIELDS)
+        writer.writeheader()
+        for v in valid_variants:
+            writer.writerow(
+                {
+                    "run_id": v.run_id,
+                    "pdf_workers": v.pdf_workers,
+                    "pdf_num_cpus": v.pdf_num_cpus,
+                    "pdf_split_bs": v.pdf_split_bs,
+                    "pdf_bs": v.pdf_bs,
+                    "page_elements_bs": v.page_elements_bs,
+                    "page_elements_workers": v.page_elements_workers,
+                    "ocr_workers": v.ocr_workers,
+                    "ocr_bs": v.ocr_bs,
+                    "embed_workers": v.embed_workers,
+                    "embed_bs": v.embed_bs,
+                    "page_elements_cpus_per_actor": v.page_elements_cpus_per_actor,
+                    "ocr_cpus_per_actor": v.ocr_cpus_per_actor,
+                    "embed_cpus_per_actor": v.embed_cpus_per_actor,
+                    "gpu_page_elements": v.gpu_page_elements,
+                    "gpu_ocr": v.gpu_ocr,
+                    "gpu_embed": v.gpu_embed,
+                    "ray_address": v.ray_address or "",
+                    "start_ray": str(v.start_ray).lower(),
+                }
+            )
+
+
+def load_variants_from_csv(path: Path) -> list[Variant]:
+    required = {
+        "pdf_workers",
+        "pdf_num_cpus",
+        "pdf_split_bs",
+        "pdf_bs",
+        "page_elements_bs",
+        "page_elements_workers",
+        "ocr_workers",
+        "ocr_bs",
+        "embed_workers",
+        "embed_bs",
+        "page_elements_cpus_per_actor",
+        "ocr_cpus_per_actor",
+        "embed_cpus_per_actor",
+        "gpu_page_elements",
+        "gpu_ocr",
+        "gpu_embed",
+    }
+    variants: list[Variant] = []
+    invalid_rows = 0
+    with path.open("r", newline="", encoding="utf-8") as f:
+        reader = csv.DictReader(f)
+        if reader.fieldnames is None:
+            raise ValueError(f"Matrix CSV has no header: {path}")
+        missing = sorted(required.difference(set(reader.fieldnames)))
+        if missing:
+            raise ValueError(f"Matrix CSV is missing required columns: {missing}")
+
+        for idx, row in enumerate(reader, start=1):
+            run_id = (row.get("run_id") or "").strip() or f"R{idx:05d}"
+            ray_address_raw = (row.get("ray_address") or "").strip()
+            raw = Variant(
+                run_id=run_id,
+                pdf_workers=int(row["pdf_workers"]),
+                pdf_num_cpus=float(row["pdf_num_cpus"]),
+                pdf_split_bs=int(row.get("pdf_split_bs") or 1),
+                pdf_bs=int(row["pdf_bs"]),
+                page_elements_bs=int(row.get("page_elements_bs") or 24),
+                page_elements_workers=int(row.get("page_elements_workers") or 1),
+                ocr_workers=int(row["ocr_workers"]),
+                ocr_bs=int(row["ocr_bs"]),
+                embed_workers=int(row["embed_workers"]),
+                embed_bs=int(row["embed_bs"]),
+                page_elements_cpus_per_actor=float(row.get("page_elements_cpus_per_actor") or 1.0),
+                ocr_cpus_per_actor=float(row.get("ocr_cpus_per_actor") or 1.0),
+                embed_cpus_per_actor=float(row.get("embed_cpus_per_actor") or 1.0),
+                gpu_page_elements=float(row["gpu_page_elements"]),
+                gpu_ocr=float(row["gpu_ocr"]),
+                gpu_embed=float(row["gpu_embed"]),
+                ray_address=ray_address_raw if ray_address_raw else None,
+                start_ray=_parse_bool(row.get("start_ray"), default=False),
+            )
+            if _is_valid_variant(raw):
+                variants.append(raw)
+            else:
+                invalid_rows += 1
+    if invalid_rows:
+        print(f"Skipped invalid variant rows from CSV: {invalid_rows}")
+    return variants
+
+
+def format_float(value: Any, ndigits: int = 3) -> str:
+    if value is None:
+        return "-"
+    try:
+        return f"{float(value):.{ndigits}f}"
+    except Exception:
+        return str(value)
+
+
+def _variant_to_dict(v: Variant) -> dict[str, Any]:
+    return {k: getattr(v, k) for k in TUNABLE_KNOBS}
+
+
+def _changed_knobs(baseline: Variant, candidate: Variant) -> list[str]:
+    out: list[str] = []
+    for k in TUNABLE_KNOBS:
+        if getattr(baseline, k) != getattr(candidate, k):
+            out.append(k)
+    return out
+
+
+def print_matrix(rows: list[dict[str, Any]]) -> None:
+    cols = [
+        "matrix_row",
+        "run_id",
+        "pdf_workers",
+        "pdf_num_cpus",
+        "pdf_split_bs",
+        "pdf_bs",
+        "page_elements_bs",
+        "page_elements_workers",
+        "ocr_workers",
+        "ocr_bs",
+        "embed_workers",
+        "embed_bs",
+        "page_elements_cpus_per_actor",
+        "ocr_cpus_per_actor",
+        "embed_cpus_per_actor",
+        "gpu_page_elements",
+        "gpu_ocr",
+        "gpu_embed",
+        "return_code",
+        "skipped",
+        "prune_reason",
+        "pages",
+        "wall_secs",
+        "ingest_secs",
+        "pages_per_sec_total",
+        "pages_per_sec_ingest",
+        "recall_recall_1",
+        "recall_recall_5",
+        "recall_recall_10",
+    ]
+
+    widths = {col: max(len(col), *(len(str(row.get(col, ""))) for row in rows)) for col in cols}
+    header = " | ".join(col.ljust(widths[col]) for col in cols)
+    sep = "-+-".join("-" * widths[col] for col in cols)
+
+    print("\nResults Matrix")
+    print(header)
+    print(sep)
+    for row in rows:
+        vals: list[str] = []
+        for col in cols:
+            value = row.get(col, "")
+            if col in {
+                "pdf_num_cpus",
+                "gpu_page_elements",
+                "gpu_ocr",
+                "gpu_embed",
+                "page_elements_cpus_per_actor",
+                "ocr_cpus_per_actor",
+                "embed_cpus_per_actor",
+                "wall_secs",
+                "ingest_secs",
+                "pages_per_sec_total",
+                "pages_per_sec_ingest",
+                "recall_recall_1",
+                "recall_recall_5",
+                "recall_recall_10",
+            }:
+                value = format_float(value, 3)
+            vals.append(str(value).ljust(widths[col]))
+        print(" | ".join(vals))
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Run nemo_retriever.examples.batch_pipeline across variants and report throughput."
+    )
+    parser.add_argument("--input-dir", required=True, help="Directory containing PDFs.")
+    parser.add_argument("--output-csv", default="batch_matrix_results.csv", help="CSV output path.")
+    parser.add_argument("--query-csv", default="bo767_query_gt.csv", help="Query CSV for batch_pipeline.")
+    parser.add_argument(
+        "--runner",
+        default="uv run python",
+        help="Command prefix used to invoke Python (default: 'uv run python').",
+    )
+    parser.add_argument(
+        "--module",
+        default="nemo_retriever.examples.batch_pipeline",
+        help="Python module to run (default: nemo_retriever.examples.batch_pipeline).",
+    )
+    parser.add_argument(
+        "--logs-dir",
+        default="batch_matrix_logs",
+        help="Directory for per-run stdout/stderr logs.",
+    )
+    parser.add_argument(
+        "--lancedb-uri",
+        default="lancedb",
+        help="LanceDB URI/path reused by each run (cleaned before each run).",
+    )
+    parser.add_argument(
+        "--matrix-csv",
+        default=None,
+        help=(
+            "Optional external matrix CSV path. If omitted, a default matrix is generated "
+            "using built-in cpu/gpu settings and the requested batch-size ranges."
+        ),
+    )
+    parser.add_argument(
+        "--write-default-matrix-csv",
+        default=None,
+        help="Optional path to write the generated default matrix CSV.",
+    )
+    parser.add_argument(
+        "--exit-after-writing-matrix",
+        action="store_true",
+        help="Write matrix CSV then exit without running any jobs.",
+    )
+    parser.add_argument(
+        "--row-start",
+        type=int,
+        default=1,
+        help="1-based inclusive start row from matrix to run.",
+    )
+    parser.add_argument(
+        "--row-end",
+        type=int,
+        default=None,
+        help="1-based inclusive end row from matrix to run. Defaults to final row.",
+    )
+    parser.add_argument(
+        "--adaptive-prune",
+        action="store_true",
+        help=(
+            "Enable conservative pruning: if a single-knob variant is slower than baseline, "
+            "skip later variants that move that same knob farther in that direction."
+        ),
+    )
+    parser.add_argument(
+        "--slowdown-threshold-pct",
+        type=float,
+        default=0.0,
+        help="Minimum slowdown percentage vs baseline required before pruning logic triggers.",
+    )
+    parser.add_argument(
+        "--prune-log",
+        default=None,
+        help="Optional JSONL log path for adaptive pruning decisions (default: <logs-dir>/adaptive_prune.jsonl).",
+    )
+    args = parser.parse_args()
+
+    input_dir = Path(args.input_dir).resolve()
+    output_csv = Path(args.output_csv).resolve()
+    logs_dir = Path(args.logs_dir).resolve()
+    logs_dir.mkdir(parents=True, exist_ok=True)
+    lancedb_uri_path = Path(args.lancedb_uri).expanduser().resolve()
+    prune_log_path = Path(args.prune_log).resolve() if args.prune_log else (logs_dir / "adaptive_prune.jsonl")
+
+    if not input_dir.exists():
+        print(f"ERROR: input directory does not exist: {input_dir}", file=sys.stderr)
+        return 2
+
+    if args.matrix_csv:
+        matrix_path = Path(args.matrix_csv).resolve()
+        if not matrix_path.exists():
+            print(f"ERROR: matrix CSV does not exist: {matrix_path}", file=sys.stderr)
+            return 2
+        variants = load_variants_from_csv(matrix_path)
+        print(f"Loaded matrix CSV from: {matrix_path}")
+        print(f"Loaded matrix variant rows: {len(variants)}")
+    else:
+        variants = build_default_variants()
+        print("Loaded matrix source: generated default variants")
+        print(f"Loaded matrix variant rows: {len(variants)}")
+
+    if args.write_default_matrix_csv:
+        write_path = Path(args.write_default_matrix_csv).resolve()
+        # Write whichever matrix is currently active so sharding is reproducible.
+        write_matrix_csv(variants, write_path)
+        print(f"Wrote matrix CSV ({len(variants)} rows): {write_path}")
+        if args.exit_after_writing_matrix:
+            return 0
+
+    total_rows = len(variants)
+    if total_rows == 0:
+        print("ERROR: matrix contains zero rows.", file=sys.stderr)
+        return 2
+
+    row_start = int(args.row_start)
+    row_end = int(args.row_end) if args.row_end is not None else total_rows
+    if row_start < 1:
+        print("--row-start must be >= 1", file=sys.stderr)
+        return 2
+    if row_end < row_start:
+        print("--row-end must be >= --row-start", file=sys.stderr)
+        return 2
+    if row_end > total_rows:
+        print(f"--row-end ({row_end}) exceeds matrix size ({total_rows})", file=sys.stderr)
+        return 2
+
+    # Preserve original matrix row numbers for distributed sharding visibility.
+    selected: list[tuple[int, Variant]] = [(idx, variants[idx - 1]) for idx in range(row_start, row_end + 1)]
+
+    print(f"Loaded matrix rows: {total_rows}")
+    print(f"Running row range: [{row_start}, {row_end}] ({len(selected)} rows)")
+
+    base_cmd = shlex.split(args.runner) + ["-m", args.module]
+    rows: list[dict[str, Any]] = []
+    prune_rules: dict[str, dict[str, Any]] = {}
+    baseline_variant: Variant | None = None
+    for _, v in selected:
+        if v.run_id == "V00001":
+            baseline_variant = v
+            break
+    if baseline_variant is None and selected:
+        baseline_variant = selected[0][1]
+
+    baseline_pps: float | None = None
+    threshold = max(0.0, float(args.slowdown_threshold_pct)) / 100.0
+
+    def _log_prune_event(event: dict[str, Any]) -> None:
+        try:
+            prune_log_path.parent.mkdir(parents=True, exist_ok=True)
+            with prune_log_path.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(event, ensure_ascii=False) + "\n")
+        except Exception:
+            pass
+
+    for matrix_row, variant in selected:
+        if args.adaptive_prune and baseline_variant is not None and baseline_pps is not None and prune_rules:
+            matched: list[str] = []
+            for knob, rule in prune_rules.items():
+                base_val = float(getattr(baseline_variant, knob))
+                cur_val = float(getattr(variant, knob))
+                delta = cur_val - base_val
+                direction = int(rule["direction"])
+                min_abs_delta = float(rule["min_abs_delta"])
+                if direction * delta > 0 and abs(delta) >= min_abs_delta:
+                    matched.append(knob)
+            if matched:
+                reason = "pruned_by_knob:" + ",".join(sorted(matched))
+                row = {
+                    "matrix_row": matrix_row,
+                    "run_id": variant.run_id,
+                    "pdf_workers": variant.pdf_workers,
+                    "pdf_num_cpus": variant.pdf_num_cpus,
+                    "pdf_split_bs": variant.pdf_split_bs,
+                    "pdf_bs": variant.pdf_bs,
+                    "page_elements_bs": variant.page_elements_bs,
+                    "page_elements_workers": variant.page_elements_workers,
+                    "ocr_workers": variant.ocr_workers,
+                    "ocr_bs": variant.ocr_bs,
+                    "embed_workers": variant.embed_workers,
+                    "embed_bs": variant.embed_bs,
+                    "page_elements_cpus_per_actor": variant.page_elements_cpus_per_actor,
+                    "ocr_cpus_per_actor": variant.ocr_cpus_per_actor,
+                    "embed_cpus_per_actor": variant.embed_cpus_per_actor,
+                    "gpu_page_elements": variant.gpu_page_elements,
+                    "gpu_ocr": variant.gpu_ocr,
+                    "gpu_embed": variant.gpu_embed,
+                    "ray_address": variant.ray_address,
+                    "start_ray": variant.start_ray,
+                    "return_code": 99,
+                    "recall_ran": False,
+                    "failure_reason": reason,
+                    "skipped": True,
+                    "prune_reason": reason,
+                    "files": None,
+                    "pages": None,
+                    "wall_secs": None,
+                    "ingest_secs": None,
+                    "pages_per_sec_total": None,
+                    "pages_per_sec_ingest": None,
+                }
+                rows.append(row)
+                _log_prune_event(
+                    {
+                        "event": "variant_pruned",
+                        "matrix_row": matrix_row,
+                        "run_id": variant.run_id,
+                        "reason": reason,
+                    }
+                )
+                print(f"\n=== Run {variant.run_id} (row {matrix_row}) ===")
+                print(f"SKIPPED: {reason}")
+                continue
+
+        # Ensure runs are isolated: remove prior LanceDB artifacts before each run.
+        if lancedb_uri_path.exists():
+            if lancedb_uri_path.is_dir():
+                shutil.rmtree(lancedb_uri_path)
+            else:
+                lancedb_uri_path.unlink()
+
+        cmd = base_cmd + [str(input_dir), "--query-csv", str(args.query_csv), "--no-recall-details"]
+        if variant.ray_address:
+            cmd += ["--ray-address", variant.ray_address]
+        if variant.start_ray:
+            cmd += ["--start-ray"]
+        cmd += [
+            "--pdf-extract-workers",
+            str(variant.pdf_workers),
+            "--pdf-extract-num-cpus",
+            str(variant.pdf_num_cpus),
+            "--pdf-split-batch-size",
+            str(variant.pdf_split_bs),
+            "--pdf-extract-batch-size",
+            str(variant.pdf_bs),
+            "--page-elements-batch-size",
+            str(variant.page_elements_bs),
+            "--page-elements-workers",
+            str(variant.page_elements_workers),
+            "--ocr-workers",
+            str(variant.ocr_workers),
+            "--ocr-batch-size",
+            str(variant.ocr_bs),
+            "--embed-workers",
+            str(variant.embed_workers),
+            "--embed-batch-size",
+            str(variant.embed_bs),
+            "--page-elements-cpus-per-actor",
+            str(variant.page_elements_cpus_per_actor),
+            "--ocr-cpus-per-actor",
+            str(variant.ocr_cpus_per_actor),
+            "--embed-cpus-per-actor",
+            str(variant.embed_cpus_per_actor),
+            "--gpu-page-elements",
+            str(variant.gpu_page_elements),
+            "--gpu-ocr",
+            str(variant.gpu_ocr),
+            "--gpu-embed",
+            str(variant.gpu_embed),
+            "--lancedb-uri",
+            str(lancedb_uri_path),
+            "--runtime-metrics-dir",
+            str(logs_dir / "runtime_metrics"),
+            "--runtime-metrics-prefix",
+            f"{matrix_row:05d}_{variant.run_id}",
+        ]
+
+        print(f"\n=== Run {variant.run_id} (row {matrix_row}) ===")
+        print("CMD:", " ".join(shlex.quote(x) for x in cmd))
+
+        t0 = time.perf_counter()
+        proc = subprocess.run(
+            cmd,
+            text=True,
+            capture_output=True,
+            env=os.environ.copy(),
+        )
+        wall_secs = time.perf_counter() - t0
+
+        metrics = parse_done_metrics(proc.stdout)
+        pages = metrics["pages"]
+        ingest_secs = metrics["ingest_secs"]
+        recall_metrics = parse_recall_metrics(proc.stdout)
+        recall_ran = bool(recall_metrics)
+        effective_return_code = proc.returncode if (proc.returncode != 0 or recall_ran) else 98
+        failure_reason = ""
+        if proc.returncode != 0:
+            failure_reason = f"subprocess_exit_{proc.returncode}"
+        elif not recall_ran:
+            failure_reason = "missing_recall_metrics"
+
+        row: dict[str, Any] = {
+            "matrix_row": matrix_row,
+            "run_id": variant.run_id,
+            "pdf_workers": variant.pdf_workers,
+            "pdf_num_cpus": variant.pdf_num_cpus,
+            "pdf_split_bs": variant.pdf_split_bs,
+            "pdf_bs": variant.pdf_bs,
+            "page_elements_bs": variant.page_elements_bs,
+            "page_elements_workers": variant.page_elements_workers,
+            "ocr_workers": variant.ocr_workers,
+            "ocr_bs": variant.ocr_bs,
+            "embed_workers": variant.embed_workers,
+            "embed_bs": variant.embed_bs,
+            "page_elements_cpus_per_actor": variant.page_elements_cpus_per_actor,
+            "ocr_cpus_per_actor": variant.ocr_cpus_per_actor,
+            "embed_cpus_per_actor": variant.embed_cpus_per_actor,
+            "gpu_page_elements": variant.gpu_page_elements,
+            "gpu_ocr": variant.gpu_ocr,
+            "gpu_embed": variant.gpu_embed,
+            "ray_address": variant.ray_address,
+            "start_ray": variant.start_ray,
+            "return_code": effective_return_code,
+            "recall_ran": recall_ran,
+            "failure_reason": failure_reason,
+            "skipped": False,
+            "prune_reason": "",
+            "files": metrics["files"],
+            "pages": pages,
+            "wall_secs": wall_secs,
+            "ingest_secs": ingest_secs,
+            "pages_per_sec_total": (pages / wall_secs) if (pages and wall_secs > 0) else None,
+            "pages_per_sec_ingest": (pages / ingest_secs) if (pages and ingest_secs and ingest_secs > 0) else None,
+        }
+        row.update(recall_metrics)
+        rows.append(row)
+
+        # Baseline = V00001 when present in selection, else first selected variant.
+        if baseline_variant is not None and baseline_pps is None and variant.run_id == baseline_variant.run_id:
+            baseline_pps = row.get("pages_per_sec_total")
+            _log_prune_event(
+                {
+                    "event": "baseline_set",
+                    "matrix_row": matrix_row,
+                    "run_id": variant.run_id,
+                    "baseline_pages_per_sec_total": baseline_pps,
+                    "baseline_knobs": _variant_to_dict(variant),
+                }
+            )
+
+        if (
+            args.adaptive_prune
+            and baseline_variant is not None
+            and baseline_pps is not None
+            and not row.get("skipped")
+            and isinstance(row.get("pages_per_sec_total"), (int, float))
+        ):
+            pps = float(row["pages_per_sec_total"])
+            if pps < float(baseline_pps) * (1.0 - threshold):
+                changed = _changed_knobs(baseline_variant, variant)
+                event = {
+                    "event": "slower_than_baseline",
+                    "matrix_row": matrix_row,
+                    "run_id": variant.run_id,
+                    "baseline_pages_per_sec_total": baseline_pps,
+                    "current_pages_per_sec_total": pps,
+                    "threshold_pct": float(args.slowdown_threshold_pct),
+                    "changed_knobs": changed,
+                    "changed_actors": sorted({KNOB_TO_ACTOR.get(k, "unknown") for k in changed}),
+                }
+                if len(changed) == 1:
+                    knob = changed[0]
+                    base_val = float(getattr(baseline_variant, knob))
+                    cur_val = float(getattr(variant, knob))
+                    delta = cur_val - base_val
+                    if delta != 0:
+                        rule = prune_rules.get(knob)
+                        abs_delta = abs(delta)
+                        direction = 1 if delta > 0 else -1
+                        if rule is None:
+                            prune_rules[knob] = {
+                                "direction": direction,
+                                "min_abs_delta": abs_delta,
+                                "actor": KNOB_TO_ACTOR.get(knob, "unknown"),
+                                "source_run_id": variant.run_id,
+                            }
+                        else:
+                            # Tighten prune threshold if this is closer to baseline.
+                            if direction == int(rule["direction"]):
+                                rule["min_abs_delta"] = min(float(rule["min_abs_delta"]), abs_delta)
+                        event["prune_rule_added"] = {knob: prune_rules.get(knob)}
+                else:
+                    event["prune_rule_added"] = None
+                _log_prune_event(event)
+
+        (logs_dir / f"{matrix_row:05d}_{variant.run_id}.stdout.log").write_text(proc.stdout or "", encoding="utf-8")
+        (logs_dir / f"{matrix_row:05d}_{variant.run_id}.stderr.log").write_text(proc.stderr or "", encoding="utf-8")
+
+        print(
+            f"Run {variant.run_id}: rc={effective_return_code}, pages={row['pages']}, "
+            f"wall={format_float(row['wall_secs'])}s, "
+            f"pps_total={format_float(row['pages_per_sec_total'])}, "
+            f"recall@10={format_float(row.get('recall_recall_10'))}"
+        )
+
+    base_fieldnames = [
+        "matrix_row",
+        "run_id",
+        "pdf_workers",
+        "pdf_num_cpus",
+        "pdf_split_bs",
+        "pdf_bs",
+        "page_elements_bs",
+        "page_elements_workers",
+        "ocr_workers",
+        "ocr_bs",
+        "embed_workers",
+        "embed_bs",
+        "page_elements_cpus_per_actor",
+        "ocr_cpus_per_actor",
+        "embed_cpus_per_actor",
+        "gpu_page_elements",
+        "gpu_ocr",
+        "gpu_embed",
+        "ray_address",
+        "start_ray",
+        "return_code",
+        "recall_ran",
+        "failure_reason",
+        "skipped",
+        "prune_reason",
+        "files",
+        "pages",
+        "wall_secs",
+        "ingest_secs",
+        "pages_per_sec_total",
+        "pages_per_sec_ingest",
+    ]
+    recall_fieldnames = sorted(
+        {
+            k
+            for row in rows
+            for k in row.keys()
+            if k.startswith("recall_") and k not in {"recall_recall_1", "recall_recall_5", "recall_recall_10"}
+        }
+    )
+    common_recall_fields = [
+        k for k in ["recall_recall_1", "recall_recall_5", "recall_recall_10"] if any(k in r for r in rows)
+    ]
+    fieldnames = base_fieldnames + common_recall_fields + recall_fieldnames
+    with output_csv.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        for row in rows:
+            writer.writerow(row)
+
+    print_matrix(rows)
+    print(f"\nCSV written to: {output_csv}")
+    print(f"Logs written to: {logs_dir}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/nemo_retriever/src/nemo_retriever/recall/__init__.py b/nemo_retriever/src/nemo_retriever/recall/__init__.py
new file mode 100644
index 000000000..b4cdfb39b
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/recall/__init__.py
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Recall evaluation utilities and CLI.
+"""
+
+from .__main__ import app
+from .core import RecallConfig, evaluate_recall
+
+__all__ = [
+    "app",
+    "RecallConfig",
+    "evaluate_recall",
+]
diff --git a/nemo_retriever/src/nemo_retriever/recall/__main__.py b/nemo_retriever/src/nemo_retriever/recall/__main__.py
new file mode 100644
index 000000000..3755fe5c4
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/recall/__main__.py
@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from . import vdb_recall
+
+app = typer.Typer(help="Recall utilities (query -> embed -> vector DB search).")
+app.add_typer(vdb_recall.app, name="vdb-recall")
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/recall/core.py b/nemo_retriever/src/nemo_retriever/recall/core.py
new file mode 100644
index 000000000..9fc80d59f
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/recall/core.py
@@ -0,0 +1,368 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+logger = logging.getLogger(__name__)
+
+import numpy as np
+import pandas as pd
+
+from nv_ingest_api.util.nim import infer_microservice
+
+
+@dataclass(frozen=True)
+class RecallConfig:
+    lancedb_uri: str
+    lancedb_table: str
+    embedding_model: str
+    # Embedding endpoints (optional).
+    #
+    # If neither HTTP nor gRPC endpoint is provided (and embedding_endpoint is empty),
+    # stage7 will fall back to local HuggingFace embeddings via:
+    #   nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder
+    embedding_http_endpoint: Optional[str] = None
+    embedding_grpc_endpoint: Optional[str] = None
+    # Back-compat single endpoint string (http URL or host:port for gRPC).
+    embedding_endpoint: Optional[str] = None
+    embedding_api_key: str = ""
+    top_k: int = 10
+    ks: Sequence[int] = (1, 3, 5, 10)
+    # ANN search tuning (LanceDB IVF_HNSW_SQ).
+    # nprobes=0 means "search all partitions" (exhaustive); refine_factor re-ranks
+    # top candidates with full-precision vectors to eliminate SQ quantization error.
+    nprobes: int = 0
+    refine_factor: int = 10
+    hybrid: bool = False
+    # Local HF knobs (only used when endpoints are missing).
+    local_hf_device: Optional[str] = None
+    local_hf_cache_dir: Optional[str] = None
+    local_hf_batch_size: int = 64
+
+
+def _normalize_query_df(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Normalize a query CSV into:
+      - query (string)
+      - golden_answer (string key that should match LanceDB `pdf_page`)
+
+    Supported inputs:
+      - query,pdf_page
+      - query,pdf,page (or query,pdf,gt_page)
+    """
+    df = df.copy()
+    if "gt_page" in df.columns and "page" not in df.columns:
+        df = df.rename(columns={"gt_page": "page"})
+
+    if "query" not in df.columns:
+        raise KeyError("Query CSV must contain a 'query' column.")
+
+    if "pdf_page" in df.columns:
+        df["golden_answer"] = df["pdf_page"].astype(str)
+        return df
+
+    required = {"pdf", "page"}
+    missing = required.difference(df.columns)
+    if missing:
+        raise KeyError(
+            "Query CSV must contain either columns ['query','pdf_page'] or ['query','pdf','page'] "
+            f"(missing: {sorted(missing)})"
+        )
+
+    df["pdf"] = df["pdf"].astype(str).str.replace(".pdf", "", regex=False)
+    df["page"] = df["page"].astype(str)
+    df["golden_answer"] = df.apply(lambda x: f"{x.pdf}_{x.page}", axis=1)
+    return df
+
+
+def _resolve_embedding_endpoint(cfg: RecallConfig) -> Tuple[Optional[str], Optional[bool]]:
+    """
+    Resolve which embedding endpoint to use.
+
+    Returns (endpoint, use_grpc) where:
+      - endpoint is either an http(s) URL or a host:port string for gRPC
+      - use_grpc is True for gRPC, False for HTTP, None when no endpoint is configured
+    """
+    http_ep = (cfg.embedding_http_endpoint or "").strip() if isinstance(cfg.embedding_http_endpoint, str) else None
+    grpc_ep = (cfg.embedding_grpc_endpoint or "").strip() if isinstance(cfg.embedding_grpc_endpoint, str) else None
+    single = (cfg.embedding_endpoint or "").strip() if isinstance(cfg.embedding_endpoint, str) else None
+
+    if http_ep:
+        return http_ep, False
+    if grpc_ep:
+        return grpc_ep, True
+    if single:
+        # Infer protocol: if a URL scheme is present, treat as HTTP; otherwise gRPC.
+        return single, (not single.lower().startswith("http"))
+
+    return None, None
+
+
+def _embed_queries_nim(
+    queries: List[str],
+    *,
+    endpoint: str,
+    model: str,
+    api_key: str,
+    grpc: bool,
+) -> List[List[float]]:
+    # `infer_microservice` returns a list of embeddings.
+    embeddings = infer_microservice(
+        queries,
+        model_name=model,
+        embedding_endpoint=endpoint,
+        nvidia_api_key=(api_key or "").strip(),
+        grpc=bool(grpc),
+        input_type="query",
+    )
+    # Some backends return numpy arrays; normalize to list-of-list floats.
+    out: List[List[float]] = []
+    for e in embeddings:
+        if isinstance(e, np.ndarray):
+            out.append(e.astype("float32").tolist())
+        else:
+            out.append(list(e))
+    return out
+
+
+def _embed_queries_local_hf(
+    queries: List[str],
+    *,
+    device: Optional[str],
+    cache_dir: Optional[str],
+    batch_size: int,
+    model_name: Optional[str] = None,
+) -> List[List[float]]:
+    # Lazy import: only load torch/HF when needed.
+    from nemo_retriever.model import is_vl_embed_model, resolve_embed_model
+
+    model_id = resolve_embed_model(model_name)
+
+    if is_vl_embed_model(model_name):
+        from nemo_retriever.model.local.llama_nemotron_embed_vl_1b_v2_embedder import LlamaNemotronEmbedVL1BV2Embedder
+
+        embedder = LlamaNemotronEmbedVL1BV2Embedder(device=device, hf_cache_dir=cache_dir, model_id=model_id)
+        # VL model handles query formatting internally via encode_queries().
+        vecs = embedder.embed_queries(queries, batch_size=int(batch_size))
+    else:
+        from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import LlamaNemotronEmbed1BV2Embedder
+
+        embedder = LlamaNemotronEmbed1BV2Embedder(
+            device=device, hf_cache_dir=cache_dir, normalize=True, model_id=model_id
+        )
+        vecs = embedder.embed(["query: " + q for q in queries], batch_size=int(batch_size))
+    # Ensure list-of-list floats.
+    return vecs.detach().to("cpu").tolist()
+
+
+def _search_lancedb(
+    *,
+    lancedb_uri: str,
+    table_name: str,
+    query_vectors: List[List[float]],
+    top_k: int,
+    vector_column_name: str = "vector",
+    nprobes: int = 0,
+    refine_factor: int = 10,
+    query_texts: Optional[List[str]] = None,
+    hybrid: bool = False,
+) -> List[List[Dict[str, Any]]]:
+    import lancedb  # type: ignore
+
+    db = lancedb.connect(lancedb_uri)
+    table = db.open_table(table_name)
+
+    # Determine nprobes: 0 means "search all partitions" for exhaustive ANN search.
+    # Read the actual partition count from the index so we don't hard-code it.
+    effective_nprobes = nprobes
+    if effective_nprobes <= 0:
+        try:
+            indices = table.list_indices()
+            for idx in indices:
+                np_ = getattr(idx, "num_partitions", None)
+                if np_ and int(np_) > 0:
+                    effective_nprobes = int(np_)
+                    break
+        except Exception:
+            pass
+        if effective_nprobes <= 0:
+            effective_nprobes = 16  # safe fallback matching default index config
+
+    results: List[List[Dict[str, Any]]] = []
+    for i, v in enumerate(query_vectors):
+        q = np.asarray(v, dtype="float32")
+
+        if hybrid and query_texts is not None:
+            from lancedb.rerankers import RRFReranker  # type: ignore
+
+            text = query_texts[i]
+            hits = (
+                table.search(query_type="hybrid")
+                .vector(q)
+                .text(text)
+                .nprobes(effective_nprobes)
+                .refine_factor(refine_factor)
+                .select(["text", "metadata", "source"])
+                .limit(top_k)
+                .rerank(RRFReranker())
+                .to_list()
+            )
+        else:
+            hits = (
+                table.search(q, vector_column_name=vector_column_name)
+                .nprobes(effective_nprobes)
+                .refine_factor(refine_factor)
+                .select(["text", "metadata", "source", "_distance"])
+                .limit(top_k)
+                .to_list()
+            )
+
+        results.append(hits)
+    return results
+
+
+def _hits_to_keys(raw_hits: List[List[Dict[str, Any]]]) -> List[List[str]]:
+    retrieved_keys: List[List[str]] = []
+    for hits in raw_hits:
+        keys: List[str] = []
+        for h in hits:
+            res = json.loads(h["metadata"])
+            source = json.loads(h["source"])
+            # Prefer explicit `pdf_page` column; fall back to derived form.
+            if res.get("page_number") is not None and source.get("source_id"):
+                filename = Path(source["source_id"]).stem
+                keys.append(filename + "_" + str(res["page_number"]))
+            else:
+                logger.warning(
+                    "Skipping hit with missing page_number or source_id: metadata=%s source=%s",
+                    h.get("metadata", ""),
+                    h.get("source", ""),
+                )
+        retrieved_keys.append([k for k in keys if k])
+    return retrieved_keys
+
+
+def _is_hit(golden_key: str, retrieved: List[str], k: int) -> bool:
+    """Check if a golden key is found in the top-k retrieved keys.
+
+    Handles filenames with underscores via ``rsplit`` and also accepts
+    whole-document keys (page ``-1``).
+    """
+    parts = golden_key.rsplit("_", 1)
+    if len(parts) != 2:
+        return golden_key in retrieved[:k]
+    filename, page = parts
+    specific_page = f"{filename}_{page}"
+    entire_document = f"{filename}_-1"
+    top = retrieved[:k]
+    return specific_page in top or entire_document in top
+
+
+def _recall_at_k(gold: List[str], retrieved: List[List[str]], k: int) -> float:
+    hits = sum(_is_hit(g, r, k) for g, r in zip(gold, retrieved))
+    return hits / max(1, len(gold))
+
+
+def retrieve_and_score(
+    query_csv: Path,
+    *,
+    cfg: RecallConfig,
+    limit: Optional[int] = None,
+    vector_column_name: str = "vector",
+) -> Tuple[pd.DataFrame, List[str], List[List[Dict[str, Any]]], List[List[str]], Dict[str, float]]:
+    """
+    Run embeddings + LanceDB retrieval for a query CSV.
+
+    Returns:
+      - normalized query DataFrame
+      - gold keys
+      - raw LanceDB hits
+      - retrieved keys (pdf_page-like)
+      - metrics dict (recall@k)
+    """
+    df_query = _normalize_query_df(pd.read_csv(query_csv))
+    if limit is not None:
+        df_query = df_query.head(int(limit)).copy()
+
+    queries = df_query["query"].astype(str).tolist()
+    gold = df_query["golden_answer"].astype(str).tolist()
+
+    endpoint, use_grpc = _resolve_embedding_endpoint(cfg)
+    if endpoint is not None and use_grpc is not None:
+        vectors = _embed_queries_nim(
+            queries,
+            endpoint=endpoint,
+            model=cfg.embedding_model,
+            api_key=cfg.embedding_api_key,
+            grpc=bool(use_grpc),
+        )
+    else:
+        vectors = _embed_queries_local_hf(
+            queries,
+            device=cfg.local_hf_device,
+            cache_dir=cfg.local_hf_cache_dir,
+            batch_size=int(cfg.local_hf_batch_size),
+            model_name=cfg.embedding_model,
+        )
+    raw_hits = _search_lancedb(
+        lancedb_uri=cfg.lancedb_uri,
+        table_name=cfg.lancedb_table,
+        query_vectors=vectors,
+        top_k=int(cfg.top_k),
+        vector_column_name=vector_column_name,
+        nprobes=int(cfg.nprobes),
+        refine_factor=int(cfg.refine_factor),
+        query_texts=queries,
+        hybrid=bool(cfg.hybrid),
+    )
+    retrieved_keys = _hits_to_keys(raw_hits)
+    metrics = {f"recall@{k}": _recall_at_k(gold, retrieved_keys, int(k)) for k in cfg.ks}
+    return df_query, gold, raw_hits, retrieved_keys, metrics
+
+
+def evaluate_recall(
+    query_csv: Path,
+    *,
+    cfg: RecallConfig,
+    output_dir: Optional[Path] = None,
+) -> Dict[str, Any]:
+    df_query, gold, raw_hits, retrieved_keys, metrics = retrieve_and_score(
+        query_csv,
+        cfg=cfg,
+        limit=None,
+        vector_column_name="vector",
+    )
+
+    # Build per-query analysis DataFrame
+    rows = []
+    for i, (q, g, r) in enumerate(zip(df_query["query"].astype(str).tolist(), gold, retrieved_keys)):
+        row = {"query_id": i, "query": q, "golden_answer": g, "top_retrieved": r[: cfg.top_k]}
+        for k in cfg.ks:
+            k = int(k)
+            row[f"hit@{k}"] = _is_hit(g, r, k)
+            row[f"rank@{k}"] = (r[: cfg.top_k].index(g) + 1) if (g in r[: cfg.top_k]) else None
+        rows.append(row)
+    results_df = pd.DataFrame(rows)
+
+    saved: Dict[str, str] = {}
+    if output_dir is not None:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        ts = time.strftime("%Y%m%d_%H%M%S")
+        out = output_dir / f"recall_results_{ts}.csv"
+        results_df.to_csv(out, index=False)
+        saved["results_csv"] = str(out)
+
+    return {
+        "n_queries": int(len(df_query)),
+        "top_k": int(cfg.top_k),
+        "metrics": metrics,
+        "saved": saved,
+    }
diff --git a/nemo_retriever/src/nemo_retriever/recall/main_recall.py b/nemo_retriever/src/nemo_retriever/recall/main_recall.py
new file mode 100644
index 000000000..b0f471a5e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/recall/main_recall.py
@@ -0,0 +1,142 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+E2E Recall test case - fresh ingestion + recall evaluation.
+
+Calls e2e.py to handle ingestion and collection creation, then recall.py for evaluation.
+"""
+
+import json
+import os
+
+from nv_ingest_harness.cases.e2e import main as e2e_main
+from nv_ingest_harness.cases.recall import main as recall_main
+from nv_ingest_harness.utils.recall import get_recall_collection_name
+
+
+def main(config=None, log_path: str = "test_results") -> int:
+    """
+    Main test entry point for E2E recall testing.
+
+    Args:
+        config: TestConfig object with all settings
+        log_path: Path for logging output
+
+    Returns:
+        Exit code (0 = success)
+    """
+    if config is None:
+        print("ERROR: No configuration provided")
+        return 2
+
+    # Require explicit recall_dataset
+    recall_dataset = getattr(config, "recall_dataset", None)
+    if not recall_dataset:
+        print("ERROR: recall_dataset must be specified in configuration")
+        print("Set recall_dataset in test_configs.yaml recall section or via RECALL_DATASET environment variable")
+        return 1
+
+    # Recall-specific configuration
+    test_name = config.test_name or os.path.basename(config.dataset_dir.rstrip("/"))
+
+    # Generate collection name using standardized pattern
+    collection_name = get_recall_collection_name(test_name)
+
+    # Temporarily override collection_name in config for e2e.main()
+    original_collection_name = config.collection_name
+    config.collection_name = collection_name
+
+    # Print configuration
+    print("=" * 60)
+    print("E2E Recall Test Configuration")
+    print("=" * 60)
+    print(f"Dataset: {config.dataset_dir}")
+    print(f"Test Name: {test_name}")
+    print(f"Collection: {collection_name}")
+    print(f"Recall Dataset: {recall_dataset}")
+    print("=" * 60)
+
+    # Step 1: Run ingestion via e2e.main() - this creates the collection
+    print("\n" + "=" * 60)
+    print("Step 1: Running Ingestion (via e2e)")
+    print("=" * 60)
+
+    e2e_rc = e2e_main(config=config, log_path=log_path)
+    if e2e_rc != 0:
+        print(f"ERROR: Ingestion failed with exit code: {e2e_rc}")
+        config.collection_name = original_collection_name  # Restore original
+        return e2e_rc
+
+    # Load e2e results before recall overwrites them
+    results_file = os.path.join(log_path, "_test_results.json")
+    e2e_results = {}
+    if os.path.exists(results_file):
+        try:
+            with open(results_file) as f:
+                e2e_data = json.load(f)
+                # Extract ingestion metrics
+                e2e_results = {
+                    "test_config": e2e_data.get("test_config", {}),
+                    "results": e2e_data.get("results", {}),
+                }
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    # Step 2: Run recall evaluation via recall.main()
+    print("\n" + "=" * 60)
+    print("Step 2: Running Recall Evaluation (via recall)")
+    print("=" * 60)
+
+    recall_rc = recall_main(config=config, log_path=log_path)
+    if recall_rc != 0:
+        print(f"Warning: Recall evaluation returned non-zero exit code: {recall_rc}")
+
+    # Restore original collection_name
+    config.collection_name = original_collection_name
+
+    # Load recall results
+    recall_results = {}
+    if os.path.exists(results_file):
+        try:
+            with open(results_file) as f:
+                recall_data = json.load(f)
+                recall_results = recall_data.get("recall_results", {})
+        except (json.JSONDecodeError, IOError):
+            pass
+
+    # Combine results
+    test_results = {
+        "test_type": "e2e_recall",
+        "test_config": {
+            "test_name": test_name,
+            "collection_name": collection_name,
+            "recall_dataset": recall_dataset,
+        },
+        "ingestion_results": e2e_results.get("results", {}),
+        "recall_results": recall_results,
+    }
+
+    # Merge in any additional config from e2e
+    if "test_config" in e2e_results:
+        e2e_config = e2e_results["test_config"]
+        # Keep ingestion-specific config but don't override recall settings
+        for key in ["api_version", "dataset_dir", "hostname", "model_name", "dense_dim", "sparse", "gpu_search"]:
+            if key in e2e_config:
+                test_results["test_config"][key] = e2e_config[key]
+
+    # Write combined results
+    with open(results_file, "w") as f:
+        json.dump(test_results, f, indent=2)
+
+    print("\n" + "=" * 60)
+    print(f"{test_name}_e2e_recall Summary")
+    print("=" * 60)
+    print(json.dumps(test_results, indent=2))
+
+    return 0 if recall_rc == 0 else recall_rc
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/nemo_retriever/src/nemo_retriever/recall/vdb_recall.py b/nemo_retriever/src/nemo_retriever/recall/vdb_recall.py
new file mode 100644
index 000000000..8132f8268
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/recall/vdb_recall.py
@@ -0,0 +1,317 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple
+
+import typer
+import pandas as pd  # noqa: F401
+from rich.console import Console
+
+from .core import RecallConfig, evaluate_recall, retrieve_and_score, _normalize_query_df  # noqa: F401
+
+app = typer.Typer(help="Embed query CSV rows, search LanceDB, print hits, and compute recall@k.")
+console = Console()
+
+
+def _resolve_query_csv(path: Path) -> Path:
+    if path.exists():
+        return path
+    # Convenience fallback for common repo layout.
+    for candidate in (Path("bo767_query_gt.csv"), Path("data/bo767_query_gt.csv")):
+        if candidate.exists():
+            return candidate
+    raise typer.BadParameter(
+        f"Query CSV not found at '{path}'. Tried also: 'bo767_query_gt.csv', 'data/bo767_query_gt.csv'."
+    )
+
+
+def _extract_hits(result: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    hits = []
+    for res in result:
+        hits.append(
+            {
+                "text": res.get("text", {}),
+                "metadata": res.get("metadata", {}),
+                "source": res.get("source", {}),
+                "distance": res.get("_distance", {}),
+            }
+        )
+    return hits
+
+
+def _coerce_endpoint_str(v: Optional[str]) -> Optional[str]:
+    if v is None:
+        return None
+    s = str(v).strip()
+    if not s or s.lower() in ("none", "null"):
+        return None
+    return s
+
+
+def _resolve_endpoints(
+    *,
+    embedding_endpoint: Optional[str],
+    embedding_http_endpoint: Optional[str],
+    embedding_grpc_endpoint: Optional[str],
+) -> Tuple[Optional[str], Optional[str]]:
+    """
+    Resolve endpoint options with precedence:
+      1) explicit http/grpc options
+      2) single --embedding-endpoint (auto-routed by scheme)
+    """
+    http_ep = _coerce_endpoint_str(embedding_http_endpoint)
+    grpc_ep = _coerce_endpoint_str(embedding_grpc_endpoint)
+    single = _coerce_endpoint_str(embedding_endpoint)
+
+    if http_ep or grpc_ep:
+        return http_ep, grpc_ep
+    if single:
+        if single.lower().startswith("http"):
+            return single, None
+        return None, single
+    return None, None
+
+
+@app.command("recall-with-main")
+def recall_with_main(
+    query_csv: Path = typer.Option(
+        Path("bo767_query_gt.csv"),
+        "--query-csv",
+        help="Query ground-truth CSV (expects columns: query,pdf_page OR query,pdf,page).",
+    ),
+    top_k: int = typer.Option(10, "--top-k", min=1, help="Top-k to print per query."),
+    embedding_endpoint: Optional[str] = typer.Option(
+        None,
+        "--embedding-endpoint",
+        help=(
+            "Embedding endpoint (http(s) URL or host:port for gRPC). "
+            "If omitted, you may specify --embedding-http-endpoint/--embedding-grpc-endpoint instead; "
+            "if no endpoints are provided, falls back to local HF embeddings."
+        ),
+    ),
+    embedding_http_endpoint: Optional[str] = typer.Option(
+        None,
+        "--embedding-http-endpoint",
+        help="HTTP embedding endpoint URL (e.g. 'http://localhost:8012/v1').",
+    ),
+    embedding_grpc_endpoint: Optional[str] = typer.Option(
+        None,
+        "--embedding-grpc-endpoint",
+        help="gRPC embedding endpoint (e.g. 'localhost:8013').",
+    ),
+    embedding_model: str = typer.Option(
+        "nvidia/llama-3.2-nv-embedqa-1b-v2",
+        "--embedding-model",
+        help="Embedding model name.",
+    ),
+    embedding_api_key: Optional[str] = typer.Option(None, "--embedding-api-key", help="Embedding API key (optional)."),
+    lancedb_uri: str = typer.Option("lancedb", "--lancedb-uri", help="LanceDB database URI (directory path)."),
+    table_name: str = typer.Option("nv-ingest", "--table-name", help="LanceDB table name."),
+    vector_column_name: str = typer.Option("vector", "--vector-column", help="Vector column name in the table."),
+    local_hf_device: Optional[str] = typer.Option(
+        None,
+        "--local-hf-device",
+        help="Device for local HF embeddings when endpoints are missing (e.g. 'cuda', 'cpu', 'cuda:0').",
+    ),
+    local_hf_cache_dir: Optional[Path] = typer.Option(
+        None,
+        "--local-hf-cache-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Optional HuggingFace cache directory for local embeddings.",
+    ),
+    local_hf_batch_size: int = typer.Option(
+        64,
+        "--local-hf-batch-size",
+        min=1,
+        help="Batch size for local HF embedding inference.",
+    ),
+) -> None:
+    query_csv = _resolve_query_csv(Path(query_csv))
+
+    metrics_ks = (1, 5, 10)
+    search_k = max(int(top_k), max(metrics_ks))
+
+    http_ep, grpc_ep = _resolve_endpoints(
+        embedding_endpoint=embedding_endpoint,
+        embedding_http_endpoint=embedding_http_endpoint,
+        embedding_grpc_endpoint=embedding_grpc_endpoint,
+    )
+    cfg = RecallConfig(
+        lancedb_uri=str(lancedb_uri),
+        lancedb_table=str(table_name),
+        embedding_http_endpoint=http_ep,
+        embedding_grpc_endpoint=grpc_ep,
+        embedding_endpoint=_coerce_endpoint_str(embedding_endpoint),
+        embedding_model=str(embedding_model),
+        embedding_api_key=(embedding_api_key or ""),
+        top_k=int(search_k),
+        ks=metrics_ks,
+        local_hf_device=_coerce_endpoint_str(local_hf_device),
+        local_hf_cache_dir=(str(local_hf_cache_dir) if local_hf_cache_dir is not None else None),
+        local_hf_batch_size=int(local_hf_batch_size),
+    )
+
+    print("Reading and normalizing query CSV...")
+    df_query, gold, raw_hits, retrieved_keys, metrics = retrieve_and_score(
+        query_csv=query_csv,
+        cfg=cfg,
+        limit=None,
+        vector_column_name=str(vector_column_name),
+    )
+
+    queries = df_query["query"].astype(str).tolist()
+    has_separate_cols = "pdf" in df_query.columns and "page" in df_query.columns
+    if has_separate_cols:
+        gold_pdfs = df_query["pdf"].astype(str).tolist()
+        gold_pages = df_query["page"].astype(str).tolist()
+
+    print(f"Retrieval completed for {len(queries)} queries.")
+
+    for idx, (query, g_key, hits) in enumerate(zip(queries, gold, raw_hits)):
+        print(f"\nQuery: {query}")
+        g_pdf, g_page = g_key.rsplit("_", 1)
+        print(f"\tGold PDF: {g_pdf} - Gold Page: {g_page}")
+        if has_separate_cols:
+            print(f"\tOther PDF: {gold_pdfs[idx]} - Other Page: {gold_pages[idx]}")
+        print(f"\tTop-k Results:")  # noqa: F541
+
+        for i, h in enumerate(hits[:top_k]):
+            meta = json.loads(h["metadata"]) if isinstance(h["metadata"], str) else h["metadata"]
+            src = json.loads(h["source"]) if isinstance(h["source"], str) else h["source"]
+            pdf_name = Path(src["source_id"]).stem
+            page_number = meta.get("page_number", -1)
+            print(f"\tResult {i}: {pdf_name} - {page_number}")
+
+            if page_number == -1:
+                print(f"Seeing page numbers -1 for query: {query}")
+
+    print(f"\n\nRecall@1: {metrics['recall@1']}")
+    print(f"Recall@5: {metrics['recall@5']}")
+    print(f"Recall@10: {metrics['recall@10']}")
+
+
+@app.command("run")
+def run(
+    query_csv: Path = typer.Option(
+        Path("bo767_query_gt.csv"),
+        "--query-csv",
+        help="Query ground-truth CSV (expects columns: query,pdf_page OR query,pdf,page).",
+    ),
+    limit: Optional[int] = typer.Option(None, "--limit", min=1, help="Optionally limit number of queries."),
+    top_k: int = typer.Option(5, "--top-k", min=1, help="Top-k to print per query."),
+    lancedb_uri: str = typer.Option("lancedb", "--lancedb-uri", help="LanceDB database URI (directory path)."),
+    table_name: str = typer.Option("nv-ingest", "--table-name", help="LanceDB table name."),
+    vector_column_name: str = typer.Option("vector", "--vector-column", help="Vector column name in the table."),
+    embedding_endpoint: Optional[str] = typer.Option(
+        None,
+        "--embedding-endpoint",
+        help=(
+            "Embedding endpoint (http(s) URL or host:port for gRPC). "
+            "If omitted, you may specify --embedding-http-endpoint/--embedding-grpc-endpoint instead; "
+            "if no endpoints are provided, stage7 falls back to local HF embeddings."
+        ),
+    ),
+    embedding_http_endpoint: Optional[str] = typer.Option(
+        None,
+        "--embedding-http-endpoint",
+        help="HTTP embedding endpoint URL (e.g. 'http://localhost:8012/v1').",
+    ),
+    embedding_grpc_endpoint: Optional[str] = typer.Option(
+        None,
+        "--embedding-grpc-endpoint",
+        help="gRPC embedding endpoint (e.g. 'localhost:8013').",
+    ),
+    embedding_model: str = typer.Option(
+        "nvidia/llama-3.2-nv-embedqa-1b-v2",
+        "--embedding-model",
+        help="Embedding model name.",
+    ),
+    embedding_api_key: Optional[str] = typer.Option(None, "--embedding-api-key", help="Embedding API key (optional)."),
+    local_hf_device: Optional[str] = typer.Option(
+        None,
+        "--local-hf-device",
+        help="Device for local HF embeddings when endpoints are missing (e.g. 'cuda', 'cpu', 'cuda:0').",
+    ),
+    local_hf_cache_dir: Optional[Path] = typer.Option(
+        None,
+        "--local-hf-cache-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Optional HuggingFace cache directory for local embeddings.",
+    ),
+    local_hf_batch_size: int = typer.Option(
+        64,
+        "--local-hf-batch-size",
+        min=1,
+        help="Batch size for local HF embedding inference.",
+    ),
+    print_hits: bool = typer.Option(True, "--print-hits/--no-print-hits", help="Print top-k hits per query."),
+) -> None:
+    """
+    Reads a query CSV, embeds each query, searches LanceDB, prints top-k results, and prints recall@1/@5/@10.
+
+    Note: recall@10 requires retrieving at least 10 results per query; we will query LanceDB with
+    search_k = max(top_k, 10) but only print the first `--top-k`.
+    """
+    query_csv = _resolve_query_csv(Path(query_csv))
+
+    metrics_ks = (1, 5, 10)
+    search_k = max(int(top_k), max(metrics_ks))
+
+    http_ep, grpc_ep = _resolve_endpoints(
+        embedding_endpoint=embedding_endpoint,
+        embedding_http_endpoint=embedding_http_endpoint,
+        embedding_grpc_endpoint=embedding_grpc_endpoint,
+    )
+    cfg = RecallConfig(
+        lancedb_uri=str(lancedb_uri),
+        lancedb_table=str(table_name),
+        embedding_http_endpoint=http_ep,
+        embedding_grpc_endpoint=grpc_ep,
+        embedding_endpoint=_coerce_endpoint_str(embedding_endpoint),
+        embedding_model=str(embedding_model),
+        embedding_api_key=(embedding_api_key or ""),
+        top_k=int(search_k),
+        ks=metrics_ks,
+        local_hf_device=_coerce_endpoint_str(local_hf_device),
+        local_hf_cache_dir=(str(local_hf_cache_dir) if local_hf_cache_dir is not None else None),
+        local_hf_batch_size=int(local_hf_batch_size),
+    )
+
+    df_query, gold, raw_hits, retrieved_keys, metrics = retrieve_and_score(
+        query_csv=query_csv,
+        cfg=cfg,
+        limit=limit,
+        vector_column_name=str(vector_column_name),
+    )
+
+    if print_hits:
+        # Pretty-print top-k results per query.
+        for q, g, hits in zip(
+            df_query["query"].astype(str).tolist(),
+            gold,
+            raw_hits,
+        ):
+            flat = _extract_hits(hits)
+            console.print(f"[bold cyan]Query[/bold cyan] {q}")
+            console.print(f"[bold]Gold[/bold]  {g}")
+            console.print(f"[bold]Hits[/bold]  {flat[: int(top_k)]}")
+            console.print("")
+
+    console.print("[bold green]Recall metrics[/bold green]")
+    for k, v in metrics.items():
+        console.print(f"  {k}: {v:.4f}")
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/retriever.py b/nemo_retriever/src/nemo_retriever/retriever.py
new file mode 100644
index 000000000..28ab35d4b
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/retriever.py
@@ -0,0 +1,208 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Optional, Sequence
+
+
+@dataclass
+class Retriever:
+    """Simple query helper over LanceDB with configurable embedders."""
+
+    lancedb_uri: str = "lancedb"
+    lancedb_table: str = "nv-ingest"
+    embedder: str = "nvidia/llama-3.2-nv-embedqa-1b-v2"
+    embedding_http_endpoint: Optional[str] = None
+    embedding_endpoint: Optional[str] = None
+    embedding_api_key: str = ""
+    top_k: int = 10
+    vector_column_name: str = "vector"
+    nprobes: int = 0
+    refine_factor: int = 10
+    hybrid: bool = False
+    local_hf_device: Optional[str] = None
+    local_hf_cache_dir: Optional[Path] = None
+    local_hf_batch_size: int = 64
+
+    def _resolve_embedding_endpoint(self) -> Optional[str]:
+        http_ep = self.embedding_http_endpoint.strip() if isinstance(self.embedding_http_endpoint, str) else None
+        single = self.embedding_endpoint.strip() if isinstance(self.embedding_endpoint, str) else None
+
+        if http_ep:
+            return http_ep
+        if single:
+            if not single.lower().startswith("http"):
+                raise ValueError("gRPC endpoints are not supported; provide an HTTP NIM endpoint URL.")
+            return single
+        return None
+
+    def _embed_queries_nim(
+        self,
+        query_texts: list[str],
+        *,
+        endpoint: str,
+        model: str,
+    ) -> list[list[float]]:
+        import numpy as np
+        from nv_ingest_api.util.nim import infer_microservice
+
+        embeddings = infer_microservice(
+            query_texts,
+            model_name=model,
+            embedding_endpoint=endpoint,
+            nvidia_api_key=(self.embedding_api_key or "").strip(),
+            input_type="query",
+        )
+        out: list[list[float]] = []
+        for embedding in embeddings:
+            if isinstance(embedding, np.ndarray):
+                out.append(embedding.astype("float32").tolist())
+            else:
+                out.append(list(embedding))
+        return out
+
+    def _embed_queries_local_hf(self, query_texts: list[str], *, model_name: str) -> list[list[float]]:
+        from nemo_retriever.model import is_vl_embed_model, resolve_embed_model
+
+        model_id = resolve_embed_model(model_name)
+        cache_dir = str(self.local_hf_cache_dir) if self.local_hf_cache_dir else None
+
+        if is_vl_embed_model(model_name):
+            from nemo_retriever.model.local.llama_nemotron_embed_vl_1b_v2_embedder import (
+                LlamaNemotronEmbedVL1BV2Embedder,
+            )
+
+            embedder = LlamaNemotronEmbedVL1BV2Embedder(
+                device=self.local_hf_device,
+                hf_cache_dir=cache_dir,
+                model_id=model_id,
+            )
+            vectors = embedder.embed_queries(query_texts, batch_size=int(self.local_hf_batch_size))
+        else:
+            from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import LlamaNemotronEmbed1BV2Embedder
+
+            embedder = LlamaNemotronEmbed1BV2Embedder(
+                device=self.local_hf_device,
+                hf_cache_dir=cache_dir,
+                normalize=True,
+                model_id=model_id,
+            )
+            vectors = embedder.embed(["query: " + q for q in query_texts], batch_size=int(self.local_hf_batch_size))
+        return vectors.detach().to("cpu").tolist()
+
+    def _search_lancedb(
+        self,
+        *,
+        lancedb_uri: str,
+        lancedb_table: str,
+        query_vectors: list[list[float]],
+        query_texts: list[str],
+    ) -> list[list[dict[str, Any]]]:
+        import lancedb  # type: ignore
+        import numpy as np
+
+        db = lancedb.connect(lancedb_uri)
+        table = db.open_table(lancedb_table)
+
+        effective_nprobes = int(self.nprobes)
+        if effective_nprobes <= 0:
+            try:
+                for idx in table.list_indices():
+                    num_parts = getattr(idx, "num_partitions", None)
+                    if num_parts and int(num_parts) > 0:
+                        effective_nprobes = int(num_parts)
+                        break
+            except Exception:
+                pass
+            if effective_nprobes <= 0:
+                effective_nprobes = 16
+
+        results: list[list[dict[str, Any]]] = []
+        for i, vector in enumerate(query_vectors):
+            q = np.asarray(vector, dtype="float32")
+            if self.hybrid:
+                from lancedb.rerankers import RRFReranker  # type: ignore
+
+                hits = (
+                    table.search(query_type="hybrid")
+                    .vector(q)
+                    .text(query_texts[i])
+                    .nprobes(effective_nprobes)
+                    .refine_factor(int(self.refine_factor))
+                    .select(["text", "metadata", "source"])
+                    .limit(int(self.top_k))
+                    .rerank(RRFReranker())
+                    .to_list()
+                )
+            else:
+                hits = (
+                    table.search(q, vector_column_name=self.vector_column_name)
+                    .nprobes(effective_nprobes)
+                    .refine_factor(int(self.refine_factor))
+                    .select(["text", "metadata", "source", "_distance"])
+                    .limit(int(self.top_k))
+                    .to_list()
+                )
+            results.append(hits)
+        return results
+
+    def query(
+        self,
+        query: str,
+        *,
+        embedder: Optional[str] = None,
+        lancedb_uri: Optional[str] = None,
+        lancedb_table: Optional[str] = None,
+    ) -> list[dict[str, Any]]:
+        """Run retrieval for a single query string."""
+        return self.queries(
+            [query],
+            embedder=embedder,
+            lancedb_uri=lancedb_uri,
+            lancedb_table=lancedb_table,
+        )[0]
+
+    def queries(
+        self,
+        queries: Sequence[str],
+        *,
+        embedder: Optional[str] = None,
+        lancedb_uri: Optional[str] = None,
+        lancedb_table: Optional[str] = None,
+    ) -> list[list[dict[str, Any]]]:
+        """Run retrieval for multiple query strings."""
+        query_texts = [str(q) for q in queries]
+        if not query_texts:
+            return []
+
+        resolved_embedder = str(embedder or self.embedder)
+        resolved_lancedb_uri = str(lancedb_uri or self.lancedb_uri)
+        resolved_lancedb_table = str(lancedb_table or self.lancedb_table)
+
+        endpoint = self._resolve_embedding_endpoint()
+        if endpoint is not None:
+            vectors = self._embed_queries_nim(
+                query_texts,
+                endpoint=endpoint,
+                model=resolved_embedder,
+            )
+        else:
+            vectors = self._embed_queries_local_hf(
+                query_texts,
+                model_name=resolved_embedder,
+            )
+
+        return self._search_lancedb(
+            lancedb_uri=resolved_lancedb_uri,
+            lancedb_table=resolved_lancedb_table,
+            query_vectors=vectors,
+            query_texts=query_texts,
+        )
+
+
+# Backward compatibility alias.
+retriever = Retriever
diff --git a/nemo_retriever/src/nemo_retriever/table/__init__.py b/nemo_retriever/src/nemo_retriever/table/__init__.py
new file mode 100644
index 000000000..7075a95bb
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/table/__init__.py
@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Table extraction stage (pure Python + Ray Data adapters).
+
+This stage enriches existing STRUCTURED/table primitives by populating
+`metadata.table_metadata.table_content` using OCR (and optionally YOLOX).
+"""
+
+from .config import TableExtractionStageConfig, load_table_extractor_schema_from_dict
+from .commands import app
+from .processor import extract_table_data_from_primitives_df
+
+__all__ = [
+    "app",
+    "TableExtractionStageConfig",
+    "extract_table_data_from_primitives_df",
+    "load_table_extractor_schema_from_dict",
+]
diff --git a/nemo_retriever/src/nemo_retriever/table/commands.py b/nemo_retriever/src/nemo_retriever/table/commands.py
new file mode 100644
index 000000000..689f2461a
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/table/commands.py
@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import typer
+from rich.console import Console
+
+from nemo_retriever.ingest_config import load_ingest_config_section
+from nemo_retriever.io.dataframe import read_dataframe, write_dataframe
+
+from nemo_retriever.table.config import load_table_extractor_schema_from_dict
+from nemo_retriever.table.processor import extract_table_data_from_primitives_df
+
+app = typer.Typer(help="Table extraction: enrich table primitives with OCR/structure-derived table_content.")
+console = Console()
+
+
+@app.command()
+def run(
+    input_path: Path = typer.Option(
+        ...,
+        "--input",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="Input primitives as a DataFrame file (.parquet, .jsonl, or .json). Must include a 'metadata' column.",
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None,
+        "--output",
+        dir_okay=False,
+        file_okay=True,
+        help="Output path (.parquet, .jsonl, or .json). Defaults to <input>.+table<ext>.",
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help=(
+            "Optional ingest YAML config file. If omitted, we auto-discover ./ingest-config.yaml then "
+            "$HOME/.ingest-config.yaml. Uses section: table."
+        ),
+    ),
+) -> None:
+    """
+    Load a primitives DataFrame, run table enrichment, and write the enriched DataFrame.
+    """
+    try:
+        df = read_dataframe(input_path)
+    except ValueError as e:
+        raise typer.BadParameter(str(e)) from e
+
+    cfg_dict: Dict[str, Any] = load_ingest_config_section(config, section="table")
+    schema = load_table_extractor_schema_from_dict(cfg_dict)
+    out_df, _info = extract_table_data_from_primitives_df(df, extractor_config=schema, task_config={})
+
+    if output_path is None:
+        output_path = input_path.with_name(input_path.stem + ".table" + input_path.suffix)
+
+    try:
+        write_dataframe(out_df, output_path)
+    except ValueError as e:
+        raise typer.BadParameter(str(e)) from e
+
+    console.print(f"[green]Done[/green] wrote={output_path} rows={len(out_df)}")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/table/config.py b/nemo_retriever/src/nemo_retriever/table/config.py
new file mode 100644
index 000000000..aea446b74
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/table/config.py
@@ -0,0 +1,31 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from nemo_retriever.config_utils import endpoints_from_yaml
+
+from nv_ingest_api.internal.schemas.extract.extract_table_schema import TableExtractorSchema
+
+
+def load_table_extractor_schema_from_dict(cfg: Dict[str, Any]) -> TableExtractorSchema:
+    cfg = dict(cfg or {})
+    endpoint_cfg = cfg.get("endpoint_config")
+    if isinstance(endpoint_cfg, dict):
+        endpoint_cfg = dict(endpoint_cfg)
+        if "yolox_endpoints" in endpoint_cfg:
+            endpoint_cfg["yolox_endpoints"] = endpoints_from_yaml(endpoint_cfg.get("yolox_endpoints"))
+        if "ocr_endpoints" in endpoint_cfg:
+            endpoint_cfg["ocr_endpoints"] = endpoints_from_yaml(endpoint_cfg.get("ocr_endpoints"))
+        cfg["endpoint_config"] = endpoint_cfg
+    return TableExtractorSchema(**cfg)
+
+
+@dataclass(frozen=True)
+class TableExtractionStageConfig:
+    batch_size: int = 64
+    stage_name: str = "table_extraction"
diff --git a/nemo_retriever/src/nemo_retriever/table/processor.py b/nemo_retriever/src/nemo_retriever/table/processor.py
new file mode 100644
index 000000000..3122d2231
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/table/processor.py
@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+import pandas as pd
+
+from nv_ingest_api.internal.extract.image.table_extractor import extract_table_data_from_image_internal
+from nv_ingest_api.internal.primitives.tracing.tagging import traceable_func
+from nv_ingest_api.internal.schemas.extract.extract_table_schema import TableExtractorSchema
+
+from nemo_retriever.io.dataframe import validate_primitives_dataframe
+
+logger = logging.getLogger(__name__)
+
+
+@traceable_func(trace_name="retriever::table_extraction")
+def extract_table_data_from_primitives_df(
+    df_primitives: pd.DataFrame,
+    *,
+    extractor_config: TableExtractorSchema,
+    task_config: Optional[Dict[str, Any]] = None,
+    trace_info: Optional[Dict[str, Any]] = None,
+) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    """Enrich table primitives in-place by running OCR / YOLOX and writing table_content."""
+    _ = trace_info
+    validate_primitives_dataframe(df_primitives)
+
+    if task_config is None:
+        task_config = {}
+
+    execution_trace_log: Dict[str, Any] = {}
+    try:
+        out_df, info = extract_table_data_from_image_internal(
+            df_extraction_ledger=df_primitives,
+            task_config=task_config,
+            extraction_config=extractor_config,
+            execution_trace_log=execution_trace_log,
+        )
+    except Exception:
+        logger.exception("Table extraction failed")
+        raise
+
+    info = dict(info or {})
+    info.setdefault("execution_trace_log", execution_trace_log)
+    return out_df, info
diff --git a/nemo_retriever/src/nemo_retriever/table/stage.py b/nemo_retriever/src/nemo_retriever/table/stage.py
new file mode 100644
index 000000000..84f86c529
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/table/stage.py
@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.table.commands import app, main, run
+from nemo_retriever.table.processor import extract_table_data_from_primitives_df
+
+__all__ = ["app", "extract_table_data_from_primitives_df", "main", "run"]
diff --git a/nemo_retriever/src/nemo_retriever/table/table_structure.py b/nemo_retriever/src/nemo_retriever/table/table_structure.py
new file mode 100644
index 000000000..1b61b9c21
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/table/table_structure.py
@@ -0,0 +1,807 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence, Tuple, cast
+
+import base64
+import io
+import time
+import traceback
+
+import pandas as pd
+from nemo_retriever.params import RemoteRetryParams
+from nemo_retriever.nim.nim import invoke_image_inference_batches
+
+try:
+    import numpy as np
+except Exception:  # pragma: no cover
+    np = None  # type: ignore[assignment]
+
+try:
+    import torch
+except Exception:  # pragma: no cover
+    torch = None  # type: ignore[assignment]
+
+try:
+    from PIL import Image
+except Exception:  # pragma: no cover
+    Image = None  # type: ignore[assignment]
+
+
+def _error_payload(*, stage: str, exc: BaseException) -> Dict[str, Any]:
+    return {
+        "detections": [],
+        "error": {
+            "stage": str(stage),
+            "type": exc.__class__.__name__,
+            "message": str(exc),
+            "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+        },
+    }
+
+
+def _decode_b64_image_to_chw_tensor(image_b64: str) -> Tuple["torch.Tensor", Tuple[int, int]]:
+    if torch is None or Image is None or np is None:  # pragma: no cover
+        raise ImportError("table structure detection requires torch, pillow, and numpy.")
+
+    raw = base64.b64decode(image_b64)
+    with Image.open(io.BytesIO(raw)) as im0:
+        im = im0.convert("RGB")
+        w, h = im.size
+        arr = np.array(im, dtype=np.uint8)  # (H,W,3)
+
+    t = torch.from_numpy(arr).permute(2, 0, 1).contiguous()  # (3,H,W) uint8
+    t = t.to(dtype=torch.float32) / 255.0
+    return t, (int(h), int(w))
+
+
+def _crop_b64_image_by_norm_bbox(
+    page_image_b64: str,
+    *,
+    bbox_xyxy_norm: Sequence[float],
+    image_format: str = "png",
+) -> Tuple[Optional[str], Optional[Tuple[int, int]]]:
+    """
+    Crop a base64-encoded RGB image by a normalized xyxy bbox.
+
+    Returns:
+      - cropped_image_b64 (same encoding as `image_format`) or None on failure
+      - cropped_shape_hw (H,W) or None on failure
+    """
+    if Image is None:  # pragma: no cover
+        raise ImportError("Cropping requires pillow.")
+
+    if not isinstance(page_image_b64, str) or not page_image_b64:
+        return None, None
+    try:
+        x1n, y1n, x2n, y2n = [float(x) for x in bbox_xyxy_norm]
+    except Exception:
+        return None, None
+
+    try:
+        raw = base64.b64decode(page_image_b64)
+        with Image.open(io.BytesIO(raw)) as im0:
+            im = im0.convert("RGB")
+            w, h = im.size
+            if w <= 1 or h <= 1:
+                return None, None
+
+            # Convert normalized coords to pixel coords and clamp.
+            def _clamp_int(v: float, lo: int, hi: int) -> int:
+                if v != v:  # NaN
+                    return lo
+                return int(min(max(v, float(lo)), float(hi)))
+
+            x1 = _clamp_int(x1n * w, 0, w)
+            x2 = _clamp_int(x2n * w, 0, w)
+            y1 = _clamp_int(y1n * h, 0, h)
+            y2 = _clamp_int(y2n * h, 0, h)
+
+            # Ensure a valid rectangle.
+            if x2 <= x1 or y2 <= y1:
+                return None, None
+
+            crop = im.crop((x1, y1, x2, y2))
+            cw, ch = crop.size
+            if cw <= 1 or ch <= 1:
+                return None, None
+
+            buf = io.BytesIO()
+            fmt = str(image_format or "png").lower()
+            if fmt not in {"png"}:
+                fmt = "png"
+            crop.save(buf, format=fmt.upper())
+            return base64.b64encode(buf.getvalue()).decode("ascii"), (int(ch), int(cw))
+    except Exception:
+        return None, None
+
+
+def _labels_from_model(model: Any) -> List[str]:
+    # Prefer underlying model labels if present.
+    try:
+        labels = getattr(getattr(model, "_model", None), "labels", None)
+        if isinstance(labels, (list, tuple)) and all(isinstance(x, str) for x in labels):
+            return [str(x) for x in labels]
+    except Exception:
+        pass
+
+    try:
+        out = getattr(model, "output", None)
+        if isinstance(out, dict):
+            classes = out.get("classes")
+            if isinstance(classes, (list, tuple)) and all(isinstance(x, str) for x in classes):
+                return [str(x) for x in classes]
+    except Exception:
+        pass
+
+    return []
+
+
+def _prediction_to_detections(pred: Any, *, label_names: List[str]) -> List[Dict[str, Any]]:
+    """
+    Best-effort conversion of model output into a standard detection list.
+
+    Produces dicts of the form:
+      {"bbox_xyxy_norm": [...], "label": int|None, "label_name": str, "score": float|None}
+    """
+    if torch is None:  # pragma: no cover
+        raise ImportError("torch required for prediction parsing.")
+
+    boxes = labels = scores = None
+    if isinstance(pred, dict):
+        # IMPORTANT: do not use `or` chains here. torch.Tensor truthiness is ambiguous and raises.
+        def _get_any(d: Dict[str, Any], *keys: str) -> Any:
+            for k in keys:
+                if k in d:
+                    v = d.get(k)
+                    if v is not None:
+                        return v
+            return None
+
+        boxes = _get_any(pred, "boxes", "bboxes", "bbox", "box")
+        labels = _get_any(pred, "labels", "classes", "class_ids", "class")
+        scores = _get_any(pred, "scores", "conf", "confidences", "score")
+    elif isinstance(pred, (list, tuple)) and len(pred) >= 3:
+        boxes, labels, scores = pred[0], pred[1], pred[2]
+
+    if boxes is None or labels is None:
+        return []
+
+    # Normalize to torch tensors.
+    def _to_tensor(x: Any) -> Optional["torch.Tensor"]:
+        if x is None:
+            return None
+        if isinstance(x, torch.Tensor):
+            return x.detach().cpu()
+        try:
+            return torch.as_tensor(x).detach().cpu()
+        except Exception:
+            return None
+
+    b = _to_tensor(boxes)
+    labels_t = _to_tensor(labels)
+    s = _to_tensor(scores) if scores is not None else None
+    if b is None or labels_t is None:
+        return []
+
+    # Expect boxes (N,4), labels (N,)
+    if b.ndim != 2 or int(b.shape[-1]) != 4:
+        return []
+    if labels_t.ndim == 2 and int(labels_t.shape[-1]) == 1:
+        labels_t = labels_t.squeeze(-1)
+    if labels_t.ndim != 1:
+        return []
+
+    n = int(min(b.shape[0], labels_t.shape[0]))
+    dets: List[Dict[str, Any]] = []
+    for i in range(n):
+        try:
+            x1, y1, x2, y2 = [float(x) for x in b[i].tolist()]
+        except Exception:
+            continue
+
+        label_i: Optional[int]
+        try:
+            label_i = int(labels_t[i].item())
+        except Exception:
+            label_i = None
+
+        score_f: Optional[float]
+        if s is not None and s.ndim >= 1 and int(s.shape[0]) > i:
+            try:
+                score_f = float(s[i].item())
+            except Exception:
+                score_f = None
+        else:
+            score_f = None
+
+        label_name = None
+        if label_i is not None and 0 <= label_i < len(label_names):
+            label_name = label_names[label_i]
+        if not label_name:
+            label_name = f"label_{label_i}" if label_i is not None else "unknown"
+
+        dets.append(
+            {
+                "bbox_xyxy_norm": [x1, y1, x2, y2],
+                "label": label_i,
+                "label_name": str(label_name),
+                "score": score_f,
+            }
+        )
+    return dets
+
+
+def _extract_remote_pred_item(response_item: Any) -> Any:
+    if isinstance(response_item, dict):
+        for k in ("prediction", "predictions", "output", "outputs", "data"):
+            v = response_item.get(k)
+            if isinstance(v, list) and v:
+                return v[0]
+            if v is not None:
+                return v
+    return response_item
+
+
+def _counts_by_label(detections: Sequence[Dict[str, Any]]) -> Dict[str, int]:
+    out: Dict[str, int] = {}
+    for d in detections:
+        if not isinstance(d, dict):
+            continue
+        name = d.get("label_name")
+        if not isinstance(name, str) or not name.strip():
+            name = f"label_{d.get('label')}"
+        k = str(name)
+        out[k] = int(out.get(k, 0) + 1)
+    return out
+
+
+def detect_table_structure_v1(
+    batch_df: Any,
+    *,
+    model: Any = None,
+    invoke_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    request_timeout_s: float = 120.0,
+    inference_batch_size: int = 8,
+    output_column: str = "table_structure_v1",
+    num_detections_column: str = "table_structure_v1_num_detections",
+    counts_by_label_column: str = "table_structure_v1_counts_by_label",
+    remote_retry: RemoteRetryParams | None = None,
+    **kwargs: Any,
+) -> Any:
+    retry = remote_retry or RemoteRetryParams(
+        remote_max_pool_workers=int(kwargs.get("remote_max_pool_workers", 16)),
+        remote_max_retries=int(kwargs.get("remote_max_retries", 10)),
+        remote_max_429_retries=int(kwargs.get("remote_max_429_retries", 5)),
+    )
+    """
+    Run Nemotron Table Structure v1 on a pandas batch.
+
+    Input:
+      - `batch_df`: pandas.DataFrame (Ray Data `batch_format="pandas"`)
+        Must contain a base64 image source (best-effort from `tables`/`image_b64`/etc).
+    Output:
+      - pandas.DataFrame with original columns preserved, plus:
+        - `output_column`: {"detections": [...], "timing": {...}, "error": ...}
+        - `num_detections_column`: int
+        - `counts_by_label_column`: dict[str,int]
+
+    Notes:
+      - This function chunks work in `inference_batch_size` to bound per-call cost even if
+        Ray provides larger batches.
+      - If the underlying model doesn't support batched invocation, we fall back to per-image calls.
+    """
+    if not isinstance(batch_df, pd.DataFrame):
+        raise NotImplementedError("detect_table_structure_v1 currently only supports pandas.DataFrame input.")
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+
+    invoke_url = (invoke_url or kwargs.get("table_structure_invoke_url") or "").strip()
+    use_remote = bool(invoke_url)
+    if not use_remote and model is None:
+        raise ValueError("A local `model` is required when `invoke_url` is not provided.")
+
+    label_names = _labels_from_model(model) if model is not None else []
+
+    # Decode inputs.
+    tensors: List[Optional["torch.Tensor"]] = []
+    shapes: List[Optional[Tuple[int, int]]] = []
+    image_b64_list: List[Optional[str]] = []
+    payloads: List[Dict[str, Any]] = []
+    for _, row in batch_df.iterrows():
+        try:
+            b64 = row.get("page_image", {}).get("image_b64", None)
+            if not b64:
+                raise ValueError("No usable image_b64 found in row.")
+            image_b64_list.append(b64)
+            if use_remote:
+                tensors.append(None)
+                shapes.append(None)
+            else:
+                t, orig_shape = _decode_b64_image_to_chw_tensor(b64)
+                tensors.append(t)
+                shapes.append(orig_shape)
+            payloads.append({"detections": []})
+        except BaseException as e:
+            tensors.append(None)
+            shapes.append(None)
+            image_b64_list.append(None)
+            payloads.append(_error_payload(stage="decode_image", exc=e))
+
+    if use_remote:
+        valid = [i for i, b64 in enumerate(image_b64_list) if isinstance(b64, str) and bool(b64)]
+    else:
+        valid = [i for i, t in enumerate(tensors) if t is not None and shapes[i] is not None]
+
+    if use_remote and valid:
+        valid_b64 = [image_b64_list[i] for i in valid if image_b64_list[i]]
+        t0 = time.perf_counter()
+        try:
+            response_items = invoke_image_inference_batches(
+                invoke_url=invoke_url,
+                image_b64_list=cast(List[str], valid_b64),
+                api_key=api_key,
+                timeout_s=float(request_timeout_s),
+                max_batch_size=int(inference_batch_size),
+                max_pool_workers=int(retry.remote_max_pool_workers),
+                max_retries=int(retry.remote_max_retries),
+                max_429_retries=int(retry.remote_max_429_retries),
+            )
+            elapsed = time.perf_counter() - t0
+            if len(response_items) != len(valid):
+                raise RuntimeError(f"Expected {len(valid)} remote predictions, got {len(response_items)}")
+
+            for local_j, row_i in enumerate(valid):
+                pred_item = _extract_remote_pred_item(response_items[local_j])
+                dets = _prediction_to_detections(pred_item, label_names=label_names)
+                payloads[row_i] = {"detections": dets, "timing": {"seconds": float(elapsed)}, "error": None}
+        except BaseException as e:
+            elapsed = time.perf_counter() - t0
+            for row_i in valid:
+                payloads[row_i] = _error_payload(stage="remote_invoke", exc=e) | {"timing": {"seconds": float(elapsed)}}
+
+    for chunk_start in range(0, len(valid), int(inference_batch_size)):
+        if use_remote:
+            break
+        idxs = valid[chunk_start : chunk_start + int(inference_batch_size)]
+        if not idxs:
+            continue
+
+        # Attempt batched preprocess/invoke; fall back to per-image if unsupported.
+        pre_list: List["torch.Tensor"] = []
+        orig_shapes: List[Tuple[int, int]] = []
+        for i in idxs:
+            t = tensors[i]
+            sh = shapes[i]
+            if t is None or sh is None:
+                continue
+            orig_shapes.append(sh)
+            x = t.unsqueeze(0)  # BCHW
+            try:
+                pre = model.preprocess(x, sh)
+            except TypeError:
+                pre = model.preprocess(x)
+            if isinstance(pre, torch.Tensor) and pre.ndim == 4 and int(pre.shape[0]) == 1:
+                pre_list.append(pre[0])
+            elif isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                pre_list.append(pre)
+            else:
+                pre_list.append(t)
+
+        if not pre_list:
+            continue
+
+        batch = torch.stack(pre_list, dim=0)
+        t0 = time.perf_counter()
+        try:
+            preds = model.invoke(batch, orig_shapes)  # type: ignore[arg-type]
+            elapsed = time.perf_counter() - t0
+            # Normalize to per-image list
+            if isinstance(preds, list):
+                preds_list = preds
+            else:
+                preds_list = [preds]
+            # If model returned single pred for whole batch, duplicate best-effort by slicing not possible -> fallback.
+            if len(preds_list) != len(idxs):
+                raise RuntimeError("Batched invoke returned unexpected output shape; falling back to per-image calls.")
+            for local_j, row_i in enumerate(idxs):
+                dets = _prediction_to_detections(preds_list[local_j], label_names=label_names)
+                payloads[row_i] = {"detections": dets, "timing": {"seconds": float(elapsed)}, "error": None}
+        except BaseException:
+            # Per-image fallback
+            for local_j, row_i in enumerate(idxs):
+                t = tensors[row_i]
+                sh = shapes[row_i]
+                if t is None or sh is None:
+                    continue
+                x = t.unsqueeze(0)
+                t1 = time.perf_counter()
+                try:
+                    try:
+                        pre = model.preprocess(x, sh)
+                    except TypeError:
+                        pre = model.preprocess(x)
+                    if isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                        pre = pre.unsqueeze(0)
+                    pred = model.invoke(pre, sh)
+                    dets = _prediction_to_detections(pred, label_names=label_names)
+                    payloads[row_i] = {
+                        "detections": dets,
+                        "timing": {"seconds": float(time.perf_counter() - t1)},
+                        "error": None,
+                    }
+                except BaseException as e:
+                    payloads[row_i] = _error_payload(stage="invoke", exc=e) | {
+                        "timing": {"seconds": float(time.perf_counter() - t1)}
+                    }
+
+    out = batch_df.copy()
+    out[output_column] = payloads
+    out[num_detections_column] = [int(len(p.get("detections") or [])) if isinstance(p, dict) else 0 for p in payloads]
+    out[counts_by_label_column] = [
+        _counts_by_label(p.get("detections") or []) if isinstance(p, dict) else {} for p in payloads
+    ]
+    return out
+
+
+def detect_table_structure_v1_from_page_elements_v3(
+    pages_df: Any,
+    *,
+    model: Any = None,
+    invoke_url: Optional[str] = None,
+    api_key: Optional[str] = None,
+    request_timeout_s: float = 120.0,
+    inference_batch_size: int = 8,
+    page_elements_column: str = "page_elements_v3",
+    page_elements_counts_by_label_column: str = "page_elements_v3_counts_by_label",
+    page_image_column: str = "page_image",
+    output_column: str = "table_structure_v1",
+    num_detections_column: str = "table_structure_v1_num_detections",
+    counts_by_label_column: str = "table_structure_v1_counts_by_label",
+    remote_retry: RemoteRetryParams | None = None,
+    **kwargs: Any,
+) -> Any:
+    retry = remote_retry or RemoteRetryParams(
+        remote_max_pool_workers=int(kwargs.get("remote_max_pool_workers", 16)),
+        remote_max_retries=int(kwargs.get("remote_max_retries", 10)),
+        remote_max_429_retries=int(kwargs.get("remote_max_429_retries", 5)),
+    )
+    """
+    Run Nemotron Table Structure v1 *only* on detected table regions.
+
+    For each input page row:
+    - Check `page_elements_counts_by_label_column` for `"table" > 0`
+    - If so, enumerate `pages_df[page_elements_column]["detections"]`
+      and for each detection with `label_name == "table"`:
+        - crop `page_image.image_b64` by the detection bbox
+        - run table-structure model on that crop
+
+    Output payload shape:
+      - `output_column`: {"regions": [ {bbox..., detections: [...], ...}, ... ], "timing": {...}, "error": ...}
+      - `num_detections_column`: total detections across all regions (int)
+      - `counts_by_label_column`: aggregated counts across all regions (dict[str,int])
+    """
+    if not isinstance(pages_df, pd.DataFrame):
+        raise NotImplementedError(
+            "detect_table_structure_v1_from_page_elements_v3 currently only supports pandas.DataFrame input."
+        )
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+    invoke_url = (invoke_url or kwargs.get("table_structure_invoke_url") or "").strip()
+    use_remote = bool(invoke_url)
+    if not use_remote and model is None:
+        raise ValueError("A local `model` is required when `invoke_url` is not provided.")
+
+    # Prepare per-row output containers.
+    out_payloads: List[Dict[str, Any]] = []
+    out_total_dets: List[int] = []
+    out_counts: List[Dict[str, int]] = []
+
+    # Collect all table crops across the whole batch so we can batch-invoke the model.
+    crop_b64s: List[str] = []
+    crop_shapes: List[Tuple[int, int]] = []
+    crop_row_region_refs: List[Tuple[int, int, Dict[str, Any]]] = []  # (row_i, region_i, region_dict_ref)
+
+    t0_total = time.perf_counter()
+
+    # First pass: decide which pages have tables and build region stubs + crops.
+    for row_i, (_, row) in enumerate(pages_df.iterrows()):
+        page_payload: Dict[str, Any] = {"regions": [], "timing": {"seconds": 0.0}, "error": None}
+
+        counts = row.get(page_elements_counts_by_label_column)
+        table_count = 0
+        if isinstance(counts, dict):
+            try:
+                table_count = int(counts.get("table") or 0)
+            except Exception:
+                table_count = 0
+
+        if table_count <= 0:
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        pe = row.get(page_elements_column)
+        dets = []
+        if isinstance(pe, dict):
+            dets = pe.get("detections") or []
+        if not isinstance(dets, list) or not dets:
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        page_image = row.get(page_image_column) or {}
+        page_image_b64 = page_image.get("image_b64") if isinstance(page_image, dict) else None
+        if not isinstance(page_image_b64, str) or not page_image_b64:
+            # Counts said there are tables, but we can't crop without an image.
+            page_payload["error"] = {
+                "stage": "crop",
+                "type": "ValueError",
+                "message": "page_image.image_b64 missing; cannot crop tables for table_structure_v1.",
+                "traceback": "",
+            }
+            out_payloads.append(page_payload)
+            out_total_dets.append(0)
+            out_counts.append({})
+            continue
+
+        regions: List[Dict[str, Any]] = []
+        for det in dets:
+            if not isinstance(det, dict):
+                continue
+            if str(det.get("label_name") or "").strip() != "table":
+                continue
+            bbox = det.get("bbox_xyxy_norm")
+            if not isinstance(bbox, (list, tuple)) or len(bbox) != 4:
+                continue
+
+            crop_b64, crop_shape_hw = _crop_b64_image_by_norm_bbox(
+                page_image_b64, bbox_xyxy_norm=cast(Sequence[float], bbox)
+            )
+            if not crop_b64 or crop_shape_hw is None:
+                continue
+
+            region_payload: Dict[str, Any] = {
+                "label_name": "table",
+                "bbox_xyxy_norm": [float(x) for x in bbox],
+                "score": det.get("score"),
+                "orig_shape_hw": crop_shape_hw,
+                "detections": [],
+                "timing": None,
+                "error": None,
+            }
+            regions.append(region_payload)
+
+            crop_b64s.append(crop_b64)
+            crop_shapes.append(crop_shape_hw)
+            crop_row_region_refs.append((row_i, len(regions) - 1, region_payload))
+
+        page_payload["regions"] = regions
+        out_payloads.append(page_payload)
+        out_total_dets.append(0)  # filled after model invocation
+        out_counts.append({})  # filled after model invocation
+
+    # Second pass: run model on all crops (if any) and write results back into region dict refs.
+    if crop_b64s:
+        label_names = _labels_from_model(model) if model is not None else []
+
+        crop_payloads: List[Dict[str, Any]] = []
+        if use_remote:
+            t0 = time.perf_counter()
+            try:
+                response_items = invoke_image_inference_batches(
+                    invoke_url=invoke_url,
+                    image_b64_list=crop_b64s,
+                    api_key=api_key,
+                    timeout_s=float(request_timeout_s),
+                    max_batch_size=int(inference_batch_size),
+                    max_pool_workers=int(retry.remote_max_pool_workers),
+                    max_retries=int(retry.remote_max_retries),
+                    max_429_retries=int(retry.remote_max_429_retries),
+                )
+                elapsed = time.perf_counter() - t0
+                if len(response_items) != len(crop_b64s):
+                    raise RuntimeError(f"Expected {len(crop_b64s)} remote predictions, got {len(response_items)}")
+                for i, resp in enumerate(response_items):
+                    pred_item = _extract_remote_pred_item(resp)
+                    dets = _prediction_to_detections(pred_item, label_names=label_names)
+                    crop_payloads.append({"detections": dets, "timing": {"seconds": float(elapsed)}, "error": None})
+            except BaseException as e:
+                elapsed = time.perf_counter() - t0
+                for _ in crop_b64s:
+                    crop_payloads.append(
+                        _error_payload(stage="remote_invoke", exc=e) | {"timing": {"seconds": float(elapsed)}}
+                    )
+        else:
+            tensors: List[Optional["torch.Tensor"]] = []
+            shapes: List[Optional[Tuple[int, int]]] = []
+            for b64 in crop_b64s:
+                try:
+                    t, orig_shape = _decode_b64_image_to_chw_tensor(b64)
+                    tensors.append(t)
+                    shapes.append(orig_shape)
+                    crop_payloads.append({"detections": []})
+                except BaseException as e:
+                    tensors.append(None)
+                    shapes.append(None)
+                    crop_payloads.append(_error_payload(stage="decode_image", exc=e))
+
+            valid = [i for i, t in enumerate(tensors) if t is not None and shapes[i] is not None]
+
+            for chunk_start in range(0, len(valid), int(inference_batch_size)):
+                idxs = valid[chunk_start : chunk_start + int(inference_batch_size)]
+                if not idxs:
+                    continue
+
+                pre_list: List["torch.Tensor"] = []
+                orig_shapes: List[Tuple[int, int]] = []
+                for i in idxs:
+                    t = tensors[i]
+                    sh = shapes[i]
+                    if t is None or sh is None:
+                        continue
+                    orig_shapes.append(sh)
+                    x = t.unsqueeze(0)  # BCHW
+                    try:
+                        pre = model.preprocess(x, sh)
+                    except TypeError:
+                        pre = model.preprocess(x)
+                    if isinstance(pre, torch.Tensor) and pre.ndim == 4 and int(pre.shape[0]) == 1:
+                        pre_list.append(pre[0])
+                    elif isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                        pre_list.append(pre)
+                    else:
+                        pre_list.append(t)
+
+                if not pre_list:
+                    continue
+
+                batch = torch.stack(pre_list, dim=0)
+                t0 = time.perf_counter()
+                try:
+                    preds = model.invoke(batch, orig_shapes)  # type: ignore[arg-type]
+                    elapsed = time.perf_counter() - t0
+                    preds_list = preds if isinstance(preds, list) else [preds]
+                    if len(preds_list) != len(idxs):
+                        raise RuntimeError(
+                            "Batched invoke returned unexpected output shape; falling back to per-image calls."
+                        )
+                    for local_j, crop_i in enumerate(idxs):
+                        dets = _prediction_to_detections(preds_list[local_j], label_names=label_names)
+                        crop_payloads[crop_i] = {
+                            "detections": dets,
+                            "timing": {"seconds": float(elapsed)},
+                            "error": None,
+                        }
+                except BaseException:
+                    for local_j, crop_i in enumerate(idxs):
+                        t = tensors[crop_i]
+                        sh = shapes[crop_i]
+                        if t is None or sh is None:
+                            continue
+                        x = t.unsqueeze(0)
+                        t1 = time.perf_counter()
+                        try:
+                            try:
+                                pre = model.preprocess(x, sh)
+                            except TypeError:
+                                pre = model.preprocess(x)
+                            if isinstance(pre, torch.Tensor) and pre.ndim == 3:
+                                pre = pre.unsqueeze(0)
+                            pred = model.invoke(pre, sh)
+                            dets = _prediction_to_detections(pred, label_names=label_names)
+                            crop_payloads[crop_i] = {
+                                "detections": dets,
+                                "timing": {"seconds": float(time.perf_counter() - t1)},
+                                "error": None,
+                            }
+                        except BaseException as e:
+                            crop_payloads[crop_i] = _error_payload(stage="invoke", exc=e) | {
+                                "timing": {"seconds": float(time.perf_counter() - t1)}
+                            }
+
+        # Write crop payloads back into their owning regions.
+        for crop_i, (_, _, region_ref) in enumerate(crop_row_region_refs):
+            payload = crop_payloads[crop_i] if crop_i < len(crop_payloads) else {"detections": []}
+            if isinstance(payload, dict):
+                region_ref["detections"] = payload.get("detections") or []
+                region_ref["timing"] = payload.get("timing")
+                region_ref["error"] = payload.get("error")
+            else:
+                region_ref["detections"] = []
+                region_ref["timing"] = None
+                region_ref["error"] = {
+                    "stage": "invoke",
+                    "type": "TypeError",
+                    "message": "Unexpected payload type",
+                    "traceback": "",
+                }
+
+    # Aggregate per-page totals.
+    for row_i, page_payload in enumerate(out_payloads):
+        regions = page_payload.get("regions") or []
+        total_dets = 0
+        agg_counts: Dict[str, int] = {}
+        if isinstance(regions, list):
+            for r in regions:
+                if not isinstance(r, dict):
+                    continue
+                dets = r.get("detections") or []
+                if isinstance(dets, list):
+                    total_dets += int(len(dets))
+                    for d in dets:
+                        if not isinstance(d, dict):
+                            continue
+                        name = d.get("label_name")
+                        if not isinstance(name, str) or not name.strip():
+                            name = f"label_{d.get('label')}"
+                        k = str(name)
+                        agg_counts[k] = int(agg_counts.get(k, 0) + 1)
+        out_total_dets[row_i] = int(total_dets)
+        out_counts[row_i] = agg_counts
+
+    elapsed_total = time.perf_counter() - t0_total
+    for page_payload in out_payloads:
+        if isinstance(page_payload, dict):
+            page_payload["timing"] = {"seconds": float(elapsed_total)}
+
+    out = pages_df.copy()
+    out[output_column] = out_payloads
+    out[num_detections_column] = out_total_dets
+    out[counts_by_label_column] = out_counts
+    return out
+
+
+@dataclass(slots=True)
+class TableStructureActor:
+    """
+    Ray-friendly callable that initializes Nemotron Table Structure v1 once.
+    """
+
+    detect_kwargs: Dict[str, Any]
+
+    def __init__(self, **detect_kwargs: Any) -> None:
+        self.detect_kwargs = dict(detect_kwargs)
+        invoke_url = str(
+            self.detect_kwargs.get("table_structure_invoke_url") or self.detect_kwargs.get("invoke_url") or ""
+        ).strip()
+        if invoke_url and "invoke_url" not in self.detect_kwargs:
+            self.detect_kwargs["invoke_url"] = invoke_url
+        if invoke_url:
+            self._model = None
+        else:
+            from nemo_retriever.model.local import NemotronTableStructureV1
+
+            self._model = NemotronTableStructureV1()
+
+    def __call__(self, batch_df: Any, **override_kwargs: Any) -> Any:
+        try:
+            # Prefer table-structure-on-crops when page-elements are present.
+            if isinstance(batch_df, pd.DataFrame) and (
+                "page_elements_v3" in batch_df.columns or "page_elements_v3_counts_by_label" in batch_df.columns
+            ):
+                return detect_table_structure_v1_from_page_elements_v3(
+                    batch_df,
+                    model=self._model,
+                    **self.detect_kwargs,
+                    **override_kwargs,
+                )
+            return detect_table_structure_v1(batch_df, model=self._model, **self.detect_kwargs, **override_kwargs)
+        except BaseException as e:
+            if isinstance(batch_df, pd.DataFrame):
+                out = batch_df.copy()
+                payload = _error_payload(stage="actor_call", exc=e)
+                out["table_structure_v1"] = [
+                    {"regions": [], "timing": None, "error": payload.get("error")} for _ in range(len(out.index))
+                ]
+                out["table_structure_v1_num_detections"] = [0 for _ in range(len(out.index))]
+                out["table_structure_v1_counts_by_label"] = [{} for _ in range(len(out.index))]
+                return out
+            return [{"table_structure_v1": _error_payload(stage="actor_call", exc=e)}]
diff --git a/nemo_retriever/src/nemo_retriever/text_embed/__init__.py b/nemo_retriever/src/nemo_retriever/text_embed/__init__.py
new file mode 100644
index 000000000..7d92f403a
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/text_embed/__init__.py
@@ -0,0 +1,32 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Text embedding stage (pure Python + Ray Data adapters).
+
+This stage calls `nv-ingest-api`'s `transform_create_text_embeddings_internal`
+to populate `metadata.embedding` (or a custom target field).
+"""
+
+from .text_embed import TextEmbedActor, embed_text_1b_v2
+
+__all__ = ["TextEmbedActor", "embed_text_1b_v2"]
+
+# Optional imports: the "full" embedding stage depends on nv-ingest-api (and its deps).
+# Keep lightweight embedding importable even in minimal environments.
+try:  # pragma: no cover
+    from .commands import app
+    from .config import TextEmbeddingStageConfig, load_text_embedding_schema_from_dict
+    from .processor import embed_text_from_primitives_df
+    from .ray_data import embed_text_ray_data
+
+    __all__ += [
+        "app",
+        "TextEmbeddingStageConfig",
+        "embed_text_from_primitives_df",
+        "embed_text_ray_data",
+        "load_text_embedding_schema_from_dict",
+    ]
+except Exception:
+    pass
diff --git a/nemo_retriever/src/nemo_retriever/text_embed/commands.py b/nemo_retriever/src/nemo_retriever/text_embed/commands.py
new file mode 100644
index 000000000..5a47fd60a
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/text_embed/commands.py
@@ -0,0 +1,248 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import pandas as pd
+import typer
+from rich.console import Console
+from rich.traceback import install
+from tqdm import tqdm
+
+from nemo_retriever.ingest_config import load_ingest_config_section
+from nemo_retriever.text_embed.processor import embed_text_from_primitives_df, maybe_inject_local_hf_embedder
+
+logger = logging.getLogger(__name__)
+console = Console()
+install(show_locals=False)
+
+app = typer.Typer(
+    help="Text embedding stage: generate embeddings for primitives (and optional helpers for local runs)."
+)
+
+
+def _atomic_write_json(path: Path, obj: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_name(path.name + ".tmp")
+    with tmp.open("w", encoding="utf-8") as file_handle:
+        json.dump(obj, file_handle, ensure_ascii=False, indent=2)
+        file_handle.flush()
+        try:
+            import os
+
+            os.fsync(file_handle.fileno())
+        except Exception:
+            pass
+    tmp.replace(path)
+
+
+def _to_jsonable(obj: Any) -> Any:
+    if obj is None or isinstance(obj, (str, int, float, bool)):
+        return obj
+    if isinstance(obj, dict):
+        return {str(key): _to_jsonable(value) for key, value in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_to_jsonable(value) for value in obj]
+
+    item = getattr(obj, "item", None)
+    if callable(item):
+        try:
+            return _to_jsonable(item())
+        except Exception:
+            pass
+
+    tolist = getattr(obj, "tolist", None)
+    if callable(tolist):
+        try:
+            return _to_jsonable(tolist())
+        except Exception:
+            pass
+
+    return str(obj)
+
+
+def _embedding_input_path_for_input_json(input_json: Path, *, output_dir: Optional[Path]) -> Path:
+    out_name = input_json.with_suffix(".embedding_input.txt").name
+    return (output_dir / out_name) if output_dir is not None else input_json.with_suffix(".embedding_input.txt")
+
+
+def _embeddings_out_path_for_input_json(input_json: Path, *, output_dir: Optional[Path]) -> Path:
+    out_name = input_json.with_suffix(".text_embeddings.json").name
+    return (output_dir / out_name) if output_dir is not None else input_json.with_suffix(".text_embeddings.json")
+
+
+@app.command()
+def run(
+    input_dir: Path = typer.Option(..., "--input-dir", exists=True, file_okay=False, dir_okay=True),
+    pattern: str = typer.Option(
+        "*.pdf_extraction.infographic.table.json",
+        "--pattern",
+        help="Glob pattern for input JSON files (non-recursive unless --recursive is set).",
+    ),
+    recursive: bool = typer.Option(False, "--recursive/--no-recursive", help="Scan subdirectories for inputs too."),
+    output_dir: Optional[Path] = typer.Option(
+        None,
+        "--output-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="If set, write outputs into this directory (instead of alongside inputs).",
+    ),
+    config: Optional[Path] = typer.Option(
+        None,
+        "--config",
+        exists=True,
+        file_okay=True,
+        dir_okay=False,
+        help=(
+            "Optional ingest YAML config file. If omitted, we auto-discover ./ingest-config.yaml then "
+            "$HOME/.ingest-config.yaml. Uses section: embedding."
+        ),
+    ),
+    api_key: Optional[str] = typer.Option(None, "--api-key", help="Optional API key override for embedding service."),
+    endpoint_url: Optional[str] = typer.Option(
+        None,
+        "--endpoint-url",
+        help=(
+            "Optional embedding service endpoint override (e.g. 'http://embedding:8000/v1'). "
+            "Use 'none' to disable remote embeddings and force local HF fallback."
+        ),
+    ),
+    model_name: Optional[str] = typer.Option(None, "--model-name", help="Optional embedding model name override."),
+    dimensions: Optional[int] = typer.Option(None, "--dimensions", help="Optional embedding dimensions override."),
+    use_local_hf_if_no_endpoint: bool = typer.Option(
+        True,
+        "--local-hf-fallback/--no-local-hf-fallback",
+        help="If no embedding endpoint is configured, run local HuggingFace embeddings instead.",
+    ),
+    local_hf_device: Optional[str] = typer.Option(
+        None,
+        "--local-hf-device",
+        help="Device for local HF embeddings (e.g. 'cuda', 'cpu', 'cuda:0').",
+    ),
+    local_hf_cache_dir: Optional[Path] = typer.Option(
+        None,
+        "--local-hf-cache-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Optional HuggingFace cache directory for local embeddings.",
+    ),
+    local_hf_batch_size: int = typer.Option(
+        64,
+        "--local-hf-batch-size",
+        min=1,
+        help="Batch size for local HF embedding inference.",
+    ),
+    overwrite: bool = typer.Option(False, "--overwrite", help="Overwrite existing outputs."),
+    limit: Optional[int] = typer.Option(None, "--limit", min=1, help="Optionally limit number of input files."),
+    write_embedding_input: bool = typer.Option(
+        True,
+        "--write-embedding-input/--no-write-embedding-input",
+        help="Write *.embedding_input.txt containing the exact combined text used for embedding.",
+    ),
+) -> None:
+    # Local import to avoid a circular import at module load.
+    from nemo_retriever.text_embed.config import load_text_embedding_schema_from_dict
+
+    input_dir = Path(input_dir)
+    output_dir = Path(output_dir) if output_dir is not None else None
+    if output_dir is not None:
+        output_dir.mkdir(parents=True, exist_ok=True)
+
+    cfg_dict: Dict[str, Any] = load_ingest_config_section(config, section="embedding")
+    schema = load_text_embedding_schema_from_dict(cfg_dict)
+
+    # Task-config overrides (takes precedence over schema defaults).
+    task_cfg: Dict[str, Any] = {}
+    if api_key is not None:
+        task_cfg["api_key"] = api_key
+    if endpoint_url is not None:
+        value = endpoint_url.strip()
+        task_cfg["endpoint_url"] = None if value.lower() in ("", "none", "null") else value
+    elif not cfg_dict.get("embedding_nim_endpoint"):
+        # No CLI endpoint and no config-file endpoint — override the schema default
+        # so maybe_inject_local_hf_embedder() will inject the local HF fallback.
+        task_cfg["endpoint_url"] = None
+    if model_name is not None:
+        task_cfg["model_name"] = model_name
+    if dimensions is not None:
+        task_cfg["dimensions"] = int(dimensions)
+    task_cfg["use_local_hf_if_no_endpoint"] = bool(use_local_hf_if_no_endpoint)
+    if local_hf_device is not None:
+        task_cfg["local_hf_device"] = str(local_hf_device)
+    if local_hf_cache_dir is not None:
+        task_cfg["local_hf_cache_dir"] = str(local_hf_cache_dir)
+    if local_hf_batch_size is not None:
+        task_cfg["local_hf_batch_size"] = int(local_hf_batch_size)
+
+    inputs = sorted((input_dir.rglob(pattern) if recursive else input_dir.glob(pattern)))
+    if limit is not None:
+        inputs = inputs[: int(limit)]
+
+    if not inputs:
+        console.print(f"[red]No input files found[/red] input_dir={input_dir} pattern={pattern} recursive={recursive}")
+        raise typer.Exit(code=2)
+
+    processed = 0
+    skipped = 0
+    failed = 0
+
+    console.print(
+        f"[bold cyan]Text embeddings[/bold cyan] inputs={len(inputs)} input_dir={input_dir} recursive={recursive} "
+        f"output_dir={output_dir if output_dir is not None else '(alongside inputs)'}"
+    )
+
+    # Pre-warm: inject the local HF embedder (if applicable) into task_cfg ONCE,
+    # so per-file copies inside embed_text_from_primitives_df reuse it instead
+    # of re-loading the model for every file.
+    console.print("[bold yellow]Loading embedding model...[/bold yellow]")
+    maybe_inject_local_hf_embedder(task_cfg, schema)
+    console.print("[bold green]Embedding model ready.[/bold green]")
+
+    for input_path in tqdm(inputs, desc="Text embeddings", unit="json"):
+        out_txt = _embedding_input_path_for_input_json(input_path, output_dir=output_dir)
+        out_json = _embeddings_out_path_for_input_json(input_path, output_dir=output_dir)
+
+        if out_json.exists() and not overwrite:
+            skipped += 1
+            continue
+
+        t0 = time.perf_counter()
+        try:
+            df_in = pd.read_json(input_path)
+
+            df_out, info = embed_text_from_primitives_df(
+                df_in,
+                transform_config=schema,
+                task_config=task_cfg,
+            )
+
+            payload: Dict[str, Any] = {
+                "schema_version": 1,
+                "stage": "text_embedding",
+                "input_json": str(input_path),
+                "pattern": str(pattern),
+                "embedding_input_txt": str(out_txt) if write_embedding_input else None,
+                "outputs": {"text_embeddings_json": str(out_json)},
+                "df_records": _to_jsonable(df_out.to_dict(orient="records")),
+                "info": _to_jsonable(info),
+                "timing": {"seconds": float(time.perf_counter() - t0)},
+            }
+            _atomic_write_json(out_json, payload)
+            processed += 1
+        except Exception as e:
+            failed += 1
+            logger.exception("Text embedding failed for %s", input_path)
+            console.print(f"[red]Failed[/red] input={input_path} err={e}")
+
+    console.print(f"[green]Done[/green] processed={processed} skipped={skipped} failed={failed}")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/text_embed/config.py b/nemo_retriever/src/nemo_retriever/text_embed/config.py
new file mode 100644
index 000000000..3c14a4485
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/text_embed/config.py
@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from nv_ingest_api.internal.schemas.transform.transform_text_embedding_schema import TextEmbeddingSchema
+
+
+def load_text_embedding_schema_from_dict(cfg: Dict[str, Any]) -> TextEmbeddingSchema:
+    return TextEmbeddingSchema(**(cfg or {}))
+
+
+@dataclass(frozen=True)
+class TextEmbeddingStageConfig:
+    batch_size: int = 256
+    stage_name: str = "text_embedding"
diff --git a/nemo_retriever/src/nemo_retriever/text_embed/main_text_embed.py b/nemo_retriever/src/nemo_retriever/text_embed/main_text_embed.py
new file mode 100644
index 000000000..0c20f7eb6
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/text_embed/main_text_embed.py
@@ -0,0 +1,705 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Standalone text embedding helper for retriever-local pandas DataFrames.
+
+Goal:
+- Mirror (as closely as practical) the batching/runner logic from
+  `nv_ingest_api.internal.transform.embed_text.transform_create_text_embeddings_internal`,
+  but adapt it to the **retriever-local** DataFrame structure used by
+  `nemo_retriever.text_embed.text_embed.embed_text_1b_v2`.
+
+Key differences vs the API transform:
+- This module operates on a simple pandas.DataFrame that typically contains:
+  - `text`: the text to embed (or other common text columns)
+  - `metadata`: optional dict; if present, embeddings are written to `metadata["embedding"]`
+- No imports from other files in this repo. Only stdlib + external deps (pandas/httpx).
+
+Usage:
+
+```python
+import pandas as pd
+from nemo_retriever.text_embed.main_text_embed import create_text_embeddings_for_df
+
+# df must have a `text` column (recommended) and may have `metadata` dicts.
+df = pd.DataFrame([{"text": "hello", "metadata": {"source_path": "/tmp/a.pdf"}}])
+
+# Option A: local callable (recommended for retriever inprocess)
+def local_embedder(texts):
+    # return list[list[float]] matching len(texts)
+    return [[0.0, 1.0] for _ in texts]
+
+out_df, _info = create_text_embeddings_for_df(
+    df,
+    task_config={"embedder": local_embedder, "endpoint_url": None, "local_batch_size": 64},
+)
+
+# Embedding is written to out_df.loc[i, "metadata"]["embedding"] and _contains_embeddings is set.
+```
+"""
+
+from __future__ import annotations
+
+import logging
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple
+from urllib.parse import urlparse  # noqa: F401
+
+import pandas as pd
+
+from nemo_retriever.params.models import IMAGE_MODALITIES
+
+logger = logging.getLogger(__name__)
+
+# Keep HTTP client logging quiet by default (parity with API transform).
+logging.getLogger("httpx").setLevel(logging.ERROR)
+logging.getLogger("httpcore").setLevel(logging.ERROR)
+
+EmbeddingCallable = Callable[[Sequence[str]], Sequence[Sequence[float]]]
+
+
+@dataclass(slots=True)
+class TextEmbeddingConfig:
+    """
+    Minimal config surface mirroring the API's TextEmbeddingSchema fields used by the transform.
+    """
+
+    # Remote / NIM-like settings
+    api_key: Optional[str] = None
+    embedding_nim_endpoint: Optional[str] = None  # e.g. "http://host:8000/v1"
+    embedding_model: str = "nvidia/llama-3.2-nv-embedqa-1b-v2"
+    encoding_format: str = "float"  # OpenAI-compatible embeddings often accept "float"
+    input_type: str = "passage"
+    truncate: str = "END"
+    batch_size: int = 128  # remote batch size
+    dimensions: Optional[int] = None
+
+    # Retriever-local dataframe settings
+    text_column: str = "text"
+    write_embedding_to_metadata: bool = True
+    metadata_column: str = "metadata"
+    # Optional extra output column containing a payload dict (similar to embed_text_1b_v2)
+    output_payload_column: Optional[str] = None
+    # Modality: "text" (default), "image", or "text_image"
+    embed_modality: str = "text"
+
+
+# ------------------------------------------------------------------------------
+# Batch Processing Utilities (copied from API transform with minimal edits)
+# ------------------------------------------------------------------------------
+
+
+def _batch_generator(iterable: Iterable[Any], batch_size: int = 10) -> Iterable[List[Any]]:
+    """
+    Yield list batches from any iterable.
+
+    The API transform assumes sized/sliceable inputs; for robustness we also accept
+    generators/iterators by materializing them once.
+    """
+    if batch_size <= 0:
+        raise ValueError("batch_size must be > 0")
+
+    # If we can't take len() / slices, materialize.
+    if not hasattr(iterable, "__len__") or not hasattr(iterable, "__getitem__"):
+        iterable = list(iterable)
+
+    seq = iterable  # now sized + sliceable
+    iter_len = len(seq)  # type: ignore[arg-type]
+    for idx in range(0, iter_len, batch_size):
+        yield list(seq[idx : min(idx + batch_size, iter_len)])  # type: ignore[index]
+
+
+def _generate_batches(prompts: Iterable[str], batch_size: int = 100) -> List[List[str]]:
+    """
+    Split prompts into concrete list batches.
+    """
+    return [batch for batch in _batch_generator(prompts, batch_size)]
+
+
+# ------------------------------------------------------------------------------
+# Content extraction for retriever-local DataFrames
+# ------------------------------------------------------------------------------
+
+
+def _text_from_row(row: pd.Series, *, text_column: str) -> Optional[str]:
+    """
+    Extract text from a row with small fallbacks (mirrors `nemo_retriever.text_embed.text_embed`).
+    """
+    v = row.get(text_column)
+    if isinstance(v, str) and v.strip():
+        return v
+
+    for k in ("text", "content", "chunk", "page_text"):
+        v2 = row.get(k)
+        if isinstance(v2, str) and v2.strip():
+            return v2
+
+    return None
+
+
+def _ensure_metadata_dict(row: pd.Series, *, metadata_column: str = "metadata") -> Dict[str, Any]:
+    md = row.get(metadata_column)
+    if isinstance(md, dict):
+        return md
+    return {}
+
+
+def _image_from_row(row: pd.Series) -> Optional[str]:
+    """Extract ``_image_b64`` column value from a row."""
+    v = row.get("_image_b64")
+    if isinstance(v, str) and v.strip():
+        return v
+    return None
+
+
+def _format_image_input_string(image_b64: str, mime: str = "image/png") -> str:
+    """Format a base64 image as a data URL string for remote NIM embedding."""
+    return f"data:{mime};base64,{image_b64}"
+
+
+def _format_text_image_pair_input_string(text: str, image_b64: str, mime: str = "image/png") -> str:
+    """Combine text and a data URL image for remote NIM text_image embedding."""
+    data_url = f"data:{mime};base64,{image_b64}"
+    return f"{text}\n{data_url}"
+
+
+def _multimodal_callable_runner(
+    df_slice: pd.DataFrame,
+    *,
+    embedder: Any,
+    batch_size: int,
+    embed_modality: str,
+    text_column: str = "text",
+) -> dict:
+    """Run multimodal embedding (image-only or text+image) using a local VL embedder.
+
+    Processes the DataFrame slice in batches, calling
+    ``embedder.embed_images()`` or ``embedder.embed_text_image()``
+    depending on *embed_modality*.
+
+    For ``text_image`` mode, rows that have text but no image are
+    embedded with the text-only ``embedder.embed()`` method as a
+    graceful fallback (e.g. pdfium-extracted text without a rendered
+    page image).  For ``image`` mode, rows without images get ``None``.
+
+    Returns the same ``{"embeddings": [...], "info_msgs": [...]}``
+    structure as ``_callable_runner``.
+    """
+    flat_embeddings: List[Optional[Sequence[float]]] = []
+    flat_info_msgs: List[Optional[dict]] = []
+
+    n = len(df_slice)
+    bs = max(1, int(batch_size))
+    for start in range(0, n, bs):
+        chunk = df_slice.iloc[start : start + bs]
+        size = len(chunk)
+        images_b64 = [_image_from_row(chunk.iloc[i]) or "" for i in range(size)]
+        texts = [_text_from_row(chunk.iloc[i], text_column=text_column) or "" for i in range(size)]
+
+        if embed_modality == "image":
+            vecs = embedder.embed_images(images_b64, batch_size=bs)
+            tolist = getattr(vecs, "tolist", None)
+            vecs_list = tolist() if callable(tolist) else list(vecs)
+
+            if len(vecs_list) == size:
+                flat_embeddings.extend(vecs_list)
+            else:
+                vec_iter = iter(vecs_list)
+                for b64 in images_b64:
+                    flat_embeddings.append(next(vec_iter, None) if b64 else None)
+
+        else:  # text_image
+            # Split rows into those with images (multimodal) and those
+            # without (text-only fallback).
+            has_image = [bool(b) for b in images_b64]
+
+            # multimodal subset
+            mm_texts = [t for t, h in zip(texts, has_image) if h]
+            mm_images = [b for b, h in zip(images_b64, has_image) if h]
+            mm_vecs_list: List[Optional[Sequence[float]]] = []
+            if mm_images:
+                vecs = embedder.embed_text_image(mm_texts, mm_images, batch_size=bs)
+                tolist = getattr(vecs, "tolist", None)
+                mm_vecs_list = tolist() if callable(tolist) else list(vecs)
+
+            # text-only fallback subset
+            fb_texts = [t for t, h in zip(texts, has_image) if not h and t.strip()]
+            fb_vecs_list: List[Optional[Sequence[float]]] = []
+            if fb_texts:
+                vecs = embedder.embed(fb_texts, batch_size=bs)
+                tolist = getattr(vecs, "tolist", None)
+                fb_vecs_list = tolist() if callable(tolist) else list(vecs)
+
+            # reassemble in original order
+            mm_iter = iter(mm_vecs_list)
+            fb_iter = iter(fb_vecs_list)
+            for h, t in zip(has_image, texts):
+                if h:
+                    flat_embeddings.append(next(mm_iter, None))
+                elif t.strip():
+                    flat_embeddings.append(next(fb_iter, None))
+                else:
+                    flat_embeddings.append(None)
+
+        flat_info_msgs.extend([None] * size)
+
+    return {"embeddings": flat_embeddings, "info_msgs": flat_info_msgs}
+
+
+# ------------------------------------------------------------------------------
+# Remote embeddings (OpenAI-compatible HTTP) + Local callable runner
+# ------------------------------------------------------------------------------
+
+
+def _normalize_embeddings_endpoint(endpoint_url: str) -> str:
+    """
+    Normalize endpoint to a concrete embeddings URL.
+
+    Accepts:
+    - "http://host:8000/v1"
+    - "http://host:8000/v1/embeddings"
+    - "http://host:8000/embeddings"
+    """
+    s = (endpoint_url or "").strip().rstrip("/")
+    if not s:
+        raise ValueError("endpoint_url is empty")
+    if s.endswith("/embeddings"):
+        return s
+    return f"{s}/embeddings"
+
+
+def _http_embed_openai_compat(
+    prompts: List[str],
+    *,
+    api_key: Optional[str],
+    endpoint_url: str,
+    model_name: str,
+    encoding_format: str,
+    input_type: str,
+    truncate: str,
+    dimensions: Optional[int] = None,
+    timeout_s: float = 120.0,
+) -> List[Optional[List[float]]]:
+    """
+    Best-effort HTTP embeddings call using an OpenAI-compatible schema.
+
+    Expected response:
+      {"data": [{"index": 0, "embedding": [...]}, ...]}
+    """
+    try:
+        import httpx  # type: ignore
+    except Exception as e:  # pragma: no cover
+        raise RuntimeError("Remote embedding requested but `httpx` is not installed.") from e
+
+    url = _normalize_embeddings_endpoint(endpoint_url)
+    headers: Dict[str, str] = {"accept": "application/json", "content-type": "application/json"}
+    token = (api_key or "").strip()
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+
+    # Mimic the OpenAI Python client's `extra_body={...}` behavior by including
+    # vendor-specific fields at the top-level JSON body.
+    payload: Dict[str, Any] = {
+        "model": model_name,
+        "input": prompts,
+        "encoding_format": encoding_format,
+        "input_type": str(input_type),
+        "truncate": str(truncate),
+    }
+    if dimensions is not None:
+        payload["dimensions"] = int(dimensions)
+
+    with httpx.Client(timeout=float(timeout_s)) as client:
+        resp = client.post(url, headers=headers, json=payload)
+        resp.raise_for_status()
+        data = resp.json()
+
+    # Parse embeddings.
+    items = data.get("data") if isinstance(data, dict) else None
+    if not isinstance(items, list):
+        raise RuntimeError("Unexpected embeddings response (missing 'data' list).")
+
+    by_index: Dict[int, Optional[List[float]]] = {}
+    for it in items:
+        if not isinstance(it, dict):
+            continue
+        idx = it.get("index")
+        emb = it.get("embedding")
+        if isinstance(idx, int) and isinstance(emb, list):
+            by_index[int(idx)] = emb
+
+    # Preserve input order; unknown entries become None.
+    return [by_index.get(i) for i in range(len(prompts))]
+
+
+def _make_async_request(
+    prompts: List[str],
+    api_key: Optional[str],
+    embedding_nim_endpoint: str,
+    embedding_model: str,
+    encoding_format: str,
+    input_type: str,
+    truncate: str,
+    filter_errors: bool,
+    modalities: Optional[List[str]] = None,
+    dimensions: Optional[int] = None,
+) -> dict:
+    """
+    Mirrors the API transform's request wrapper, but uses HTTP OpenAI-compatible embeddings.
+
+    Notes:
+    - `input_type` and `truncate` are sent as top-level JSON fields, matching the effective
+      request body produced by the OpenAI Python client when using `extra_body={...}`.
+    """
+    _ = (filter_errors, modalities)  # reserved for parity/future support
+
+    response: Dict[str, Any] = {}
+    try:
+        vecs = _http_embed_openai_compat(
+            prompts,
+            api_key=api_key,
+            endpoint_url=str(embedding_nim_endpoint),
+            model_name=str(embedding_model),
+            encoding_format=str(encoding_format),
+            input_type=str(input_type),
+            truncate=str(truncate),
+            dimensions=dimensions,
+        )
+        response["embedding"] = vecs
+        response["info_msg"] = None
+    except Exception as err:
+        err_str = str(err)
+        if len(err_str) > 500:
+            err_str = err_str[:200] + "... [truncated] ..." + err_str[-100:]
+        raise RuntimeError(f"Embedding error occurred: {err_str}") from err
+
+    return response
+
+
+def _async_request_handler(
+    prompts: List[List[str]],
+    api_key: Optional[str],
+    embedding_nim_endpoint: str,
+    embedding_model: str,
+    encoding_format: str,
+    input_type: str,
+    truncate: str,
+    filter_errors: bool,
+    modalities: Optional[List[List[str]]] = None,
+    dimensions: Optional[int] = None,
+    max_concurrent: Optional[int] = None,
+) -> List[dict]:
+    if modalities is None:
+        modalities = [None] * len(prompts)  # type: ignore[assignment]
+
+    pool_size = max_concurrent if max_concurrent and max_concurrent > 0 else None
+    with ThreadPoolExecutor(max_workers=pool_size) as executor:
+        futures = [
+            executor.submit(
+                _make_async_request,
+                prompts=prompt_batch,
+                api_key=api_key or None,
+                embedding_nim_endpoint=str(embedding_nim_endpoint),
+                embedding_model=str(embedding_model),
+                encoding_format=str(encoding_format),
+                input_type=str(input_type),
+                truncate=str(truncate),
+                filter_errors=bool(filter_errors),
+                modalities=modality_batch,  # type: ignore[arg-type]
+                dimensions=dimensions,
+            )
+            for prompt_batch, modality_batch in zip(prompts, modalities)
+        ]
+        results = [future.result() for future in futures]
+
+    return results
+
+
+def _async_runner(
+    prompts: List[List[str]],
+    api_key: Optional[str],
+    embedding_nim_endpoint: str,
+    embedding_model: str,
+    encoding_format: str,
+    input_type: str,
+    truncate: str,
+    filter_errors: bool,
+    modalities: Optional[List[List[str]]] = None,
+    dimensions: Optional[int] = None,
+    max_concurrent: Optional[int] = None,
+) -> dict:
+    results = _async_request_handler(
+        prompts,
+        api_key,
+        embedding_nim_endpoint,
+        embedding_model,
+        encoding_format,
+        input_type,
+        truncate,
+        filter_errors,
+        modalities=modalities,
+        dimensions=dimensions,
+        max_concurrent=max_concurrent,
+    )
+
+    flat_results = {"embeddings": [], "info_msgs": []}
+    for batch_dict in results:
+        info_msg = batch_dict.get("info_msg")
+        for embedding in batch_dict.get("embedding") or []:
+            flat_results["embeddings"].append(embedding)
+            flat_results["info_msgs"].append(info_msg)
+
+    return flat_results
+
+
+def _callable_runner(
+    prompts: List[List[str]],
+    *,
+    embedder: EmbeddingCallable,
+    batch_size: int,
+) -> dict:
+    flat_embeddings: List[Optional[Sequence[float]]] = []
+    flat_info_msgs: List[Optional[dict]] = []
+
+    for prompt_batch in prompts:
+        if not prompt_batch:
+            continue
+        for i in range(0, len(prompt_batch), max(1, int(batch_size))):
+            chunk = prompt_batch[i : i + max(1, int(batch_size))]
+            vecs = embedder(chunk)
+            vecs_list = list(vecs)
+            if len(vecs_list) != len(chunk):
+                raise ValueError(
+                    "Local embedder returned a mismatched number of embeddings "
+                    f"(got={len(vecs_list)} expected={len(chunk)})"
+                )
+            flat_embeddings.extend(vecs_list)
+            flat_info_msgs.extend([None] * len(vecs_list))
+
+    return {"embeddings": flat_embeddings, "info_msgs": flat_info_msgs}
+
+
+# ------------------------------------------------------------------------------
+# Row update helpers (adapted for retriever-local DataFrames)
+# ------------------------------------------------------------------------------
+
+
+def _add_embeddings_retriever_df(
+    row: pd.Series,
+    embeddings: Dict[Any, Any],
+    info_msgs: Dict[Any, Any],
+    *,
+    metadata_column: str,
+    write_embedding_to_metadata: bool,
+    output_payload_column: Optional[str],
+) -> pd.Series:
+    embedding = embeddings.get(row.name, None)
+    info_msg = info_msgs.get(row.name, None)
+
+    if write_embedding_to_metadata:
+        md = _ensure_metadata_dict(row, metadata_column=metadata_column)
+        md["embedding"] = embedding
+        if info_msg:
+            md["info_message_metadata"] = info_msg
+        row[metadata_column] = md
+
+    if output_payload_column:
+        row[output_payload_column] = {"embedding": embedding, "info_msg": info_msg}
+
+    row["_contains_embeddings"] = embedding is not None
+    return row
+
+
+# ------------------------------------------------------------------------------
+# Public API (mirrors the API transform's surface, but for retriever-local df schema)
+# ------------------------------------------------------------------------------
+
+
+def create_text_embeddings_for_df(
+    df_transform_ledger: pd.DataFrame,
+    *,
+    task_config: Dict[str, Any],
+    transform_config: Optional[TextEmbeddingConfig] = None,
+    execution_trace_log: Optional[Dict[str, Any]] = None,
+) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    """
+    Create embeddings for a retriever-local DataFrame and write them into row metadata.
+
+    Parameters
+    ----------
+    df_transform_ledger:
+        Input pandas.DataFrame. Recommended columns:
+        - `text` (or provide `transform_config.text_column`)
+        - `metadata` (optional dict; created if missing when writing embeddings)
+    task_config:
+        Controls runtime behavior. Keys (compatible with the API transform):
+        - **api_key**: optional str
+        - **endpoint_url**: optional str; if set, remote HTTP embeddings are used
+        - **model_name**: optional str
+        - **dimensions**: optional int
+        - **embedder**: optional callable(texts)->vectors; used when endpoint_url is empty/None
+        - **local_batch_size**: int; used to sub-batch for the callable embedder path
+    transform_config:
+        Optional TextEmbeddingConfig; if omitted, defaults are used.
+    execution_trace_log:
+        Optional dict to populate with trace info.
+
+    Returns
+    -------
+    (out_df, info_dict)
+    """
+    if transform_config is None:
+        transform_config = TextEmbeddingConfig()
+
+    # Allow task_config to explicitly override values with None by checking key presence (API parity).
+    api_key = task_config["api_key"] if "api_key" in task_config else transform_config.api_key
+    endpoint_url = (
+        task_config["endpoint_url"] if "endpoint_url" in task_config else transform_config.embedding_nim_endpoint
+    )
+    model_name = task_config["model_name"] if "model_name" in task_config else transform_config.embedding_model
+    dimensions = task_config["dimensions"] if "dimensions" in task_config else transform_config.dimensions
+
+    endpoint_url = endpoint_url.strip() if isinstance(endpoint_url, str) else endpoint_url
+    if isinstance(endpoint_url, str) and not endpoint_url:
+        endpoint_url = None
+
+    embedder: Optional[EmbeddingCallable] = task_config.get("embedder")
+    local_batch_size = int(task_config.get("local_batch_size") or 4)
+
+    if execution_trace_log is None:
+        execution_trace_log = {}
+
+    if df_transform_ledger.empty:
+        return df_transform_ledger, {"trace_info": execution_trace_log}
+
+    embed_modality = transform_config.embed_modality
+    multimodal_embedder = task_config.get("multimodal_embedder")  # local VL model for image/text_image
+
+    # Extract content and normalize empty or non-str to None (adapted for retriever-local schema).
+    if embed_modality == "image":
+        # For image-only, valid rows are those with a non-empty _image_b64.
+        extracted_content = df_transform_ledger.apply(lambda r: _image_from_row(r), axis=1).apply(
+            lambda x: x if isinstance(x, str) and x.strip() else None
+        )
+    elif embed_modality == "text_image":
+        # For text_image, a row is valid if it has either text or image (prefer both).
+        def _text_image_content(r: pd.Series) -> Optional[str]:
+            text = _text_from_row(r, text_column=str(transform_config.text_column))
+            image = _image_from_row(r)
+            if text or image:
+                return text or "__image_only__"
+            return None
+
+        extracted_content = df_transform_ledger.apply(_text_image_content, axis=1)
+    else:
+        extracted_content = df_transform_ledger.apply(
+            lambda r: _text_from_row(r, text_column=str(transform_config.text_column)), axis=1
+        ).apply(lambda x: x.strip() if isinstance(x, str) and x.strip() else None)
+
+    df_content = df_transform_ledger.copy()
+    df_content["_content"] = extracted_content
+
+    valid_content_mask = df_content["_content"].notna()
+    if valid_content_mask.any():
+        if embed_modality in IMAGE_MODALITIES and multimodal_embedder is not None:
+            # Local multimodal path: use _multimodal_callable_runner
+            content_embeddings = _multimodal_callable_runner(
+                df_content.loc[valid_content_mask],
+                embedder=multimodal_embedder,
+                batch_size=local_batch_size,
+                embed_modality=embed_modality,
+                text_column=str(transform_config.text_column),
+            )
+        elif embed_modality in IMAGE_MODALITIES and endpoint_url:
+            # Remote NIM path: format content as data URLs
+            if embed_modality == "image":
+                filtered_content_list = [
+                    _format_image_input_string(img_b64)
+                    for img_b64 in df_content.loc[valid_content_mask, "_content"].tolist()
+                ]
+            else:  # text_image
+                filtered_content_list = []
+                for _, r in df_content.loc[valid_content_mask].iterrows():
+                    text = _text_from_row(r, text_column=str(transform_config.text_column)) or ""
+                    image = _image_from_row(r) or ""
+                    if image and text.strip():
+                        filtered_content_list.append(_format_text_image_pair_input_string(text, image))
+                    elif image:
+                        # Image without text — send as image-only to avoid
+                        # "Text part must be non-empty for text_image modality" errors.
+                        filtered_content_list.append(_format_image_input_string(image))
+                    else:
+                        filtered_content_list.append(text)
+            filtered_content_batches = _generate_batches(
+                filtered_content_list, batch_size=int(transform_config.batch_size)
+            )
+            content_embeddings = _async_runner(
+                filtered_content_batches,
+                api_key,
+                str(endpoint_url),
+                str(model_name),
+                str(transform_config.encoding_format),
+                str(transform_config.input_type),
+                str(transform_config.truncate),
+                False,
+                modalities=None,
+                dimensions=dimensions,
+                max_concurrent=8,
+            )
+        else:
+            # Text-only path (default)
+            filtered_content_list = df_content.loc[valid_content_mask, "_content"].tolist()
+            filtered_content_batches = _generate_batches(
+                filtered_content_list, batch_size=int(transform_config.batch_size)
+            )
+
+            if endpoint_url:
+                content_embeddings = _async_runner(
+                    filtered_content_batches,
+                    api_key,
+                    str(endpoint_url),
+                    str(model_name),
+                    str(transform_config.encoding_format),
+                    str(transform_config.input_type),
+                    str(transform_config.truncate),
+                    False,
+                    modalities=None,
+                    dimensions=dimensions,
+                )
+            elif callable(embedder):
+                content_embeddings = _callable_runner(
+                    filtered_content_batches,
+                    embedder=embedder,
+                    batch_size=local_batch_size,
+                )
+            else:
+                raise ValueError(
+                    "No embedding endpoint configured (endpoint_url/embedding_nim_endpoint are empty) "
+                    "and no local embedder was provided in task_config['embedder']."
+                )
+
+        # Build a simple row index -> embedding map (API parity).
+        embeddings_dict = dict(zip(df_content.loc[valid_content_mask].index, content_embeddings.get("embeddings", [])))
+        info_msgs_dict = dict(zip(df_content.loc[valid_content_mask].index, content_embeddings.get("info_msgs", [])))
+    else:
+        embeddings_dict = {}
+        info_msgs_dict = {}
+
+    df_content = df_content.apply(
+        _add_embeddings_retriever_df,
+        embeddings=embeddings_dict,
+        info_msgs=info_msgs_dict,
+        metadata_column=str(transform_config.metadata_column),
+        write_embedding_to_metadata=bool(transform_config.write_embedding_to_metadata),
+        output_payload_column=transform_config.output_payload_column,
+        axis=1,
+    )
+
+    # Drop helper column to keep the output clean.
+    if "_content" in df_content.columns:
+        df_content = df_content.drop(columns=["_content"])
+
+    return df_content, {"trace_info": execution_trace_log}
diff --git a/nemo_retriever/src/nemo_retriever/text_embed/processor.py b/nemo_retriever/src/nemo_retriever/text_embed/processor.py
new file mode 100644
index 000000000..555f7e28b
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/text_embed/processor.py
@@ -0,0 +1,109 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional, Tuple
+
+import pandas as pd
+
+from nv_ingest_api.internal.primitives.tracing.tagging import traceable_func
+from nv_ingest_api.internal.schemas.transform.transform_text_embedding_schema import TextEmbeddingSchema
+from nv_ingest_api.internal.transform.embed_text import transform_create_text_embeddings_internal
+
+from nemo_retriever.io.dataframe import validate_primitives_dataframe
+from nemo_retriever.vector_store.lancedb_store import LanceDBConfig, write_embeddings_to_lancedb
+
+logger = logging.getLogger(__name__)
+
+
+@traceable_func(trace_name="retriever::text_embedding")
+def embed_text_from_primitives_df(
+    df_primitives: pd.DataFrame,
+    *,
+    transform_config: TextEmbeddingSchema,
+    task_config: Optional[Dict[str, Any]] = None,
+    lancedb: Optional[LanceDBConfig] = None,
+    trace_info: Optional[Dict[str, Any]] = None,
+) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    """Generate embeddings for supported content types and write to metadata."""
+    _ = trace_info
+    validate_primitives_dataframe(df_primitives)
+
+    if task_config is None:
+        task_config = {}
+    else:
+        # Avoid mutating the caller's dict (we may inject a local embedder callable).
+        task_config = dict(task_config)
+
+    # Auto-fallback: if no embedding endpoint is configured, inject a local HF embedder callable.
+    maybe_inject_local_hf_embedder(task_config, transform_config)
+
+    execution_trace_log: Dict[str, Any] = {}
+    try:
+        out_df, info = transform_create_text_embeddings_internal(
+            df_primitives,
+            task_config=task_config,
+            transform_config=transform_config,
+            execution_trace_log=execution_trace_log,
+        )
+    except Exception:
+        logger.exception("Text embedding failed")
+        raise
+
+    if lancedb is not None:
+        try:
+            write_embeddings_to_lancedb(out_df, cfg=lancedb)
+        except Exception:
+            logger.exception("Failed writing embeddings to LanceDB")
+            raise
+
+    info = dict(info or {})
+    info.setdefault("execution_trace_log", execution_trace_log)
+    return out_df, info
+
+
+def maybe_inject_local_hf_embedder(task_config: Dict[str, Any], transform_config: TextEmbeddingSchema) -> None:
+    """
+    If no remote embedding endpoint is configured, inject a local HF embedder into task_config.
+
+    This keeps the DataFrame embedding logic centralized in `nv_ingest_api.internal.transform.embed_text`
+    while allowing retriever-local runs to operate without an embedding microservice.
+    """
+    # Respect explicit caller-provided embedder.
+    if callable(task_config.get("embedder")):
+        return
+
+    # Resolve endpoint_url with explicit None override support.
+    if "endpoint_url" in task_config:
+        endpoint_url = task_config.get("endpoint_url")
+    else:
+        endpoint_url = getattr(transform_config, "embedding_nim_endpoint", None)
+
+    endpoint_url = endpoint_url.strip() if isinstance(endpoint_url, str) else endpoint_url
+    has_endpoint = bool(endpoint_url)
+
+    use_local = bool(task_config.get("use_local_hf_if_no_endpoint", True))
+    if has_endpoint or not use_local:
+        return
+
+    # Lazy import: only load torch/HF when we truly need local embeddings.
+    from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import LlamaNemotronEmbed1BV2Embedder
+
+    local_device = task_config.get("local_hf_device")
+    local_cache_dir = task_config.get("local_hf_cache_dir")
+    local_batch_size = int(task_config.get("local_hf_batch_size") or 64)
+
+    embedder = LlamaNemotronEmbed1BV2Embedder(device=local_device, hf_cache_dir=local_cache_dir, normalize=True)
+
+    def _embed(texts):
+        prefix = f"{transform_config.input_type}: " if getattr(transform_config, "input_type", None) else ""
+        vecs = embedder.embed([prefix + t for t in texts], batch_size=local_batch_size)
+        return vecs.tolist()
+
+    # Force the API transform to use the callable path by explicitly overriding endpoint_url to None.
+    task_config["endpoint_url"] = None
+    task_config["embedder"] = _embed
+    task_config["local_batch_size"] = local_batch_size
diff --git a/nemo_retriever/src/nemo_retriever/text_embed/ray_data.py b/nemo_retriever/src/nemo_retriever/text_embed/ray_data.py
new file mode 100644
index 000000000..198f48491
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/text_embed/ray_data.py
@@ -0,0 +1,40 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, Optional
+
+import pandas as pd
+
+from .text_embed import embed_text_1b_v2
+
+logger = logging.getLogger(__name__)
+
+
+def embed_text_ray_data(
+    ds: "ray.data.Dataset",  # noqa: F821
+    *,
+    model: Any,
+    task_config: Optional[Dict[str, Any]] = None,
+    batch_size: int = 256,
+) -> "ray.data.Dataset":  # noqa: F821
+    """
+    Ray Data adapter for lightweight local text embedding.
+
+    Notes:
+    - This is independent of `nv-ingest-api`.
+    - For actor-based embedding (so the embedder/model stays resident), use `TextEmbedActor`
+      from `nemo_retriever.text_embed.text_embed` with Ray's ActorPoolStrategy.
+    """
+    import ray.data  # type: ignore  # noqa: F401
+
+    task_config = dict(task_config or {})
+
+    def _map_batch(batch: pd.DataFrame) -> pd.DataFrame:
+        return embed_text_1b_v2(batch, model=model, **task_config)
+
+    logger.info("Running Ray Data local text embedding: batch_size=%s", batch_size)
+    return ds.map_batches(_map_batch, batch_format="pandas", batch_size=batch_size)
diff --git a/nemo_retriever/src/nemo_retriever/text_embed/stage.py b/nemo_retriever/src/nemo_retriever/text_embed/stage.py
new file mode 100644
index 000000000..9b166457f
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/text_embed/stage.py
@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from nemo_retriever.text_embed.commands import app, main, run
+from nemo_retriever.text_embed.processor import embed_text_from_primitives_df, maybe_inject_local_hf_embedder
+
+__all__ = ["app", "embed_text_from_primitives_df", "main", "maybe_inject_local_hf_embedder", "run"]
diff --git a/nemo_retriever/src/nemo_retriever/text_embed/text_embed.py b/nemo_retriever/src/nemo_retriever/text_embed/text_embed.py
new file mode 100644
index 000000000..6d5d30610
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/text_embed/text_embed.py
@@ -0,0 +1,232 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+"""
+Lightweight text embedding helpers (local HF).
+
+This module is intentionally independent of `nv-ingest-api` so it can be used in
+environments that don't have the full schema/transform stack installed.
+
+It mirrors the "pure pandas batch fn + Ray-friendly actor" pattern used by:
+- `nemo_retriever.page_elements.detect_page_elements_v3`
+- `nemo_retriever.chart.chart_detection.detect_graphic_elements_v1`
+"""
+
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Sequence  # noqa: F401
+
+import time
+import traceback
+
+import pandas as pd
+
+try:
+    import torch
+except Exception:  # pragma: no cover
+    torch = None  # type: ignore[assignment]
+
+
+def _error_payload(*, stage: str, exc: BaseException) -> Dict[str, Any]:
+    return {
+        "embedding": None,
+        "error": {
+            "stage": str(stage),
+            "type": exc.__class__.__name__,
+            "message": str(exc),
+            "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+        },
+    }
+
+
+def _text_from_row(row: pd.Series, *, text_column: str) -> str:
+    """
+    Extract text from a row with a small set of fallbacks.
+    """
+    v = row.get(text_column)
+    if isinstance(v, str) and v.strip():
+        return v
+
+    # Common alternative keys.
+    for k in ("text", "content", "chunk", "page_text"):
+        v2 = row.get(k)
+        if isinstance(v2, str) and v2.strip():
+            return v2
+
+    return ""
+
+
+def embed_text_1b_v2(
+    batch_df: Any,
+    *,
+    model: Any,
+    # Optional compatibility args (e.g. passed by `.embed(model_name=..., embedding_endpoint=...)`).
+    # This lightweight implementation uses the provided local `model` regardless.
+    model_name: Optional[str] = None,
+    embedding_endpoint: Optional[str] = None,
+    input_type: str = "passage",
+    text_column: str = "text",
+    inference_batch_size: int = 32,
+    output_column: str = "text_embeddings_1b_v2",
+    embedding_dim_column: str = "text_embeddings_1b_v2_dim",
+    has_embedding_column: str = "text_embeddings_1b_v2_has_embedding",
+    **_: Any,
+) -> Any:
+    """
+    Embed a batch of text rows using the local `LlamaNemotronEmbed1BV2Embedder`.
+
+    Input:
+      - `batch_df`: pandas.DataFrame (Ray Data `batch_format="pandas"` compatible)
+      - `text_column`: preferred column name to read text from (defaults to `"text"`)
+
+    Output:
+      - Returns a pandas.DataFrame with original columns preserved, plus:
+        - `output_column`: dict payload `{"embedding": list[float]|None, "timing": {...}, "error": ...}`
+        - `embedding_dim_column`: int
+        - `has_embedding_column`: bool
+    """
+    _ = (model_name, embedding_endpoint)  # reserved for future remote execution support
+    if not isinstance(batch_df, pd.DataFrame):
+        raise NotImplementedError("embed_text_1b_v2 currently only supports pandas.DataFrame input.")
+    if inference_batch_size <= 0:
+        raise ValueError("inference_batch_size must be > 0")
+
+    payloads: List[Dict[str, Any]] = [{"embedding": None, "error": None} for _ in range(len(batch_df.index))]
+    texts: List[str] = []
+    text_row_idxs: List[int] = []
+
+    for i, (_, row) in enumerate(batch_df.iterrows()):
+        try:
+            txt = _text_from_row(row, text_column=str(text_column))
+            if not txt.strip():
+                # Keep placeholder but mark as "no text".
+                payloads[i] = {"embedding": None, "error": None}
+                continue
+            # VL model handles formatting internally; skip prefix.
+            if input_type and not hasattr(model, "embed_queries"):
+                texts.append(f"{input_type}: {txt}")
+            else:
+                texts.append(txt)
+            text_row_idxs.append(i)
+        except BaseException as e:
+            payloads[i] = _error_payload(stage="extract_text", exc=e)
+
+    # Nothing to embed.
+    if not texts:
+        out0 = batch_df.copy()
+        out0[output_column] = payloads
+        out0[embedding_dim_column] = [0 for _ in range(len(out0.index))]
+        out0[has_embedding_column] = [False for _ in range(len(out0.index))]
+        return out0
+
+    # Run inference in chunks.
+    for start in range(0, len(texts), int(inference_batch_size)):
+        chunk_texts = texts[start : start + int(inference_batch_size)]
+        chunk_idxs = text_row_idxs[start : start + int(inference_batch_size)]
+        if not chunk_texts:
+            continue
+
+        t0 = time.perf_counter()
+        try:
+            vecs = model.embed(chunk_texts, batch_size=int(inference_batch_size))
+            elapsed = time.perf_counter() - t0
+
+            if torch is not None and isinstance(vecs, torch.Tensor):
+                vecs_list = vecs.detach().to("cpu").tolist()
+            elif isinstance(vecs, list):
+                vecs_list = vecs
+            else:
+                # Best-effort conversion.
+                tolist = getattr(vecs, "tolist", None)
+                vecs_list = tolist() if callable(tolist) else vecs  # type: ignore[assignment]
+
+            if not isinstance(vecs_list, list) or len(vecs_list) != len(chunk_idxs):
+                raise RuntimeError("Embedder returned unexpected output shape/type.")
+
+            for local_i, row_i in enumerate(chunk_idxs):
+                emb = vecs_list[local_i]
+                if not isinstance(emb, list):
+                    # Allow numpy arrays or tensors that slipped through.
+                    tolist = getattr(emb, "tolist", None)
+                    emb = tolist() if callable(tolist) else emb
+                payloads[row_i] = {
+                    "embedding": emb,
+                    "timing": {"seconds": float(elapsed)},
+                    "error": None,
+                }
+        except BaseException as e:
+            elapsed = time.perf_counter() - t0
+            for row_i in chunk_idxs:
+                payloads[row_i] = _error_payload(stage="embed", exc=e) | {"timing": {"seconds": float(elapsed)}}
+
+    out = batch_df.copy()
+    out[output_column] = payloads
+    out[embedding_dim_column] = [
+        (
+            int(len((p or {}).get("embedding") or []))
+            if isinstance(p, dict) and isinstance(p.get("embedding"), list)
+            else 0
+        )
+        for p in payloads
+    ]
+    out[has_embedding_column] = [bool(d > 0) for d in out[embedding_dim_column].tolist()]
+    return out
+
+
+@dataclass(slots=True)
+class TextEmbedActor:
+    """
+    Ray-friendly callable that initializes `LlamaNemotronEmbed1BV2Embedder` once.
+    """
+
+    detect_kwargs: Dict[str, Any]
+
+    def __init__(self, **detect_kwargs: Any) -> None:
+        self.detect_kwargs = dict(detect_kwargs)
+
+        device = self.detect_kwargs.pop("device", None)
+        hf_cache_dir = self.detect_kwargs.pop("hf_cache_dir", None)
+        normalize = bool(self.detect_kwargs.pop("normalize", True))
+        max_length = self.detect_kwargs.pop("max_length", 4096)
+        model_name = self.detect_kwargs.get("model_name")
+
+        from nemo_retriever.model import is_vl_embed_model
+
+        if is_vl_embed_model(model_name):
+            from nemo_retriever.model.local.llama_nemotron_embed_vl_1b_v2_embedder import (
+                LlamaNemotronEmbedVL1BV2Embedder,
+            )
+
+            self._model = LlamaNemotronEmbedVL1BV2Embedder(
+                device=str(device) if device is not None else None,
+                hf_cache_dir=str(hf_cache_dir) if hf_cache_dir is not None else None,
+            )
+        else:
+            from nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder import LlamaNemotronEmbed1BV2Embedder
+
+            self._model = LlamaNemotronEmbed1BV2Embedder(
+                device=str(device) if device is not None else None,
+                hf_cache_dir=str(hf_cache_dir) if hf_cache_dir is not None else None,
+                normalize=normalize,
+                max_length=int(max_length),
+            )
+
+    def __call__(self, batch_df: Any, **override_kwargs: Any) -> Any:
+        try:
+            return embed_text_1b_v2(
+                batch_df,
+                model=self._model,
+                **self.detect_kwargs,
+                **override_kwargs,
+            )
+        except BaseException as e:
+            if isinstance(batch_df, pd.DataFrame):
+                out = batch_df.copy()
+                payload = _error_payload(stage="actor_call", exc=e)
+                out["text_embeddings_1b_v2"] = [payload for _ in range(len(out.index))]
+                out["text_embeddings_1b_v2_dim"] = [0 for _ in range(len(out.index))]
+                out["text_embeddings_1b_v2_has_embedding"] = [False for _ in range(len(out.index))]
+                return out
+            return [{"text_embeddings_1b_v2": _error_payload(stage="actor_call", exc=e)}]
diff --git a/nemo_retriever/src/nemo_retriever/txt/__init__.py b/nemo_retriever/src/nemo_retriever/txt/__init__.py
new file mode 100644
index 000000000..f6673198f
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/txt/__init__.py
@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Txt ingestion: tokenizer-based split and chunk DataFrame builder.
+
+Compatible with the same embed and LanceDB stages as PDF primitives.
+"""
+
+from .split import (
+    DEFAULT_MAX_TOKENS,
+    DEFAULT_OVERLAP_TOKENS,
+    DEFAULT_TOKENIZER_MODEL_ID,
+    split_text_by_tokens,
+    txt_file_to_chunks_df,
+)
+
+__all__ = [
+    "DEFAULT_MAX_TOKENS",
+    "DEFAULT_OVERLAP_TOKENS",
+    "DEFAULT_TOKENIZER_MODEL_ID",
+    "split_text_by_tokens",
+    "txt_file_to_chunks_df",
+]
diff --git a/nemo_retriever/src/nemo_retriever/txt/__main__.py b/nemo_retriever/src/nemo_retriever/txt/__main__.py
new file mode 100644
index 000000000..b769c774e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/txt/__main__.py
@@ -0,0 +1,108 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+CLI for .txt extraction: tokenizer-based split, write *.txt_extraction.json.
+
+Use with: retriever local stage5 run --pattern "*.txt_extraction.json" then stage6.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional  # noqa: F401
+
+import typer
+from rich.console import Console
+from nemo_retriever.params import TextChunkParams
+
+from . import txt_file_to_chunks_df
+
+console = Console()
+app = typer.Typer(help="Txt extraction: tokenizer-based split, write primitives-like JSON.")
+
+
+def _to_jsonable(val: Any) -> Any:
+    """Convert to JSON-serializable (e.g. numpy int64 -> int)."""
+    if hasattr(val, "item"):
+        return val.item()
+    if hasattr(val, "tolist"):
+        return val.tolist()
+    if isinstance(val, dict):
+        return {k: _to_jsonable(v) for k, v in val.items()}
+    if isinstance(val, list):
+        return [_to_jsonable(x) for x in val]
+    return val
+
+
+@app.command("run")
+def run(
+    input_dir: Path = typer.Option(
+        ...,
+        "--input-dir",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to scan for *.txt files.",
+    ),
+    output_dir: Optional[Path] = typer.Option(
+        None,
+        "--output-dir",
+        file_okay=False,
+        dir_okay=True,
+        help="Directory to write *.txt_extraction.json. Default: alongside each input file.",
+    ),
+    max_tokens: int = typer.Option(512, "--max-tokens", min=1, help="Max tokens per chunk."),
+    overlap: int = typer.Option(0, "--overlap", min=0, help="Overlap tokens between consecutive chunks."),
+    encoding: str = typer.Option("utf-8", "--encoding", help="File encoding for reading .txt."),
+    limit: Optional[int] = typer.Option(None, "--limit", min=1, help="Limit number of .txt files processed."),
+) -> None:
+    """
+    Scan input_dir for *.txt, tokenizer-split each into chunks, write <stem>.txt_extraction.json.
+
+    Output JSON has the same primitives-like shape as stage5 input (text, path, page_number, metadata).
+    Then run: retriever local stage5 run --input-dir <dir> --pattern "*.txt_extraction.json"
+    and retriever local stage6 run --input-dir <dir>.
+    """
+    input_dir = Path(input_dir)
+    txt_files = sorted(input_dir.glob("*.txt"))
+    if not txt_files:
+        console.print(f"[red]No *.txt files found in[/red] {input_dir}")
+        raise typer.Exit(code=2)
+    if limit is not None:
+        txt_files = txt_files[:limit]
+
+    for path in txt_files:
+        try:
+            df = txt_file_to_chunks_df(
+                str(path),
+                params=TextChunkParams(
+                    max_tokens=max_tokens,
+                    overlap_tokens=overlap,
+                    encoding=encoding,
+                ),
+            )
+        except Exception as e:
+            console.print(f"[red]Failed[/red] {path}: {e}")
+            continue
+
+        out_path: Path
+        if output_dir is not None:
+            output_dir.mkdir(parents=True, exist_ok=True)
+            out_path = Path(output_dir) / f"{path.stem}.txt_extraction.json"
+        else:
+            out_path = path.with_suffix(".txt_extraction.json")
+
+        records = df.to_dict(orient="records")
+        jsonable = _to_jsonable(records)
+        # Write as JSON array so stage5's pd.read_json(in_path) returns a DataFrame
+        out_path.write_text(json.dumps(jsonable, ensure_ascii=False, indent=2), encoding="utf-8")
+        console.print(f"[green]Wrote[/green] {out_path} ({len(df)} chunks)")
+
+    console.print(f"[green]Done[/green] processed={len(txt_files)}")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/txt/ray_data.py b/nemo_retriever/src/nemo_retriever/txt/ray_data.py
new file mode 100644
index 000000000..1cb86970e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/txt/ray_data.py
@@ -0,0 +1,50 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Ray Data adapter for .txt: TxtSplitActor turns bytes+path batches into chunk rows.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List  # noqa: F401
+
+import pandas as pd
+
+from nemo_retriever.params import TextChunkParams
+
+from .split import txt_bytes_to_chunks_df
+
+
+class TxtSplitActor:
+    """
+    Ray Data map_batches callable: DataFrame with bytes, path -> DataFrame of chunks.
+
+    Each output row has: text, path, page_number, metadata (same shape as txt_file_to_chunks_df).
+    """
+
+    def __init__(self, params: TextChunkParams | None = None) -> None:
+        self._params = params or TextChunkParams()
+
+    def __call__(self, batch_df: pd.DataFrame) -> pd.DataFrame:
+        if not isinstance(batch_df, pd.DataFrame) or batch_df.empty:
+            return pd.DataFrame(columns=["text", "path", "page_number", "metadata"])
+
+        params = self._params
+        out_dfs: List[pd.DataFrame] = []
+        for _, row in batch_df.iterrows():
+            raw = row.get("bytes")
+            path = row.get("path")
+            if raw is None or path is None:
+                continue
+            path_str = str(path) if path is not None else ""
+            try:
+                chunk_df = txt_bytes_to_chunks_df(raw, path_str, params=params)
+                if not chunk_df.empty:
+                    out_dfs.append(chunk_df)
+            except Exception:
+                continue
+        if not out_dfs:
+            return pd.DataFrame(columns=["text", "path", "page_number", "metadata"])
+        return pd.concat(out_dfs, ignore_index=True)
diff --git a/nemo_retriever/src/nemo_retriever/txt/split.py b/nemo_retriever/src/nemo_retriever/txt/split.py
new file mode 100644
index 000000000..146dac02c
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/txt/split.py
@@ -0,0 +1,211 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Tokenizer-based text splitting for .txt ingestion.
+
+Produces chunk DataFrames compatible with embed_text_from_primitives_df
+and the LanceDB row builder (text, path, page_number, metadata).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+from nemo_retriever.params import TextChunkParams
+
+DEFAULT_TOKENIZER_MODEL_ID = "nvidia/llama-3.2-nv-embedqa-1b-v2"
+DEFAULT_MAX_TOKENS = 512
+DEFAULT_OVERLAP_TOKENS = 0
+
+
+def _get_tokenizer(model_id: str, cache_dir: Optional[str] = None):  # noqa: ANN201
+    """Lazy-load HuggingFace tokenizer."""
+    from transformers import AutoTokenizer
+
+    return AutoTokenizer.from_pretrained(
+        model_id,
+        cache_dir=cache_dir,
+    )
+
+
+def split_text_by_tokens(
+    text: str,
+    *,
+    tokenizer: Any,
+    max_tokens: int,
+    overlap_tokens: int = 0,
+) -> List[str]:
+    """
+    Split text into chunks by token count with optional overlap.
+
+    Chunk boundaries align with tokenizer token boundaries. Uses a sliding
+    window: each chunk has at most max_tokens tokens; consecutive chunks
+    overlap by overlap_tokens tokens.
+
+    Parameters
+    ----------
+    text : str
+        Input text to split.
+    tokenizer
+        HuggingFace tokenizer (e.g. AutoTokenizer) with encode/decode.
+    max_tokens : int
+        Maximum tokens per chunk.
+    overlap_tokens : int
+        Number of tokens to overlap between consecutive chunks (default 0).
+
+    Returns
+    -------
+    list[str]
+        Chunk strings in order.
+    """
+    if not text or not text.strip():
+        return []
+    if max_tokens <= 0:
+        raise ValueError("max_tokens must be positive")
+
+    enc = tokenizer.encode(text, add_special_tokens=False)
+    if not enc:
+        return []
+
+    step = max(1, max_tokens - overlap_tokens)
+    chunks: List[str] = []
+    start = 0
+    while start < len(enc):
+        end = min(start + max_tokens, len(enc))
+        chunk_ids = enc[start:end]
+        chunk_text = tokenizer.decode(chunk_ids, skip_special_tokens=True)
+        if chunk_text.strip():
+            chunks.append(chunk_text)
+        start += step
+        if end >= len(enc):
+            break
+
+    return chunks if chunks else [text]
+
+
+def txt_file_to_chunks_df(
+    path: str,
+    params: TextChunkParams | None = None,
+) -> pd.DataFrame:
+    chunk_params = params or TextChunkParams()
+    max_tokens = chunk_params.max_tokens
+    overlap_tokens = chunk_params.overlap_tokens
+    tokenizer_model_id = chunk_params.tokenizer_model_id
+    encoding = chunk_params.encoding
+    tokenizer_cache_dir = chunk_params.tokenizer_cache_dir
+
+    """
+    Read a .txt file and return a DataFrame of chunks (one row per chunk).
+
+    Columns: text, path, page_number (chunk index, 1-based), metadata.
+    Shape is compatible with embed_text_from_primitives_df and LanceDB row build.
+
+    Parameters
+    ----------
+    path : str
+        Path to the .txt file.
+    max_tokens : int
+        Max tokens per chunk (default 512).
+    overlap_tokens : int
+        Overlap between consecutive chunks (default 0).
+    tokenizer_model_id : str, optional
+        HuggingFace model id for tokenizer (default: same as embedder).
+    encoding : str
+        File encoding (default utf-8).
+    tokenizer_cache_dir : str, optional
+        HuggingFace cache directory for tokenizer.
+
+    Returns
+    -------
+    pd.DataFrame
+        Columns: text, path, page_number, metadata.
+    """
+    path = str(Path(path).resolve())
+    raw = Path(path).read_text(encoding=encoding, errors="replace")
+    model_id = tokenizer_model_id or DEFAULT_TOKENIZER_MODEL_ID
+    tokenizer = _get_tokenizer(model_id, cache_dir=tokenizer_cache_dir)
+    chunk_texts = split_text_by_tokens(
+        raw,
+        tokenizer=tokenizer,
+        max_tokens=max_tokens,
+        overlap_tokens=overlap_tokens,
+    )
+
+    if not chunk_texts:
+        return pd.DataFrame(
+            columns=["text", "path", "page_number", "metadata"],
+        ).astype({"page_number": "int64"})
+
+    rows: List[Dict[str, Any]] = []
+    for i, chunk in enumerate(chunk_texts):
+        rows.append(
+            {
+                "text": chunk,
+                "content": chunk,
+                "path": path,
+                "page_number": i + 1,
+                "metadata": {
+                    "source_path": path,
+                    "chunk_index": i,
+                    "content_metadata": {"type": "text"},
+                    "content": chunk,
+                },
+            }
+        )
+    return pd.DataFrame(rows)
+
+
+def txt_bytes_to_chunks_df(
+    content_bytes: bytes,
+    path: str,
+    params: TextChunkParams | None = None,
+) -> pd.DataFrame:
+    chunk_params = params or TextChunkParams()
+    max_tokens = chunk_params.max_tokens
+    overlap_tokens = chunk_params.overlap_tokens
+    tokenizer_model_id = chunk_params.tokenizer_model_id
+    encoding = chunk_params.encoding
+    tokenizer_cache_dir = chunk_params.tokenizer_cache_dir
+
+    """
+    Decode bytes to text and return a DataFrame of chunks (same shape as txt_file_to_chunks_df).
+
+    Used by batch TxtSplitActor when input is bytes + path from read_binary_files.
+    """
+    path = str(Path(path).resolve())
+    raw = content_bytes.decode(encoding, errors="replace")
+    model_id = tokenizer_model_id or DEFAULT_TOKENIZER_MODEL_ID
+    tokenizer = _get_tokenizer(model_id, cache_dir=tokenizer_cache_dir)
+    chunk_texts = split_text_by_tokens(
+        raw,
+        tokenizer=tokenizer,
+        max_tokens=max_tokens,
+        overlap_tokens=overlap_tokens,
+    )
+
+    if not chunk_texts:
+        return pd.DataFrame(
+            columns=["text", "path", "page_number", "metadata"],
+        ).astype({"page_number": "int64"})
+
+    rows: List[Dict[str, Any]] = []
+    for i, chunk in enumerate(chunk_texts):
+        rows.append(
+            {
+                "text": chunk,
+                "content": chunk,
+                "path": path,
+                "page_number": i + 1,
+                "metadata": {
+                    "source_path": path,
+                    "chunk_index": i,
+                    "content_metadata": {"type": "text"},
+                    "content": chunk,
+                },
+            }
+        )
+    return pd.DataFrame(rows)
diff --git a/nemo_retriever/src/nemo_retriever/util/__init__.py b/nemo_retriever/src/nemo_retriever/util/__init__.py
new file mode 100644
index 000000000..6aa2e3d5b
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/util/__init__.py
@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
diff --git a/nemo_retriever/src/nemo_retriever/util/table_and_chart.py b/nemo_retriever/src/nemo_retriever/util/table_and_chart.py
new file mode 100644
index 000000000..62eb5776e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/util/table_and_chart.py
@@ -0,0 +1,623 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Table/chart/infographic content reconstruction utilities.
+
+Ports bbox-matching and content-reconstruction algorithms from
+``nv_ingest_api.util.image_processing.table_and_chart`` and adds adapter
+functions that convert the retriever's detection/OCR formats into the
+pixel-coordinate representations expected by the core joining routines.
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+from typing import Any, Dict, List, Optional, Sequence, Tuple  # noqa: F401
+
+import numpy as np
+import pandas as pd
+from sklearn.cluster import DBSCAN
+
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Core algorithms ported from nv-ingest
+# ---------------------------------------------------------------------------
+
+
+def match_bboxes(
+    yolox_box: np.ndarray,
+    ocr_boxes: np.ndarray,
+    already_matched: Optional[list] = None,
+    delta: float = 2.0,
+) -> np.ndarray:
+    """Union-based IoU matching for chart graphic elements."""
+    x0_1, y0_1, x1_1, y1_1 = yolox_box
+    x0_2, y0_2, x1_2, y1_2 = (
+        ocr_boxes[:, 0],
+        ocr_boxes[:, 1],
+        ocr_boxes[:, 2],
+        ocr_boxes[:, 3],
+    )
+
+    inter_y0 = np.maximum(y0_1, y0_2)
+    inter_y1 = np.minimum(y1_1, y1_2)
+    inter_x0 = np.maximum(x0_1, x0_2)
+    inter_x1 = np.minimum(x1_1, x1_2)
+    inter_area = np.maximum(0, inter_y1 - inter_y0) * np.maximum(0, inter_x1 - inter_x0)
+
+    area_1 = (y1_1 - y0_1) * (x1_1 - x0_1)
+    area_2 = (y1_2 - y0_2) * (x1_2 - x0_2)
+    union_area = area_1 + area_2 - inter_area
+
+    ious = inter_area / union_area
+    max_iou = np.max(ious)
+    if max_iou <= 0.01:
+        return []
+
+    matches = np.where(ious > (max_iou / delta))[0]
+    if already_matched is not None:
+        matches = np.array([m for m in matches if m not in already_matched])
+    return matches
+
+
+def assign_boxes(
+    ocr_box: np.ndarray,
+    boxes: np.ndarray,
+    delta: float = 2.0,
+    min_overlap: float = 0.25,
+) -> np.ndarray:
+    """Area-normalized overlap matching for table structure."""
+    if not len(boxes):
+        return []
+
+    boxes = np.array(boxes)
+    x0_1, y0_1, x1_1, y1_1 = ocr_box
+    x0_2, y0_2, x1_2, y1_2 = (
+        boxes[:, 0],
+        boxes[:, 1],
+        boxes[:, 2],
+        boxes[:, 3],
+    )
+
+    inter_y0 = np.maximum(y0_1, y0_2)
+    inter_y1 = np.minimum(y1_1, y1_2)
+    inter_x0 = np.maximum(x0_1, x0_2)
+    inter_x1 = np.minimum(x1_1, x1_2)
+    inter_area = np.maximum(0, inter_y1 - inter_y0) * np.maximum(0, inter_x1 - inter_x0)
+
+    area_1 = (y1_1 - y0_1) * (x1_1 - x0_1)
+    ious = inter_area / (area_1 + 1e-6)
+
+    max_iou = np.max(ious)
+    if max_iou <= min_overlap:
+        return []
+
+    n = len(np.where(ious >= (max_iou / delta))[0])
+    matches = np.argsort(-ious)[:n]
+    return matches
+
+
+def _join_yolox_graphic_elements_and_ocr_output(
+    yolox_output: Dict[str, list],
+    ocr_boxes: np.ndarray,
+    ocr_txts: list,
+) -> Dict[str, str]:
+    """Match graphic-element detections to OCR text via IoU."""
+    KEPT_CLASSES = [
+        "chart_title",
+        "x_title",
+        "y_title",
+        "xlabel",
+        "ylabel",
+        "other",
+        "legend_label",
+        "legend_title",
+        "mark_label",
+        "value_label",
+    ]
+
+    ocr_txts = np.array(ocr_txts)
+    ocr_boxes = np.array(ocr_boxes)
+
+    if ocr_txts.size == 0 or ocr_boxes.size == 0:
+        return {}
+
+    # Convert quadrilateral (N,4,2) → xyxy (N,4).
+    ocr_boxes = np.array(
+        [
+            ocr_boxes[:, :, 0].min(-1),
+            ocr_boxes[:, :, 1].min(-1),
+            ocr_boxes[:, :, 0].max(-1),
+            ocr_boxes[:, :, 1].max(-1),
+        ]
+    ).T
+
+    already_matched: list = []
+    results: Dict[str, str] = {}
+
+    for k in KEPT_CLASSES:
+        if not len(yolox_output.get(k, [])):
+            continue
+
+        texts = []
+        for yolox_box in yolox_output[k]:
+            yolox_box = yolox_box[:4]
+            ocr_ids = match_bboxes(yolox_box, ocr_boxes, already_matched=already_matched, delta=4)
+            if len(ocr_ids) > 0:
+                text = " ".join(ocr_txts[ocr_ids].tolist())
+                texts.append(text)
+
+        processed_texts = []
+        for t in texts:
+            t = re.sub(r"\s+", " ", t)
+            t = re.sub(r"\.+", ".", t)
+            processed_texts.append(t)
+
+        if "title" in k:
+            processed_texts = " ".join(processed_texts)
+        else:
+            processed_texts = " - ".join(processed_texts)
+
+        results[k] = processed_texts
+
+    return results
+
+
+def process_yolox_graphic_elements(yolox_text_dict: Dict[str, str]) -> str:
+    """Concatenate chart text by semantic region."""
+    chart_content = ""
+    chart_content += yolox_text_dict.get("chart_title", "")
+    chart_content += " " + yolox_text_dict.get("caption", "")
+    chart_content += " " + yolox_text_dict.get("x_title", "")
+    chart_content += " " + yolox_text_dict.get("xlabel", "")
+    chart_content += " " + yolox_text_dict.get("y_title", "")
+    chart_content += " " + yolox_text_dict.get("ylabel", "")
+    chart_content += " " + yolox_text_dict.get("legend_label", "")
+    chart_content += " " + yolox_text_dict.get("legend_title", "")
+    chart_content += " " + yolox_text_dict.get("mark_label", "")
+    chart_content += " " + yolox_text_dict.get("value_label", "")
+    chart_content += " " + yolox_text_dict.get("other", "")
+    return chart_content.strip()
+
+
+def _join_yolox_table_structure_and_ocr_output(
+    yolox_cell_preds: Dict[str, np.ndarray],
+    ocr_boxes: list,
+    ocr_txts: list,
+) -> str:
+    """Combine table-structure cell/row/column predictions with OCR text."""
+    if not ocr_boxes or not ocr_txts:
+        return ""
+
+    ocr_boxes = np.array(ocr_boxes)
+    ocr_boxes_ = np.array(
+        [
+            ocr_boxes[:, :, 0].min(-1),
+            ocr_boxes[:, :, 1].min(-1),
+            ocr_boxes[:, :, 0].max(-1),
+            ocr_boxes[:, :, 1].max(-1),
+        ]
+    ).T
+
+    assignments = []
+    for i, (b, t) in enumerate(zip(ocr_boxes_, ocr_txts)):
+        matches_cell = assign_boxes(b, yolox_cell_preds["cell"], delta=1)
+        cell = yolox_cell_preds["cell"][matches_cell[0]] if len(matches_cell) else b
+
+        matches_row = assign_boxes(cell, yolox_cell_preds["row"], delta=1)
+        row_ids = matches_row if len(matches_row) else -1
+
+        if isinstance(row_ids, np.ndarray):
+            delta = 2 if row_ids.min() == 0 else 1
+        else:
+            delta = 1
+        matches_col = assign_boxes(cell, yolox_cell_preds["column"], delta=delta)
+        col_ids = matches_col if len(matches_col) else -1
+
+        assignments.append(
+            {
+                "index": i,
+                "ocr_box": b,
+                "is_table": isinstance(col_ids, np.ndarray) and isinstance(row_ids, np.ndarray),
+                "cell_id": matches_cell[0] if len(matches_cell) else -1,
+                "cell": cell,
+                "col_ids": col_ids,
+                "row_ids": row_ids,
+                "text": t,
+            }
+        )
+
+    df_assign = pd.DataFrame(assignments)
+
+    dfs = []
+    for cell_id, df_cell in df_assign.groupby("cell_id"):
+        if len(df_cell) > 1 and cell_id > -1:
+            df_cell = merge_text_in_cell(df_cell)
+        dfs.append(df_cell)
+    df_assign = pd.concat(dfs)
+
+    df_text = df_assign[~df_assign["is_table"]].reset_index(drop=True)
+
+    df_table = df_assign[df_assign["is_table"]].reset_index(drop=True)
+    if len(df_table):
+        mat = build_markdown(df_table)
+        markdown_table = display_markdown(mat, use_header=True)
+
+        all_boxes = np.stack(df_table.ocr_box.values)
+        table_box = np.concatenate([all_boxes[:, [0, 1]].min(0), all_boxes[:, [2, 3]].max(0)])
+
+        df_table_to_text = pd.DataFrame(
+            [
+                {
+                    "ocr_box": table_box,
+                    "text": markdown_table,
+                    "is_table": True,
+                }
+            ]
+        )
+        df_text = pd.concat([df_text, df_table_to_text], ignore_index=True)
+
+    df_text = df_text.rename(columns={"ocr_box": "box"})
+
+    df_text["x"] = df_text["box"].apply(lambda x: (x[0] + x[2]) / 2)
+    df_text["y"] = df_text["box"].apply(lambda x: (x[1] + x[3]) / 2)
+    df_text["x"] = (df_text["x"] - df_text["x"].min()) // 10
+    df_text["y"] = (df_text["y"] - df_text["y"].min()) // 20
+    df_text = df_text.sort_values(["y", "x"], ignore_index=True)
+
+    rows_list = []
+    for r, df_row in df_text.groupby("y"):
+        if df_row["is_table"].values.any():
+            table = df_row[df_row["is_table"]]
+            df_row = df_row[~df_row["is_table"]]
+        else:
+            table = None
+
+        if len(df_row) > 1:
+            df_row = df_row.reset_index(drop=True)
+            df_row["text"] = "\n".join(df_row["text"].values.tolist())
+
+        rows_list.append(df_row.head(1))
+
+        if table is not None:
+            rows_list.append(table)
+
+    df_display = pd.concat(rows_list, ignore_index=True)
+    result = "\n".join(df_display.text.values.tolist())
+    return result
+
+
+def build_markdown(df: pd.DataFrame) -> list:
+    """Convert a dataframe with row_ids/col_ids/text into a markdown matrix."""
+    df = df.reset_index(drop=True)
+    n_cols = max([np.max(c) for c in df["col_ids"].values])
+    n_rows = max([np.max(c) for c in df["row_ids"].values])
+
+    mat = np.empty((n_rows + 1, n_cols + 1), dtype=str).tolist()
+
+    for i in range(len(df)):
+        if isinstance(df["row_ids"][i], int) or isinstance(df["col_ids"][i], int):
+            continue
+        for r in df["row_ids"][i]:
+            for c in df["col_ids"][i]:
+                mat[r][c] = (mat[r][c] + " " + df["text"][i]).strip()
+
+    mat = remove_empty_row(mat)
+    mat = np.array(remove_empty_row(np.array(mat).T.tolist())).T.tolist()
+    return mat
+
+
+def display_markdown(data: list, use_header: bool = False) -> str:
+    """Convert a list-of-lists into a markdown table string."""
+    if not len(data):
+        return "EMPTY TABLE"
+
+    max_cols = max(len(row) for row in data)
+    data = [row + [""] * (max_cols - len(row)) for row in data]
+
+    if use_header:
+        header = "| " + " | ".join(data[0]) + " |"
+        separator = "| " + " | ".join(["---"] * max_cols) + " |"
+        body = "\n".join("| " + " | ".join(row) + " |" for row in data[1:])
+        markdown_table = f"{header}\n{separator}\n{body}" if body else f"{header}\n{separator}"
+    else:
+        markdown_table = "\n".join("| " + " | ".join(row) + " |" for row in data)
+
+    return markdown_table
+
+
+def merge_text_in_cell(df_cell: pd.DataFrame) -> pd.DataFrame:
+    """Merge text from multiple OCR items inside one table cell."""
+    ocr_boxes = np.stack(df_cell["ocr_box"].values)
+
+    df_cell = df_cell.copy()
+    df_cell["x"] = (ocr_boxes[:, 0] - ocr_boxes[:, 0].min()) // 10
+    df_cell["y"] = (ocr_boxes[:, 1] - ocr_boxes[:, 1].min()) // 10
+    df_cell = df_cell.sort_values(["y", "x"])
+
+    text = " ".join(df_cell["text"].values.tolist())
+    df_cell["text"] = text
+    df_cell = df_cell.head(1)
+    df_cell["ocr_box"] = df_cell["cell"]
+    df_cell = df_cell.drop(["x", "y"], axis=1)
+    return df_cell
+
+
+def remove_empty_row(mat: list) -> list:
+    """Remove empty rows from a matrix."""
+    mat_filter = []
+    for row in mat:
+        if max([len(c) for c in row]):
+            mat_filter.append(row)
+    return mat_filter
+
+
+def reorder_boxes(
+    boxes: np.ndarray,
+    texts: list,
+    confs: list,
+    mode: str = "top_left",
+    dbscan_eps: float = 10,
+) -> Tuple[list, list, list]:
+    """Reorder OCR boxes in reading order using DBSCAN clustering."""
+    df = pd.DataFrame(
+        [[b, t, c] for b, t, c in zip(boxes, texts, confs)],
+        columns=["bbox", "text", "conf"],
+    )
+
+    if mode == "center":
+        df["x"] = df["bbox"].apply(lambda box: (box[0][0] + box[2][0]) / 2)
+        df["y"] = df["bbox"].apply(lambda box: (box[0][1] + box[2][1]) / 2)
+    elif mode == "top_left":
+        df["x"] = df["bbox"].apply(lambda box: box[0][0])
+        df["y"] = df["bbox"].apply(lambda box: box[0][1])
+
+    if dbscan_eps:
+        do_naive_sorting = False
+        try:
+            dbscan = DBSCAN(eps=dbscan_eps, min_samples=1)
+            dbscan.fit(df["y"].values[:, None])
+            df["cluster"] = dbscan.labels_
+            df["cluster_centers"] = df.groupby("cluster")["y"].transform("mean").astype(int)
+            df = df.sort_values(["cluster_centers", "x"], ascending=[True, True], ignore_index=True)
+        except ValueError:
+            do_naive_sorting = True
+    else:
+        do_naive_sorting = True
+
+    if do_naive_sorting:
+        df["y"] = np.round((df["y"] - df["y"].min()) // 5, 0)
+        df = df.sort_values(["y", "x"], ascending=[True, True], ignore_index=True)
+
+    bboxes = df["bbox"].values.tolist()
+    texts = df["text"].values.tolist()
+    confs = df["conf"].values.tolist()
+    return bboxes, texts, confs
+
+
+# ---------------------------------------------------------------------------
+# Adapter functions  (retriever formats → nv-ingest formats)
+# ---------------------------------------------------------------------------
+
+
+def _normalize_ocr_items(preds: Any) -> List[Dict[str, Any]]:
+    """Normalize any OCR output format to ``[{"left", "right", "upper", "lower", "text"}, ...]``.
+
+    Handles both list-of-dict (Nemotron OCR normalized-coord form) and
+    dict with ``boxes``/``texts`` keys (packed form).
+    """
+    items: List[Dict[str, Any]] = []
+
+    if isinstance(preds, list):
+        for item in preds:
+            if not isinstance(item, dict):
+                continue
+            if not all(k in item for k in ("left", "right", "upper", "lower")):
+                continue
+            txt = str(item.get("text") or "").strip()
+            if not txt or txt == "nan":
+                continue
+            items.append(
+                {
+                    "left": float(item["left"]),
+                    "right": float(item["right"]),
+                    "upper": float(item["upper"]),
+                    "lower": float(item["lower"]),
+                    "text": txt,
+                }
+            )
+    elif isinstance(preds, dict):
+        pb = preds.get("boxes") or preds.get("bboxes") or []
+        pt = preds.get("texts") or preds.get("text") or []
+        if isinstance(pb, list) and isinstance(pt, list):
+            for b, txt in zip(pb, pt):
+                if not isinstance(txt, str) or not txt.strip():
+                    continue
+                if isinstance(b, (list, tuple)) and len(b) == 4:
+                    if all(isinstance(p, (list, tuple)) and len(p) == 2 for p in b):
+                        xs = [float(p[0]) for p in b]
+                        ys = [float(p[1]) for p in b]
+                        items.append(
+                            {
+                                "left": min(xs),
+                                "right": max(xs),
+                                "upper": min(ys),
+                                "lower": max(ys),
+                                "text": txt.strip(),
+                            }
+                        )
+                    elif all(isinstance(v, (int, float)) for v in b):
+                        items.append(
+                            {
+                                "left": float(b[0]),
+                                "upper": float(b[1]),
+                                "right": float(b[2]),
+                                "lower": float(b[3]),
+                                "text": txt.strip(),
+                            }
+                        )
+
+    return items
+
+
+def _ocr_items_to_pixel_quad_boxes(
+    ocr_items: List[Dict[str, Any]],
+    crop_hw: Tuple[int, int],
+) -> Tuple[list, list]:
+    """Convert normalized OCR items to pixel-coordinate quadrilateral boxes.
+
+    Returns ``(quad_boxes, texts)`` where *quad_boxes* is a list of
+    ``[[x0,y0],[x1,y1],[x2,y2],[x3,y3]]`` arrays (pixel coords) and
+    *texts* is the corresponding list of strings.
+    """
+    H, W = crop_hw
+    quad_boxes: list = []
+    texts: list = []
+    for item in ocr_items:
+        left = float(item["left"]) * W
+        right = float(item["right"]) * W
+        upper = float(item["upper"]) * H
+        lower = float(item["lower"]) * H
+        quad_boxes.append([[left, upper], [right, upper], [right, lower], [left, lower]])
+        texts.append(item["text"])
+    return quad_boxes, texts
+
+
+def _structure_dets_to_class_boxes(
+    dets: List[Dict[str, Any]],
+    crop_hw: Tuple[int, int],
+) -> Dict[str, np.ndarray]:
+    """Group structure-model detections by label_name and scale to pixel coords.
+
+    Parameters
+    ----------
+    dets : list[dict]
+        Output of ``_prediction_to_detections()`` — each dict has
+        ``bbox_xyxy_norm`` (normalized [0,1]) and ``label_name``.
+    crop_hw : (int, int)
+        ``(H, W)`` of the crop image.
+
+    Returns
+    -------
+    dict[str, ndarray]
+        ``{label_name: array_of_shape_(N, 4)}`` in pixel coordinates.
+    """
+    H, W = crop_hw
+    grouped: Dict[str, list] = {}
+    for d in dets:
+        name = d.get("label_name", "")
+        bbox = d.get("bbox_xyxy_norm")
+        if not bbox or len(bbox) != 4:
+            continue
+        x1, y1, x2, y2 = float(bbox[0]) * W, float(bbox[1]) * H, float(bbox[2]) * W, float(bbox[3]) * H
+        grouped.setdefault(name, []).append([x1, y1, x2, y2])
+
+    return {k: np.array(v) for k, v in grouped.items()}
+
+
+def join_table_structure_and_ocr_output(
+    structure_dets: List[Dict[str, Any]],
+    ocr_preds: Any,
+    crop_hw: Tuple[int, int],
+) -> str:
+    """Adapter: convert retriever table-structure detections + OCR items,
+    then call the core joining function.
+
+    Parameters
+    ----------
+    structure_dets : list[dict]
+        From ``_prediction_to_detections()`` with label_names cell/row/column
+        and ``bbox_xyxy_norm`` in [0, 1].
+    ocr_preds : list | dict
+        Raw OCR output from ``NemotronOCRV1.invoke()``.
+    crop_hw : (int, int)
+        ``(H, W)`` of the crop image.
+    """
+    ocr_items = _normalize_ocr_items(ocr_preds)
+    if not ocr_items:
+        return ""
+
+    class_boxes = _structure_dets_to_class_boxes(structure_dets, crop_hw)
+
+    # Ensure all three required keys exist.
+    cell_preds: Dict[str, np.ndarray] = {
+        "cell": class_boxes.get("cell", np.empty((0, 4))),
+        "row": class_boxes.get("row", np.empty((0, 4))),
+        "column": class_boxes.get("column", np.empty((0, 4))),
+    }
+
+    if cell_preds["cell"].shape[0] == 0:
+        return ""
+
+    quad_boxes, texts = _ocr_items_to_pixel_quad_boxes(ocr_items, crop_hw)
+    return _join_yolox_table_structure_and_ocr_output(cell_preds, quad_boxes, texts)
+
+
+def join_graphic_elements_and_ocr_output(
+    ge_dets: List[Dict[str, Any]],
+    ocr_preds: Any,
+    crop_hw: Tuple[int, int],
+) -> str:
+    """Adapter: convert retriever graphic-elements detections + OCR items,
+    then call the core joining + concatenation functions.
+
+    Parameters
+    ----------
+    ge_dets : list[dict]
+        From ``_prediction_to_detections()`` with chart-element label_names
+        and ``bbox_xyxy_norm`` in [0, 1].
+    ocr_preds : list | dict
+        Raw OCR output from ``NemotronOCRV1.invoke()``.
+    crop_hw : (int, int)
+        ``(H, W)`` of the crop image.
+    """
+    ocr_items = _normalize_ocr_items(ocr_preds)
+    if not ocr_items:
+        return ""
+
+    class_boxes = _structure_dets_to_class_boxes(ge_dets, crop_hw)
+    if not class_boxes:
+        return ""
+
+    # Convert class_boxes values from (N,4) arrays to list-of-arrays (one per detection).
+    yolox_output: Dict[str, list] = {}
+    for k, arr in class_boxes.items():
+        yolox_output[k] = [arr[i] for i in range(arr.shape[0])]
+
+    quad_boxes, texts = _ocr_items_to_pixel_quad_boxes(ocr_items, crop_hw)
+
+    matched = _join_yolox_graphic_elements_and_ocr_output(yolox_output, quad_boxes, texts)
+    if not matched:
+        return ""
+
+    return process_yolox_graphic_elements(matched)
+
+
+def reorder_ocr_for_infographic(
+    ocr_preds: Any,
+    crop_hw: Tuple[int, int],
+) -> str:
+    """Adapter: convert OCR items to pixel-coord quad boxes, reorder in
+    reading order, and return joined text.
+    """
+    ocr_items = _normalize_ocr_items(ocr_preds)
+    if not ocr_items:
+        return ""
+
+    quad_boxes, texts = _ocr_items_to_pixel_quad_boxes(ocr_items, crop_hw)
+    if not quad_boxes:
+        return ""
+
+    confs = [1.0] * len(texts)
+    _, reordered_texts, _ = reorder_boxes(
+        np.array(quad_boxes),
+        texts,
+        confs,
+        mode="top_left",
+        dbscan_eps=10,
+    )
+    return "\n".join(t for t in reordered_texts if t)
diff --git a/nemo_retriever/src/nemo_retriever/utils/__init__.py b/nemo_retriever/src/nemo_retriever/utils/__init__.py
new file mode 100644
index 000000000..43b4d8a60
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Utility command/tooling subpackages for nemo_retriever."""
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/__init__.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/__init__.py
new file mode 100644
index 000000000..6df7baacf
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/__init__.py
@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Benchmark commands for measuring actor-stage throughput.
+"""
+
+from .__main__ import app
+
+__all__ = ["app"]
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/__main__.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/__main__.py
new file mode 100644
index 000000000..2c57619ba
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/__main__.py
@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from . import all_actor, audio_extract_actor, extract_actor, ocr_actor, page_elements_actor, split_actor
+
+app = typer.Typer(help="Actor-stage throughput benchmarks.")
+app.add_typer(split_actor.app, name="split")
+app.add_typer(extract_actor.app, name="extract")
+app.add_typer(audio_extract_actor.app, name="audio-extract")
+app.add_typer(page_elements_actor.app, name="page-elements")
+app.add_typer(ocr_actor.app, name="ocr")
+app.add_typer(all_actor.app, name="all")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/all_actor.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/all_actor.py
new file mode 100644
index 000000000..d67a56286
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/all_actor.py
@@ -0,0 +1,106 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from . import extract_actor, ocr_actor, page_elements_actor, split_actor
+
+app = typer.Typer(help="Run all actor-stage benchmarks in sequence.")
+
+
+@app.command("run")
+def run(
+    pdf_path: Path = typer.Option(..., "--pdf-path", exists=True, dir_okay=False, file_okay=True, help="Input PDF."),
+    rows_split: int = typer.Option(256, "--rows-split", min=1, help="Synthetic rows per split benchmark trial."),
+    rows_extract: int = typer.Option(256, "--rows-extract", min=1, help="Synthetic rows per extract benchmark trial."),
+    rows_page_elements: int = typer.Option(
+        256, "--rows-page-elements", min=1, help="Synthetic rows per page-elements benchmark trial."
+    ),
+    rows_ocr: int = typer.Option(128, "--rows-ocr", min=1, help="Synthetic rows per OCR benchmark trial."),
+    workers: str = typer.Option("1,2", "--workers", help="Comma-separated worker counts used by all stages."),
+    batch_sizes: str = typer.Option("1,2,4,8", "--batch-sizes", help="Comma-separated batch sizes used by all stages."),
+    dpi: int = typer.Option(200, "--dpi", min=72, help="Seed extraction DPI for extraction/detection/OCR stages."),
+    inference_batch_size: int = typer.Option(
+        8, "--inference-batch-size", min=1, help="Internal model inference batch size for page-elements stage."
+    ),
+    num_gpus: float = typer.Option(1.0, "--num-gpus", min=0.0, help="GPUs reserved per page-elements/OCR actor."),
+    num_cpus: float = typer.Option(1.0, "--num-cpus", min=0.0, help="CPUs reserved per page-elements/OCR actor."),
+    extract_tables: bool = typer.Option(True, "--extract-tables/--no-extract-tables", help="OCR table detections."),
+    extract_charts: bool = typer.Option(False, "--extract-charts/--no-extract-charts", help="OCR chart detections."),
+    extract_infographics: bool = typer.Option(
+        False, "--extract-infographics/--no-extract-infographics", help="OCR infographic detections."
+    ),
+    ray_address: Optional[str] = typer.Option(None, "--ray-address", help="Ray address (default local)."),
+    output_dir: Optional[Path] = typer.Option(
+        None, "--output-dir", help="Optional directory for per-stage JSON benchmark summaries."
+    ),
+) -> None:
+    output_dir_resolved = output_dir.expanduser().resolve() if output_dir is not None else None
+    if output_dir_resolved is not None:
+        output_dir_resolved.mkdir(parents=True, exist_ok=True)
+
+    split_json = (output_dir_resolved / "split.json") if output_dir_resolved is not None else None
+    extract_json = (output_dir_resolved / "extract.json") if output_dir_resolved is not None else None
+    page_elements_json = (output_dir_resolved / "page_elements.json") if output_dir_resolved is not None else None
+    ocr_json = (output_dir_resolved / "ocr.json") if output_dir_resolved is not None else None
+
+    typer.echo("=== benchmark: split ===")
+    split_actor.run(
+        pdf_path=pdf_path,
+        rows=int(rows_split),
+        workers=workers,
+        batch_sizes=batch_sizes,
+        ray_address=ray_address,
+        output_json=split_json,
+    )
+
+    typer.echo("=== benchmark: extract ===")
+    extract_actor.run(
+        pdf_path=pdf_path,
+        rows=int(rows_extract),
+        workers=workers,
+        batch_sizes=batch_sizes,
+        dpi=int(dpi),
+        extract_text=True,
+        extract_page_as_image=True,
+        ray_address=ray_address,
+        output_json=extract_json,
+    )
+
+    typer.echo("=== benchmark: page-elements ===")
+    page_elements_actor.run(
+        pdf_path=pdf_path,
+        rows=int(rows_page_elements),
+        workers=workers,
+        batch_sizes=batch_sizes,
+        inference_batch_size=int(inference_batch_size),
+        num_gpus=float(num_gpus),
+        num_cpus=float(num_cpus),
+        dpi=int(dpi),
+        ray_address=ray_address,
+        output_json=page_elements_json,
+    )
+
+    typer.echo("=== benchmark: ocr ===")
+    ocr_actor.run(
+        pdf_path=pdf_path,
+        rows=int(rows_ocr),
+        workers=workers,
+        batch_sizes=batch_sizes,
+        extract_tables=bool(extract_tables),
+        extract_charts=bool(extract_charts),
+        extract_infographics=bool(extract_infographics),
+        num_gpus=float(num_gpus),
+        num_cpus=float(num_cpus),
+        dpi=int(dpi),
+        ray_address=ray_address,
+        output_json=ocr_json,
+    )
+
+    typer.echo("Completed all benchmark stages.")
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/audio_extract_actor.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/audio_extract_actor.py
new file mode 100644
index 000000000..748a00975
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/audio_extract_actor.py
@@ -0,0 +1,164 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Benchmark MediaChunkActor + ASRActor throughput (chunk rows per second).
+
+Supports --mock-asr to avoid loading Parakeet/GPU; measures chunking + actor overhead.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import pandas as pd
+import ray.data as rd
+import typer
+
+from nemo_retriever.audio.asr_actor import ASRActor
+from nemo_retriever.audio.asr_actor import asr_params_from_env
+from nemo_retriever.audio.chunk_actor import MediaChunkActor
+from nemo_retriever.audio.media_interface import is_media_available
+from nemo_retriever.params import AudioChunkParams
+
+from .common import (
+    benchmark_sweep,
+    maybe_init_ray,
+    maybe_write_results_json,
+    parse_csv_ints,
+)
+
+
+def make_seed_audio_row(audio_path: Path) -> Dict[str, Any]:
+    """One row per source file (path only); MediaChunkActor will read and chunk."""
+    p = audio_path.expanduser().resolve()
+    if not p.is_file():
+        raise typer.BadParameter(f"Audio path does not exist: {p}")
+    return {"path": str(p)}
+
+
+class MockASRActor:
+    """Returns fixed transcript per chunk row so benchmark runs without Parakeet/GPU."""
+
+    def __call__(self, batch_df: pd.DataFrame) -> pd.DataFrame:
+        if not isinstance(batch_df, pd.DataFrame) or batch_df.empty:
+            return pd.DataFrame(
+                columns=["path", "source_path", "duration", "chunk_index", "metadata", "page_number", "text"]
+            )
+        out = batch_df.drop(columns=["bytes"], errors="ignore").copy()
+        out["text"] = "mock transcript"
+        return out
+
+
+app = typer.Typer(help="Benchmark audio extraction (MediaChunkActor + ASRActor) throughput (chunk rows/sec).")
+
+
+@app.command("run")
+def run(
+    audio_path: Path = typer.Option(
+        ...,
+        "--audio-path",
+        exists=True,
+        dir_okay=False,
+        file_okay=True,
+        help="Input audio file (e.g. WAV, MP3).",
+    ),
+    rows: int = typer.Option(
+        16,
+        "--rows",
+        min=1,
+        help="Number of source-file rows to replicate for each trial.",
+    ),
+    workers: str = typer.Option(
+        "1,2",
+        "--workers",
+        help="Comma-separated worker counts to try.",
+    ),
+    batch_sizes: str = typer.Option(
+        "2,4,8",
+        "--batch-sizes",
+        help="Comma-separated Ray batch sizes to try.",
+    ),
+    mock_asr: bool = typer.Option(
+        True,
+        "--mock-asr/--no-mock-asr",
+        help="Use mock ASR (no GPU/Parakeet); when False, uses local or remote ASR from env.",
+    ),
+    split_type: str = typer.Option(
+        "size",
+        "--split-type",
+        help="Chunk split type: size, time, or frame.",
+    ),
+    split_interval: int = typer.Option(
+        450,
+        "--split-interval",
+        min=1,
+        help="Chunk split interval (bytes/seconds/frames).",
+    ),
+    ray_address: Optional[str] = typer.Option(
+        None,
+        "--ray-address",
+        help="Ray address (default local).",
+    ),
+    output_json: Optional[Path] = typer.Option(
+        None,
+        "--output-json",
+        help="Optional output JSON summary path.",
+    ),
+) -> None:
+    if not is_media_available():
+        raise typer.BadParameter("Audio benchmark requires ffmpeg on PATH.")
+
+    if split_type not in ("size", "time", "frame"):
+        raise typer.BadParameter("--split-type must be one of: size, time, frame")
+
+    maybe_init_ray(ray_address)
+    worker_grid = parse_csv_ints(workers, name="workers")
+    batch_grid = parse_csv_ints(batch_sizes, name="batch_sizes")
+    seed_row = make_seed_audio_row(audio_path)
+
+    chunk_params = AudioChunkParams(
+        split_type=split_type,
+        split_interval=split_interval,
+    )
+
+    def _map(ds: rd.Dataset, worker_count: int, batch_size: int) -> rd.Dataset:
+        chunk_actor = MediaChunkActor(params=chunk_params)
+        if mock_asr:
+            asr_actor = MockASRActor()
+        else:
+            asr_actor = ASRActor(params=asr_params_from_env())
+
+        ds = ds.map_batches(
+            chunk_actor,
+            batch_size=int(batch_size),
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+            compute=rd.TaskPoolStrategy(size=int(worker_count)),
+        )
+        ds = ds.map_batches(
+            asr_actor,
+            batch_size=int(batch_size),
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0.25 if not mock_asr else 0,
+            compute=rd.TaskPoolStrategy(size=int(worker_count)),
+        )
+        return ds
+
+    best, results = benchmark_sweep(
+        stage_name="audio_extract",
+        seed_row=seed_row,
+        rows=int(rows),
+        workers=worker_grid,
+        batch_sizes=batch_grid,
+        map_builder=_map,
+    )
+    typer.echo(
+        f"BEST audio_extract: workers={best.workers} batch_size={best.batch_size} "
+        f"chunk_rows={best.rows} elapsed={best.elapsed_seconds:.3f}s rows_per_second={best.rows_per_second:.2f}"
+    )
+    maybe_write_results_json(output_json, best=best, results=results)
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/common.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/common.py
new file mode 100644
index 000000000..d088f8ace
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/common.py
@@ -0,0 +1,206 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
+
+import pandas as pd
+import ray
+import ray.data as rd
+import typer
+
+from nemo_retriever.pdf.extract import PDFExtractionActor
+from nemo_retriever.pdf.split import split_pdf_batch
+
+
+@dataclass(frozen=True)
+class ThroughputResult:
+    workers: int
+    batch_size: int
+    rows: int
+    elapsed_seconds: float
+    rows_per_second: float
+
+
+def parse_csv_ints(value: str, *, name: str) -> List[int]:
+    out: List[int] = []
+    for part in str(value or "").split(","):
+        token = part.strip()
+        if not token:
+            continue
+        try:
+            n = int(token)
+        except ValueError as e:
+            raise typer.BadParameter(f"{name} must be a comma-separated list of ints, got {value!r}") from e
+        if n <= 0:
+            raise typer.BadParameter(f"{name} entries must be > 0, got {n}")
+        out.append(n)
+    if not out:
+        raise typer.BadParameter(f"{name} cannot be empty")
+    return sorted(set(out))
+
+
+def maybe_init_ray(ray_address: Optional[str]) -> None:
+    if not ray.is_initialized():
+        ray.init(address=ray_address or "local", ignore_reinit_error=True)
+
+
+def read_pdf_bytes(pdf_path: Path) -> bytes:
+    p = pdf_path.expanduser().resolve()
+    if not p.is_file():
+        raise typer.BadParameter(f"PDF path does not exist: {p}")
+    return p.read_bytes()
+
+
+def make_seed_split_row(pdf_path: Path) -> Dict[str, Any]:
+    pdf_bytes = read_pdf_bytes(pdf_path)
+    return {"path": str(pdf_path.expanduser().resolve()), "bytes": pdf_bytes}
+
+
+def make_seed_extraction_row(pdf_path: Path) -> Dict[str, Any]:
+    split_df = split_pdf_batch(pd.DataFrame([make_seed_split_row(pdf_path)]))
+    if split_df.empty:
+        raise RuntimeError("PDF split returned no rows; cannot benchmark extraction stage.")
+    row = split_df.iloc[0].to_dict()
+    return row
+
+
+def make_seed_page_elements_row(pdf_path: Path, *, dpi: int) -> Dict[str, Any]:
+    extract_row = make_seed_extraction_row(pdf_path)
+    extraction_actor = PDFExtractionActor(
+        extract_text=True,
+        # Force raster generation for seed rows. The extractor currently renders
+        # images when one of these feature flags is enabled.
+        extract_images=True,
+        extract_tables=False,
+        extract_charts=False,
+        extract_infographics=False,
+        extract_page_as_image=True,
+        dpi=int(dpi),
+    )
+    extracted_df = extraction_actor(pd.DataFrame([extract_row]))
+    if extracted_df is None or extracted_df.empty:
+        raise RuntimeError("PDF extraction seed generation returned no rows.")
+    out = extracted_df.iloc[0].to_dict()
+    page_image = out.get("page_image") if isinstance(out, dict) else None
+    if not (
+        isinstance(page_image, dict) and isinstance(page_image.get("image_b64"), str) and page_image.get("image_b64")
+    ):
+        raise RuntimeError("Seed extraction row does not contain page_image.image_b64.")
+    return out
+
+
+def with_fake_detections(
+    row: Dict[str, Any],
+    *,
+    extract_tables: bool,
+    extract_charts: bool,
+    extract_infographics: bool,
+) -> Dict[str, Any]:
+    labels: List[str] = []
+    if extract_tables:
+        labels.append("table")
+    if extract_charts:
+        labels.append("chart")
+    if extract_infographics:
+        labels.append("infographic")
+    if not labels:
+        labels.append("table")
+
+    detections: List[Dict[str, Any]] = []
+    x1 = 0.05
+    y1 = 0.05
+    width = 0.6
+    height = 0.25
+    for idx, label in enumerate(labels):
+        top = min(0.7, y1 + idx * 0.28)
+        det = {
+            "bbox_xyxy_norm": [x1, top, min(0.98, x1 + width), min(0.98, top + height)],
+            "label": idx,
+            "label_name": label,
+            "score": 0.99,
+        }
+        detections.append(det)
+
+    out = dict(row)
+    out["page_elements_v3"] = {"detections": detections, "timing": {"seconds": 0.0}, "error": None}
+    out["page_elements_v3_num_detections"] = len(detections)
+    out["page_elements_v3_counts_by_label"] = {d["label_name"]: 1 for d in detections}
+    return out
+
+
+def benchmark_sweep(
+    *,
+    stage_name: str,
+    seed_row: Dict[str, Any],
+    rows: int,
+    workers: Sequence[int],
+    batch_sizes: Sequence[int],
+    map_builder: Callable[[rd.Dataset, int, int], rd.Dataset],
+) -> Tuple[ThroughputResult, List[ThroughputResult]]:
+    all_results: List[ThroughputResult] = []
+    best: Optional[ThroughputResult] = None
+
+    base_items = [dict(seed_row) for _ in range(int(rows))]
+    for worker_count in workers:
+        for batch_size in batch_sizes:
+            ds = rd.from_items(base_items)
+            mapped = map_builder(ds, int(worker_count), int(batch_size))
+            t0 = time.perf_counter()
+            count = int(mapped.count())
+            elapsed = max(time.perf_counter() - t0, 1e-9)
+            rows_per_second = float(count) / elapsed
+            result = ThroughputResult(
+                workers=int(worker_count),
+                batch_size=int(batch_size),
+                rows=count,
+                elapsed_seconds=float(elapsed),
+                rows_per_second=float(rows_per_second),
+            )
+            all_results.append(result)
+            typer.echo(
+                f"[{stage_name}] workers={result.workers} batch_size={result.batch_size} "
+                f"rows={result.rows} elapsed={result.elapsed_seconds:.3f}s rps={result.rows_per_second:.2f}"
+            )
+            if best is None or result.rows_per_second > best.rows_per_second:
+                best = result
+
+    if best is None:
+        raise RuntimeError(f"No benchmark results were produced for stage {stage_name}")
+    return best, all_results
+
+
+def maybe_write_results_json(
+    path: Optional[Path], *, best: ThroughputResult, results: Sequence[ThroughputResult]
+) -> None:
+    if path is None:
+        return
+    payload = {
+        "best": {
+            "workers": best.workers,
+            "batch_size": best.batch_size,
+            "rows": best.rows,
+            "elapsed_seconds": best.elapsed_seconds,
+            "rows_per_second": best.rows_per_second,
+        },
+        "results": [
+            {
+                "workers": r.workers,
+                "batch_size": r.batch_size,
+                "rows": r.rows,
+                "elapsed_seconds": r.elapsed_seconds,
+                "rows_per_second": r.rows_per_second,
+            }
+            for r in results
+        ],
+    }
+    out = path.expanduser().resolve()
+    out.parent.mkdir(parents=True, exist_ok=True)
+    out.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    typer.echo(f"Wrote results JSON to {out}")
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/extract_actor.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/extract_actor.py
new file mode 100644
index 000000000..43aedc8e6
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/extract_actor.py
@@ -0,0 +1,75 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import ray.data as rd
+import typer
+
+from nemo_retriever.pdf.extract import PDFExtractionActor
+
+from .common import (
+    benchmark_sweep,
+    make_seed_extraction_row,
+    maybe_init_ray,
+    maybe_write_results_json,
+    parse_csv_ints,
+)
+
+app = typer.Typer(help="Benchmark `PDFExtractionActor` throughput (rows/sec).")
+
+
+@app.command("run")
+def run(
+    pdf_path: Path = typer.Option(..., "--pdf-path", exists=True, dir_okay=False, file_okay=True, help="Input PDF."),
+    rows: int = typer.Option(256, "--rows", min=1, help="How many page rows to synthesize for each benchmark trial."),
+    workers: str = typer.Option("1,2,4", "--workers", help="Comma-separated worker counts to try."),
+    batch_sizes: str = typer.Option("1,2,4,8,16", "--batch-sizes", help="Comma-separated Ray batch sizes to try."),
+    dpi: int = typer.Option(200, "--dpi", min=72, help="Render DPI for page image extraction."),
+    extract_text: bool = typer.Option(True, "--extract-text/--no-extract-text", help="Enable text extraction."),
+    extract_page_as_image: bool = typer.Option(
+        True, "--extract-page-as-image/--no-extract-page-as-image", help="Emit page image payload."
+    ),
+    ray_address: Optional[str] = typer.Option(None, "--ray-address", help="Ray address (default local)."),
+    output_json: Optional[Path] = typer.Option(None, "--output-json", help="Optional output JSON summary path."),
+) -> None:
+    maybe_init_ray(ray_address)
+    worker_grid = parse_csv_ints(workers, name="workers")
+    batch_grid = parse_csv_ints(batch_sizes, name="batch_sizes")
+    seed_row = make_seed_extraction_row(pdf_path)
+
+    def _map(ds: rd.Dataset, worker_count: int, batch_size: int) -> rd.Dataset:
+        actor = PDFExtractionActor(
+            extract_text=bool(extract_text),
+            extract_tables=False,
+            extract_charts=False,
+            extract_infographics=False,
+            extract_page_as_image=bool(extract_page_as_image),
+            dpi=int(dpi),
+        )
+        return ds.map_batches(
+            actor,
+            batch_size=int(batch_size),
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+            compute=rd.TaskPoolStrategy(size=int(worker_count)),
+        )
+
+    best, results = benchmark_sweep(
+        stage_name="pdf_extract",
+        seed_row=seed_row,
+        rows=int(rows),
+        workers=worker_grid,
+        batch_sizes=batch_grid,
+        map_builder=_map,
+    )
+    typer.echo(
+        f"BEST pdf_extract: workers={best.workers} batch_size={best.batch_size} "
+        f"rows={best.rows} elapsed={best.elapsed_seconds:.3f}s rows_per_second={best.rows_per_second:.2f}"
+    )
+    maybe_write_results_json(output_json, best=best, results=results)
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/ocr_actor.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/ocr_actor.py
new file mode 100644
index 000000000..52e7ad579
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/ocr_actor.py
@@ -0,0 +1,82 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import ray.data as rd
+import typer
+
+from nemo_retriever.ocr import OCRActor
+
+from .common import (
+    benchmark_sweep,
+    make_seed_page_elements_row,
+    maybe_init_ray,
+    maybe_write_results_json,
+    parse_csv_ints,
+    with_fake_detections,
+)
+
+app = typer.Typer(help="Benchmark `OCRActor` throughput (rows/sec).")
+
+
+@app.command("run")
+def run(
+    pdf_path: Path = typer.Option(..., "--pdf-path", exists=True, dir_okay=False, file_okay=True, help="Input PDF."),
+    rows: int = typer.Option(128, "--rows", min=1, help="How many page rows to benchmark per trial."),
+    workers: str = typer.Option("1,2", "--workers", help="Comma-separated actor counts to try."),
+    batch_sizes: str = typer.Option("1,2,4,8", "--batch-sizes", help="Comma-separated Ray batch sizes to try."),
+    extract_tables: bool = typer.Option(True, "--extract-tables/--no-extract-tables", help="OCR table detections."),
+    extract_charts: bool = typer.Option(False, "--extract-charts/--no-extract-charts", help="OCR chart detections."),
+    extract_infographics: bool = typer.Option(
+        False, "--extract-infographics/--no-extract-infographics", help="OCR infographic detections."
+    ),
+    num_gpus: float = typer.Option(1.0, "--num-gpus", min=0.0, help="GPUs reserved per actor."),
+    num_cpus: float = typer.Option(1.0, "--num-cpus", min=0.0, help="CPUs reserved per actor."),
+    dpi: int = typer.Option(200, "--dpi", min=72, help="Seed extraction DPI."),
+    ray_address: Optional[str] = typer.Option(None, "--ray-address", help="Ray address (default local)."),
+    output_json: Optional[Path] = typer.Option(None, "--output-json", help="Optional output JSON summary path."),
+) -> None:
+    maybe_init_ray(ray_address)
+    worker_grid = parse_csv_ints(workers, name="workers")
+    batch_grid = parse_csv_ints(batch_sizes, name="batch_sizes")
+    base_row = make_seed_page_elements_row(pdf_path, dpi=int(dpi))
+    seed_row = with_fake_detections(
+        base_row,
+        extract_tables=bool(extract_tables),
+        extract_charts=bool(extract_charts),
+        extract_infographics=bool(extract_infographics),
+    )
+
+    def _map(ds: rd.Dataset, worker_count: int, batch_size: int) -> rd.Dataset:
+        return ds.map_batches(
+            OCRActor,
+            batch_size=int(batch_size),
+            batch_format="pandas",
+            num_cpus=float(num_cpus),
+            num_gpus=float(num_gpus),
+            compute=rd.ActorPoolStrategy(size=int(worker_count)),
+            fn_constructor_kwargs={
+                "extract_tables": bool(extract_tables),
+                "extract_charts": bool(extract_charts),
+                "extract_infographics": bool(extract_infographics),
+            },
+        )
+
+    best, results = benchmark_sweep(
+        stage_name="ocr",
+        seed_row=seed_row,
+        rows=int(rows),
+        workers=worker_grid,
+        batch_sizes=batch_grid,
+        map_builder=_map,
+    )
+    typer.echo(
+        f"BEST ocr: workers={best.workers} batch_size={best.batch_size} "
+        f"rows={best.rows} elapsed={best.elapsed_seconds:.3f}s rows_per_second={best.rows_per_second:.2f}"
+    )
+    maybe_write_results_json(output_json, best=best, results=results)
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/page_elements_actor.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/page_elements_actor.py
new file mode 100644
index 000000000..56f17d6dc
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/page_elements_actor.py
@@ -0,0 +1,69 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import ray.data as rd
+import typer
+
+from nemo_retriever.page_elements import PageElementDetectionActor
+
+from .common import (
+    benchmark_sweep,
+    make_seed_page_elements_row,
+    maybe_init_ray,
+    maybe_write_results_json,
+    parse_csv_ints,
+)
+
+app = typer.Typer(help="Benchmark `PageElementDetectionActor` throughput (rows/sec).")
+
+
+@app.command("run")
+def run(
+    pdf_path: Path = typer.Option(..., "--pdf-path", exists=True, dir_okay=False, file_okay=True, help="Input PDF."),
+    rows: int = typer.Option(256, "--rows", min=1, help="How many page rows to benchmark per trial."),
+    workers: str = typer.Option("1,2", "--workers", help="Comma-separated actor counts to try."),
+    batch_sizes: str = typer.Option("1,2,4,8,16", "--batch-sizes", help="Comma-separated Ray batch sizes to try."),
+    inference_batch_size: int = typer.Option(
+        8, "--inference-batch-size", min=1, help="Internal model inference batch size inside the actor."
+    ),
+    num_gpus: float = typer.Option(1.0, "--num-gpus", min=0.0, help="GPUs reserved per actor."),
+    num_cpus: float = typer.Option(1.0, "--num-cpus", min=0.0, help="CPUs reserved per actor."),
+    dpi: int = typer.Option(200, "--dpi", min=72, help="Seed extraction DPI."),
+    ray_address: Optional[str] = typer.Option(None, "--ray-address", help="Ray address (default local)."),
+    output_json: Optional[Path] = typer.Option(None, "--output-json", help="Optional output JSON summary path."),
+) -> None:
+    maybe_init_ray(ray_address)
+    worker_grid = parse_csv_ints(workers, name="workers")
+    batch_grid = parse_csv_ints(batch_sizes, name="batch_sizes")
+    seed_row = make_seed_page_elements_row(pdf_path, dpi=int(dpi))
+
+    def _map(ds: rd.Dataset, worker_count: int, batch_size: int) -> rd.Dataset:
+        return ds.map_batches(
+            PageElementDetectionActor,
+            batch_size=int(batch_size),
+            batch_format="pandas",
+            num_cpus=float(num_cpus),
+            num_gpus=float(num_gpus),
+            compute=rd.ActorPoolStrategy(size=int(worker_count)),
+            fn_constructor_kwargs={"inference_batch_size": int(inference_batch_size)},
+        )
+
+    best, results = benchmark_sweep(
+        stage_name="page_elements",
+        seed_row=seed_row,
+        rows=int(rows),
+        workers=worker_grid,
+        batch_sizes=batch_grid,
+        map_builder=_map,
+    )
+    typer.echo(
+        f"BEST page_elements: workers={best.workers} batch_size={best.batch_size} "
+        f"rows={best.rows} elapsed={best.elapsed_seconds:.3f}s rows_per_second={best.rows_per_second:.2f}"
+    )
+    maybe_write_results_json(output_json, best=best, results=results)
diff --git a/nemo_retriever/src/nemo_retriever/utils/benchmark/split_actor.py b/nemo_retriever/src/nemo_retriever/utils/benchmark/split_actor.py
new file mode 100644
index 000000000..d06dce5d3
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/benchmark/split_actor.py
@@ -0,0 +1,65 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import ray.data as rd
+import typer
+
+from nemo_retriever.pdf.split import PDFSplitActor
+
+from .common import (
+    benchmark_sweep,
+    make_seed_split_row,
+    maybe_init_ray,
+    maybe_write_results_json,
+    parse_csv_ints,
+)
+
+app = typer.Typer(help="Benchmark `PDFSplitActor` throughput (rows/sec).")
+
+
+@app.command("run")
+def run(
+    pdf_path: Path = typer.Option(..., "--pdf-path", exists=True, dir_okay=False, file_okay=True, help="Input PDF."),
+    rows: int = typer.Option(
+        256, "--rows", min=1, help="How many input rows to synthesize from the seed PDF for each benchmark trial."
+    ),
+    workers: str = typer.Option("1,2,4", "--workers", help="Comma-separated worker counts to try."),
+    batch_sizes: str = typer.Option("1,2,4,8,16", "--batch-sizes", help="Comma-separated Ray batch sizes to try."),
+    ray_address: Optional[str] = typer.Option(None, "--ray-address", help="Ray address (default local)."),
+    output_json: Optional[Path] = typer.Option(None, "--output-json", help="Optional output JSON summary path."),
+) -> None:
+    maybe_init_ray(ray_address)
+    worker_grid = parse_csv_ints(workers, name="workers")
+    batch_grid = parse_csv_ints(batch_sizes, name="batch_sizes")
+    seed_row = make_seed_split_row(pdf_path)
+
+    def _map(ds: rd.Dataset, worker_count: int, batch_size: int) -> rd.Dataset:
+        return ds.map_batches(
+            PDFSplitActor(),
+            batch_size=int(batch_size),
+            batch_format="pandas",
+            num_cpus=1,
+            num_gpus=0,
+            compute=rd.TaskPoolStrategy(size=int(worker_count)),
+        )
+
+    best, results = benchmark_sweep(
+        stage_name="pdf_split",
+        seed_row=seed_row,
+        rows=int(rows),
+        workers=worker_grid,
+        batch_sizes=batch_grid,
+        map_builder=_map,
+    )
+
+    typer.echo(
+        f"BEST pdf_split: workers={best.workers} batch_size={best.batch_size} "
+        f"rows={best.rows} elapsed={best.elapsed_seconds:.3f}s rows_per_second={best.rows_per_second:.2f}"
+    )
+    maybe_write_results_json(output_json, best=best, results=results)
diff --git a/nemo_retriever/src/nemo_retriever/utils/compare/__init__.py b/nemo_retriever/src/nemo_retriever/utils/compare/__init__.py
new file mode 100644
index 000000000..e3e0a0fac
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/compare/__init__.py
@@ -0,0 +1,11 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Comparison utilities for inspecting differences between pipeline outputs.
+"""
+
+from .__main__ import app
+
+__all__ = ["app"]
diff --git a/nemo_retriever/src/nemo_retriever/utils/compare/__main__.py b/nemo_retriever/src/nemo_retriever/utils/compare/__main__.py
new file mode 100644
index 000000000..594a5ee6e
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/compare/__main__.py
@@ -0,0 +1,18 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from . import compare_json
+from . import compare_results
+
+app = typer.Typer(help="Comparison utilities")
+app.add_typer(compare_json.app, name="json")
+app.add_typer(compare_results.app, name="results")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/utils/compare/compare_json.py b/nemo_retriever/src/nemo_retriever/utils/compare/compare_json.py
new file mode 100644
index 000000000..d09c2220b
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/compare/compare_json.py
@@ -0,0 +1,321 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+from pathlib import Path
+from typing import Any
+
+import typer
+from rich import box
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+
+app = typer.Typer(
+    no_args_is_help=True,
+    help="Compare two JSON files and render a side-by-side diff.",
+)
+
+
+@dataclass(frozen=True)
+class _DiffRow:
+    marker: str  # " " | "~" | "-" | "+"
+    a_idx: int | None
+    b_idx: int | None
+    a_line: str
+    b_line: str
+
+
+def _load_json(path: Path) -> Any:
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            return json.load(f)
+    except json.JSONDecodeError as e:
+        # Surface as a CLI error rather than a stack trace.
+        raise typer.BadParameter(f"Invalid JSON in '{path}': {e.msg} (line {e.lineno}, column {e.colno})") from e
+
+
+def _to_pretty_lines(obj: Any, *, sort_keys: bool) -> list[str]:
+    # Stable formatting is important for meaningful diffs.
+    rendered = json.dumps(obj, indent=2, sort_keys=sort_keys, ensure_ascii=False)
+    return rendered.splitlines()
+
+
+def _strip_ignored_fields(obj: Any, *, ignore_fields: set[str], ignore_case: bool) -> Any:
+    """
+    Remove dict keys matching `ignore_fields` at any depth.
+
+    This is a simple (field-name based) filter intended to hide expected-to-differ
+    metadata like timestamps, runtimes, UUIDs, etc.
+    """
+    if not ignore_fields:
+        return obj
+
+    if isinstance(obj, dict):
+        out: dict[str, Any] = {}
+        for k, v in obj.items():
+            k_norm = k.lower() if ignore_case and isinstance(k, str) else k
+            if isinstance(k_norm, str) and k_norm in ignore_fields:
+                continue
+            out[k] = _strip_ignored_fields(v, ignore_fields=ignore_fields, ignore_case=ignore_case)
+        return out
+
+    if isinstance(obj, list):
+        return [_strip_ignored_fields(v, ignore_fields=ignore_fields, ignore_case=ignore_case) for v in obj]
+
+    return obj
+
+
+def _iter_rows(a_lines: list[str], b_lines: list[str]) -> tuple[list[_DiffRow], dict[str, int]]:
+    sm = SequenceMatcher(a=a_lines, b=b_lines, autojunk=False)
+    rows: list[_DiffRow] = []
+    stats = {"equal": 0, "replace": 0, "delete": 0, "insert": 0}
+
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        stats[tag] = stats.get(tag, 0) + (
+            max(i2 - i1, j2 - j1) if tag == "replace" else (i2 - i1) if tag in {"equal", "delete"} else (j2 - j1)
+        )
+
+        if tag == "equal":
+            for k in range(i2 - i1):
+                ai = i1 + k
+                bj = j1 + k
+                rows.append(_DiffRow(" ", ai, bj, a_lines[ai], b_lines[bj]))
+        elif tag == "replace":
+            n = max(i2 - i1, j2 - j1)
+            for k in range(n):
+                ai = i1 + k
+                bj = j1 + k
+                a_idx = ai if ai < i2 else None
+                b_idx = bj if bj < j2 else None
+                rows.append(
+                    _DiffRow(
+                        "~",
+                        a_idx,
+                        b_idx,
+                        a_lines[a_idx] if a_idx is not None else "",
+                        b_lines[b_idx] if b_idx is not None else "",
+                    )
+                )
+        elif tag == "delete":
+            for ai in range(i1, i2):
+                rows.append(_DiffRow("-", ai, None, a_lines[ai], ""))
+        elif tag == "insert":
+            for bj in range(j1, j2):
+                rows.append(_DiffRow("+", None, bj, "", b_lines[bj]))
+        else:  # pragma: no cover
+            raise RuntimeError(f"Unexpected diff opcode tag: {tag}")
+
+    return rows, stats
+
+
+def _collapse_equal_rows(rows: list[_DiffRow], *, context: int) -> list[_DiffRow | None]:
+    """
+    Return a list of rows where long equal runs are replaced with `None` sentinels.
+    The rendering step will convert `None` gaps into a single "unchanged" row.
+    """
+    if context < 0:
+        context = 0
+
+    diff_idxs = [i for i, r in enumerate(rows) if r.marker != " "]
+    if not diff_idxs:
+        return [*rows]
+
+    keep = [False] * len(rows)
+    for i in diff_idxs:
+        start = max(0, i - context)
+        end = min(len(rows), i + context + 1)
+        for j in range(start, end):
+            keep[j] = True
+
+    collapsed: list[_DiffRow | None] = []
+    in_gap = False
+    for i, r in enumerate(rows):
+        if keep[i]:
+            collapsed.append(r)
+            in_gap = False
+        else:
+            if not in_gap:
+                collapsed.append(None)
+                in_gap = True
+    return collapsed
+
+
+def _styled_line(idx: int | None, line: str, *, style: str) -> Text:
+    if idx is None:
+        prefix = "     │ "
+    else:
+        prefix = f"{idx + 1:>5}│ "
+    t = Text(prefix + line)
+    if style:
+        t.stylize(style)
+    return t
+
+
+def _marker_style(marker: str) -> tuple[str, str]:
+    if marker == " ":
+        return " ", "dim"
+    if marker == "~":
+        return "~", "yellow"
+    if marker == "-":
+        return "-", "red"
+    if marker == "+":
+        return "+", "green"
+    return marker, ""
+
+
+def _render_side_by_side(
+    *,
+    a_path: Path,
+    b_path: Path,
+    rows: list[_DiffRow],
+    context: int,
+    show_all: bool,
+    max_rows: int,
+    no_color: bool,
+) -> None:
+    console = Console(color_system=None if no_color else "auto")
+
+    if show_all:
+        display_rows: list[_DiffRow | None] = [*rows]
+    else:
+        display_rows = _collapse_equal_rows(rows, context=context)
+
+    table = Table(
+        box=box.SIMPLE_HEAVY,
+        show_header=True,
+        header_style="bold",
+        pad_edge=False,
+        collapse_padding=True,
+    )
+    table.add_column("", no_wrap=True, width=1)
+    table.add_column(f"A: {a_path}", overflow="fold", ratio=1)
+    table.add_column(f"B: {b_path}", overflow="fold", ratio=1)
+
+    rendered = 0
+    gap_size = 0
+
+    def flush_gap() -> None:
+        nonlocal gap_size, rendered
+        if gap_size <= 0:
+            return
+        msg = Text(f"... {gap_size} unchanged line(s) ...", style="dim")
+        table.add_row(Text("…", style="dim"), msg, msg)
+        rendered += 1
+        gap_size = 0
+
+    for r in display_rows:
+        if max_rows > 0 and rendered >= max_rows:
+            flush_gap()
+            msg = Text(f"... truncated after {max_rows} row(s) ...", style="bold red")
+            table.add_row(Text("!", style="bold red"), msg, msg)
+            break
+
+        if r is None:
+            gap_size += 1
+            continue
+
+        flush_gap()
+        m, m_style = _marker_style(r.marker)
+        a_style = "dim" if r.marker == " " else ("yellow" if r.marker == "~" else ("red" if r.marker == "-" else ""))
+        b_style = (
+            "dim"
+            if r.marker == " "
+            else ("yellow" if r.marker == "~" else ("" if r.marker == "-" else "green" if r.marker == "+" else ""))
+        )
+
+        table.add_row(
+            Text(m, style=m_style),
+            _styled_line(r.a_idx, r.a_line, style=a_style),
+            _styled_line(r.b_idx, r.b_line, style=b_style),
+        )
+        rendered += 1
+
+    flush_gap()
+    console.print(table)
+
+
+@app.callback(invoke_without_command=True)
+def compare_json(
+    ctx: typer.Context,
+    a_json: Path = typer.Argument(..., exists=True, dir_okay=False, file_okay=True, readable=True, help="JSON file A"),
+    b_json: Path = typer.Argument(..., exists=True, dir_okay=False, file_okay=True, readable=True, help="JSON file B"),
+    context: int = typer.Option(
+        3,
+        "--context",
+        "-C",
+        help="Number of unchanged lines of context to show around differences (ignored with --show-all).",
+    ),
+    show_all: bool = typer.Option(False, "--show-all", help="Show all lines (not just differences with context)."),
+    sort_keys: bool = typer.Option(
+        True,
+        "--sort-keys/--no-sort-keys",
+        help="Sort object keys before diffing for stable output.",
+    ),
+    ignore_field: list[str] = typer.Option(
+        [],
+        "--ignore-field",
+        "-i",
+        help=(
+            "Field name to ignore during comparison. Can be passed multiple times. "
+            "Example: -i runtime_seconds -i uuid -i date"
+        ),
+    ),
+    ignore_field_case_insensitive: bool = typer.Option(
+        True,
+        "--ignore-field-case-insensitive/--ignore-field-case-sensitive",
+        help="Whether --ignore-field matching is case-insensitive.",
+    ),
+    max_rows: int = typer.Option(
+        2000,
+        "--max-rows",
+        help="Maximum number of table rows to render (0 = unlimited).",
+    ),
+    no_color: bool = typer.Option(False, "--no-color", help="Disable ANSI color output."),
+) -> None:
+    """
+    Render a side-by-side diff of two JSON files.
+
+    Exit codes:
+      - 0: no differences
+      - 1: differences found
+      - 2: invalid inputs (e.g., JSON parse error)
+    """
+    _ = ctx  # typer passes context; we don't use it yet.
+
+    a_obj = _load_json(a_json)
+    b_obj = _load_json(b_json)
+
+    ignore_fields_set = {s.lower() if ignore_field_case_insensitive else s for s in ignore_field if s}
+    if ignore_fields_set:
+        a_obj = _strip_ignored_fields(a_obj, ignore_fields=ignore_fields_set, ignore_case=ignore_field_case_insensitive)
+        b_obj = _strip_ignored_fields(b_obj, ignore_fields=ignore_fields_set, ignore_case=ignore_field_case_insensitive)
+
+    a_lines = _to_pretty_lines(a_obj, sort_keys=sort_keys)
+    b_lines = _to_pretty_lines(b_obj, sort_keys=sort_keys)
+
+    rows, _stats = _iter_rows(a_lines, b_lines)
+    has_diff = any(r.marker != " " for r in rows)
+
+    if not has_diff:
+        Console(color_system=None if no_color else "auto").print(
+            Text("No differences.", style="bold green" if not no_color else "")
+        )
+        raise typer.Exit(code=0)
+
+    _render_side_by_side(
+        a_path=a_json,
+        b_path=b_json,
+        rows=rows,
+        context=context,
+        show_all=show_all,
+        max_rows=max_rows,
+        no_color=no_color,
+    )
+    raise typer.Exit(code=1)
diff --git a/nemo_retriever/src/nemo_retriever/utils/compare/compare_results.py b/nemo_retriever/src/nemo_retriever/utils/compare/compare_results.py
new file mode 100644
index 000000000..15f32a78a
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/compare/compare_results.py
@@ -0,0 +1,871 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import hashlib
+import json
+from collections import Counter, defaultdict
+from dataclasses import dataclass
+from difflib import SequenceMatcher
+from pathlib import Path
+from typing import Any, Iterable
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+
+
+app = typer.Typer(
+    no_args_is_help=True,
+    help=(
+        "Compare nv-ingest-main outputs vs inprocess outputs for the same PDFs.\n\n"
+        "This command is designed for schema drift: it normalizes both JSON formats into a small"
+        " common shape, then prints a per-PDF breakdown of differences so you can quickly find"
+        " where rewritten code diverges."
+    ),
+)
+
+
+# --------------------------------------------------------------------------------------
+# Mapping / normalization configuration
+#
+# This is intentionally simple and meant to be edited as schemas evolve.
+# --------------------------------------------------------------------------------------
+
+# How to align "structured subtype" (nv-ingest-main) to label names (inprocess).
+# If your inprocess output uses different names, update this dict.
+SUBTYPE_TO_INPROCESS_LABEL: dict[str, str] = {
+    "table": "table",
+    "chart": "chart",
+    "infographic": "infographic",
+}
+
+# Some inprocess outputs might use alternate label strings; normalize them here.
+INPROCESS_LABEL_NORMALIZATION: dict[str, str] = {
+    "figure": "chart",
+    "graphic": "chart",
+}
+
+
+# --------------------------------------------------------------------------------------
+# Data models
+# --------------------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class _MainStructuredItem:
+    page_number: int | None
+    subtype: str
+    bbox_xyxy: list[float] | None
+    table_markdown: str | None
+
+
+@dataclass(frozen=True)
+class _NormalizedMain:
+    pdf_key: str
+    page_count: int | None
+    document_text: str
+    structured_items: list[_MainStructuredItem]
+    structured_counts_by_page: dict[int, Counter[str]]
+    structured_counts_total: Counter[str]
+
+
+@dataclass(frozen=True)
+class _NormalizedInprocess:
+    pdf_key: str
+    page_count: int
+    document_text: str
+    page_element_counts_by_page: dict[int, Counter[str]]
+    page_element_counts_total: Counter[str]
+    table_region_counts_by_page: dict[int, int]
+    table_region_counts_total: int
+
+
+# --------------------------------------------------------------------------------------
+# Helpers
+# --------------------------------------------------------------------------------------
+
+
+def _load_json(path: Path) -> Any:
+    try:
+        with path.open("r", encoding="utf-8") as f:
+            return json.load(f)
+    except json.JSONDecodeError as e:
+        raise typer.BadParameter(f"Invalid JSON in '{path}': {e.msg} (line {e.lineno}, column {e.colno})") from e
+
+
+def _main_pdf_key(path: Path) -> str:
+    """
+    nv-ingest-main file naming looks like: 1015168.pdf.metadata.json
+    We normalize the key to the PDF filename: 1015168.pdf
+    """
+    name = path.name
+    if name.endswith(".metadata.json"):
+        name = name[: -len(".metadata.json")]
+    return name
+
+
+def _simple_pdf_key_variants(pdf_key: str) -> set[str]:
+    """
+    Convenience for matching user-provided --only values.
+    """
+    v = {pdf_key}
+    if pdf_key.endswith(".pdf"):
+        v.add(pdf_key[: -len(".pdf")])
+    return v
+
+
+def _normalize_inprocess_label(label: str) -> str:
+    if not label:
+        return label
+    label_norm = label.strip().lower()
+    return INPROCESS_LABEL_NORMALIZATION.get(label_norm, label_norm)
+
+
+def _counter_from_counts_by_label(value: Any) -> Counter[str]:
+    if not isinstance(value, dict):
+        return Counter()
+    out: Counter[str] = Counter()
+    for k, v in value.items():
+        if not isinstance(k, str):
+            continue
+        try:
+            n = int(v)
+        except Exception:
+            continue
+        out[_normalize_inprocess_label(k)] += n
+    return out
+
+
+def _counter_from_page_elements_v3(value: Any) -> Counter[str]:
+    """
+    Fallback when *_counts_by_label is missing/empty.
+    Expected shape:
+      { "detections": [ {"label_name": "text", ...}, ... ] }
+    """
+    if not isinstance(value, dict):
+        return Counter()
+    dets = value.get("detections")
+    if not isinstance(dets, list):
+        return Counter()
+    c: Counter[str] = Counter()
+    for d in dets:
+        if not isinstance(d, dict):
+            continue
+        ln = d.get("label_name")
+        if isinstance(ln, str) and ln:
+            c[_normalize_inprocess_label(ln)] += 1
+    return c
+
+
+def _count_table_regions(table_data: Any) -> int:
+    """
+    Count table regions from either the ``table`` column format (list of
+    OCR entries) or the legacy ``table_structure_v1`` format (dict with
+    ``regions``).
+
+    ``table`` format::
+
+        [ {"bbox_xyxy_norm": [...], "text": "..."}, ... ]
+
+    Legacy format (``table_structure_v1``)::
+
+        { "regions": [ {"label_name": "table", ...}, ... ] }
+    """
+    # New format: list of OCR entries — each entry is one table region.
+    if isinstance(table_data, list):
+        return len(table_data)
+
+    # Legacy format: dict with "regions" list.
+    if not isinstance(table_data, dict):
+        return 0
+    regions = table_data.get("regions")
+    if not isinstance(regions, list):
+        return 0
+    n = 0
+    for r in regions:
+        if not isinstance(r, dict):
+            continue
+        if _normalize_inprocess_label(str(r.get("label_name") or "")) == "table":
+            n += 1
+    return n
+
+
+def _safe_int(value: Any) -> int | None:
+    try:
+        if value is None:
+            return None
+        return int(value)
+    except Exception:
+        return None
+
+
+def _normalize_main(
+    *,
+    pdf_key: str,
+    structured_path: Path | None,
+    text_path: Path | None,
+) -> _NormalizedMain:
+    structured_items: list[_MainStructuredItem] = []
+    structured_counts_by_page: dict[int, Counter[str]] = defaultdict(Counter)
+    structured_counts_total: Counter[str] = Counter()
+
+    page_count: int | None = None
+
+    if structured_path is not None and structured_path.exists():
+        structured_obj = _load_json(structured_path)
+        if not isinstance(structured_obj, list):
+            raise typer.BadParameter(f"Expected list JSON in '{structured_path}', got {type(structured_obj).__name__}")
+
+        for item in structured_obj:
+            if not isinstance(item, dict):
+                continue
+            md = item.get("metadata") if isinstance(item.get("metadata"), dict) else {}
+            cm = md.get("content_metadata") if isinstance(md.get("content_metadata"), dict) else {}
+            hierarchy = cm.get("hierarchy") if isinstance(cm.get("hierarchy"), dict) else {}
+
+            pc = _safe_int(hierarchy.get("page_count"))
+            if pc is not None:
+                page_count = pc
+
+            subtype = cm.get("subtype") if isinstance(cm.get("subtype"), str) else ""
+            subtype_norm = subtype.strip().lower() if subtype else ""
+
+            pn = _safe_int(cm.get("page_number"))
+            if pn is None:
+                pn = _safe_int(hierarchy.get("page"))
+
+            tm = md.get("table_metadata") if isinstance(md.get("table_metadata"), dict) else {}
+            bbox = tm.get("table_location")
+            bbox_xyxy: list[float] | None = None
+            if isinstance(bbox, list) and len(bbox) == 4:
+                try:
+                    bbox_xyxy = [float(x) for x in bbox]
+                except Exception:
+                    bbox_xyxy = None
+
+            table_md = tm.get("table_content")
+            if not isinstance(table_md, str) or not table_md.strip():
+                table_md = None
+
+            structured_items.append(
+                _MainStructuredItem(page_number=pn, subtype=subtype_norm, bbox_xyxy=bbox_xyxy, table_markdown=table_md)
+            )
+
+            if subtype_norm:
+                structured_counts_total[subtype_norm] += 1
+                if pn is not None and pn >= 1:
+                    structured_counts_by_page[pn][subtype_norm] += 1
+
+    # Document-level text: nv-ingest-main text output is typically a list of document chunks.
+    document_text_parts: list[str] = []
+    if text_path is not None and text_path.exists():
+        text_obj = _load_json(text_path)
+        if not isinstance(text_obj, list):
+            raise typer.BadParameter(f"Expected list JSON in '{text_path}', got {type(text_obj).__name__}")
+
+        for item in text_obj:
+            if not isinstance(item, dict):
+                continue
+            md = item.get("metadata") if isinstance(item.get("metadata"), dict) else {}
+            cm = md.get("content_metadata") if isinstance(md.get("content_metadata"), dict) else {}
+            hierarchy = cm.get("hierarchy") if isinstance(cm.get("hierarchy"), dict) else {}
+
+            pc = _safe_int(hierarchy.get("page_count"))
+            if pc is not None:
+                page_count = pc
+
+            content = md.get("content")
+            if isinstance(content, str) and content.strip():
+                document_text_parts.append(content)
+
+    document_text = "\n\n".join(document_text_parts).strip()
+    return _NormalizedMain(
+        pdf_key=pdf_key,
+        page_count=page_count,
+        document_text=document_text,
+        structured_items=structured_items,
+        structured_counts_by_page=dict(structured_counts_by_page),
+        structured_counts_total=structured_counts_total,
+    )
+
+
+def _normalize_inprocess(*, path: Path) -> _NormalizedInprocess:
+    obj = _load_json(path)
+    if not isinstance(obj, dict):
+        raise typer.BadParameter(f"Expected dict JSON in '{path}', got {type(obj).__name__}")
+
+    source_path = obj.get("source_path")
+    if isinstance(source_path, str) and source_path:
+        pdf_key = Path(source_path).name
+    else:
+        # Fallback: 1015168.20260210T....json -> 1015168.pdf
+        prefix = path.name.split(".", 1)[0]
+        pdf_key = prefix if prefix.endswith(".pdf") else f"{prefix}.pdf"
+
+    records = obj.get("records")
+    if not isinstance(records, list):
+        raise typer.BadParameter(f"Expected 'records' list in '{path}'")
+
+    page_element_counts_by_page: dict[int, Counter[str]] = {}
+    table_region_counts_by_page: dict[int, int] = {}
+    text_by_page: dict[int, str] = {}
+
+    for rec in records:
+        if not isinstance(rec, dict):
+            continue
+        pn = _safe_int(rec.get("page_number"))
+        if pn is None:
+            continue
+
+        # Text
+        t = rec.get("text")
+        if isinstance(t, str) and t.strip():
+            text_by_page[pn] = t
+
+        # Page elements counts
+        counts = _counter_from_counts_by_label(rec.get("page_elements_v3_counts_by_label"))
+        if not counts:
+            counts = _counter_from_page_elements_v3(rec.get("page_elements_v3"))
+        if counts:
+            page_element_counts_by_page[pn] = counts
+
+        # Table regions (independent of "page elements" model)
+        table_region_counts_by_page[pn] = _count_table_regions(rec.get("table") or rec.get("table_structure_v1"))
+
+    # Document text: join in ascending page order (keeps comparison stable).
+    document_text = "\n\n".join(text_by_page[p] for p in sorted(text_by_page.keys())).strip()
+
+    page_element_counts_total: Counter[str] = Counter()
+    for c in page_element_counts_by_page.values():
+        page_element_counts_total.update(c)
+
+    table_region_counts_total = sum(table_region_counts_by_page.values())
+
+    return _NormalizedInprocess(
+        pdf_key=pdf_key,
+        page_count=len([r for r in records if isinstance(r, dict) and _safe_int(r.get("page_number")) is not None]),
+        document_text=document_text,
+        page_element_counts_by_page=page_element_counts_by_page,
+        page_element_counts_total=page_element_counts_total,
+        table_region_counts_by_page=table_region_counts_by_page,
+        table_region_counts_total=table_region_counts_total,
+    )
+
+
+def _similarity(a: str, b: str) -> float:
+    if not a and not b:
+        return 1.0
+    if not a or not b:
+        return 0.0
+    return SequenceMatcher(a=a, b=b, autojunk=False).ratio()
+
+
+def _fmt_ratio(r: float) -> str:
+    return f"{r*100:.1f}%"
+
+
+def _fmt_counter(c: Counter[str], keys: Iterable[str]) -> str:
+    parts = []
+    for k in keys:
+        parts.append(f"{k}={c.get(k, 0)}")
+    return ", ".join(parts)
+
+
+def _sha256_text(s: str) -> str:
+    return hashlib.sha256(s.encode("utf-8", errors="ignore")).hexdigest()
+
+
+def _counter_to_dict(c: Counter[str]) -> dict[str, int]:
+    return {k: int(v) for k, v in sorted(c.items())}
+
+
+def _slug_filename(s: str) -> str:
+    """
+    Keep filenames stable and shell-friendly.
+    """
+    s = s.strip()
+    out = []
+    for ch in s:
+        if ch.isalnum() or ch in {".", "-", "_"}:
+            out.append(ch)
+        else:
+            out.append("_")
+    # avoid empty
+    return "".join(out) or "output"
+
+
+def _compute_diff_json(
+    *,
+    main: _NormalizedMain | None,
+    inp: _NormalizedInprocess | None,
+    missing: list[str] | None,
+    min_text_similarity: float,
+) -> dict[str, Any]:
+    """
+    Returns a structured diff payload that can be written to JSON and later rendered.
+    """
+    if missing:
+        return {
+            "status": "missing_inputs",
+            "pdf_key": (main.pdf_key if main else inp.pdf_key if inp else None),
+            "missing": missing,
+        }
+
+    assert main is not None and inp is not None
+
+    txt_sim = _similarity(main.document_text, inp.document_text)
+    page_count_ok = (main.page_count is None) or (main.page_count == inp.page_count)
+    text_ok = txt_sim >= min_text_similarity
+
+    subtype_keys = sorted({*SUBTYPE_TO_INPROCESS_LABEL.keys()})
+
+    # Compare structured subtype totals vs mapped inprocess label totals
+    structured_mismatches: list[dict[str, Any]] = []
+    for st in subtype_keys:
+        label = _normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL.get(st, st))
+        a_n = int(main.structured_counts_total.get(st, 0))
+        b_n = int(inp.page_element_counts_total.get(label, 0))
+        ok = a_n == b_n
+        if not ok:
+            structured_mismatches.append({"subtype": st, "inprocess_label": label, "main": a_n, "inprocess": b_n})
+
+    # Per-page diffs (store all diffs; UI printing can truncate)
+    pages = sorted(
+        {
+            *main.structured_counts_by_page.keys(),
+            *inp.page_element_counts_by_page.keys(),
+            *inp.table_region_counts_by_page.keys(),
+        }
+    )
+    page_diffs: list[dict[str, Any]] = []
+    for p in pages:
+        main_c = main.structured_counts_by_page.get(p, Counter())
+        inp_c = inp.page_element_counts_by_page.get(p, Counter())
+        inp_tables = int(inp.table_region_counts_by_page.get(p, 0))
+
+        a_tbl = int(main_c.get("table", 0))
+        a_cht = int(main_c.get("chart", 0))
+        a_inf = int(main_c.get("infographic", 0))
+
+        b_tbl = int(inp_c.get(_normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL.get("table", "table")), 0))
+        b_cht = int(inp_c.get(_normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL.get("chart", "chart")), 0))
+        b_inf = int(
+            inp_c.get(_normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL.get("infographic", "infographic")), 0)
+        )
+
+        ok = (a_tbl == b_tbl) and (a_cht == b_cht) and (a_inf == b_inf) and (a_tbl == inp_tables)
+        if not ok:
+            page_diffs.append(
+                {
+                    "page": int(p),
+                    "main": {"table": a_tbl, "chart": a_cht, "infographic": a_inf},
+                    "inprocess_page_elements_v3": {"table": b_tbl, "chart": b_cht, "infographic": b_inf},
+                    "inprocess_table_regions": inp_tables,
+                }
+            )
+
+    main_tables_total = int(main.structured_counts_total.get("table", 0))
+    table_regions_ok = main_tables_total == int(inp.table_region_counts_total)
+
+    return {
+        "status": "ok",
+        "pdf_key": main.pdf_key,
+        "schema": {
+            "subtype_to_inprocess_label": dict(SUBTYPE_TO_INPROCESS_LABEL),
+            "inprocess_label_normalization": dict(INPROCESS_LABEL_NORMALIZATION),
+        },
+        "metrics": {
+            "page_count_ok": page_count_ok,
+            "main_page_count": main.page_count,
+            "inprocess_page_count": inp.page_count,
+            "text_similarity_ratio": float(txt_sim),
+            "text_ok": text_ok,
+            "min_text_similarity": float(min_text_similarity),
+            "main_text_len": int(len(main.document_text)),
+            "inprocess_text_len": int(len(inp.document_text)),
+            "main_text_sha256": _sha256_text(main.document_text) if main.document_text else None,
+            "inprocess_text_sha256": _sha256_text(inp.document_text) if inp.document_text else None,
+            "table_regions_ok": table_regions_ok,
+            "main_tables_total": main_tables_total,
+            "inprocess_table_regions_total": int(inp.table_region_counts_total),
+        },
+        "totals": {
+            "main_structured_counts_total": _counter_to_dict(main.structured_counts_total),
+            "inprocess_page_elements_counts_total": _counter_to_dict(inp.page_element_counts_total),
+        },
+        "differences": {
+            "structured_total_mismatches": structured_mismatches,
+            "page_diffs": page_diffs,
+        },
+    }
+
+
+def _render_pdf_summary(
+    *,
+    console: Console,
+    main: _NormalizedMain,
+    inp: _NormalizedInprocess,
+    show_page_diffs: bool,
+    max_page_diffs: int,
+    min_text_similarity: float,
+) -> bool:
+    """
+    Returns True if any differences were found.
+    """
+    has_diff = False
+
+    title = Text(main.pdf_key, style="bold")
+    console.print(title)
+
+    # Summary table
+    summary = Table(show_header=True, header_style="bold", pad_edge=False)
+    summary.add_column("Field", style="bold")
+    summary.add_column("nv-ingest-main")
+    summary.add_column("inprocess")
+    summary.add_column("Status", no_wrap=True)
+
+    def add_row(field: str, a: str, b: str, ok: bool, note: str | None = None) -> None:
+        nonlocal has_diff
+        if not ok:
+            has_diff = True
+        status = Text("OK", style="green") if ok else Text("DIFF", style="red")
+        if note:
+            status.append(f" ({note})", style="dim")
+        summary.add_row(field, a, b, status)
+
+    # Page count
+    main_pc = str(main.page_count) if main.page_count is not None else "?"
+    inp_pc = str(inp.page_count)
+    add_row("page_count", main_pc, inp_pc, (main.page_count is None) or (main.page_count == inp.page_count))
+
+    # Text
+    txt_sim = _similarity(main.document_text, inp.document_text)
+    add_row(
+        "document_text",
+        f"len={len(main.document_text)}",
+        f"len={len(inp.document_text)}",
+        txt_sim >= min_text_similarity,
+        note=f"sim={_fmt_ratio(txt_sim)}",
+    )
+
+    # Structured subtype totals vs inprocess page-elements label totals
+    subtype_keys = sorted({*SUBTYPE_TO_INPROCESS_LABEL.keys()})
+    main_counts = main.structured_counts_total
+    inp_counts = inp.page_element_counts_total
+
+    # Compare using mapping (subtype -> label)
+    mismatch_notes: list[str] = []
+    for st in subtype_keys:
+        label = _normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL.get(st, st))
+        a_n = main_counts.get(st, 0)
+        b_n = inp_counts.get(label, 0)
+        if a_n != b_n:
+            mismatch_notes.append(f"{st}:{a_n}!={b_n}")
+    add_row(
+        "structured_counts",
+        _fmt_counter(main_counts, subtype_keys),
+        _fmt_counter(inp_counts, [_normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL[k]) for k in subtype_keys]),
+        ok=(len(mismatch_notes) == 0),
+        note=(
+            None if not mismatch_notes else "; ".join(mismatch_notes[:4]) + ("; ..." if len(mismatch_notes) > 4 else "")
+        ),
+    )
+
+    # Table-region totals (different model, but useful sanity check)
+    main_tables = main.structured_counts_total.get("table", 0)
+    add_row(
+        "table_regions",
+        str(main_tables),
+        str(inp.table_region_counts_total),
+        ok=(main_tables == inp.table_region_counts_total),
+    )
+
+    console.print(summary)
+
+    # Per-page diffs
+    if show_page_diffs:
+        pages = sorted(
+            {
+                *main.structured_counts_by_page.keys(),
+                *inp.page_element_counts_by_page.keys(),
+                *inp.table_region_counts_by_page.keys(),
+            }
+        )
+        if pages:
+            per_page = Table(show_header=True, header_style="bold", pad_edge=False)
+            per_page.add_column("page", justify="right", no_wrap=True)
+            per_page.add_column("main (tables/charts/infographics)")
+            per_page.add_column("inprocess page_elements_v3 (table/chart/infographic)")
+            per_page.add_column("inprocess table_regions(table)")
+            per_page.add_column("Status", no_wrap=True)
+
+            shown = 0
+            for p in pages:
+                main_c = main.structured_counts_by_page.get(p, Counter())
+                inp_c = inp.page_element_counts_by_page.get(p, Counter())
+                inp_tables = inp.table_region_counts_by_page.get(p, 0)
+
+                # Align counts for display
+                a_tbl = main_c.get("table", 0)
+                a_cht = main_c.get("chart", 0)
+                a_inf = main_c.get("infographic", 0)
+
+                b_tbl = inp_c.get(_normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL.get("table", "table")), 0)
+                b_cht = inp_c.get(_normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL.get("chart", "chart")), 0)
+                b_inf = inp_c.get(
+                    _normalize_inprocess_label(SUBTYPE_TO_INPROCESS_LABEL.get("infographic", "infographic")), 0
+                )
+
+                ok = (a_tbl == b_tbl) and (a_cht == b_cht) and (a_inf == b_inf) and (a_tbl == inp_tables)
+                if ok:
+                    continue
+
+                shown += 1
+                if max_page_diffs > 0 and shown > max_page_diffs:
+                    per_page.add_row("…", "…", "…", "…", Text("truncated", style="dim"))
+                    break
+
+                status = Text("DIFF", style="red")
+                per_page.add_row(
+                    str(p),
+                    f"table={a_tbl}, chart={a_cht}, infographic={a_inf}",
+                    f"table={b_tbl}, chart={b_cht}, infographic={b_inf}",
+                    str(inp_tables),
+                    status,
+                )
+
+            if shown > 0:
+                console.print(per_page)
+
+    console.print()  # spacer
+    return has_diff
+
+
+def _discover_main_files(nv_ingest_main_results: Path) -> dict[str, dict[str, Path]]:
+    """
+    Returns:
+      { pdf_key: { 'structured': Path, 'text': Path } }  (either key may be missing)
+    """
+    out: dict[str, dict[str, Path]] = defaultdict(dict)
+    structured_dir = nv_ingest_main_results / "structured"
+    text_dir = nv_ingest_main_results / "text"
+
+    if structured_dir.exists():
+        for p in structured_dir.glob("*.json"):
+            out[_main_pdf_key(p)]["structured"] = p
+    if text_dir.exists():
+        for p in text_dir.glob("*.json"):
+            out[_main_pdf_key(p)]["text"] = p
+    return dict(out)
+
+
+def _discover_inprocess_files(inprocess_results: Path) -> dict[str, Path]:
+    """
+    Discovers per-PDF JSON files in the inprocess results directory.
+
+    File naming typically looks like:
+      1015168.20260210T030444Z.e7cfd55b.json
+
+    We derive the PDF key from the filename without loading the (potentially huge) JSON:
+      1015168.pdf
+    Returns:
+      { pdf_key: inprocess_json_path }
+    """
+    out: dict[str, Path] = {}
+    for p in sorted(inprocess_results.glob("*.json")):
+        stem = p.name[: -len(".json")] if p.name.endswith(".json") else p.stem
+        parts = stem.split(".")
+        # If the name matches "<pdfstem>.<timestamp>.<hash>", keep everything except the last 2 parts.
+        # This is resilient to dots in the original PDF stem.
+        if len(parts) >= 3:
+            pdf_stem = ".".join(parts[:-2])
+        else:
+            pdf_stem = parts[0]
+        pdf_key = pdf_stem if pdf_stem.endswith(".pdf") else f"{pdf_stem}.pdf"
+        out[pdf_key] = p
+    return out
+
+
+# --------------------------------------------------------------------------------------
+# CLI
+# --------------------------------------------------------------------------------------
+
+
+@app.callback(invoke_without_command=True)
+def compare_results(
+    nv_ingest_main_results: Path = typer.Option(
+        ...,
+        "--nv-ingest-main-results",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+        help="Directory like /home/jdyer/datasets/nv-ingest-main-results-jp20 (contains structured/ and text/).",
+    ),
+    inprocess_results: Path = typer.Option(
+        ...,
+        "--inprocess-results",
+        "--jp20-results-inprocess",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        readable=True,
+        help="Directory like /home/jdyer/datasets/jp20_results_inprocess (contains per-PDF .json).",
+    ),
+    only: list[str] = typer.Option(
+        [],
+        "--only",
+        help="Only compare PDFs whose key matches this value (repeatable). Accepts '1015168' or '1015168.pdf'.",
+    ),
+    limit: int = typer.Option(
+        0,
+        "--limit",
+        help="Limit how many PDFs to compare (0 = all).",
+    ),
+    show_page_diffs: bool = typer.Option(
+        True,
+        "--show-page-diffs/--no-show-page-diffs",
+        help="Show per-page count diffs (tables/charts/infographics).",
+    ),
+    max_page_diffs: int = typer.Option(
+        25,
+        "--max-page-diffs",
+        help="Max per-page diff rows to show per PDF (0 = unlimited).",
+    ),
+    min_text_similarity: float = typer.Option(
+        0.985,
+        "--min-text-similarity",
+        help="Mark document text as DIFF when similarity ratio drops below this threshold.",
+    ),
+    out_dir: Path = typer.Option(
+        Path("compare_results_out"),
+        "--out-dir",
+        "-o",
+        help="Directory where per-PDF .txt and .diff.json files are written.",
+    ),
+    no_color: bool = typer.Option(False, "--no-color", help="Disable ANSI color output."),
+    fail_on_diff: bool = typer.Option(
+        False,
+        "--fail-on-diff",
+        help="Exit with code 1 if any differences are found.",
+    ),
+) -> None:
+    console = Console(color_system=None if no_color else "auto")
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    main_files = _discover_main_files(nv_ingest_main_results)
+    inproc_files = _discover_inprocess_files(inprocess_results)
+
+    all_pdf_keys = sorted({*main_files.keys(), *inproc_files.keys()})
+
+    if only:
+        only_set = {o.strip() for o in only if o.strip()}
+        filtered: list[str] = []
+        for k in all_pdf_keys:
+            variants = _simple_pdf_key_variants(k)
+            if variants & only_set:
+                filtered.append(k)
+        all_pdf_keys = filtered
+
+    if limit > 0:
+        all_pdf_keys = all_pdf_keys[:limit]
+
+    if not all_pdf_keys:
+        raise typer.BadParameter("No matching PDFs found to compare.")
+
+    any_diff = False
+
+    for pdf_key in all_pdf_keys:
+        mf = main_files.get(pdf_key, {})
+        structured_path = mf.get("structured")
+        text_path = mf.get("text")
+        inproc_path = inproc_files.get(pdf_key)
+
+        if inproc_path is None or (structured_path is None and text_path is None):
+            # Missing pairing
+            missing = []
+            if structured_path is None:
+                missing.append("nv-ingest-main structured")
+            if text_path is None:
+                missing.append("nv-ingest-main text")
+            if inproc_path is None:
+                missing.append("inprocess")
+
+            # Render to screen
+            console.print(Text(pdf_key, style="bold"))
+            console.print(Text("Missing: " + ", ".join(missing), style="yellow"))
+            console.print()
+
+            # Also write per-PDF outputs
+            safe = _slug_filename(pdf_key)
+            txt_path = out_dir / f"{safe}.txt"
+            json_path = out_dir / f"{safe}.diff.json"
+
+            file_console = Console(record=True, color_system=None, width=140)
+            file_console.print(Text(pdf_key, style="bold"))
+            file_console.print(Text("Missing: " + ", ".join(missing), style="yellow"))
+            file_console.print()
+
+            txt_path.write_text(file_console.export_text(), encoding="utf-8")
+            json_payload = _compute_diff_json(
+                main=None, inp=None, missing=missing, min_text_similarity=min_text_similarity
+            )
+            json_payload["pdf_key"] = pdf_key
+            json_path.write_text(
+                json.dumps(json_payload, indent=2, sort_keys=True, ensure_ascii=False) + "\n", encoding="utf-8"
+            )
+
+            any_diff = True
+            continue
+
+        main_norm = _normalize_main(pdf_key=pdf_key, structured_path=structured_path, text_path=text_path)
+        inproc_norm = _normalize_inprocess(path=inproc_path)
+
+        # If source_path-derived key disagrees, still compare but show a hint.
+        if inproc_norm.pdf_key != pdf_key:
+            console.print(Text(f"Note: inprocess source_path key '{inproc_norm.pdf_key}' != '{pdf_key}'", style="dim"))
+
+        # Render to screen
+        this_has_diff = _render_pdf_summary(
+            console=console,
+            main=main_norm,
+            inp=inproc_norm,
+            show_page_diffs=show_page_diffs,
+            max_page_diffs=max_page_diffs,
+            min_text_similarity=min_text_similarity,
+        )
+        any_diff |= this_has_diff
+
+        # Render to file (no ANSI, wide)
+        safe = _slug_filename(pdf_key)
+        txt_path = out_dir / f"{safe}.txt"
+        json_path = out_dir / f"{safe}.diff.json"
+
+        file_console = Console(record=True, color_system=None, width=140)
+        _ = _render_pdf_summary(
+            console=file_console,
+            main=main_norm,
+            inp=inproc_norm,
+            show_page_diffs=show_page_diffs,
+            max_page_diffs=0,  # don't truncate in file (table itself prints only diffs anyway)
+            min_text_similarity=min_text_similarity,
+        )
+        txt_path.write_text(file_console.export_text(), encoding="utf-8")
+
+        json_payload = _compute_diff_json(
+            main=main_norm, inp=inproc_norm, missing=None, min_text_similarity=min_text_similarity
+        )
+        json_path.write_text(
+            json.dumps(json_payload, indent=2, sort_keys=True, ensure_ascii=False) + "\n", encoding="utf-8"
+        )
+
+    if any_diff and fail_on_diff:
+        raise typer.Exit(code=1)
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/utils/convert/__init__.py b/nemo_retriever/src/nemo_retriever/utils/convert/__init__.py
new file mode 100644
index 000000000..4eb75a6f0
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/convert/__init__.py
@@ -0,0 +1,17 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Document-to-PDF conversion utilities."""
+
+from .to_pdf import (
+    SUPPORTED_EXTENSIONS,
+    DocToPdfConversionActor,
+    convert_to_pdf_bytes,
+)
+
+__all__ = [
+    "SUPPORTED_EXTENSIONS",
+    "DocToPdfConversionActor",
+    "convert_to_pdf_bytes",
+]
diff --git a/nemo_retriever/src/nemo_retriever/utils/convert/to_pdf.py b/nemo_retriever/src/nemo_retriever/utils/convert/to_pdf.py
new file mode 100644
index 000000000..69280bed1
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/convert/to_pdf.py
@@ -0,0 +1,151 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Convert DOCX/PPTX files to PDF bytes via LibreOffice headless."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+import traceback
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+SUPPORTED_EXTENSIONS = frozenset({".pdf", ".docx", ".pptx"})
+
+
+def _error_record(
+    *,
+    source_path: Optional[str],
+    stage: str,
+    exc: BaseException,
+) -> Dict[str, Any]:
+    return {
+        "bytes": b"",
+        "path": source_path,
+        "metadata": {
+            "source_path": source_path,
+            "error": {
+                "stage": str(stage),
+                "type": exc.__class__.__name__,
+                "message": str(exc),
+                "traceback": "".join(traceback.format_exception(type(exc), exc, exc.__traceback__)),
+            },
+        },
+    }
+
+
+def convert_to_pdf_bytes(file_bytes: bytes, extension: str) -> bytes:
+    """Convert file bytes to PDF bytes.
+
+    If *extension* is ``".pdf"``, return *file_bytes* unchanged.
+    For ``".docx"`` / ``".pptx"``, write to a temp dir, invoke
+    ``libreoffice --headless --convert-to pdf``, and return the
+    resulting PDF bytes.
+
+    Raises
+    ------
+    FileNotFoundError
+        If the ``libreoffice`` binary is not on ``$PATH``.
+    subprocess.CalledProcessError
+        If LibreOffice conversion fails.
+    RuntimeError
+        If the expected PDF output file is missing after conversion.
+    """
+    ext = extension.lower()
+    if ext == ".pdf":
+        return file_bytes
+
+    if ext not in SUPPORTED_EXTENSIONS:
+        raise ValueError(f"Unsupported extension: {extension!r}")
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        # Strip leading dot for the filename suffix (e.g. ".docx" -> "docx").
+        input_path = os.path.join(tmp_dir, f"input{ext}")
+        with open(input_path, "wb") as f:
+            f.write(file_bytes)
+
+        command = [
+            "libreoffice",
+            "--headless",
+            "--convert-to",
+            "pdf",
+            input_path,
+            "--outdir",
+            tmp_dir,
+        ]
+
+        subprocess.run(command, check=True, capture_output=True, text=True)
+
+        pdf_path = os.path.join(tmp_dir, "input.pdf")
+        if not os.path.exists(pdf_path):
+            raise RuntimeError(f"LibreOffice conversion produced no output for {extension} file")
+
+        with open(pdf_path, "rb") as f:
+            return f.read()
+
+
+def convert_batch_to_pdf(batch_df: Any) -> pd.DataFrame:
+    """Convert a batch of files to PDF, passing PDFs through unchanged.
+
+    Expects a :class:`pandas.DataFrame` with at least ``bytes`` and ``path``
+    columns (the same schema produced by ``ray.data.read_binary_files``).
+    Rows whose path ends with a supported non-PDF extension are converted;
+    rows that are already PDFs are returned as-is.  On error, an error record
+    is emitted (matching the pattern in ``pdf/split.py``).
+    """
+    if not isinstance(batch_df, pd.DataFrame):
+        raise NotImplementedError("convert_batch_to_pdf currently only supports pandas.DataFrame input.")
+
+    out_rows: List[Dict[str, Any]] = []
+    for _, row in batch_df.iterrows():
+        file_path = row.get("path") or ""
+        file_bytes = row.get("bytes", b"")
+
+        ext = os.path.splitext(file_path)[1].lower() if file_path else ".pdf"
+
+        if ext not in SUPPORTED_EXTENSIONS:
+            # Unsupported extension — pass through unchanged (let downstream
+            # stages handle or error).
+            out_rows.append({"bytes": file_bytes, "path": file_path})
+            continue
+
+        if ext == ".pdf":
+            out_rows.append({"bytes": file_bytes, "path": file_path})
+            continue
+
+        try:
+            if not isinstance(file_bytes, (bytes, bytearray, memoryview)):
+                raise ValueError(f"Unsupported bytes payload type: {type(file_bytes)!r}")
+            pdf_bytes = convert_to_pdf_bytes(bytes(file_bytes), ext)
+            # Preserve original path so downstream metadata tracks the source file.
+            out_rows.append({"bytes": pdf_bytes, "path": file_path})
+        except BaseException as e:
+            out_rows.append(
+                _error_record(
+                    source_path=str(file_path) if file_path else None,
+                    stage="convert_to_pdf",
+                    exc=e,
+                )
+            )
+
+    return pd.DataFrame(out_rows)
+
+
+@dataclass(slots=True)
+class DocToPdfConversionActor:
+    """Ray Data actor that converts DOCX/PPTX batches to PDF.
+
+    Used with ``ray.data.Dataset.map_batches`` in the same style as
+    ``PDFSplitActor``.
+    """
+
+    def __init__(self) -> None:
+        pass
+
+    def __call__(self, batch_df: Any) -> Any:
+        return convert_batch_to_pdf(batch_df)
diff --git a/nemo_retriever/src/nemo_retriever/utils/image/__init__.py b/nemo_retriever/src/nemo_retriever/utils/image/__init__.py
new file mode 100644
index 000000000..8a78faf24
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/image/__init__.py
@@ -0,0 +1,15 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .__main__ import app
+from .render import (
+    render_page_element_detections_for_image,
+    render_page_element_detections_for_dir,
+)
+
+__all__ = [
+    "app",
+    "render_page_element_detections_for_image",
+    "render_page_element_detections_for_dir",
+]
diff --git a/nemo_retriever/src/nemo_retriever/utils/image/__main__.py b/nemo_retriever/src/nemo_retriever/utils/image/__main__.py
new file mode 100644
index 000000000..b178e1fb3
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/image/__main__.py
@@ -0,0 +1,16 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from . import render
+
+app = typer.Typer(help="Utilities for working with images (visualization, inspection, conversions)")
+app.add_typer(render.app, name="render")
+
+
+def main() -> None:
+    app()
diff --git a/nemo_retriever/src/nemo_retriever/utils/image/render.py b/nemo_retriever/src/nemo_retriever/utils/image/render.py
new file mode 100644
index 000000000..3eb66c874
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/utils/image/render.py
@@ -0,0 +1,241 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple
+
+import typer
+from PIL import Image, ImageDraw, ImageFont
+from rich.console import Console
+from tqdm import tqdm
+
+console = Console()
+app = typer.Typer(help="Render/visualize various model outputs on images.")
+
+
+def _stage2_json_path_for_image(img_path: Path) -> Path:
+    # Matches stage2_page_elements_v3.py naming.
+    return img_path.with_name(img_path.name + ".page_elements_v3.json")
+
+
+def _out_path_for_image(img_path: Path) -> Path:
+    # Matches requested suffix: "page_element_detections.png"
+    return img_path.with_name(img_path.name + ".page_element_detections.png")
+
+
+def _clamp_bbox_xyxy_px(bbox: Sequence[float], *, w: int, h: int) -> Tuple[int, int, int, int]:
+    x1, y1, x2, y2 = [float(x) for x in bbox]
+    x1_i = int(round(x1))
+    y1_i = int(round(y1))
+    x2_i = int(round(x2))
+    y2_i = int(round(y2))
+
+    x1_i = max(0, min(x1_i, w - 1))
+    y1_i = max(0, min(y1_i, h - 1))
+    x2_i = max(x1_i + 1, min(x2_i, w))
+    y2_i = max(y1_i + 1, min(y2_i, h))
+    return x1_i, y1_i, x2_i, y2_i
+
+
+def _bbox_xyxy_norm_to_px(bbox_xyxy_norm: Sequence[float], *, w: int, h: int) -> Tuple[int, int, int, int]:
+    x1n, y1n, x2n, y2n = [float(x) for x in bbox_xyxy_norm]
+    x1 = x1n * w
+    y1 = y1n * h
+    x2 = x2n * w
+    y2 = y2n * h
+    return _clamp_bbox_xyxy_px((x1, y1, x2, y2), w=w, h=h)
+
+
+def _label_color(label_name: str) -> Tuple[int, int, int]:
+    # High-contrast palette.
+    palette: Dict[str, Tuple[int, int, int]] = {
+        "table": (0, 170, 255),
+        "chart": (255, 170, 0),
+        "title": (0, 220, 120),
+        "infographic": (200, 100, 255),
+        "text": (255, 80, 80),
+        "header_footer": (255, 255, 0),
+    }
+    return palette.get(label_name, (255, 0, 0))
+
+
+@dataclass(frozen=True)
+class PageElementDetection:
+    bbox_xyxy_norm: Tuple[float, float, float, float]
+    label: Optional[int]
+    label_name: str
+    score: Optional[float]
+
+
+def _iter_page_element_detections(payload: Any) -> Iterable[PageElementDetection]:
+    if not isinstance(payload, dict):
+        return []
+    dets = payload.get("detections", [])
+    if not isinstance(dets, list):
+        return []
+
+    out: List[PageElementDetection] = []
+    for d in dets:
+        if not isinstance(d, dict):
+            continue
+        bbox = d.get("bbox_xyxy_norm")
+        if not (isinstance(bbox, (list, tuple)) and len(bbox) == 4):
+            continue
+        try:
+            bbox_f = (float(bbox[0]), float(bbox[1]), float(bbox[2]), float(bbox[3]))
+        except Exception:
+            continue
+        label = d.get("label")
+        try:
+            label_i = int(label) if label is not None else None
+        except Exception:
+            label_i = None
+        label_name = str(d.get("label_name") or (f"label_{label_i}" if label_i is not None else "unknown"))
+        score = d.get("score")
+        try:
+            score_f = float(score) if score is not None else None
+        except Exception:
+            score_f = None
+        out.append(
+            PageElementDetection(
+                bbox_xyxy_norm=bbox_f,
+                label=label_i,
+                label_name=label_name,
+                score=score_f,
+            )
+        )
+    return out
+
+
+def render_page_element_detections_for_image(
+    *,
+    image_path: Path,
+    stage2_json_path: Optional[Path] = None,
+    output_path: Optional[Path] = None,
+    min_score: float = 0.0,
+    line_width: int = 3,
+    draw_labels: bool = True,
+) -> Optional[Path]:
+    """
+    Read stage2 page_elements_v3 JSON and render bbox overlays onto the original image.
+
+    Output file naming follows:
+      <image>.<ext>.page_element_detections.png
+    """
+    stage2_json_path = stage2_json_path or _stage2_json_path_for_image(image_path)
+    output_path = output_path or _out_path_for_image(image_path)
+
+    if not stage2_json_path.exists():
+        console.print(f"[yellow]Skip[/yellow] missing stage2 json: {stage2_json_path}")
+        return None
+
+    payload = read_json(stage2_json_path)  # noqa: F821
+    dets = list(_iter_page_element_detections(payload))
+    if not dets:
+        console.print(f"[yellow]Skip[/yellow] no detections in: {stage2_json_path}")
+        return None
+
+    with Image.open(image_path) as im0:
+        im = im0.convert("RGB")
+
+    w, h = im.size
+    draw = ImageDraw.Draw(im)
+    font = ImageFont.load_default()
+
+    rendered = 0
+    for d in dets:
+        if d.score is not None and float(d.score) < float(min_score):
+            continue
+        x1, y1, x2, y2 = _bbox_xyxy_norm_to_px(d.bbox_xyxy_norm, w=w, h=h)
+        color = _label_color(d.label_name)
+        try:
+            draw.rectangle([x1, y1, x2, y2], outline=color, width=max(1, int(line_width)))
+        except TypeError:
+            # Pillow older API fallback: no width=
+            draw.rectangle([x1, y1, x2, y2], outline=color)
+
+        if draw_labels:
+            score_s = f"{d.score:.3f}" if d.score is not None else "?"
+            text = f"{d.label_name} {score_s}"
+            tx, ty = x1 + 2, max(0, y1 - 12)
+            # background box for readability
+            tw, th = draw.textbbox((0, 0), text, font=font)[2:]
+            draw.rectangle([tx - 1, ty - 1, tx + tw + 3, ty + th + 1], fill=(0, 0, 0))
+            draw.text((tx + 1, ty), text, fill=(255, 255, 255), font=font)
+
+        rendered += 1
+
+    if rendered == 0:
+        console.print(f"[yellow]Skip[/yellow] all detections filtered by min_score={min_score}: {image_path}")
+        return None
+
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    im.save(output_path, format="PNG")
+    return output_path
+
+
+def render_page_element_detections_for_dir(
+    *,
+    input_dir: Path,
+    overwrite: bool = False,
+    min_score: float = 0.0,
+    line_width: int = 3,
+    draw_labels: bool = True,
+    limit: Optional[int] = None,
+) -> List[Path]:
+    imgs = iter_images(input_dir)  # noqa: F821
+    if limit is not None:
+        imgs = imgs[: int(limit)]
+
+    outputs: List[Path] = []
+    skipped_existing = 0
+    skipped_errors = 0
+    rendered = 0
+    for img_path in tqdm(imgs, desc="Render page element bboxes", unit="img"):
+        out_path = _out_path_for_image(img_path)
+        if out_path.exists() and not overwrite:
+            skipped_existing += 1
+            continue
+        try:
+            p = render_page_element_detections_for_image(
+                image_path=img_path,
+                output_path=out_path,
+                min_score=min_score,
+                line_width=line_width,
+                draw_labels=draw_labels,
+            )
+            if p is not None:
+                outputs.append(p)
+                rendered += 1
+        except Exception:
+            skipped_errors += 1
+            continue
+    return outputs
+
+
+@app.command("page-elements")
+def render_page_elements(
+    input_dir: Path = typer.Option(..., "--input-dir", exists=True, file_okay=False, dir_okay=True),
+    overwrite: bool = typer.Option(False, "--overwrite", help="Overwrite existing .page_element_detections.png files."),
+    min_score: float = typer.Option(0.0, "--min-score", help="Only draw detections with score >= min_score."),
+    line_width: int = typer.Option(3, "--line-width", min=1, help="Bounding box line width in pixels."),
+    draw_labels: bool = typer.Option(True, "--draw-labels/--no-draw-labels", help="Draw label + score text."),
+    limit: Optional[int] = typer.Option(None, "--limit", help="Optionally limit number of images processed."),
+) -> None:
+    """
+    For each image in input_dir, read adjacent stage2 JSON (<image>.page_elements_v3.json)
+    and write <image>.page_element_detections.png with bounding boxes rendered.
+    """
+    outs = render_page_element_detections_for_dir(
+        input_dir=input_dir,
+        overwrite=overwrite,
+        min_score=min_score,
+        line_width=line_width,
+        draw_labels=draw_labels,
+        limit=limit,
+    )
+    console.print(f"[green]Done[/green] wrote={len(outs)}")
diff --git a/nemo_retriever/src/nemo_retriever/vector_store/__init__.py b/nemo_retriever/src/nemo_retriever/vector_store/__init__.py
new file mode 100644
index 000000000..1c05e4e8f
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/vector_store/__init__.py
@@ -0,0 +1,19 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from .__main__ import app
+from .lancedb_store import (
+    LanceDBConfig,
+    create_lancedb_index,
+    write_embeddings_to_lancedb,
+    write_text_embeddings_dir_to_lancedb,
+)
+
+__all__ = [
+    "app",
+    "LanceDBConfig",
+    "create_lancedb_index",
+    "write_embeddings_to_lancedb",
+    "write_text_embeddings_dir_to_lancedb",
+]
diff --git a/nemo_retriever/src/nemo_retriever/vector_store/__main__.py b/nemo_retriever/src/nemo_retriever/vector_store/__main__.py
new file mode 100644
index 000000000..bd39e9ea8
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/vector_store/__main__.py
@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import typer
+
+from . import stage
+
+app = typer.Typer(help="Vector store utilities (LanceDB upload, etc).")
+app.add_typer(stage.app, name="stage")
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/vector_store/lancedb_store.py b/nemo_retriever/src/nemo_retriever/vector_store/lancedb_store.py
new file mode 100644
index 000000000..ad392bf15
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/vector_store/lancedb_store.py
@@ -0,0 +1,325 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Optional, Sequence, Tuple  # noqa: F401
+
+from nv_ingest_client.util.vdb.lancedb import LanceDB
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(frozen=True)
+class LanceDBConfig:
+    """
+    Minimal config for writing embeddings into LanceDB.
+
+    This module is intentionally lightweight: it can be used by the text-embedding
+    stage (`nemo_retriever.text_embed.stage`) and by the vector-store CLI (`nemo_retriever.vector_store.stage`).
+    """
+
+    uri: str = "lancedb"
+    table_name: str = "nv-ingest"
+    overwrite: bool = True
+
+    # Optional index creation (recommended for recall/search runs).
+    create_index: bool = True
+    index_type: str = "IVF_HNSW_SQ"
+    metric: str = "l2"
+    num_partitions: int = 16
+    num_sub_vectors: int = 256
+
+    hybrid: bool = False
+    fts_language: str = "English"
+
+
+def _read_text_embeddings_json_df(path: Path) -> pd.DataFrame:
+    """
+    Read a `*.text_embeddings.json` file emitted by `nemo_retriever.text_embed.stage`.
+
+    Expected wrapper shape:
+      {
+        ...,
+        "df_records": [ { "document_type": ..., "metadata": {...}, ... }, ... ],
+        ...
+      }
+    """
+    try:
+        obj = json.loads(path.read_text(encoding="utf-8", errors="replace"))
+    except Exception as e:
+        raise ValueError(f"Failed reading JSON {path}: {e}") from e
+
+    if isinstance(obj, dict):
+        recs = obj.get("df_records")
+        if isinstance(recs, list):
+            return pd.DataFrame([r for r in recs if isinstance(r, dict)])
+        # Fall back to a single record.
+        return pd.DataFrame([obj])
+
+    if isinstance(obj, list):
+        return pd.DataFrame([r for r in obj if isinstance(r, dict)])
+
+    return pd.DataFrame([])
+
+
+def _iter_text_embeddings_json_files(input_dir: Path, *, recursive: bool) -> List[Path]:
+    """
+    Return sorted list of `*.text_embeddings.json` files.
+
+    The stage5 default naming is: `<input>.text_embeddings.json` (where `<input>` is
+    typically a stage4 output filename).
+    """
+    if recursive:
+        files = list(input_dir.rglob("*.text_embeddings.json"))
+    else:
+        files = list(input_dir.glob("*.text_embeddings.json"))
+    return sorted([p for p in files if p.is_file()])
+
+
+def _safe_str(x: Any) -> str:
+    return "" if x is None else str(x)
+
+
+def _extract_source_path_and_id(meta: Dict[str, Any]) -> Tuple[str, str]:
+    """
+    Extract a stable source path/id from metadata.
+
+    Prefers:
+      - metadata.source_metadata.source_id
+      - metadata.source_metadata.source_name
+      - metadata.custom_content.path
+    """
+    source = meta.get("source_metadata") if isinstance(meta.get("source_metadata"), dict) else {}
+    source_id = source.get("source_id") or ""
+    source_name = source.get("source_name") or ""
+
+    custom = meta.get("custom_content") if isinstance(meta.get("custom_content"), dict) else {}
+    custom_path = custom.get("path") or custom.get("input_pdf") or custom.get("pdf_path") or ""
+
+    path = _safe_str(custom_path or source_id or source_name)
+    sid = _safe_str(source_id or path or source_name)
+    return path, sid
+
+
+def _extract_page_number(meta: Dict[str, Any]) -> int:
+    cm = meta.get("content_metadata") if isinstance(meta.get("content_metadata"), dict) else {}
+    page = cm.get("hierarchy", {}).get("page", -1)
+    try:
+        return int(page)
+    except Exception:
+        return -1
+
+
+def _build_lancedb_rows_from_df(df: pd.DataFrame) -> List[Dict[str, Any]]:
+    """
+    Transform an embeddings-enriched primitives DataFrame into LanceDB rows.
+
+    Rows include:
+      - vector (embedding)
+      - pdf_basename
+      - page_number
+      - pdf_page (basename_page)
+      - source_id
+      - path
+    """
+    out: List[Dict[str, Any]] = []
+
+    for _, row in df.iterrows():
+        meta = row.get("metadata")
+        if not isinstance(meta, dict):
+            continue
+
+        embedding = meta.get("embedding")
+        if embedding is None:
+            continue
+
+        # Normalize embedding to list[float]
+        if not isinstance(embedding, list):
+            try:
+                embedding = list(embedding)  # type: ignore[arg-type]
+            except Exception:
+                continue
+
+        path, source_id = _extract_source_path_and_id(meta)
+        page_number = _extract_page_number(meta)
+        p = Path(path) if path else None
+        filename = p.name if p is not None else ""
+        pdf_basename = p.stem if p is not None else ""
+        pdf_page = f"{pdf_basename}_{page_number}" if (pdf_basename and page_number >= 0) else ""
+
+        if page_number == -1:
+            logger.debug("Unable to determine page number for %s", path)
+
+        out.append(
+            {
+                "vector": embedding,
+                "pdf_page": pdf_page,
+                "filename": filename,
+                "pdf_basename": pdf_basename,
+                "page_number": int(page_number),
+                "source_id": source_id,
+                "path": path,
+            }
+        )
+
+    return out
+
+
+def _infer_vector_dim(rows: Sequence[Dict[str, Any]]) -> int:
+    for r in rows:
+        v = r.get("vector")
+        if isinstance(v, list) and v:
+            return int(len(v))
+    return 0
+
+
+def create_lancedb_index(table: Any, *, cfg: LanceDBConfig, text_column: str = "text") -> None:
+    """Create vector (IVF_HNSW_SQ) and optionally FTS indices on a LanceDB table."""
+    try:
+        table.create_index(
+            index_type=cfg.index_type,
+            metric=cfg.metric,
+            num_partitions=int(cfg.num_partitions),
+            num_sub_vectors=int(cfg.num_sub_vectors),
+            vector_column_name="vector",
+        )
+    except TypeError:
+        table.create_index(vector_column_name="vector")
+
+    if cfg.hybrid:
+        try:
+            table.create_fts_index(text_column, language=cfg.fts_language)
+        except Exception:
+            logger.warning(
+                "FTS index creation failed on column %r; continuing with vector-only search.",
+                text_column,
+                exc_info=True,
+            )
+
+
+def _write_rows_to_lancedb(rows: Sequence[Dict[str, Any]], *, cfg: LanceDBConfig) -> None:
+    if not rows:
+        logger.warning("No embeddings rows provided; nothing to write to LanceDB.")
+        return
+
+    dim = _infer_vector_dim(rows)
+    if dim <= 0:
+        raise ValueError("Failed to infer embedding dimension from rows.")
+
+    try:
+        import lancedb  # type: ignore
+        import pyarrow as pa  # type: ignore
+    except Exception as e:
+        raise RuntimeError(
+            "LanceDB write requested but dependencies are missing. "
+            "Install `lancedb` and `pyarrow` in this environment."
+        ) from e
+
+    db = lancedb.connect(uri=cfg.uri)
+
+    schema = pa.schema(
+        [
+            pa.field("vector", pa.list_(pa.float32(), dim)),
+            pa.field("pdf_page", pa.string()),
+            pa.field("filename", pa.string()),
+            pa.field("pdf_basename", pa.string()),
+            pa.field("page_number", pa.int32()),
+            pa.field("source_id", pa.string()),
+            pa.field("path", pa.string()),
+        ]
+    )
+
+    mode = "overwrite" if cfg.overwrite else "append"
+    table = db.create_table(cfg.table_name, data=list(rows), schema=schema, mode=mode)
+
+    if cfg.create_index:
+        create_lancedb_index(table, cfg=cfg)
+
+
+def write_embeddings_to_lancedb(df_with_embeddings: pd.DataFrame, *, cfg: LanceDBConfig) -> None:
+    """
+    Write embeddings found in `df_with_embeddings.metadata.embedding` to LanceDB.
+
+    This is used programmatically by `nemo_retriever.text_embed.stage.embed_text_from_primitives_df(...)`.
+    """
+    rows = _build_lancedb_rows_from_df(df_with_embeddings)
+    _write_rows_to_lancedb(rows, cfg=cfg)
+
+
+def write_text_embeddings_dir_to_lancedb(
+    input_dir: Path,
+    *,
+    cfg: LanceDBConfig,
+    recursive: bool = False,
+    limit: Optional[int] = None,
+) -> Dict[str, Any]:
+    """
+    Read `*.text_embeddings.json` files from `input_dir` and upload their embeddings to LanceDB.
+    """
+    input_dir = Path(input_dir)
+    files = _iter_text_embeddings_json_files(input_dir, recursive=bool(recursive))
+    if limit is not None:
+        files = files[: int(limit)]
+
+    processed = 0
+    skipped = 0
+    failed = 0
+
+    lancedb = LanceDB(uri=cfg.uri, table_name=cfg.table_name, overwrite=cfg.overwrite)
+
+    results = []
+
+    for p in files:
+        df = _read_text_embeddings_json_df(p)
+        rows = df.to_dict(orient="records")
+        results.append(rows)
+
+    if not results:
+        logger.warning("No *.text_embeddings.json files found in %s; nothing to write.", input_dir)
+        return {
+            "input_dir": str(input_dir),
+            "n_files": 0,
+            "processed": 0,
+            "skipped": 0,
+            "failed": 0,
+            "lancedb": {"uri": cfg.uri, "table_name": cfg.table_name, "overwrite": cfg.overwrite},
+        }
+
+    lancedb.run(results)
+
+    # all_rows: List[Dict[str, Any]] = []
+    # for p in files:
+    #     try:
+    #         df = _read_text_embeddings_json_df(p)
+    #         if df.empty:
+    #             skipped += 1
+    #             continue
+    #         rows = _build_lancedb_rows_from_df(df)
+    #         if not rows:
+    #             skipped += 1
+    #             continue
+    #         all_rows.extend(rows)
+    #         processed += 1
+    #     except Exception:
+    #         failed += 1
+    #         logger.exception("Failed reading embeddings from %s", p)
+
+    # # Write once so --overwrite behaves as expected.
+    # _write_rows_to_lancedb(all_rows, cfg=cfg)
+
+    return {
+        "input_dir": str(input_dir),
+        "n_files": len(files),
+        "processed": processed,
+        "skipped": skipped,
+        "failed": failed,
+        # "rows_written": len(all_rows),
+        "lancedb": {"uri": cfg.uri, "table_name": cfg.table_name, "overwrite": cfg.overwrite},
+    }
diff --git a/nemo_retriever/src/nemo_retriever/vector_store/stage.py b/nemo_retriever/src/nemo_retriever/vector_store/stage.py
new file mode 100644
index 000000000..ba3f994a1
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/vector_store/stage.py
@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from nemo_retriever.vector_store.lancedb_store import LanceDBConfig, write_text_embeddings_dir_to_lancedb
+
+console = Console()
+app = typer.Typer(help="Vector store stage: upload stage5 embeddings to a vector DB (LanceDB).")
+
+
+@app.command()
+def run(
+    input_dir: Path = typer.Option(
+        ...,
+        "--input-dir",
+        exists=True,
+        file_okay=False,
+        dir_okay=True,
+        help="Directory containing `*.text_embeddings.json` files (from `retriever local stage5`).",
+    ),
+    recursive: bool = typer.Option(False, "--recursive/--no-recursive", help="Scan subdirectories too."),
+    limit: Optional[int] = typer.Option(None, "--limit", min=1, help="Optionally limit number of input files."),
+    lancedb_uri: str = typer.Option("lancedb", "--lancedb-uri", help="LanceDB database URI (directory path)."),
+    table_name: str = typer.Option("nv-ingest", "--table-name", help="LanceDB table name."),
+    overwrite: bool = typer.Option(
+        True,
+        "--overwrite/--append",
+        help="Overwrite table (default) or append to existing.",
+    ),
+    create_index: bool = typer.Option(
+        True,
+        "--create-index/--no-create-index",
+        help="Create a vector index after upload.",
+    ),
+    index_type: str = typer.Option("IVF_HNSW_SQ", "--index-type", help="LanceDB index type."),
+    metric: str = typer.Option("l2", "--metric", help="Distance metric for the index."),
+    num_partitions: int = typer.Option(16, "--num-partitions", min=1, help="Index partitions."),
+    num_sub_vectors: int = typer.Option(256, "--num-sub-vectors", min=1, help="Index sub-vectors."),
+) -> None:
+    """
+    Upload embeddings from `*.text_embeddings.json` into LanceDB.
+
+    Each stored row includes:
+      - `vector`: the embedding
+      - `pdf_basename`: source filename stem
+      - `page_number`: page number from `metadata.content_metadata.page_number`
+      - `path` / `source_id`: source identifiers
+    """
+    cfg = LanceDBConfig(
+        uri=str(lancedb_uri),
+        table_name=str(table_name),
+        overwrite=bool(overwrite),
+        create_index=bool(create_index),
+        index_type=str(index_type),
+        metric=str(metric),
+        num_partitions=int(num_partitions),
+        num_sub_vectors=int(num_sub_vectors),
+    )
+
+    info = write_text_embeddings_dir_to_lancedb(
+        Path(input_dir),
+        cfg=cfg,
+        recursive=bool(recursive),
+        limit=limit,
+    )
+    console.print(
+        f"[green]Done[/green] files={info['n_files']} processed={info['processed']} skipped={info['skipped']} "
+        f"failed={info['failed']} lancedb_uri={cfg.uri} table={cfg.table_name}"
+    )
+
+
+def main() -> None:
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/nemo_retriever/src/nemo_retriever/version.py b/nemo_retriever/src/nemo_retriever/version.py
new file mode 100644
index 000000000..81c099013
--- /dev/null
+++ b/nemo_retriever/src/nemo_retriever/version.py
@@ -0,0 +1,162 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""Version helpers for build-time and runtime metadata."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from functools import lru_cache
+from importlib.metadata import PackageNotFoundError, version as dist_version
+from pathlib import Path
+import os
+import subprocess
+
+try:
+    from ._build_info import BUILD_DATE as _PACKAGE_BUILD_DATE
+    from ._build_info import BUILD_GIT_SHA as _PACKAGE_BUILD_GIT_SHA
+except ImportError:
+    # During setuptools build isolation the package may not be importable
+    _PACKAGE_BUILD_DATE = "unknown"
+    _PACKAGE_BUILD_GIT_SHA = "unknown"
+
+_PKG_NAME = "nemo-retriever"
+_UNKNOWN = "unknown"
+
+
+def _utc_now() -> datetime:
+    return datetime.now(timezone.utc)
+
+
+@lru_cache(maxsize=1)
+def _build_datetime() -> datetime:
+    if _PACKAGE_BUILD_DATE and _PACKAGE_BUILD_DATE != _UNKNOWN:
+        normalized = _PACKAGE_BUILD_DATE.replace("Z", "+00:00")
+        try:
+            dt = datetime.fromisoformat(normalized)
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=timezone.utc)
+            return dt.astimezone(timezone.utc)
+        except ValueError:
+            pass
+
+    source_date_epoch = os.getenv("SOURCE_DATE_EPOCH")
+    if source_date_epoch and source_date_epoch.isdigit():
+        return datetime.fromtimestamp(int(source_date_epoch), tz=timezone.utc)
+
+    build_date = os.getenv("RETRIEVER_BUILD_DATE")
+    if build_date:
+        # Accept ISO-8601-like strings from CI and normalize if timezone missing.
+        normalized = build_date.replace("Z", "+00:00")
+        try:
+            dt = datetime.fromisoformat(normalized)
+            if dt.tzinfo is None:
+                dt = dt.replace(tzinfo=timezone.utc)
+            return dt.astimezone(timezone.utc)
+        except ValueError:
+            pass
+
+    return _utc_now()
+
+
+@lru_cache(maxsize=1)
+def _run_git_short_sha() -> str | None:
+    repo_root = Path(__file__).resolve().parents[3]
+    try:
+        out = subprocess.check_output(
+            ["git", "rev-parse", "--short", "HEAD"],
+            cwd=repo_root,
+            stderr=subprocess.DEVNULL,
+            text=True,
+        ).strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        return None
+
+    return out or None
+
+
+def _is_source_checkout() -> bool:
+    package_root = Path(__file__).resolve().parents[2]
+    return (package_root / "pyproject.toml").exists()
+
+
+@lru_cache(maxsize=1)
+def _git_sha_short() -> str:
+    candidate = (
+        os.getenv("RETRIEVER_GIT_SHA")
+        or _PACKAGE_BUILD_GIT_SHA
+        or os.getenv("GITHUB_SHA")
+        or _run_git_short_sha()
+        or _UNKNOWN
+    )
+    return candidate[:7]
+
+
+@lru_cache(maxsize=1)
+def _build_number() -> str:
+    # Prefer explicit CI build numbers; fall back to timestamp so local builds
+    # naturally produce monotonically increasing dev versions.
+    candidate = os.getenv("RETRIEVER_BUILD_NUMBER") or os.getenv("GITHUB_RUN_NUMBER") or os.getenv("NV_INGEST_REV")
+    if candidate and candidate.isdigit():
+        return candidate
+    return _build_datetime().strftime("%Y%m%d%H%M%S")
+
+
+@lru_cache(maxsize=1)
+def _base_version() -> str:
+    return os.getenv("RETRIEVER_VERSION") or os.getenv("NV_INGEST_VERSION") or _build_datetime().strftime("%Y.%m.%d")
+
+
+def get_build_version() -> str:
+    """Return a PEP 440 compliant version string for packaging."""
+    release_type = (os.getenv("RETRIEVER_RELEASE_TYPE") or os.getenv("NV_INGEST_RELEASE_TYPE") or "dev").lower()
+
+    base_version = _base_version()
+    build_number = _build_number()
+
+    if release_type == "release":
+        return f"{base_version}.post{build_number}" if int(build_number) > 0 else base_version
+    if release_type == "dev":
+        return f"{base_version}.dev{build_number}"
+
+    raise ValueError("Invalid release type. Expected one of: dev, release. " f"Received: {release_type!r}")
+
+
+def _installed_version() -> str | None:
+    if _is_source_checkout():
+        return None
+    try:
+        return dist_version(_PKG_NAME)
+    except PackageNotFoundError:
+        return None
+
+
+def get_version_info() -> dict[str, str]:
+    """Return version metadata for runtime diagnostics."""
+    version = _installed_version() or get_build_version()
+    build_dt = _build_datetime()
+    build_date = build_dt.strftime("%Y-%m-%dT%H:%M:%SZ")
+    build_date_tag = build_dt.strftime("%Y%m%d")
+    git_sha = _git_sha_short()
+
+    if git_sha == _UNKNOWN:
+        full_version = version
+    else:
+        # Keep package version PEP 440 clean; expose traceability metadata here.
+        full_version = f"{version}+g{git_sha}.d{build_date_tag}"
+
+    return {
+        "version": version,
+        "git_sha": git_sha,
+        "build_date": build_date,
+        "full_version": full_version,
+    }
+
+
+def get_version() -> str:
+    """Return installed package version string."""
+    return get_version_info()["version"]
+
+
+__version__ = _installed_version() or get_build_version()
diff --git a/nemo_retriever/table_stage_config.yaml b/nemo_retriever/table_stage_config.yaml
new file mode 100644
index 000000000..e268c8ba7
--- /dev/null
+++ b/nemo_retriever/table_stage_config.yaml
@@ -0,0 +1,38 @@
+# Example config for:
+#   - `retriever table stage run --config <this.yaml> --input <primitives.parquet>`
+#   - `retriever local stage3 run --config <this.yaml> --input <primitives.parquet>`
+#
+# This YAML is parsed into `nv_ingest_api.internal.schemas.extract.extract_table_schema.TableExtractorSchema`
+# via `nemo_retriever.table.config.load_table_extractor_schema_from_dict`.
+#
+# IMPORTANT:
+# `endpoint_config.yolox_endpoints` and `endpoint_config.ocr_endpoints` must each provide at least one
+# endpoint (gRPC or HTTP). Both cannot be null/empty for either entry.
+#
+
+# Optional worker settings
+max_queue_size: 1
+n_workers: 2
+raise_on_failure: false
+
+# Endpoint configuration for table extraction (YOLOX table-structure + OCR).
+endpoint_config:
+  # Optional auth token for secured services (NIM)
+  auth_token: null
+
+  # Tuple/list in the form: [grpc, http]
+  # YOLOX table-structure model endpoints
+  # yolox_endpoints: ["localhost:8007", "http://localhost:8006/v1/infer"]
+  yolox_endpoints: null
+  # Optional; if omitted it is inferred from which endpoint is present.
+  # yolox_infer_protocol: grpc
+
+  # OCR model endpoints
+  # ocr_endpoints: ["localhost:8010", "http://localhost:8019/v1/infer"]
+  ocr_endpoints: null
+  # Optional; if omitted it is inferred from which endpoint is present.
+  # ocr_infer_protocol: grpc
+
+  # Optional performance knobs
+  nim_batch_size: 2
+  workers_per_progress_engine: 5
diff --git a/nemo_retriever/tests/__init__.py b/nemo_retriever/tests/__init__.py
new file mode 100644
index 000000000..69f6fb050
--- /dev/null
+++ b/nemo_retriever/tests/__init__.py
@@ -0,0 +1,5 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+# Tests for retriever
diff --git a/nemo_retriever/tests/test_asr_actor.py b/nemo_retriever/tests/test_asr_actor.py
new file mode 100644
index 000000000..92c73176a
--- /dev/null
+++ b/nemo_retriever/tests/test_asr_actor.py
@@ -0,0 +1,198 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Unit tests for nemo_retriever.audio: ASRActor (with mocked Parakeet client).
+
+Avoids importing nemo_retriever.model (and thus torch) by not eagerly loading
+the model package; local-ASR tests inject a fake nemo_retriever.model.local
+into sys.modules so the real module is never loaded.
+"""
+
+import base64
+import sys
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+import pandas as pd
+
+from nemo_retriever.audio.asr_actor import ASRActor
+from nemo_retriever.audio.asr_actor import apply_asr_to_df
+from nemo_retriever.params import ASRParams
+
+
+def test_strip_pad_from_transcript():
+    """Transformers backend post-process removes <pad> and normalizes spaces."""
+    # Some tests monkeypatch nemo_retriever.model.local with a mock module object.
+    # Ensure we import the real package submodule for this test.
+    local_mod = sys.modules.get("nemo_retriever.model.local")
+    if local_mod is not None and not hasattr(local_mod, "__path__"):
+        sys.modules.pop("nemo_retriever.model.local", None)
+    from nemo_retriever.model.local.parakeet_ctc_1_1b_asr import _strip_pad_from_transcript
+
+    assert _strip_pad_from_transcript("") == ""
+    assert _strip_pad_from_transcript("  ") == ""
+    assert _strip_pad_from_transcript("<pad>") == ""
+    assert _strip_pad_from_transcript("<pad> hello <pad> world") == "hello world"
+    assert _strip_pad_from_transcript("  a  <pad>  b  ") == "a b"
+    out = _strip_pad_from_transcript("  <pad> foo <pad> bar <pad>  ")
+    assert out == "foo bar"
+    assert "<pad>" not in out
+
+
+def test_asr_actor_empty_batch():
+    with patch("nemo_retriever.audio.asr_actor._get_client") as mock_get:
+        mock_client = MagicMock()
+        mock_get.return_value = mock_client
+
+        params = ASRParams(audio_endpoints=("localhost:50051", None))
+        actor = ASRActor(params=params)
+        empty = pd.DataFrame(columns=["path", "bytes"])
+        out = actor(empty)
+
+        assert isinstance(out, pd.DataFrame)
+        assert "text" in out.columns
+        assert len(out) == 0
+        mock_client.infer.assert_not_called()
+
+
+def test_asr_actor_mock_transcribe():
+    with patch("nemo_retriever.audio.asr_actor._get_client") as mock_get:
+        mock_client = MagicMock()
+        mock_client.infer.return_value = ([], "hello world transcript")
+        mock_get.return_value = mock_client
+
+        params = ASRParams(audio_endpoints=("localhost:50051", None))
+        actor = ASRActor(params=params)
+        raw = b"\x00\x00\x00\x00"
+        batch = pd.DataFrame(
+            [
+                {
+                    "path": "/tmp/chunk.wav",
+                    "bytes": raw,
+                    "source_path": "/tmp/source.wav",
+                    "duration": 1.0,
+                    "chunk_index": 0,
+                    "metadata": {"source_path": "/tmp/source.wav", "chunk_index": 0, "duration": 1.0},
+                    "page_number": 0,
+                }
+            ]
+        )
+        out = actor(batch)
+
+        assert len(out) == 1
+        assert out["text"].iloc[0] == "hello world transcript"
+        assert out["path"].iloc[0] == "/tmp/chunk.wav"
+        assert out["source_path"].iloc[0] == "/tmp/source.wav"
+        mock_client.infer.assert_called_once()
+        call_arg = mock_client.infer.call_args[0][0]
+        assert call_arg == base64.b64encode(raw).decode("ascii")
+
+
+def test_apply_asr_to_df():
+    with patch("nemo_retriever.audio.asr_actor._get_client") as mock_get:
+        mock_client = MagicMock()
+        mock_client.infer.return_value = ([], "applied transcript")
+        mock_get.return_value = mock_client
+
+        batch = pd.DataFrame(
+            [
+                {
+                    "path": "/p",
+                    "bytes": b"x",
+                    "source_path": "/s",
+                    "duration": 0.5,
+                    "chunk_index": 0,
+                    "metadata": {},
+                    "page_number": 0,
+                }
+            ]
+        )
+        out = apply_asr_to_df(batch, asr_params={"audio_endpoints": ("localhost:50051", None)})
+        assert isinstance(out, pd.DataFrame)
+        assert len(out) == 1
+        assert out["text"].iloc[0] == "applied transcript"
+
+
+def test_local_asr_does_not_call_get_client():
+    """When audio_endpoints are both null, ASRActor uses local model and does not call _get_client."""
+    mock_model = MagicMock()
+    mock_model.transcribe.return_value = ["mocked local transcript"]
+    mock_class = MagicMock(return_value=mock_model)
+    mock_local = MagicMock()
+    mock_local.ParakeetCTC1B1ASR = mock_class
+    prev_local = sys.modules.get("nemo_retriever.model.local")
+    sys.modules["nemo_retriever.model.local"] = mock_local
+    try:
+        with patch("nemo_retriever.audio.asr_actor._get_client") as mock_get:
+            params = ASRParams(audio_endpoints=(None, None))
+            actor = ASRActor(params=params)
+
+            mock_get.assert_not_called()
+            assert actor._client is None
+            assert actor._model is mock_model
+
+            batch = pd.DataFrame(
+                [
+                    {
+                        "path": "/tmp/chunk.wav",
+                        "bytes": b"fake_audio_bytes",
+                        "source_path": "/tmp/source.wav",
+                        "duration": 1.0,
+                        "chunk_index": 0,
+                        "metadata": {},
+                        "page_number": 0,
+                    }
+                ]
+            )
+            out = actor(batch)
+
+            assert len(out) == 1
+            assert out["text"].iloc[0] == "mocked local transcript"
+            mock_model.transcribe.assert_called_once()
+            # One path passed (temp file or /tmp/chunk.wav)
+            call_args = mock_model.transcribe.call_args[0][0]
+            assert isinstance(call_args, list)
+            assert len(call_args) == 1
+    finally:
+        if prev_local is None:
+            sys.modules.pop("nemo_retriever.model.local", None)
+        else:
+            sys.modules["nemo_retriever.model.local"] = prev_local
+
+
+def test_local_asr_apply_asr_to_df():
+    """apply_asr_to_df with audio_endpoints=(None, None) uses local model when mocked."""
+    mock_model = MagicMock()
+    mock_model.transcribe.return_value = ["apply local text"]
+    mock_class = MagicMock(return_value=mock_model)
+    mock_local = MagicMock()
+    mock_local.ParakeetCTC1B1ASR = mock_class
+    prev_local = sys.modules.get("nemo_retriever.model.local")
+    sys.modules["nemo_retriever.model.local"] = mock_local
+    try:
+        with patch("nemo_retriever.audio.asr_actor._get_client") as mock_get:
+            batch = pd.DataFrame(
+                [
+                    {
+                        "path": "/p",
+                        "bytes": b"x",
+                        "source_path": "/s",
+                        "duration": 0.5,
+                        "chunk_index": 0,
+                        "metadata": {},
+                        "page_number": 0,
+                    }
+                ]
+            )
+            out = apply_asr_to_df(batch, asr_params={"audio_endpoints": (None, None)})
+
+            mock_get.assert_not_called()
+            assert len(out) == 1
+            assert out["text"].iloc[0] == "apply local text"
+    finally:
+        if prev_local is None:
+            sys.modules.pop("nemo_retriever.model.local", None)
+        else:
+            sys.modules["nemo_retriever.model.local"] = prev_local
diff --git a/nemo_retriever/tests/test_audio_benchmark.py b/nemo_retriever/tests/test_audio_benchmark.py
new file mode 100644
index 000000000..3862d3a83
--- /dev/null
+++ b/nemo_retriever/tests/test_audio_benchmark.py
@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Minimal test that the audio extraction benchmark runs (mock ASR, small row count).
+Skip when ffmpeg or Ray is not available.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from nemo_retriever.audio.media_interface import is_media_available
+
+
+def _make_small_wav(path: Path, duration_sec: float = 0.3, sample_rate: int = 8000) -> None:
+    import wave
+
+    n_frames = int(sample_rate * duration_sec)
+    with wave.open(str(path), "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(sample_rate)
+        wav.writeframes(b"\x00\x00" * n_frames)
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_audio_benchmark_run_mock_asr(tmp_path: Path):
+    """Run benchmark with --mock-asr and small row count; assert it completes."""
+    wav = tmp_path / "tiny.wav"
+    _make_small_wav(wav, duration_sec=0.3)
+
+    from typer.testing import CliRunner
+
+    from nemo_retriever.utils.benchmark.audio_extract_actor import app
+
+    runner = CliRunner()
+    result = runner.invoke(
+        app,
+        [
+            "run",
+            "--audio-path",
+            str(wav),
+            "--rows",
+            "2",
+            "--workers",
+            "1",
+            "--batch-sizes",
+            "2",
+            "--mock-asr",
+        ],
+    )
+    assert result.exit_code == 0, (result.stdout, result.stderr)
+    assert "audio_extract" in result.stdout or "BEST" in result.stdout
diff --git a/nemo_retriever/tests/test_audio_chunk_actor.py b/nemo_retriever/tests/test_audio_chunk_actor.py
new file mode 100644
index 000000000..293825488
--- /dev/null
+++ b/nemo_retriever/tests/test_audio_chunk_actor.py
@@ -0,0 +1,89 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Unit tests for nemo_retriever.audio: MediaChunkActor and audio_path_to_chunks_df.
+"""
+
+import wave
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from nemo_retriever.audio.chunk_actor import CHUNK_COLUMNS
+from nemo_retriever.audio.chunk_actor import MediaChunkActor
+from nemo_retriever.audio.chunk_actor import audio_path_to_chunks_df
+from nemo_retriever.audio.media_interface import is_media_available
+from nemo_retriever.params import AudioChunkParams
+
+
+def _make_small_wav(path: Path, duration_sec: float = 0.5, sample_rate: int = 8000) -> None:
+    """Write a minimal WAV file (e.g. 0.5s mono 8kHz) for tests."""
+    n_frames = int(sample_rate * duration_sec)
+    with wave.open(str(path), "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(sample_rate)
+        wav.writeframes(b"\x00\x00" * n_frames)
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_media_chunk_actor_empty_batch():
+    from nemo_retriever.audio import MediaChunkActor
+
+    params = AudioChunkParams(split_type="size", split_interval=1000)
+    actor = MediaChunkActor(params=params)
+    empty = pd.DataFrame(columns=["path", "bytes"])
+    out = actor(empty)
+    assert isinstance(out, pd.DataFrame)
+    assert list(out.columns) == CHUNK_COLUMNS
+    assert len(out) == 0
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_media_chunk_actor_single_small_file(tmp_path: Path):
+    from nemo_retriever.audio import MediaChunkActor
+
+    wav = tmp_path / "tiny.wav"
+    _make_small_wav(wav, duration_sec=0.3)
+    with open(wav, "rb") as f:
+        body = f.read()
+
+    params = AudioChunkParams(split_type="size", split_interval=1_000_000)
+    actor = MediaChunkActor(params=params)
+    batch = pd.DataFrame([{"path": str(wav.resolve()), "bytes": body}])
+    out = actor(batch)
+
+    assert isinstance(out, pd.DataFrame)
+    for col in ["path", "source_path", "duration", "chunk_index", "metadata", "page_number", "bytes"]:
+        assert col in out.columns
+    assert len(out) >= 1
+    assert out["source_path"].iloc[0] == str(wav.resolve())
+    assert out["chunk_index"].iloc[0] == 0
+    assert isinstance(out["bytes"].iloc[0], bytes)
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_audio_path_to_chunks_df(tmp_path: Path):
+    wav = tmp_path / "small.wav"
+    _make_small_wav(wav, duration_sec=0.4)
+    params = AudioChunkParams(split_type="size", split_interval=500_000)
+    df = audio_path_to_chunks_df(str(wav), params=params)
+    assert isinstance(df, pd.DataFrame)
+    assert len(df) >= 1
+    assert "path" in df.columns and "source_path" in df.columns
+    assert "bytes" in df.columns
+    assert df["source_path"].iloc[0] == str(wav.resolve())
+
+
+def test_media_chunk_actor_requires_ffmpeg():
+    """Without ffmpeg, MediaChunkActor.__init__ raises."""
+    pytest.importorskip("ffmpeg")
+    # If ffmpeg is available, is_media_available() is True; we can't test the failure path
+    # without unimporting. So we only run the raise test when ffmpeg is missing.
+    if is_media_available():
+        pytest.skip("ffmpeg available; cannot test missing-ffmpeg path here")
+    with pytest.raises(RuntimeError, match="ffmpeg"):
+        MediaChunkActor(params=AudioChunkParams())
diff --git a/nemo_retriever/tests/test_audio_pipeline_batch.py b/nemo_retriever/tests/test_audio_pipeline_batch.py
new file mode 100644
index 000000000..09ce1a7ad
--- /dev/null
+++ b/nemo_retriever/tests/test_audio_pipeline_batch.py
@@ -0,0 +1,309 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Integration-style tests for the audio pipeline (batch, inprocess, fused).
+
+Uses a small generated WAV and mocked ASR so no Parakeet endpoint or mp3/ dir is required.
+Skip if Ray or ffmpeg is not available.
+"""
+
+from pathlib import Path
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+import pandas as pd
+import pytest
+
+from nemo_retriever.audio.chunk_actor import _chunk_one
+from nemo_retriever.audio.media_interface import MediaInterface
+from nemo_retriever.audio.media_interface import is_media_available
+from nemo_retriever.params import AudioChunkParams
+from nemo_retriever.params import ASRParams
+from nemo_retriever.params import LanceDbParams
+from nemo_retriever.params import VdbUploadParams
+
+
+def _make_small_wav(path: Path, duration_sec: float = 0.5, sample_rate: int = 8000) -> None:
+    import wave
+
+    n_frames = int(sample_rate * duration_sec)
+    with wave.open(str(path), "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(sample_rate)
+        wav.writeframes(b"\x00\x00" * n_frames)
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_audio_chunk_then_mock_asr_flow(tmp_path: Path):
+    """Chunk one small WAV and verify chunk rows have expected shape (no Ray)."""
+    wav = tmp_path / "tiny.wav"
+    _make_small_wav(wav, duration_sec=0.4)
+    params = AudioChunkParams(split_type="size", split_interval=500_000)
+    interface = MediaInterface()
+    rows = _chunk_one(str(wav), params, interface)
+    assert len(rows) >= 1
+    row = rows[0]
+    assert "path" in row and "source_path" in row and "duration" in row
+    assert "chunk_index" in row and "bytes" in row
+    assert row["source_path"] == str(wav.resolve())
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_batch_audio_pipeline_with_mocked_asr(tmp_path: Path):
+    """Run batch pipeline with Ray in local_mode so _get_client mock is visible in workers."""
+    ray = pytest.importorskip("ray")
+    pytest.importorskip("lancedb")
+
+    wav = tmp_path / "small.wav"
+    _make_small_wav(wav, duration_sec=0.5)
+    lancedb_dir = tmp_path / "lancedb"
+    lancedb_dir.mkdir()
+
+    # Ray workers/raylet resolve path deps from working_dir; use nv-ingest repo root.
+    _nv_ingest_root = Path(__file__).resolve().parents[2]
+
+    from nemo_retriever.ingest_modes.batch import BatchIngestor
+
+    mock_client = MagicMock()
+    mock_client.infer.return_value = ([], "mock transcript for integration test")
+
+    with patch("nemo_retriever.audio.asr_actor._get_client", return_value=mock_client):
+        ingestor = (
+            BatchIngestor(documents=[])
+            .files([str(wav)])
+            .extract_audio(
+                params=AudioChunkParams(split_type="size", split_interval=500_000),
+                asr_params=ASRParams(audio_endpoints=("localhost:50051", None)),
+            )
+            .embed()
+            .vdb_upload(
+                params=VdbUploadParams(
+                    lancedb=LanceDbParams(
+                        lancedb_uri=str(lancedb_dir),
+                        table_name="test_audio",
+                        overwrite=True,
+                    )
+                )
+            )
+        )
+        try:
+            ray.init(
+                ignore_reinit_error=True,
+                local_mode=True,
+                runtime_env={"working_dir": str(_nv_ingest_root)},
+            )
+            results = ingestor.ingest()
+        finally:
+            try:
+                ray.shutdown()
+            except Exception:
+                pass
+
+    assert results is not None
+    # ingest() returns num_pages (int); with mocked ASR in driver only, workers may hit real endpoint and get 0 pages
+    assert isinstance(results, (int, list))
+    if isinstance(results, int):
+        assert results >= 0
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_inprocess_audio_pipeline_with_mocked_asr(tmp_path: Path):
+    """Inprocess: files -> extract_audio (chunk + mocked ASR) -> ingest(); assert result DataFrames have text."""
+    wav = tmp_path / "small.wav"
+    _make_small_wav(wav, duration_sec=0.5)
+
+    from nemo_retriever.ingest_modes.inprocess import InProcessIngestor
+
+    mock_client = MagicMock()
+    mock_client.infer.return_value = ([], "inprocess mock transcript")
+
+    with patch("nemo_retriever.audio.asr_actor._get_client", return_value=mock_client):
+        ingestor = (
+            InProcessIngestor(documents=[])
+            .files([str(wav)])
+            .extract_audio(
+                params=AudioChunkParams(split_type="size", split_interval=500_000),
+                asr_params=ASRParams(audio_endpoints=("localhost:50051", None)),
+            )
+        )
+        results = ingestor.ingest()
+
+    assert results is not None
+    assert isinstance(results, list)
+    assert len(results) >= 1
+    df = results[0]
+    assert isinstance(df, pd.DataFrame)
+    assert "text" in df.columns
+    assert len(df) >= 1
+    assert (df["text"] == "inprocess mock transcript").all()
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_inprocess_audio_pipeline_local_asr_mocked(tmp_path: Path):
+    """Inprocess with audio_endpoints=(None, None) uses local ASR; mock ParakeetCTC1B1ASR so no real model."""
+    wav = tmp_path / "small.wav"
+    _make_small_wav(wav, duration_sec=0.5)
+
+    from nemo_retriever.ingest_modes.inprocess import InProcessIngestor
+
+    mock_model = MagicMock()
+    mock_model.transcribe.return_value = ["local asr mock transcript"]
+
+    with patch("nemo_retriever.audio.asr_actor._get_client") as mock_get_client:
+        with patch("nemo_retriever.model.local.ParakeetCTC1B1ASR", return_value=mock_model):
+            ingestor = (
+                InProcessIngestor(documents=[])
+                .files([str(wav)])
+                .extract_audio(
+                    params=AudioChunkParams(split_type="size", split_interval=500_000),
+                    asr_params=ASRParams(audio_endpoints=(None, None)),
+                )
+            )
+            results = ingestor.ingest()
+
+    mock_get_client.assert_not_called()
+    assert results is not None
+    assert isinstance(results, list)
+    assert len(results) >= 1
+    df = results[0]
+    assert isinstance(df, pd.DataFrame)
+    assert "text" in df.columns
+    assert len(df) >= 1
+    assert (df["text"] == "local asr mock transcript").all()
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_fused_audio_pipeline_with_mocked_asr(tmp_path: Path):
+    """Fused: same as batch but FusedIngestor; embed() uses explode + _BatchEmbedActor when _pipeline_type==audio."""
+    ray = pytest.importorskip("ray")
+    pytest.importorskip("lancedb")
+
+    wav = tmp_path / "small.wav"
+    _make_small_wav(wav, duration_sec=0.5)
+    lancedb_dir = tmp_path / "lancedb"
+    lancedb_dir.mkdir()
+
+    _nv_ingest_root = Path(__file__).resolve().parents[2]
+
+    from nemo_retriever.ingest_modes.fused import FusedIngestor
+
+    mock_client = MagicMock()
+    mock_client.infer.return_value = ([], "fused mock transcript")
+
+    with patch("nemo_retriever.audio.asr_actor._get_client", return_value=mock_client):
+        ingestor = (
+            FusedIngestor(documents=[])
+            .files([str(wav)])
+            .extract_audio(
+                params=AudioChunkParams(split_type="size", split_interval=500_000),
+                asr_params=ASRParams(audio_endpoints=("localhost:50051", None)),
+            )
+            .embed()
+            .vdb_upload(
+                params=VdbUploadParams(
+                    lancedb=LanceDbParams(
+                        lancedb_uri=str(lancedb_dir),
+                        table_name="test_audio_fused",
+                        overwrite=True,
+                    )
+                )
+            )
+        )
+        try:
+            ray.init(
+                ignore_reinit_error=True,
+                local_mode=True,
+                runtime_env={"working_dir": str(_nv_ingest_root)},
+            )
+            results = ingestor.ingest()
+        finally:
+            try:
+                ray.shutdown()
+            except Exception:
+                pass
+
+    assert results is not None
+    assert isinstance(results, (int, list))
+    if isinstance(results, int):
+        assert results >= 0
+
+
+def _mp3_dir() -> Path | None:
+    """Return mp3/ directory next to retriever (nv-ingest/retriever/mp3) if it exists."""
+    root = Path(__file__).resolve().parents[1]  # retriever/
+    mp3 = root / "mp3"
+    return mp3 if mp3.is_dir() else None
+
+
+def _glob_audio(mp3_dir: Path) -> list[str]:
+    """Return list of audio paths in mp3_dir (e.g. mp3/*.mp3, mp3/*.wav)."""
+    out: list[str] = []
+    for ext in ("*.mp3", "*.wav", "*.m4a"):
+        out.extend(str(p) for p in mp3_dir.glob(ext) if p.is_file())
+    return sorted(out)
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg/ffprobe not available")
+def test_audio_pipeline_with_mp3_dir_mocked_asr(tmp_path: Path):
+    """
+    Integration test using mp3/ when present: .files('mp3/*.mp3').extract_audio().embed().vdb_upload().ingest()
+    with mocked ASR. Skips if mp3/ is missing or has no audio files.
+    """
+    mp3_dir = _mp3_dir()
+    if mp3_dir is None:
+        pytest.skip("mp3/ directory not found (create nv-ingest/retriever/mp3/ for this test)")
+    audio_files = _glob_audio(mp3_dir)
+    if not audio_files:
+        pytest.skip("mp3/ has no .mp3/.wav/.m4a files (add sample audio for integration test)")
+
+    ray = pytest.importorskip("ray")
+    pytest.importorskip("lancedb")
+
+    lancedb_dir = tmp_path / "lancedb"
+    lancedb_dir.mkdir()
+    _nv_ingest_root = Path(__file__).resolve().parents[2]
+
+    from nemo_retriever.ingest_modes.batch import BatchIngestor
+
+    mock_client = MagicMock()
+    mock_client.infer.return_value = ([], "mock transcript from mp3/ integration")
+
+    with patch("nemo_retriever.audio.asr_actor._get_client", return_value=mock_client):
+        ingestor = (
+            BatchIngestor(documents=[])
+            .files(audio_files)
+            .extract_audio(
+                params=AudioChunkParams(split_type="size", split_interval=500_000),
+                asr_params=ASRParams(audio_endpoints=("localhost:50051", None)),
+            )
+            .embed()
+            .vdb_upload(
+                params=VdbUploadParams(
+                    lancedb=LanceDbParams(
+                        lancedb_uri=str(lancedb_dir),
+                        table_name="test_audio_mp3",
+                        overwrite=True,
+                    )
+                )
+            )
+        )
+        try:
+            ray.init(
+                ignore_reinit_error=True,
+                local_mode=True,
+                runtime_env={"working_dir": str(_nv_ingest_root)},
+            )
+            results = ingestor.ingest()
+        finally:
+            try:
+                ray.shutdown()
+            except Exception:
+                pass
+
+    assert results is not None
+    # Batch ingest() returns num_pages (int)
+    assert isinstance(results, int)
+    assert results >= len(audio_files)
diff --git a/nemo_retriever/tests/test_audio_stage.py b/nemo_retriever/tests/test_audio_stage.py
new file mode 100644
index 000000000..33124adbf
--- /dev/null
+++ b/nemo_retriever/tests/test_audio_stage.py
@@ -0,0 +1,100 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Tests for the audio extraction-only stage (retriever audio extract).
+"""
+
+from pathlib import Path
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+import pytest
+
+from nemo_retriever.audio.media_interface import is_media_available
+from nemo_retriever.audio.stage import _audio_extraction_json_path
+from nemo_retriever.audio.stage import _run_extract_one
+from nemo_retriever.audio.stage import extract
+from nemo_retriever.params import ASRParams
+from nemo_retriever.params import AudioChunkParams
+
+
+def _make_small_wav(path: Path, duration_sec: float = 0.5, sample_rate: int = 8000) -> None:
+    import wave
+
+    n_frames = int(sample_rate * duration_sec)
+    with wave.open(str(path), "wb") as wav:
+        wav.setnchannels(1)
+        wav.setsampwidth(2)
+        wav.setframerate(sample_rate)
+        wav.writeframes(b"\x00\x00" * n_frames)
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_audio_stage_extract_one_mocked_asr(tmp_path: Path):
+    """Run extraction (chunk + ASR) on one small WAV with mocked ASR; assert output shape."""
+    wav = tmp_path / "tiny.wav"
+    _make_small_wav(wav, duration_sec=0.4)
+    chunk_params = AudioChunkParams(split_type="size", split_interval=500_000)
+    asr_params = ASRParams(audio_endpoints=("localhost:50051", None))
+
+    mock_client = MagicMock()
+    mock_client.infer.return_value = ([], "mock transcript for stage test")
+
+    with patch("nemo_retriever.audio.asr_actor._get_client", return_value=mock_client):
+        df = _run_extract_one(str(wav), chunk_params, asr_params)
+
+    assert not df.empty
+    assert "text" in df.columns
+    assert "source_path" in df.columns
+    assert "chunk_index" in df.columns
+    assert "duration" in df.columns
+    assert df["text"].iloc[0] == "mock transcript for stage test"
+
+
+@pytest.mark.skipif(not is_media_available(), reason="ffmpeg not available")
+def test_audio_stage_extract_cli_writes_sidecar(tmp_path: Path):
+    """Run audio extract CLI; assert sidecar JSON exists and has expected shape."""
+    wav = tmp_path / "sample.wav"
+    _make_small_wav(wav, duration_sec=0.3)
+    mock_client = MagicMock()
+    mock_client.infer.return_value = ([], "cli mock transcript")
+
+    with patch("nemo_retriever.audio.asr_actor._get_client", return_value=mock_client):
+        extract(
+            input_dir=tmp_path,
+            glob="*.wav",
+            output_dir=None,
+            split_type="size",
+            split_interval=500_000,
+            audio_only=False,
+            video_audio_separate=False,
+            use_env_asr=False,
+            audio_grpc_endpoint="localhost:50051",
+            auth_token=None,
+            limit=None,
+            write_json=True,
+        )
+
+    sidecar = tmp_path / "sample.wav.audio_extraction.json"
+    assert sidecar.exists()
+    import json
+
+    data = json.loads(sidecar.read_text())
+    assert data.get("schema_version") == 1
+    assert data.get("stage") == "audio_extract"
+    assert "chunks" in data
+    assert data.get("num_chunks") == len(data["chunks"])
+    if data["chunks"]:
+        chunk = data["chunks"][0]
+        assert "text" in chunk
+        assert "source_path" in chunk
+        assert chunk["text"] == "cli mock transcript"
+
+
+def test_audio_extraction_json_path():
+    """Sidecar path is next to source or under output_dir."""
+    p = Path("/foo/bar/file.wav")
+    assert _audio_extraction_json_path(p, None) == Path("/foo/bar/file.wav.audio_extraction.json")
+    assert _audio_extraction_json_path(p, Path("/out")) == Path("/out/file.wav.audio_extraction.json")
diff --git a/nemo_retriever/tests/test_embed_params.py b/nemo_retriever/tests/test_embed_params.py
new file mode 100644
index 000000000..b75a1c39f
--- /dev/null
+++ b/nemo_retriever/tests/test_embed_params.py
@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Unit tests for EmbedParams._normalize_modality and IMAGE_MODALITIES constant.
+"""
+
+import pytest
+
+from nemo_retriever.params.models import EmbedParams, IMAGE_MODALITIES
+
+
+def test_normalize_modality_image_text_to_text_image():
+    """'image_text' is normalized to 'text_image' on all three modality fields."""
+    params = EmbedParams(
+        embed_modality="image_text",
+        text_elements_modality="image_text",
+        structured_elements_modality="image_text",
+    )
+    assert params.embed_modality == "text_image"
+    assert params.text_elements_modality == "text_image"
+    assert params.structured_elements_modality == "text_image"
+
+
+@pytest.mark.parametrize(
+    "value,expected",
+    [
+        ("text", "text"),
+        ("image", "image"),
+        ("text_image", "text_image"),
+        (None, None),
+    ],
+)
+def test_normalize_modality_passthrough(value, expected):
+    """Values other than 'image_text' pass through unchanged."""
+    kwargs = {}
+    if value is not None:
+        kwargs["embed_modality"] = value
+    kwargs["text_elements_modality"] = value
+    kwargs["structured_elements_modality"] = value
+
+    params = EmbedParams(**kwargs)
+
+    if value is not None:
+        assert params.embed_modality == expected
+    assert params.text_elements_modality == expected
+    assert params.structured_elements_modality == expected
+
+
+def test_image_modalities_constant():
+    """IMAGE_MODALITIES is a frozenset containing the three image-related modalities."""
+    assert IMAGE_MODALITIES == {"image", "text_image", "image_text"}
+    assert isinstance(IMAGE_MODALITIES, frozenset)
diff --git a/nemo_retriever/tests/test_factory.py b/nemo_retriever/tests/test_factory.py
new file mode 100644
index 000000000..dc3c0c9f7
--- /dev/null
+++ b/nemo_retriever/tests/test_factory.py
@@ -0,0 +1,64 @@
+import sys
+import types
+
+import pytest
+
+from nemo_retriever.application.modes.factory import create_runmode_ingestor
+from nemo_retriever.params import IngestorCreateParams
+
+
+def _register_dummy_mode_module(
+    monkeypatch: pytest.MonkeyPatch,
+    module_name: str,
+    class_name: str,
+) -> type:
+    module = types.ModuleType(module_name)
+
+    class DummyIngestor:
+        def __init__(self, **kwargs):
+            self.kwargs = kwargs
+
+    DummyIngestor.__name__ = class_name
+    setattr(module, class_name, DummyIngestor)
+    monkeypatch.setitem(sys.modules, module_name, module)
+    return DummyIngestor
+
+
+def test_create_runmode_ingestor_inprocess(monkeypatch: pytest.MonkeyPatch) -> None:
+    dummy_class = _register_dummy_mode_module(monkeypatch, "nemo_retriever.ingest_modes.inprocess", "InProcessIngestor")
+    params = IngestorCreateParams(documents=["a.pdf"])
+
+    ingestor = create_runmode_ingestor(run_mode="inprocess", params=params)
+
+    assert isinstance(ingestor, dummy_class)
+    assert ingestor.kwargs == {"documents": ["a.pdf"]}
+
+
+def test_create_runmode_ingestor_batch_and_fused(monkeypatch: pytest.MonkeyPatch) -> None:
+    batch_class = _register_dummy_mode_module(monkeypatch, "nemo_retriever.ingest_modes.batch", "BatchIngestor")
+    fused_class = _register_dummy_mode_module(monkeypatch, "nemo_retriever.ingest_modes.fused", "FusedIngestor")
+    params = IngestorCreateParams(documents=["doc.pdf"], ray_address="ray://cluster", ray_log_to_driver=False)
+
+    batch = create_runmode_ingestor(run_mode="batch", params=params)
+    fused = create_runmode_ingestor(run_mode="fused", params=params)
+
+    assert isinstance(batch, batch_class)
+    assert isinstance(fused, fused_class)
+    expected_kwargs = {"documents": ["doc.pdf"], "ray_address": "ray://cluster", "ray_log_to_driver": False}
+    assert batch.kwargs == expected_kwargs
+    assert fused.kwargs == expected_kwargs
+
+
+def test_create_runmode_ingestor_online(monkeypatch: pytest.MonkeyPatch) -> None:
+    dummy_class = _register_dummy_mode_module(monkeypatch, "nemo_retriever.ingest_modes.online", "OnlineIngestor")
+    params = IngestorCreateParams(documents=["doc.pdf"], base_url="http://example:7670")
+
+    ingestor = create_runmode_ingestor(run_mode="online", params=params)
+
+    assert isinstance(ingestor, dummy_class)
+    assert ingestor.kwargs == {"documents": ["doc.pdf"], "base_url": "http://example:7670"}
+
+
+def test_create_runmode_ingestor_raises_for_unknown_mode() -> None:
+    with pytest.raises(ValueError, match="Unknown run_mode"):
+        create_runmode_ingestor(run_mode="unknown-mode")  # type: ignore[arg-type]
diff --git a/nemo_retriever/tests/test_html_convert.py b/nemo_retriever/tests/test_html_convert.py
new file mode 100644
index 000000000..e558a4b29
--- /dev/null
+++ b/nemo_retriever/tests/test_html_convert.py
@@ -0,0 +1,87 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Unit tests for nemo_retriever.html.convert: html_to_markdown, html_file_to_chunks_df, html_bytes_to_chunks_df.
+"""
+
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from nemo_retriever.html.convert import html_bytes_to_chunks_df, html_file_to_chunks_df, html_to_markdown
+
+
+def test_html_to_markdown_str():
+    pytest.importorskip("markitdown")
+    html = "<html><body><p>Hello world</p></body></html>"
+    md = html_to_markdown(html)
+    assert isinstance(md, str)
+    assert "Hello" in md or "world" in md
+
+
+def test_html_to_markdown_bytes():
+    pytest.importorskip("markitdown")
+    html = b"<html><body><h1>Title</h1></body></html>"
+    md = html_to_markdown(html)
+    assert isinstance(md, str)
+    assert "Title" in md
+
+
+def test_html_to_markdown_path(tmp_path: Path):
+    pytest.importorskip("markitdown")
+    f = tmp_path / "page.html"
+    f.write_text("<html><body><p>From file</p></body></html>", encoding="utf-8")
+    md = html_to_markdown(str(f))
+    assert isinstance(md, str)
+    assert "From" in md or "file" in md
+
+
+def test_html_file_to_chunks_df(tmp_path: Path):
+    pytest.importorskip("markitdown")
+    pytest.importorskip("transformers")
+    f = tmp_path / "doc.html"
+    f.write_text(
+        "<html><body><h1>Heading</h1><p>First paragraph.</p><p>Second paragraph.</p></body></html>",
+        encoding="utf-8",
+    )
+    df = html_file_to_chunks_df(
+        str(f),
+        max_tokens=512,
+        overlap_tokens=0,
+    )
+    assert isinstance(df, pd.DataFrame)
+    assert "text" in df.columns and "path" in df.columns and "page_number" in df.columns and "metadata" in df.columns
+    assert len(df) >= 1
+    assert df["path"].iloc[0] == str(f.resolve())
+    assert df["page_number"].iloc[0] >= 1
+    assert "source_path" in df["metadata"].iloc[0]
+    assert "chunk_index" in df["metadata"].iloc[0]
+    assert df["text"].iloc[0].strip()
+
+
+def test_html_file_to_chunks_df_empty_content(tmp_path: Path):
+    pytest.importorskip("markitdown")
+    pytest.importorskip("transformers")
+    f = tmp_path / "empty.html"
+    f.write_text("<html><body></body></html>", encoding="utf-8")
+    df = html_file_to_chunks_df(str(f), max_tokens=512)
+    assert isinstance(df, pd.DataFrame)
+    assert list(df.columns) == ["text", "path", "page_number", "metadata"]
+    assert len(df) == 0
+
+
+def test_html_bytes_to_chunks_df(tmp_path: Path):
+    pytest.importorskip("markitdown")
+    pytest.importorskip("transformers")
+    html_bytes = b"<html><body><p>Chunk content from bytes.</p></body></html>"
+    path = str(tmp_path / "virtual.html")
+    df = html_bytes_to_chunks_df(html_bytes, path, max_tokens=512, overlap_tokens=0)
+    assert isinstance(df, pd.DataFrame)
+    assert "text" in df.columns and "path" in df.columns and "page_number" in df.columns and "metadata" in df.columns
+    assert len(df) >= 1
+    assert df["path"].iloc[0] == path
+    assert "source_path" in df["metadata"].iloc[0]
+    assert df["text"].iloc[0].strip()
diff --git a/nemo_retriever/tests/test_ingest_config.py b/nemo_retriever/tests/test_ingest_config.py
new file mode 100644
index 000000000..2a512ffee
--- /dev/null
+++ b/nemo_retriever/tests/test_ingest_config.py
@@ -0,0 +1,78 @@
+from pathlib import Path
+
+import pytest
+
+from nemo_retriever.ingest_config import (
+    load_ingest_config_file,
+    load_ingest_config_section,
+    resolve_ingest_config_path,
+)
+
+
+def test_resolve_ingest_config_path_prefers_explicit() -> None:
+    path, source = resolve_ingest_config_path(Path("~/custom-ingest.yaml"))
+    assert source == "explicit"
+    assert path == Path.home() / "custom-ingest.yaml"
+
+
+def test_resolve_ingest_config_path_local_then_home(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    home_dir = tmp_path / "home"
+    cwd_dir = tmp_path / "cwd"
+    home_dir.mkdir()
+    cwd_dir.mkdir()
+
+    monkeypatch.setenv("HOME", str(home_dir))
+    monkeypatch.chdir(cwd_dir)
+
+    (home_dir / ".ingest-config.yaml").write_text("chart: {}", encoding="utf-8")
+    local_path, local_source = resolve_ingest_config_path(None)
+    assert local_source == "home"
+    assert local_path == home_dir / ".ingest-config.yaml"
+
+    (cwd_dir / "ingest-config.yaml").write_text("chart: {}", encoding="utf-8")
+    local_path, local_source = resolve_ingest_config_path(None)
+    assert local_source == "local"
+    assert local_path == cwd_dir / "ingest-config.yaml"
+
+
+def test_load_ingest_config_file_without_config_returns_empty(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    home_dir = tmp_path / "empty-home"
+    cwd_dir = tmp_path / "empty-cwd"
+    home_dir.mkdir()
+    cwd_dir.mkdir()
+    monkeypatch.setenv("HOME", str(home_dir))
+    monkeypatch.chdir(cwd_dir)
+
+    cfg, path, source = load_ingest_config_file(None, verbose=False)
+    assert cfg == {}
+    assert path is None
+    assert source == "none"
+
+
+def test_load_ingest_config_file_rejects_non_mapping_yaml(tmp_path: Path) -> None:
+    config_path = tmp_path / "ingest-config.yaml"
+    config_path.write_text("- not\n- a\n- mapping\n", encoding="utf-8")
+
+    with pytest.raises(ValueError, match="must be a mapping/object"):
+        load_ingest_config_file(config_path, verbose=False)
+
+
+def test_load_ingest_config_section_nested_and_missing(tmp_path: Path, capsys: pytest.CaptureFixture[str]) -> None:
+    config_path = tmp_path / "ingest-config.yaml"
+    config_path.write_text(
+        "chart:\n" "  endpoint_config:\n" "    yolox_endpoints:\n" "      - grpc://foo\n",
+        encoding="utf-8",
+    )
+
+    nested = load_ingest_config_section(config_path, section="chart.endpoint_config", verbose=False)
+    assert nested == {"yolox_endpoints": ["grpc://foo"]}
+
+    missing = load_ingest_config_section(
+        config_path,
+        section="chart.unknown",
+        verbose=False,
+        warn_if_missing_section=True,
+    )
+    assert missing == {}
+    stderr = capsys.readouterr().err
+    assert "section 'chart.unknown' not found" in stderr
diff --git a/nemo_retriever/tests/test_ingest_interface.py b/nemo_retriever/tests/test_ingest_interface.py
new file mode 100644
index 000000000..a2b3e3cba
--- /dev/null
+++ b/nemo_retriever/tests/test_ingest_interface.py
@@ -0,0 +1,38 @@
+import pytest
+
+from nemo_retriever.ingestor import IngestorCreateParams, _merge_params, create_ingestor
+
+
+def test_merge_params_none_returns_kwargs() -> None:
+    merged = _merge_params(None, {"documents": ["a.pdf"]})
+    assert merged == {"documents": ["a.pdf"]}
+
+
+def test_merge_params_with_model_copy_updates_values() -> None:
+    params = IngestorCreateParams(documents=["before.pdf"], ray_log_to_driver=True)
+    merged = _merge_params(params, {"documents": ["after.pdf"], "ray_log_to_driver": False})
+    assert isinstance(merged, IngestorCreateParams)
+    assert merged.documents == ["after.pdf"]
+    assert merged.ray_log_to_driver is False
+
+
+def test_create_ingestor_parses_kwargs_and_uses_factory(monkeypatch: pytest.MonkeyPatch) -> None:
+    captured: dict[str, object] = {}
+
+    def fake_factory(*, run_mode, params):
+        captured["run_mode"] = run_mode
+        captured["params"] = params
+        return "sentinel-ingestor"
+
+    monkeypatch.setattr("nemo_retriever.ingestor.create_runmode_ingestor", fake_factory)
+
+    ingestor = create_ingestor(run_mode="inprocess", documents=["doc.pdf"], base_url="http://example:7670")
+    assert ingestor == "sentinel-ingestor"
+    assert captured["run_mode"] == "inprocess"
+    assert isinstance(captured["params"], IngestorCreateParams)
+    assert captured["params"].documents == ["doc.pdf"]  # type: ignore[index]
+
+
+def test_create_ingestor_rejects_unknown_kwargs() -> None:
+    with pytest.raises(Exception):
+        create_ingestor(run_mode="inprocess", unknown_field=True)
diff --git a/nemo_retriever/tests/test_io_dataframe.py b/nemo_retriever/tests/test_io_dataframe.py
new file mode 100644
index 000000000..6a6c32896
--- /dev/null
+++ b/nemo_retriever/tests/test_io_dataframe.py
@@ -0,0 +1,70 @@
+import json
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from nemo_retriever.io.dataframe import read_dataframe, validate_primitives_dataframe, write_dataframe
+
+
+def test_validate_primitives_dataframe_requires_metadata_column() -> None:
+    df = pd.DataFrame([{"text": "hello"}])
+    with pytest.raises(KeyError, match="metadata"):
+        validate_primitives_dataframe(df)
+
+
+def test_read_dataframe_json_mapping_unwraps_extracted_records(tmp_path: Path) -> None:
+    payload = {"extracted_df_records": [{"metadata": {"a": 1}, "document_type": "pdf"}]}
+    path = tmp_path / "records.json"
+    path.write_text(json.dumps(payload), encoding="utf-8")
+
+    df = read_dataframe(path)
+    assert len(df) == 1
+    assert df.iloc[0]["document_type"] == "pdf"
+    assert isinstance(df.iloc[0]["metadata"], dict)
+
+
+def test_read_dataframe_jsonl_unwraps_nested_stage_payload(tmp_path: Path) -> None:
+    wrapped = {"primitives": [{"metadata": {"id": 123}, "document_type": "txt"}]}
+    path = tmp_path / "wrapped.jsonl"
+    path.write_text(json.dumps(wrapped) + "\n", encoding="utf-8")
+
+    df = read_dataframe(path)
+    assert len(df) == 1
+    assert df.iloc[0]["document_type"] == "txt"
+    assert df.iloc[0]["metadata"]["id"] == 123
+
+
+def test_write_and_read_dataframe_json_round_trip(tmp_path: Path) -> None:
+    source = pd.DataFrame([{"metadata": {"k": "v"}, "document_type": "html", "text": "chunk"}])
+    path = tmp_path / "roundtrip.json"
+    write_dataframe(source, path)
+
+    loaded = read_dataframe(path)
+    assert loaded.to_dict(orient="records") == source.to_dict(orient="records")
+
+
+def test_write_and_read_dataframe_jsonl_round_trip(tmp_path: Path) -> None:
+    source = pd.DataFrame(
+        [
+            {"metadata": {"n": 1}, "document_type": "pdf"},
+            {"metadata": {"n": 2}, "document_type": "pdf"},
+        ]
+    )
+    path = tmp_path / "roundtrip.jsonl"
+    write_dataframe(source, path)
+
+    loaded = read_dataframe(path)
+    assert loaded.to_dict(orient="records") == source.to_dict(orient="records")
+
+
+def test_read_and_write_dataframe_reject_unsupported_suffix(tmp_path: Path) -> None:
+    path = tmp_path / "data.csv"
+    path.write_text("x,y\n1,2\n", encoding="utf-8")
+
+    with pytest.raises(ValueError, match="Unsupported DataFrame format"):
+        read_dataframe(path)
+
+    df = pd.DataFrame([{"metadata": {}}])
+    with pytest.raises(ValueError, match="Unsupported DataFrame format"):
+        write_dataframe(df, path)
diff --git a/nemo_retriever/tests/test_multimodal_embed.py b/nemo_retriever/tests/test_multimodal_embed.py
new file mode 100644
index 000000000..f9b0568c8
--- /dev/null
+++ b/nemo_retriever/tests/test_multimodal_embed.py
@@ -0,0 +1,212 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Unit tests for multimodal embedding helpers and explode_content_to_rows.
+"""
+
+from __future__ import annotations
+
+import sys
+from unittest.mock import MagicMock, patch
+
+import pandas as pd
+import pytest
+
+# ---------------------------------------------------------------------------
+# Pure helpers from main_text_embed (no transitive-import issues)
+# ---------------------------------------------------------------------------
+from nemo_retriever.text_embed.main_text_embed import (
+    _format_image_input_string,
+    _format_text_image_pair_input_string,
+    _image_from_row,
+    _multimodal_callable_runner,
+)
+
+# ---------------------------------------------------------------------------
+# Stub heavy internal modules so ``from nemo_retriever.ingest_modes.inprocess``
+# can be imported in lightweight CI (only pytest, pandas, pydantic, pyyaml).
+#
+# The ``nemo_retriever.ingest_modes`` __init__.py eagerly imports batch/fused/online
+# which pull in ray, torch, nemotron_*, nv_ingest_api, etc.  And inprocess.py
+# itself imports model/local (torch, nemotron_*), page_elements, ocr, and
+# pdf.extract — each with their own heavy transitive deps.
+#
+# Rather than chasing every third-party leaf dependency, we pre-populate
+# sys.modules for the heavy *internal* nemo_retriever sub-packages with MagicMock.
+# This cuts off the entire transitive tree at the root.
+# ---------------------------------------------------------------------------
+_HEAVY_INTERNAL = [
+    # -- sibling ingest modes (prevents batch.py/fused.py from loading) ------
+    "nemo_retriever.ingest_modes.batch",
+    "nemo_retriever.ingest_modes.fused",
+    "nemo_retriever.ingest_modes.online",
+    # -- model / ML packages (torch, nemotron_*, transformers) ---------------
+    "nemo_retriever.model.local",
+    "nemo_retriever.model.local.llama_nemotron_embed_1b_v2_embedder",
+    "nemo_retriever.model.local.nemotron_page_elements_v3",
+    "nemo_retriever.model.local.nemotron_ocr_v1",
+    "nemo_retriever.model.local.nemotron_table_structure_v1",
+    "nemo_retriever.model.local.nemotron_graphic_elements_v1",
+    # -- detection / OCR (nemotron_page_elements_v3, PIL, requests) ----------
+    "nemo_retriever.page_elements",
+    "nemo_retriever.page_elements.page_elements",
+    "nemo_retriever.ocr",
+    "nemo_retriever.ocr.ocr",
+    # -- PDF (pypdfium2, nv_ingest_api via pdf/__init__ → __main__ → stage) --
+    "nemo_retriever.pdf",
+    "nemo_retriever.pdf.__main__",
+    "nemo_retriever.pdf.config",
+    "nemo_retriever.pdf.io",
+    "nemo_retriever.pdf.stage",
+    "nemo_retriever.pdf.extract",
+    "nemo_retriever.pdf.split",
+]
+for _mod_name in _HEAVY_INTERNAL:
+    sys.modules.setdefault(_mod_name, MagicMock())
+
+from nemo_retriever.ingest_modes.inprocess import explode_content_to_rows  # noqa: E402
+
+
+# ===================================================================
+# Pure helpers
+# ===================================================================
+
+
+class TestImageFromRow:
+    def test_returns_b64_when_present(self):
+        row = pd.Series({"_image_b64": "abc123"})
+        assert _image_from_row(row) == "abc123"
+
+    @pytest.mark.parametrize("value", [None, "", "   ", 42])
+    def test_returns_none_for_missing_empty_whitespace(self, value):
+        data = {"_image_b64": value} if value is not None else {}
+        row = pd.Series(data)
+        assert _image_from_row(row) is None
+
+
+class TestFormatInputStrings:
+    def test_format_image_input_string(self):
+        result = _format_image_input_string("AAAA")
+        assert result == "data:image/png;base64,AAAA"
+
+    def test_format_image_input_string_custom_mime(self):
+        result = _format_image_input_string("BBBB", mime="image/jpeg")
+        assert result == "data:image/jpeg;base64,BBBB"
+
+    def test_format_text_image_pair_input_string(self):
+        result = _format_text_image_pair_input_string("hello world", "CCCC")
+        assert result == "hello world\ndata:image/png;base64,CCCC"
+
+
+# ===================================================================
+# _multimodal_callable_runner
+# ===================================================================
+
+
+class TestMultimodalCallableRunner:
+    def test_image_mode(self):
+        """Image-only mode calls embedder.embed_images() and returns embeddings."""
+        embedder = MagicMock()
+        embedder.embed_images.return_value = [[0.1, 0.2], [0.3, 0.4]]
+
+        df = pd.DataFrame(
+            {
+                "text": ["page one", "page two"],
+                "_image_b64": ["img1_b64", "img2_b64"],
+            }
+        )
+
+        result = _multimodal_callable_runner(
+            df,
+            embedder=embedder,
+            batch_size=64,
+            embed_modality="image",
+        )
+
+        embedder.embed_images.assert_called_once()
+        assert result["embeddings"] == [[0.1, 0.2], [0.3, 0.4]]
+        assert len(result["info_msgs"]) == 2
+
+    def test_text_image_fallback(self):
+        """text_image mode: rows with images use embed_text_image(), rows without fall back to embed()."""
+        embedder = MagicMock()
+        # Row 0 has image -> embed_text_image
+        # Row 1 has no image -> embed (text-only fallback)
+        embedder.embed_text_image.return_value = [[1.0, 2.0]]
+        embedder.embed.return_value = [[3.0, 4.0]]
+
+        df = pd.DataFrame(
+            {
+                "text": ["with image", "text only"],
+                "_image_b64": ["imgB64", ""],
+            }
+        )
+
+        result = _multimodal_callable_runner(
+            df,
+            embedder=embedder,
+            batch_size=64,
+            embed_modality="text_image",
+        )
+
+        embedder.embed_text_image.assert_called_once()
+        embedder.embed.assert_called_once()
+        # Order must be preserved: row 0 (multimodal), row 1 (text fallback)
+        assert result["embeddings"] == [[1.0, 2.0], [3.0, 4.0]]
+        assert len(result["info_msgs"]) == 2
+
+
+# ===================================================================
+# explode_content_to_rows
+# ===================================================================
+
+
+class TestExplodeContentToRows:
+    def test_text_mode_tags_modality(self):
+        """Default text mode tags every row with _embed_modality='text' and no _image_b64."""
+        df = pd.DataFrame(
+            {
+                "text": ["Hello world"],
+                "table": [[{"text": "cell data"}]],
+            }
+        )
+
+        result = explode_content_to_rows(df)
+
+        assert "_embed_modality" in result.columns
+        assert list(result["_embed_modality"]) == ["text", "text"]
+        assert "_image_b64" not in result.columns
+
+    @patch("nemo_retriever.ingest_modes.inprocess._crop_b64_image_by_norm_bbox")
+    def test_text_image_carries_image(self, mock_crop):
+        """text_image mode copies page image to _image_b64, crops for structured content."""
+        mock_crop.return_value = ("cropped_b64", None)
+
+        df = pd.DataFrame(
+            {
+                "text": ["some page text"],
+                "page_image": [{"image_b64": "full_page_b64"}],
+                "table": [[{"text": "table cell", "bbox_xyxy_norm": [0.1, 0.2, 0.9, 0.8]}]],
+            }
+        )
+
+        result = explode_content_to_rows(df, modality="text_image")
+
+        assert "_image_b64" in result.columns
+        images = list(result["_image_b64"])
+        modalities = list(result["_embed_modality"])
+
+        # Row 0: page text row gets full page image
+        assert images[0] == "full_page_b64"
+        assert modalities[0] == "text_image"
+
+        # Row 1: structured content row gets cropped image
+        assert images[1] == "cropped_b64"
+        assert modalities[1] == "text_image"
+
+        mock_crop.assert_called_once_with(
+            "full_page_b64",
+            bbox_xyxy_norm=[0.1, 0.2, 0.9, 0.8],
+        )
diff --git a/nemo_retriever/tests/test_txt_split.py b/nemo_retriever/tests/test_txt_split.py
new file mode 100644
index 000000000..212c94813
--- /dev/null
+++ b/nemo_retriever/tests/test_txt_split.py
@@ -0,0 +1,85 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Unit tests for nemo_retriever.txt.split: split_text_by_tokens and txt_file_to_chunks_df.
+"""
+
+import tempfile  # noqa: F401
+from pathlib import Path
+
+import pandas as pd
+import pytest
+
+from nemo_retriever.txt.split import split_text_by_tokens, txt_file_to_chunks_df
+
+
+class _MockTokenizer:
+    """Minimal tokenizer: encode = split on spaces, decode = join."""
+
+    def encode(self, text: str, add_special_tokens: bool = False):
+        return text.split()
+
+    def decode(self, ids, skip_special_tokens: bool = True):
+        if isinstance(ids, (list, range)):
+            return " ".join(str(i) for i in ids)
+        return str(ids)
+
+
+def test_split_text_by_tokens_empty():
+    tokenizer = _MockTokenizer()
+    assert split_text_by_tokens("", tokenizer=tokenizer, max_tokens=10) == []
+    assert split_text_by_tokens("   \n  ", tokenizer=tokenizer, max_tokens=10) == []
+
+
+def test_split_text_by_tokens_no_overlap():
+    tokenizer = _MockTokenizer()
+    # "a b c d e f g h i j" -> 10 tokens, max_tokens=3 -> 4 chunks
+    text = "a b c d e f g h i j"
+    chunks = split_text_by_tokens(text, tokenizer=tokenizer, max_tokens=3, overlap_tokens=0)
+    assert len(chunks) >= 1
+    joined = " ".join(chunks)
+    assert "a" in joined and "j" in joined
+
+
+def test_split_text_by_tokens_single_chunk():
+    tokenizer = _MockTokenizer()
+    text = "one two three"
+    chunks = split_text_by_tokens(text, tokenizer=tokenizer, max_tokens=10, overlap_tokens=0)
+    assert len(chunks) == 1
+    assert chunks[0] == "one two three"
+
+
+def test_split_text_by_tokens_max_tokens_positive():
+    tokenizer = _MockTokenizer()
+    with pytest.raises(ValueError, match="max_tokens must be positive"):
+        split_text_by_tokens("hello", tokenizer=tokenizer, max_tokens=0)
+
+
+def test_txt_file_to_chunks_df(tmp_path: Path):
+    pytest.importorskip("transformers")
+    f = tmp_path / "doc.txt"
+    f.write_text("First paragraph here. Second paragraph there.", encoding="utf-8")
+    df = txt_file_to_chunks_df(
+        str(f),
+        max_tokens=512,
+        overlap_tokens=0,
+    )
+    assert isinstance(df, pd.DataFrame)
+    assert list(df.columns) == ["text", "path", "page_number", "metadata"]
+    assert len(df) >= 1
+    assert df["path"].iloc[0] == str(f.resolve())
+    assert df["page_number"].iloc[0] >= 1
+    assert "source_path" in df["metadata"].iloc[0]
+    assert "chunk_index" in df["metadata"].iloc[0]
+
+
+def test_txt_file_to_chunks_df_empty_file(tmp_path: Path):
+    pytest.importorskip("transformers")
+    f = tmp_path / "empty.txt"
+    f.write_text("", encoding="utf-8")
+    df = txt_file_to_chunks_df(str(f), max_tokens=512)
+    assert isinstance(df, pd.DataFrame)
+    assert list(df.columns) == ["text", "path", "page_number", "metadata"]
+    assert len(df) == 0
diff --git a/scripts/filter_query_gt_by_embeddings.py b/scripts/filter_query_gt_by_embeddings.py
new file mode 100644
index 000000000..915971058
--- /dev/null
+++ b/scripts/filter_query_gt_by_embeddings.py
@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+Filter bo767_query_gt.csv down to rows whose `pdf` id exists
+as a prefix in any `*text_embeddings.json` file under an input directory.
+
+Example embedding filename:
+  1179117.pdf.pdf_extraction.infographic.table.text_embeddings.json
+Extracted id:
+  1179117
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+import sys
+from pathlib import Path
+from typing import Iterable, Set
+
+
+def iter_text_embedding_files(root: Path) -> Iterable[Path]:
+    for dirpath, _, filenames in os.walk(root):
+        for name in filenames:
+            if name.endswith("text_embeddings.json"):
+                yield Path(dirpath) / name
+
+
+def extract_pdf_id_from_embedding_filename(path: Path) -> str | None:
+    """
+    Returns the prefix before the first '.' in the file name if it looks like a pdf id.
+    """
+    first = path.name.split(".", 1)[0]
+    if not first:
+        return None
+    if not first.isdigit():
+        return None
+    return first
+
+
+def collect_pdf_ids(embeddings_root: Path) -> Set[str]:
+    ids: Set[str] = set()
+    for p in iter_text_embedding_files(embeddings_root):
+        pdf_id = extract_pdf_id_from_embedding_filename(p)
+        if pdf_id is not None:
+            ids.add(pdf_id)
+    return ids
+
+
+def filter_csv_by_pdf_ids(input_csv: Path, output_csv: Path, allowed_pdf_ids: Set[str]) -> tuple[int, int]:
+    """
+    Returns (kept_rows, total_rows) excluding the header.
+    """
+    kept = 0
+    total = 0
+
+    with input_csv.open("r", newline="", encoding="utf-8") as f_in:
+        reader = csv.DictReader(f_in)
+        if not reader.fieldnames:
+            raise ValueError(f"No header found in {input_csv}")
+        if "pdf" not in reader.fieldnames:
+            raise ValueError(f"Expected a 'pdf' column in {input_csv}, got columns: {reader.fieldnames}")
+
+        with output_csv.open("w", newline="", encoding="utf-8") as f_out:
+            writer = csv.DictWriter(f_out, fieldnames=reader.fieldnames)
+            writer.writeheader()
+
+            for row in reader:
+                total += 1
+                pdf_val = (row.get("pdf") or "").strip()
+                # normalize '001234' vs '1234' cases
+                pdf_norm = pdf_val.lstrip("0") or "0" if pdf_val.isdigit() else pdf_val
+
+                if pdf_norm in allowed_pdf_ids or pdf_val in allowed_pdf_ids:
+                    writer.writerow(row)
+                    kept += 1
+
+    return kept, total
+
+
+def main(argv: list[str]) -> int:
+    parser = argparse.ArgumentParser(
+        description="Filter bo767_query_gt.csv to PDFs present in *text_embeddings.json filenames."
+    )
+    parser.add_argument(
+        "input_dir",
+        type=Path,
+        help="Directory to search (recursively) for *text_embeddings.json",
+    )
+    parser.add_argument(
+        "--input-csv",
+        type=Path,
+        default=Path("bo767_query_gt.csv"),
+        help="Input CSV path (default: bo767_query_gt.csv)",
+    )
+    parser.add_argument(
+        "--output-csv",
+        type=Path,
+        default=Path("jp20_query_gt.csv"),
+        help="Output CSV path (default: jp20_query_gt.csv)",
+    )
+    args = parser.parse_args(argv)
+
+    if not args.input_dir.exists():
+        print(f"ERROR: input_dir does not exist: {args.input_dir}", file=sys.stderr)
+        return 2
+    if not args.input_dir.is_dir():
+        print(f"ERROR: input_dir is not a directory: {args.input_dir}", file=sys.stderr)
+        return 2
+    if not args.input_csv.exists():
+        print(f"ERROR: input_csv does not exist: {args.input_csv}", file=sys.stderr)
+        return 2
+
+    allowed = collect_pdf_ids(args.input_dir)
+    if not allowed:
+        print(
+            f"WARNING: Found 0 pdf ids from *text_embeddings.json under {args.input_dir}. "
+            f"Output will contain only the header.",
+            file=sys.stderr,
+        )
+
+    kept, total = filter_csv_by_pdf_ids(args.input_csv, args.output_csv, allowed)
+    print(f"Found {len(allowed)} pdf ids under {args.input_dir}")
+    print(f"Filtered {args.input_csv}: kept {kept}/{total} rows")
+    print(f"Wrote {args.output_csv}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
diff --git a/scripts/support/print_env.sh b/scripts/support/print_env.sh
index 1cb4613df..9e669cefe 100644
--- a/scripts/support/print_env.sh
+++ b/scripts/support/print_env.sh
@@ -56,26 +56,19 @@ printf '%-32s: %s\n' NUMBAPRO_NVVM $NUMBAPRO_NVVM
 
 printf '%-32s: %s\n' NUMBAPRO_LIBDEVICE $NUMBAPRO_LIBDEVICE
 
-printf '%-32s: %s\n' CONDA_PREFIX $CONDA_PREFIX
+printf '%-32s: %s\n' VIRTUAL_ENV $VIRTUAL_ENV
 
 printf '%-32s: %s\n' PYTHON_PATH $PYTHON_PATH
 
 echo
 
 
-# Print conda packages if conda exists
-if type "conda" &> /dev/null; then
-echo '***conda packages***'
-which conda && conda list
-echo
 # Print pip packages if pip exists
-elif type "pip" &> /dev/null; then
-echo "conda not found"
+if type "pip" &> /dev/null; then
 echo "***pip packages***"
 which pip && pip list
 echo
 else
-echo "conda not found"
 echo "pip not found"
 fi
 }
diff --git a/src/nv_ingest/api/main.py b/src/nv_ingest/api/main.py
index eaf00dc7e..98524800f 100644
--- a/src/nv_ingest/api/main.py
+++ b/src/nv_ingest/api/main.py
@@ -23,7 +23,7 @@
 app = FastAPI(
     title="NV-Ingest Microservice",
     description="Service for ingesting heterogenous datatypes",
-    version="26.1.0",
+    version="26.1.2",
     contact={
         "name": "NVIDIA Corporation",
         "url": "https://nvidia.com",
diff --git a/src/nv_ingest/framework/orchestration/process/lifecycle.py b/src/nv_ingest/framework/orchestration/process/lifecycle.py
index 5e7d4b383..cf35a812f 100644
--- a/src/nv_ingest/framework/orchestration/process/lifecycle.py
+++ b/src/nv_ingest/framework/orchestration/process/lifecycle.py
@@ -167,13 +167,19 @@ def _terminate_broker_atexit(self) -> None:
         Avoids raising exceptions during interpreter shutdown.
         """
         try:
-            self._terminate_broker()
+            self._terminate_broker(from_atexit=True)
         except Exception:
             # Swallow errors at atexit to avoid noisy shutdowns
             pass
 
-    def _terminate_broker(self) -> None:
-        """Terminate the SimpleMessageBroker process if running."""
+    def _terminate_broker(self, from_atexit: bool = False) -> None:
+        """Terminate the SimpleMessageBroker process if running.
+
+        Parameters
+        ----------
+        from_atexit : bool
+            If True, skip logging to avoid errors when called during interpreter shutdown.
+        """
         proc = self._broker_process
         if not proc:
             return
@@ -185,7 +191,9 @@ def _terminate_broker(self) -> None:
             pass
 
         pid = getattr(proc, "pid", None)
-        logger.info(f"Stopping SimpleMessageBroker (pid={pid})")
+        # Avoid logging during atexit as logging streams may be closed
+        if not from_atexit:
+            logger.info(f"Stopping SimpleMessageBroker (pid={pid})")
         try:
             # First, try graceful terminate
             proc.terminate()
diff --git a/src/nv_ingest/framework/util/service/impl/ingest/redis_ingest_service.py b/src/nv_ingest/framework/util/service/impl/ingest/redis_ingest_service.py
index 641529ccc..c96977ec2 100644
--- a/src/nv_ingest/framework/util/service/impl/ingest/redis_ingest_service.py
+++ b/src/nv_ingest/framework/util/service/impl/ingest/redis_ingest_service.py
@@ -131,13 +131,12 @@ def __init__(
         self._bulk_vdb_cache_prefix: str = "vdb_bulk_upload_cache:"
         self._cache_prefix: str = "processing_cache:"
         self._state_prefix: str = "job_state:"
-        # Bound async-to-thread concurrency slightly below Redis connection pool
-        self._async_operation_semaphore: Optional[asyncio.Semaphore] = None
 
+        pool_size = int(os.getenv("REDIS_POOL_SIZE", "50"))
         self._ingest_client = RedisClient(
             host=self._redis_hostname,
             port=self._redis_port,
-            max_pool_size=self._concurrency_level,
+            max_pool_size=pool_size,
             fetch_mode=self._fetch_mode,
             cache_config=cache_config,
             message_ttl_seconds=self._result_data_ttl_seconds,
@@ -145,21 +144,15 @@ def __init__(
             max_retries=int(os.getenv("REDIS_MAX_RETRIES", "3")),
             max_backoff=int(os.getenv("REDIS_MAX_BACKOFF", "32")),
             connection_timeout=int(os.getenv("REDIS_CONNECTION_TIMEOUT", "300")),
+            pool_name="ingest",
         )
         logger.debug(
             f"RedisClient initialized for service. Host: {redis_hostname}:{redis_port}, "
             f"FetchMode: {fetch_mode.name}, ResultTTL: {result_data_ttl_seconds}, StateTTL: {state_ttl_seconds}"
         )
 
-    def _get_async_semaphore(self) -> asyncio.Semaphore:
-        if self._async_operation_semaphore is None:
-            semaphore_limit = max(1, self._concurrency_level - 2)
-            self._async_operation_semaphore = asyncio.Semaphore(semaphore_limit)
-        return self._async_operation_semaphore
-
-    async def _run_bounded_to_thread(self, func, *args, **kwargs):
-        async with self._get_async_semaphore():
-            return await asyncio.to_thread(func, *args, **kwargs)
+    async def _run_in_thread(self, func, *args, **kwargs):
+        return await asyncio.to_thread(func, *args, **kwargs)
 
     async def submit_job(self, job_spec_wrapper: "MessageWrapper", trace_id: str) -> str:
         """
@@ -242,7 +235,7 @@ async def submit_job(self, job_spec_wrapper: "MessageWrapper", trace_id: str) ->
             logger.debug(
                 f"Submitting job {trace_id} to queue '{self._redis_task_queue}' with result TTL: {ttl_for_result}"
             )
-            await self._run_bounded_to_thread(
+            await self._run_in_thread(
                 self._ingest_client.submit_message,
                 channel_name=channel_name,
                 message=job_spec_json,
@@ -283,7 +276,7 @@ async def fetch_job(self, job_id: str) -> Optional[Dict]:
         try:
             result_channel: str = f"{job_id}"
             logger.debug(f"Attempting to fetch job result for {job_id} using mode {self._fetch_mode.name}")
-            message = await self._run_bounded_to_thread(
+            message = await self._run_in_thread(
                 self._ingest_client.fetch_message,
                 channel_name=result_channel,
                 timeout=10,
@@ -320,7 +313,7 @@ async def set_job_state(self, job_id: str, state: str) -> None:
         ttl_to_set: Optional[int] = self._state_ttl_seconds
         try:
             logger.debug(f"Setting state for {job_id} to {state} with TTL {ttl_to_set}")
-            await self._run_bounded_to_thread(
+            await self._run_in_thread(
                 self._ingest_client.get_client().set,
                 state_key,
                 state,
@@ -348,7 +341,7 @@ async def get_job_state(self, job_id: str) -> Optional[str]:
         """
         state_key: str = f"{self._state_prefix}{job_id}"
         try:
-            data_bytes: Optional[bytes] = await self._run_bounded_to_thread(
+            data_bytes: Optional[bytes] = await self._run_in_thread(
                 self._ingest_client.get_client().get,
                 state_key,
             )
@@ -384,7 +377,7 @@ async def set_processing_cache(self, job_id: str, jobs_data: List["ProcessingJob
         cache_key: str = f"{self._cache_prefix}{job_id}"
         try:
             data_to_store: str = json.dumps([job.model_dump(mode="json") for job in jobs_data])
-            await self._run_bounded_to_thread(
+            await self._run_in_thread(
                 self._ingest_client.get_client().set,
                 cache_key,
                 data_to_store,
@@ -409,7 +402,7 @@ async def get_processing_cache(self, job_id: str) -> List["ProcessingJob"]:
         """
         cache_key: str = f"{self._cache_prefix}{job_id}"
         try:
-            data_bytes: Optional[bytes] = await self._run_bounded_to_thread(
+            data_bytes: Optional[bytes] = await self._run_in_thread(
                 self._ingest_client.get_client().get,
                 cache_key,
             )
@@ -459,7 +452,7 @@ async def set_parent_job_mapping(
         try:
             # Store subjob IDs as a set (only if there are subjobs)
             if subjob_ids:
-                await self._run_bounded_to_thread(
+                await self._run_in_thread(
                     self._ingest_client.get_client().sadd,
                     parent_key,
                     *subjob_ids,
@@ -479,7 +472,7 @@ async def set_parent_job_mapping(
             if subjob_descriptors:
                 metadata_to_store["subjob_descriptors"] = json.dumps(subjob_descriptors)
 
-            await self._run_bounded_to_thread(
+            await self._run_in_thread(
                 self._ingest_client.get_client().hset,
                 metadata_key,
                 mapping=metadata_to_store,
@@ -487,12 +480,12 @@ async def set_parent_job_mapping(
 
             # Set TTL on both keys to match state TTL
             if self._state_ttl_seconds:
-                await self._run_bounded_to_thread(
+                await self._run_in_thread(
                     self._ingest_client.get_client().expire,
                     parent_key,
                     self._state_ttl_seconds,
                 )
-                await self._run_bounded_to_thread(
+                await self._run_in_thread(
                     self._ingest_client.get_client().expire,
                     metadata_key,
                     self._state_ttl_seconds,
@@ -523,7 +516,7 @@ async def get_parent_job_info(self, parent_job_id: str) -> Optional[Dict[str, An
 
         try:
             # Check if this is a parent job (check metadata_key since non-split PDFs may not have parent_key)
-            exists = await self._run_bounded_to_thread(
+            exists = await self._run_in_thread(
                 self._ingest_client.get_client().exists,
                 metadata_key,  # Check metadata instead of parent_key for non-split PDF support
             )
@@ -532,14 +525,14 @@ async def get_parent_job_info(self, parent_job_id: str) -> Optional[Dict[str, An
                 return None
 
             # Get subjob IDs (may be empty for non-split PDFs)
-            subjob_ids_bytes = await self._run_bounded_to_thread(
+            subjob_ids_bytes = await self._run_in_thread(
                 self._ingest_client.get_client().smembers,
                 parent_key,
             )
             subjob_id_set = {id.decode("utf-8") for id in subjob_ids_bytes} if subjob_ids_bytes else set()
 
             # Get metadata
-            metadata_dict = await self._run_bounded_to_thread(
+            metadata_dict = await self._run_in_thread(
                 self._ingest_client.get_client().hgetall,
                 metadata_key,
             )
diff --git a/src/pyproject.toml b/src/pyproject.toml
index e34cc3889..34c27cbc7 100644
--- a/src/pyproject.toml
+++ b/src/pyproject.toml
@@ -1,5 +1,5 @@
 [build-system]
-requires = ["setuptools", "wheel"]
+requires = ["setuptools", "wheel>=0.46.2"]
 build-backend = "setuptools.build_meta"
 
 [tool.uv]
@@ -61,13 +61,14 @@ dependencies = [
     "tqdm>=4.67.1",
     "uvicorn",
     "pip",
-    "opencv-python", # For some reason conda cant solve our req set with py-opencv so we need to use pip
+    "opencv-python",
     "pymilvus>=2.5.10",
     "pymilvus[bulk_writer, model]",
     "tritonclient",
     "nvidia-riva-client==2.20.0",
-    "unstructured-client",
+    "unstructured-client>=0.25.9",
     "markitdown",
+    "python-multipart",
 ]
 
 [project.urls]
diff --git a/tests/functional/test_pdfium_render_scale.py b/tests/functional/test_pdfium_render_scale.py
new file mode 100644
index 000000000..7e29b1438
--- /dev/null
+++ b/tests/functional/test_pdfium_render_scale.py
@@ -0,0 +1,63 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Edge case tests for _compute_render_scale_to_fit.
+
+These tests guard against degenerate inputs that could cause division by zero
+or other failures. They do NOT validate correctness of the scaling math -
+that requires integration tests comparing actual rendered output.
+"""
+
+from unittest.mock import MagicMock
+
+from nv_ingest_api.util.pdf.pdfium import _compute_render_scale_to_fit
+
+
+def _make_mock_page(width: float, height: float) -> MagicMock:
+    """Create a mock PdfPage with given dimensions."""
+    page = MagicMock()
+    page.get_width.return_value = width
+    page.get_height.return_value = height
+    return page
+
+
+class TestComputeRenderScaleToFitEdgeCases:
+    """Edge case guards for _compute_render_scale_to_fit."""
+
+    def test_zero_target_width_returns_default(self):
+        """Zero target width should return 1.0 to avoid division by zero."""
+        page = _make_mock_page(100, 100)
+        scale = _compute_render_scale_to_fit(page, (0, 100))
+        assert scale == 1.0
+
+    def test_zero_target_height_returns_default(self):
+        """Zero target height should return 1.0 to avoid division by zero."""
+        page = _make_mock_page(100, 100)
+        scale = _compute_render_scale_to_fit(page, (100, 0))
+        assert scale == 1.0
+
+    def test_zero_page_width_returns_default(self):
+        """Zero page width should return 1.0 to avoid division by zero."""
+        page = _make_mock_page(0, 100)
+        scale = _compute_render_scale_to_fit(page, (100, 100))
+        assert scale == 1.0
+
+    def test_zero_page_height_returns_default(self):
+        """Zero page height should return 1.0 to avoid division by zero."""
+        page = _make_mock_page(100, 0)
+        scale = _compute_render_scale_to_fit(page, (100, 100))
+        assert scale == 1.0
+
+    def test_negative_target_returns_default(self):
+        """Negative target dimensions should return 1.0."""
+        page = _make_mock_page(100, 100)
+        scale = _compute_render_scale_to_fit(page, (-100, 100))
+        assert scale == 1.0
+
+    def test_minimum_scale_clamp(self):
+        """Scale should be clamped to minimum of 1e-3 to prevent degenerate renders."""
+        page = _make_mock_page(1000000, 1000000)
+        scale = _compute_render_scale_to_fit(page, (1, 1))
+        assert scale >= 1e-3
diff --git a/tests/service_tests/schemas/test_chart_extractor_schema.py b/tests/service_tests/schemas/test_chart_extractor_schema.py
index 82b6ed5ce..04eb44ea4 100644
--- a/tests/service_tests/schemas/test_chart_extractor_schema.py
+++ b/tests/service_tests/schemas/test_chart_extractor_schema.py
@@ -32,9 +32,9 @@ def test_valid_config_with_http_only():
 
 
 def test_invalid_config_with_empty_services():
-    with pytest.raises(ValidationError) as excinfo:
-        ChartExtractorConfigSchema(yolox_endpoints=(None, None), ocr_endpoints=(None, None))
-    assert "Both gRPC and HTTP services cannot be empty" in str(excinfo.value)
+    config = ChartExtractorConfigSchema(yolox_endpoints=(None, None), ocr_endpoints=(None, None))
+    assert config.yolox_infer_protocol == "local"
+    assert config.ocr_infer_protocol == "local"
 
 
 def test_valid_config_with_both_grpc_and_http():
diff --git a/tests/service_tests/schemas/test_image_extrator_schema.py b/tests/service_tests/schemas/test_image_extrator_schema.py
index f8a766b93..dcfeea52b 100644
--- a/tests/service_tests/schemas/test_image_extrator_schema.py
+++ b/tests/service_tests/schemas/test_image_extrator_schema.py
@@ -35,11 +35,10 @@ def test_image_config_schema_valid_single_service():
 
 
 def test_image_config_schema_invalid_both_services_empty():
-    # Test invalid data with both gRPC and HTTP services empty
-    with pytest.raises(ValidationError) as exc_info:
-        ImageConfigSchema(yolox_endpoints=(None, None))
-    errors = exc_info.value.errors()
-    assert any("Both gRPC and HTTP services cannot be empty" in error["msg"] for error in errors)
+    # Empty endpoints are valid for local inference mode.
+    config = ImageConfigSchema(yolox_endpoints=(None, None))
+    assert config.yolox_endpoints == (None, None)
+    assert config.yolox_infer_protocol == "local"
 
 
 def test_image_config_schema_empty_service_strings():
@@ -106,8 +105,8 @@ def test_image_extractor_schema_invalid_n_workers():
 
 
 def test_image_extractor_schema_invalid_nested_config():
-    # Test invalid nested image_extraction_config
-    with pytest.raises(ValidationError) as exc_info:
-        ImageExtractorSchema(image_extraction_config={"auth_token": "token123", "yolox_endpoints": (None, None)})
-    errors = exc_info.value.errors()
-    assert any("Both gRPC and HTTP services cannot be empty" in error["msg"] for error in errors)
+    # Nested config also supports local mode when endpoints are omitted.
+    config = ImageExtractorSchema(image_extraction_config={"auth_token": "token123", "yolox_endpoints": (None, None)})
+    assert config.image_extraction_config is not None
+    assert config.image_extraction_config.yolox_endpoints == (None, None)
+    assert config.image_extraction_config.yolox_infer_protocol == "local"
diff --git a/tests/service_tests/schemas/test_table_extractor_schema.py b/tests/service_tests/schemas/test_table_extractor_schema.py
index b36864ba5..39cd70b81 100644
--- a/tests/service_tests/schemas/test_table_extractor_schema.py
+++ b/tests/service_tests/schemas/test_table_extractor_schema.py
@@ -43,12 +43,13 @@ def test_valid_config_with_both_services():
 
 
 def test_invalid_config_empty_endpoints():
-    with pytest.raises(ValidationError) as exc_info:
-        TableExtractorConfigSchema(
-            yolox_endpoints=("grpc://yolox_service", "http://yolox_service"),
-            ocr_endpoints=(None, None),
-        )
-    assert "Both gRPC and HTTP services cannot be empty for ocr_endpoints" in str(exc_info.value)
+    # Empty endpoints are valid and select local inference.
+    config = TableExtractorConfigSchema(
+        yolox_endpoints=("grpc://yolox_service", "http://yolox_service"),
+        ocr_endpoints=(None, None),
+    )
+    assert config.ocr_endpoints == (None, None)
+    assert config.ocr_infer_protocol == "local"
 
 
 def test_invalid_extra_fields():
diff --git a/tools/harness/README.md b/tools/harness/README.md
index a1dd693e6..eed5ffcdc 100644
--- a/tools/harness/README.md
+++ b/tools/harness/README.md
@@ -6,19 +6,25 @@ A configurable, dataset-agnostic testing framework for end-to-end validation of
 
 ### Prerequisites
 - Docker and Docker Compose running
-- Python environment with nv-ingest-client
+- Python 3.12+ environment
 - Access to test datasets
 
-### Run Your First Test
+### Installation
 
 ```bash
-# 1. Navigate to the tests directory
+# Navigate to the harness directory
 cd tools/harness/
 
-# 2. Install dependencies
-uv sync
+# Install the harness (includes nv-ingest packages, milvus-lite, pypdfium2, and nemotron-* model packages)
+uv pip install -e .
+```
+
+**Vanilla pip:** Install the project with `pip install -e .` (from repo root, install `nv-ingest`, `nv-ingest-api`, and `nv-ingest-client` first if needed). The harness env already includes the nemotron packages; to get nightly versions from Test PyPI, install on top: `pip install -r tools/harness/nemotron-nightly.txt --force-reinstall --no-deps`.
 
-# 3. Run with a pre-configured dataset (assumes services are running)
+### Run Your First Test
+
+```bash
+# Run with a pre-configured dataset (assumes services are running)
 uv run nv-ingest-harness-run --case=e2e --dataset=bo767
 
 # Or use a custom path that uses the "active" configuration
@@ -94,6 +100,15 @@ datasets:
     extract_infographics: false
     recall_dataset: bo767  # Evaluator for recall testing
   
+  jp20:
+    path: /path/to/jp20
+    extract_text: true
+    extract_tables: true
+    extract_charts: true
+    extract_images: false
+    extract_infographics: true
+    recall_dataset: jp20  # bo10k evaluator filtered to jp20 subset
+
   bo20:
     path: /raid/jioffe/bo20
     extract_text: true
@@ -135,6 +150,7 @@ uv run nv-ingest-harness-run --case=e2e --dataset=/custom/path
 | Dataset | Text | Tables | Charts | Images | Infographics | Recall |
 |---------|------|--------|--------|--------|--------------|--------|
 | `bo767` | ✅ | ✅ | ✅ | ❌ | ❌ | ✅ |
+| `jp20` | ✅ | ✅ | ✅ | ❌ | ✅ | ✅ |
 | `earnings` | ✅ | ✅ | ✅ | ❌ | ❌ | ✅ |
 | `bo20` | ✅ | ✅ | ✅ | ✅ | ❌ | ❌ |
 | `financebench` | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ |
@@ -274,6 +290,10 @@ DATASET_DIR=/custom/path uv run nv-ingest-harness-run --case=e2e
 | `e2e_with_llm_summary` | E2E with LLM summarization via UDF | `active` section only | ✅ Available (YAML config) |
 | `recall` | Recall evaluation against existing collections | `active` + `recall` sections | ✅ Available (YAML config) |
 | `e2e_recall` | Fresh ingestion + recall evaluation | `active` + `recall` sections | ✅ Available (YAML config) |
+| `page_elements` | nemotron-page-elements-v3 model benchmarking (PyPi) | None | ✅ Available |
+| `graphic_elements` | nemotron-graphic-elements-v1 model benchmarking (PyPi) | None | ✅ Available |
+| `table_structure` | nemotron-table-structure-v1 model benchmarking (PyPi) | None | ✅ Available |
+| `ocr` | nemotron-ocr model benchmarking (PyPi) | None | ✅ Available |
 
 **Note**: Legacy test cases (`dc20_e2e`, `dc20_v2_e2e`) have been moved to `scripts/private_local`.
 
@@ -503,6 +523,115 @@ Metrics are also logged via `kv_event_log()`:
 - `recall_eval_time_s_no_reranker`
 - `recall_eval_time_s_with_reranker`
 
+## Model Testing
+
+The harness includes benchmark test cases for Nemotron document analysis models. These cases benchmark inference performance on image datasets without requiring the full nv-ingest service infrastructure. The default install (via `uv pip install -e .`) includes the nemotron-* packages from Test PyPI (`nemotron-page-elements-v3`, `nemotron-graphic-elements-v1`, `nemotron-table-structure-v1`, `nemotron-ocr`). With vanilla pip, install the standard harness env first, then `pip install -r tools/harness/nemotron-nightly.txt --force-reinstall --no-deps` to get the nightly Nemotron packages from Test PyPI.
+
+### Available Model Benchmarks
+
+| Case | Model | Package | Description |
+|------|-------|---------|-------------|
+| `page_elements` | [Nemotron Page Element v3](https://huggingface.co/nvidia/nemotron-page-elements-v3) | nemotron_page_elements_v3 | Document layout detection (tables, figures, text blocks, headers, etc.) |
+| `table_structure` | [Nemotron Table Structure v1](https://huggingface.co/nvidia/nemotron-table-structure-v1) | nemotron_table_structure_v1 | Table cell, row, and column detection |
+| `graphic_elements` | [Nemotron Graphic Element v1](https://huggingface.co/nvidia/nemotron-graphic-elements-v1) | nemotron_graphic_elements_v1 | Chart and graphic element detection |
+| `ocr` | [Nemotron OCR v1](https://huggingface.co/nvidia/nemotron-ocr-v1) | nemotron_ocr | Optical character recognition (text extraction with bounding boxes) |
+
+### Usage
+
+Model benchmarks don't require managed services - they run the model directly on GPU:
+
+```bash
+# Page elements benchmark
+uv run nv-ingest-harness-run --case=page_elements --dataset=/path/to/page_images
+
+# Table structure benchmark  
+uv run nv-ingest-harness-run --case=table_structure --dataset=/path/to/table_images
+
+# Graphic elements benchmark
+uv run nv-ingest-harness-run --case=graphic_elements --dataset=/path/to/chart_images
+
+# Nemotron OCR benchmark
+uv run nv-ingest-harness-run --case=ocr --dataset=/path/to/images
+```
+
+### Configuration
+
+Model benchmarks use `dataset_dir` from the config to locate images. Images are discovered recursively with extensions: `.png`, `.jpg`, `.jpeg`, `.webp`.
+
+**Optional config parameters:**
+- `num_repeats` (default: 1): Number of times to run inference per image for timing accuracy
+
+### Benchmark Method
+
+All model benchmarks use `torch.utils.benchmark.Timer` for accurate timing:
+
+- **Automatic CUDA synchronization**: Timer handles GPU sync internally
+- **Warmup**: Uses `blocked_autorange()` for stable initial timing calibration
+- **Per-image timing**: Measures preprocessing + forward pass together
+
+### Output Metrics
+
+Results are written to `results.json`:
+
+| Metric | Description |
+|--------|-------------|
+| `num_images` | Total images processed |
+| `total_detections` | Sum of all detections across images (or `total_text_regions` for OCR) |
+| `mean_inference_time_ms` | Mean inference time per image |
+| `std_inference_time_ms` | Standard deviation of inference times |
+| `min_inference_time_ms` | Fastest inference time |
+| `max_inference_time_ms` | Slowest inference time |
+| `median_inference_time_ms` | Median inference time |
+| `iqr_inference_time_ms` | Interquartile range (75th - 25th percentile) |
+| `total_inference_time_ms` | Total time for all images |
+| `throughput_images_per_sec` | Processing throughput |
+| `model_load_time_s` | Time to load the model |
+
+### Example Output
+
+```
+=== Page Elements Benchmark ===
+Dataset: /path/to/images
+Timing repeats per image: 1
+Using torch.utils.benchmark.Timer
+================================
+Found 100 image(s) to process
+Loading model...
+Model loaded in 2.34s
+Available labels: ['text', 'title', 'table', 'figure', ...]
+Running warmup with torch.utils.benchmark...
+Warmup complete. Estimated per-image time: 15.23 ms
+Processing images: 100%|████████████████| 100/100 [00:01<00:00, 65.2img/s]
+```
+
+Results in `artifacts/<dataset>_<timestamp>/results.json`:
+
+```json
+{
+  "test_config": {
+    "test_name": "page_images",
+    "dataset_dir": "/path/to/images",
+    "num_repeats": 1,
+    "model": "page_element_v3",
+    "benchmark_method": "torch.utils.benchmark.Timer"
+  },
+  "results": {
+    "num_images": 100,
+    "total_detections": 1523,
+    "mean_inference_time_ms": 15.34,
+    "std_inference_time_ms": 2.18,
+    "min_inference_time_ms": 12.45,
+    "max_inference_time_ms": 28.91,
+    "median_inference_time_ms": 14.89,
+    "iqr_inference_time_ms": 2.34,
+    "total_inference_time_ms": 1534.21,
+    "throughput_images_per_sec": 65.18,
+    "model_load_time_s": 2.34
+  },
+  "per_image_results": [...]
+}
+```
+
 ## Sweeping Parameters
 
 ### Dataset Sweeping (Recommended)
@@ -546,6 +675,72 @@ EXTRACT_TABLES=false uv run nv-ingest-harness-run --case=e2e --dataset=bo767
 
 **Note**: Each test run creates a new timestamped artifact directory, so you can compare results across sweeps.
 
+## Deployment Types
+
+The harness supports two deployment orchestrators for managing nv-ingest services:
+
+### Docker Compose (Default)
+
+Docker Compose is the default deployment type and is ideal for local development and testing:
+
+```bash
+# Default - uses Docker Compose
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed
+
+# Explicitly specify Docker Compose
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --deployment-type=compose
+```
+
+**Features:**
+- Local container orchestration
+- Fast startup and rebuild
+- GPU-specific configuration via `--sku` option (A10G, L40S, A100-40GB)
+- Profile-based service selection
+- Docker volume management
+
+### Helm (Kubernetes)
+
+Helm deployment is for Kubernetes-based testing (MicroK8s, K3s, cloud K8s):
+
+```bash
+# Use Helm deployment
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --deployment-type=helm
+```
+
+**Features:**
+- Kubernetes-native deployment
+- Automatic port-forwarding with auto-restart for resilience
+- Supports both remote charts (from Helm repos) and local `./helm` chart
+- Pod log collection with previous logs on restart
+- Namespace isolation
+
+**Configuration:**
+Set deployment type in `test_configs.yaml` or use `--deployment-type` CLI flag:
+
+```yaml
+active:
+  deployment_type: compose  # or "helm"
+  
+  # Docker Compose settings
+  profiles: [retrieval, reranker]
+  
+  # Helm settings (only used when deployment_type: helm)
+  helm_bin: helm  # or "microk8s helm", "k3s helm"
+  helm_chart: nim-nvstaging/nv-ingest
+  helm_chart_version: 26.1.0-RC7
+  helm_release: nv-ingest
+  helm_namespace: nv-ingest
+  helm_values_file: .helm-env
+```
+
+**CLI flag overrides YAML setting:**
+```bash
+# Override to Helm even if YAML has deployment_type: compose
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --deployment-type=helm
+```
+
+For detailed Helm and Docker Compose configuration, see `plans/SERVICE_MANAGER.md`.
+
 ## Execution Modes
 
 ### Attach Mode (Default)
@@ -558,7 +753,7 @@ uv run nv-ingest-harness-run --case=e2e --dataset=bo767
 - Runs test case only (no service management)
 - Faster for iterative testing
 - Use when Docker services are already up
-- `--no-build` and `--keep-up` flags are ignored in attach mode
+- `--no-build`, `--keep-up`, and `--sku` flags are ignored in attach mode
 
 ### Managed Mode
 
@@ -569,7 +764,7 @@ uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed
 - Starts Docker services automatically
 - Waits for service readiness (configurable timeout)
 - Runs test case
-- Collects artifacts
+- Collects artifacts and service logs
 - Stops services after test (unless `--keep-up`)
 
 **Managed mode options:**
@@ -579,8 +774,35 @@ uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --no-build
 
 # Keep services running after test (useful for multi-test scenarios)
 uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --keep-up
+
+# Use GPU-specific configuration (A10G, L40S, A100-40GB)
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --sku=a10g
+
+# Disable service log dumping (enabled by default)
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --no-dump-logs
 ```
 
+### GPU-Specific Configuration (SKU Override)
+
+The harness supports GPU-specific configuration overrides via the `--sku` option for both Docker Compose and Helm deployments:
+
+```bash
+# A10G GPU settings
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --sku=a10g
+
+# L40S GPU settings
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --sku=l40s
+
+# A100 40GB GPU settings
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --sku=a100-40gb
+```
+
+**How it works:**
+- **Compose:** Loads `docker-compose.<sku>.yaml` and merges with base `docker-compose.yaml` (override takes precedence).
+- **Helm:** Loads `helm/overrides/values-<sku>.yaml` via `helm upgrade -f`; merged with chart defaults (and any `helm_values_file` / `helm_values` still override).
+
+**Available SKUs:** `a10g` (NVIDIA A10G), `l40s` (NVIDIA L40S), `a100-40gb` (NVIDIA A100 40GB).
+
 ## Nightly Benchmarks
 
 Automated benchmarks with Slack reporting and historical tracking.
@@ -636,6 +858,50 @@ tools/harness/artifacts/<test_name>_<timestamp>_UTC/
 
 **Note**: Artifact directories use timestamps for tracking test runs over time, while collection names are deterministic (no timestamps) to enable collection reuse and recall evaluation.
 
+### Service Logs
+
+When running in managed mode (`--managed`), service logs are automatically dumped to the artifacts directory before services are stopped (enabled by default):
+
+```
+tools/harness/artifacts/<session_or_run>/service_logs/
+├── container_nv-ingest-1.log           # Docker Compose: individual container logs
+├── container_redis-1.log
+├── docker_compose_combined.log         # Docker Compose: combined logs
+├── pod_nv-ingest-ms-runtime-xxx.log   # Helm: pod logs
+├── pod_redis-master-0.log
+├── pod_status.txt                      # Helm: pod status
+└── pod_events.txt                      # Helm: Kubernetes events
+```
+
+**Disabling log dumping:**
+```bash
+# Skip log collection if not needed (saves time)
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --no-dump-logs
+
+# Or for nightly runs
+uv run nv-ingest-harness-nightly --managed --no-dump-logs
+```
+
+**Log collection features:**
+- **Automatic**: Logs are captured before services are stopped
+- **Comprehensive**: Includes all containers/pods in the deployment
+- **Timestamped**: Container/pod logs include timestamps for correlation
+- **Previous logs**: For Helm, also captures previous container logs if pods restarted
+- **Debugging aids**: Helm logs include pod status and events for troubleshooting
+
+**Docker Compose logs include:**
+- Individual container logs with container names
+- Combined logs from all services
+- Stderr and stdout streams
+
+**Helm logs include:**
+- Logs from each container in each pod
+- Previous logs if containers restarted
+- Pod status information (`kubectl get pods`)
+- Kubernetes events (`kubectl get events`)
+
+This feature is particularly useful for debugging test failures and understanding service behavior during test runs.
+
 ### Results Structure
 
 `results.json` contains:
@@ -706,12 +972,18 @@ This provides:
   - Merges ingestion and recall metrics in results
 
 **4. Shared Utilities**
-- `interact.py` - Common testing utilities
+- `interact.py` - Common testing utilities (no external model dependencies)
   - `embed_info()` - Embedding model detection
-  - `milvus_chunks()` - Vector database statistics
   - `segment_results()` - Result categorization by type
   - `kv_event_log()` - Structured logging
+  - `run_cmd()` - Command execution helpers
+- `milvus.py` - Milvus/vector database utilities
+  - `milvus_chunks()` - Vector database statistics
+  - `load_collection()` - Load Milvus collection
+  - `unload_collection()` - Unload Milvus collection
+- `pdfium.py` - PDF utilities
   - `pdf_page_count()` - Dataset page counting
+  - `pdf_page_count_glob()` - Glob-based PDF page counting
 
 ### Configuration Flow
 
diff --git a/tools/harness/monitoring.sh b/tools/harness/monitoring.sh
new file mode 100755
index 000000000..203708f49
--- /dev/null
+++ b/tools/harness/monitoring.sh
@@ -0,0 +1,407 @@
+#!/bin/bash
+
+# ═══════════════════════════════════════════════════════════════════════════════
+# CONFIGURATION - Edit these values to match your deployment
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# Model names for each NIM service
+# Each service has an inference model and a pipeline model (for ensemble metrics)
+# Use "pipeline" if your NIM exposes generic pipeline metrics, or the ensemble name
+
+# Page elements (YOLOX-based) - uses generic "pipeline" model
+PAGE_ELEMENTS_MODEL="yolox"
+PAGE_ELEMENTS_PIPELINE="pipeline"
+
+# Graphic elements (YOLOX-based) - uses yolox_ensemble
+GRAPHIC_ELEMENTS_MODEL="yolox"
+GRAPHIC_ELEMENTS_PIPELINE="pipeline"
+
+# Table structure (YOLOX-based) - uses yolox_ensemble
+TABLE_STRUCTURE_MODEL="yolox"
+TABLE_STRUCTURE_PIPELINE="pipeline"
+
+# OCR models - uses scene_text_ensemble
+OCR_DETECTION_MODEL="scene_text_det"
+OCR_RECOGNITION_MODEL="scene_text_rec"
+OCR_PIPELINE="pipeline"
+
+# Embedding model
+EMBEDDING_MODEL="nvidia_llama_3_2_nv_embedqa_1b_v2"
+EMBEDDING_PIPELINE="pipeline"
+
+# NIM service ports
+PORT_PAGE_ELEMENTS=8002
+PORT_GRAPHIC_ELEMENTS=8005
+PORT_TABLE_STRUCTURE=8008
+PORT_OCR=8011
+PORT_EMBEDDING=8014
+
+# Redis container name
+REDIS_CONTAINER="nv-ingest-redis-1"
+
+# ═══════════════════════════════════════════════════════════════════════════════
+
+# Colors
+Y='\e[33m'; C='\e[36m'; G='\e[32m'; M='\e[35m'; RED='\e[31m'; R='\e[0m'
+
+echo "══════════════════════════════════════════════════════════════════════════════"
+echo "  $(date '+%Y-%m-%d %H:%M:%S')  NV-INGEST STATUS"
+echo "══════════════════════════════════════════════════════════════════════════════"
+
+format_num() {
+    local num=$1
+    if [ "${num:-0}" -ge 1000000 ]; then printf "%.1fM" "$(echo "${num:-0}/1000000" | bc -l 2>/dev/null)"
+    elif [ "${num:-0}" -ge 1000 ]; then printf "%.1fK" "$(echo "${num:-0}/1000" | bc -l 2>/dev/null)"
+    else echo "${num:-0}"; fi
+}
+
+# ═══ JOB STATUS ═══
+echo -e "\n${Y}▸ JOBS${R} (Queued=waiting in Redis, InFlight=processing in Ray, Done=completed & retrieved)"
+job_states=$(docker exec $REDIS_CONTAINER redis-cli --no-raw EVAL "
+local keys = redis.call('KEYS', 'job_state:*')
+local counts = {}
+for i, key in ipairs(keys) do
+    local state = redis.call('GET', key)
+    counts[state] = (counts[state] or 0) + 1
+end
+local result = {}
+for state, count in pairs(counts) do
+    table.insert(result, state .. ':' .. count)
+end
+return result
+" 0 2>/dev/null)
+
+submitted=0; completed=0; failed=0
+while IFS= read -r line; do
+    [[ "$line" =~ SUBMITTED:([0-9]+) ]] && submitted=${BASH_REMATCH[1]}
+    [[ "$line" =~ RETRIEVED.*:([0-9]+) ]] && completed=$((completed + ${BASH_REMATCH[1]}))
+    [[ "$line" =~ FAILED:([0-9]+) ]] && failed=${BASH_REMATCH[1]}
+done <<< "$job_states"
+
+inflight=$(curl -s "http://localhost:8265/logical/actors" 2>/dev/null | python3 -c "
+import sys,json
+raw=sys.stdin.read()
+if raw.startswith('<!'):raw=raw[raw.find('{'):]
+try:
+    d=json.loads(raw);t=0
+    for a in d.get('data',{}).get('actors',{}).values():
+        if a.get('state')=='ALIVE':t+=a.get('numPendingTasks',0)+a.get('taskQueueLength',0)
+    print(t)
+except:print(0)
+" 2>/dev/null)
+inflight=${inflight:-0}
+
+total=$((submitted + inflight + completed + failed))
+printf "  %-10s %10s %10s %10s %10s\n" "Status" "Queued" "InFlight" "Completed" "Failed"
+if [ "$submitted" -gt 0 ] || [ "$inflight" -gt 0 ]; then
+    printf "  %-10s ${Y}%10s${R} ${C}%10s${R} %10s %10s\n" "Count" "$submitted" "$inflight" "$completed" "$failed"
+else
+    printf "  %-10s %10s %10s %10s %10s\n" "Count" "$submitted" "$inflight" "$completed" "$failed"
+fi
+
+# ═══ REDIS QUEUES ═══
+echo -e "\n${Y}▸ REDIS QUEUES${R} (incoming document queues by size priority)"
+printf "  %-10s %10s %10s %10s %10s %10s\n" "Queue" "main" "immediate" "small" "medium" "large"
+printf "  %-10s" "Depth"
+for q in ingest_task_queue ingest_task_queue_immediate ingest_task_queue_small ingest_task_queue_medium ingest_task_queue_large; do
+    depth=$(docker exec $REDIS_CONTAINER redis-cli LLEN $q 2>/dev/null || echo "?")
+    if [ "$depth" != "?" ] && [ "$depth" -gt 0 ]; then
+        printf " ${Y}%10s${R}" "$depth"
+    else
+        printf " %10s" "$depth"
+    fi
+done
+echo ""
+
+# ═══ REDIS POOL ═══
+echo -e "\n${Y}▸ REDIS POOL${R} (connection pool utilization)"
+# Fetch metrics from nv-ingest API endpoint
+POOL_METRICS=$(curl -s "http://localhost:7670/v1/metrics" 2>/dev/null)
+if [ -n "$POOL_METRICS" ]; then
+    # Parse pool metrics using Python for reliable parsing
+    echo "$POOL_METRICS" | python3 -c "
+import sys
+import re
+
+metrics_text = sys.stdin.read()
+
+# Parse each metric type
+def get_metric(name, label_filter=''):
+    pattern = rf'{name}\{{[^}}]*{label_filter}[^}}]*\}}\s+([\d.]+)'
+    match = re.search(pattern, metrics_text)
+    return float(match.group(1)) if match else 0.0
+
+# Extract pool metrics (look for pool_name=\"ingest\")
+in_use = get_metric('redis_pool_connections_in_use', 'pool_name=\"ingest\"')
+available = get_metric('redis_pool_connections_available', 'pool_name=\"ingest\"')
+max_conn = get_metric('redis_pool_connections_max', 'pool_name=\"ingest\"')
+timeouts = get_metric('redis_pool_timeout_total', 'pool_name=\"ingest\"')
+
+# Calculate utilization
+util_pct = (in_use / max_conn * 100) if max_conn > 0 else 0
+
+# Parse histogram buckets for wait time distribution
+wait_buckets = {}
+for match in re.finditer(r'redis_pool_wait_seconds_bucket\{[^}]*pool_name=\"ingest\"[^}]*le=\"([^\"]+)\"\}\s+([\d.]+)', metrics_text):
+    le, count = match.groups()
+    wait_buckets[le] = float(count)
+
+# Calculate wait time distribution
+prev_count = 0
+le_50ms = wait_buckets.get('0.05', 0) - prev_count
+prev_count = wait_buckets.get('0.05', 0)
+le_1s = wait_buckets.get('1.0', 0) - prev_count
+prev_count = wait_buckets.get('1.0', 0)
+le_5s = wait_buckets.get('5.0', 0) - prev_count
+
+# Color codes
+Y = '\033[33m'
+G = '\033[32m'
+RED = '\033[31m'
+R = '\033[0m'
+
+# Determine utilization color
+if util_pct >= 80:
+    util_color = RED
+elif util_pct >= 50:
+    util_color = Y
+else:
+    util_color = G
+
+# Timeout color
+timeout_color = RED if timeouts > 0 else ''
+timeout_reset = R if timeouts > 0 else ''
+
+print(f'  {\"Pool\":<12} {\"InUse\":>6} {\"Avail\":>6} {\"Max\":>6} {\"Util%\":>8} {\"Timeouts\":>9}')
+print(f'  {\"ingest\":<12} {int(in_use):>6} {int(available):>6} {int(max_conn):>6} {util_color}{util_pct:>7.0f}%{R} {timeout_color}{int(timeouts):>9}{timeout_reset}')
+if wait_buckets:
+    print(f'  Wait time: <50ms: {int(le_50ms)} | <1s: {int(le_1s)} | <5s: {int(le_5s)}')
+" 2>/dev/null || echo "  (metrics not available - check if nv-ingest is running)"
+else
+    echo "  (unable to fetch metrics from http://localhost:7670/v1/metrics)"
+fi
+
+# ═══ NIM METRICS ═══
+echo -e "\n${Y}▸ NIM METRICS${R} (PipeQ=Pipeline Queue, PipeCp=Pipeline Compute, InfQ=Inference Queue, InfCp=GPU Compute)"
+printf "  %-11s %7s %5s %4s %5s %7s %7s %7s %7s %4s %6s\n" "Model" "Items" "Batch" "Pend" "Fail" "PipeQ" "PipeCp" "InfQ" "InfCp" "GPU%" "GPUMem"
+
+get_metrics() {
+    local name=$1 port=$2 model=$3 pipe_model=$4
+    metrics=$(curl -s "http://localhost:${port}/metrics" 2>/dev/null)
+
+    inputs=$(echo "$metrics" | grep "nv_inference_count{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    execs=$(echo "$metrics" | grep "nv_inference_exec_count{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    pipe_execs=$(echo "$metrics" | grep "nv_inference_exec_count{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+
+    pending_pipe=$(echo "$metrics" | grep "nv_inference_pending_request_count{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    pending_inf=$(echo "$metrics" | grep "nv_inference_pending_request_count{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    pending=$((${pending_pipe:-0} + ${pending_inf:-0}))
+
+    # Failed requests
+    failed_pipe=$(echo "$metrics" | grep "nv_inference_request_failure{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    failed_inf=$(echo "$metrics" | grep "nv_inference_request_failure{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    failed=$((${failed_pipe:-0} + ${failed_inf:-0}))
+
+    pipe_queue_us=$(echo "$metrics" | grep "nv_inference_queue_duration_us{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    pipe_compute_us=$(echo "$metrics" | grep "nv_inference_compute_infer_duration_us{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    inf_queue_us=$(echo "$metrics" | grep "nv_inference_queue_duration_us{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    inf_compute_us=$(echo "$metrics" | grep "nv_inference_compute_infer_duration_us{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+
+    gpu_util=$(echo "$metrics" | grep "^nv_gpu_utilization" | head -1 | grep -oE '[0-9.]+$')
+    gpu_mem=$(echo "$metrics" | grep "^nv_gpu_memory_used_bytes" | head -1 | awk '{printf "%.1f", $2/1024/1024/1024}')
+
+    avg_batch="0"; avg_pipe_q="0"; avg_pipe_c="0"; avg_inf_q="0"; avg_inf_c="0"
+    [ "${execs:-0}" -gt 0 ] && {
+        avg_batch=$(echo "scale=1; ${inputs:-0}/$execs" | bc 2>/dev/null)
+        avg_inf_q=$(echo "scale=0; $inf_queue_us/$execs/1000" | bc 2>/dev/null)
+        avg_inf_c=$(echo "scale=0; $inf_compute_us/$execs/1000" | bc 2>/dev/null)
+    }
+    [ "${pipe_execs:-0}" -gt 0 ] && {
+        avg_pipe_q=$(echo "scale=0; $pipe_queue_us/$pipe_execs/1000" | bc 2>/dev/null)
+        avg_pipe_c=$(echo "scale=0; $pipe_compute_us/$pipe_execs/1000" | bc 2>/dev/null)
+    }
+    gpu_pct=$(echo "scale=0; ${gpu_util:-0}*100/1" | bc 2>/dev/null || echo "0")
+
+    # Find bottleneck
+    max=$avg_pipe_q; bn="PQ"
+    [ "${avg_pipe_c:-0}" -gt "$max" ] && { max=$avg_pipe_c; bn="PC"; }
+    [ "${avg_inf_q:-0}" -gt "$max" ] && { max=$avg_inf_q; bn="IQ"; }
+    [ "${avg_inf_c:-0}" -gt "$max" ] && { max=$avg_inf_c; bn="IC"; }
+    [ "$max" -eq 0 ] && bn="-"
+
+    # Color GPU% based on utilization: Green>=80% (busy), Yellow>=50%, Red<50% (idle)
+    if [ "${gpu_pct:-0}" -ge 80 ]; then
+        gpu_color="${G}%4s%%${R}"
+    elif [ "${gpu_pct:-0}" -ge 50 ]; then
+        gpu_color="${Y}%4s%%${R}"
+    else
+        gpu_color="${RED}%4s%%${R}"
+    fi
+
+    # Format failed count with color (red if > 0)
+    if [ "${failed:-0}" -gt 0 ]; then
+        fail_fmt="${RED}%5s${R}"
+    else
+        fail_fmt="%5s"
+    fi
+
+    # Color the bottleneck column
+    case $bn in
+        PQ) printf "  %-11s %7s %5s %4s $fail_fmt ${Y}%5sms${R} %5sms %5sms %5sms $gpu_color %5sG\n" "$name" "$(format_num $inputs)" "$avg_batch" "$pending" "$(format_num $failed)" "$avg_pipe_q" "$avg_pipe_c" "$avg_inf_q" "$avg_inf_c" "$gpu_pct" "${gpu_mem:-?}" ;;
+        PC) printf "  %-11s %7s %5s %4s $fail_fmt %5sms ${M}%5sms${R} %5sms %5sms $gpu_color %5sG\n" "$name" "$(format_num $inputs)" "$avg_batch" "$pending" "$(format_num $failed)" "$avg_pipe_q" "$avg_pipe_c" "$avg_inf_q" "$avg_inf_c" "$gpu_pct" "${gpu_mem:-?}" ;;
+        IQ) printf "  %-11s %7s %5s %4s $fail_fmt %5sms %5sms ${C}%5sms${R} %5sms $gpu_color %5sG\n" "$name" "$(format_num $inputs)" "$avg_batch" "$pending" "$(format_num $failed)" "$avg_pipe_q" "$avg_pipe_c" "$avg_inf_q" "$avg_inf_c" "$gpu_pct" "${gpu_mem:-?}" ;;
+        IC) printf "  %-11s %7s %5s %4s $fail_fmt %5sms %5sms %5sms ${G}%5sms${R} $gpu_color %5sG\n" "$name" "$(format_num $inputs)" "$avg_batch" "$pending" "$(format_num $failed)" "$avg_pipe_q" "$avg_pipe_c" "$avg_inf_q" "$avg_inf_c" "$gpu_pct" "${gpu_mem:-?}" ;;
+        *)  printf "  %-11s %7s %5s %4s $fail_fmt %5sms %5sms %5sms %5sms $gpu_color %5sG\n" "$name" "$(format_num $inputs)" "$avg_batch" "$pending" "$(format_num $failed)" "$avg_pipe_q" "$avg_pipe_c" "$avg_inf_q" "$avg_inf_c" "$gpu_pct" "${gpu_mem:-?}" ;;
+    esac
+}
+
+get_metrics "page-elem" $PORT_PAGE_ELEMENTS "$PAGE_ELEMENTS_MODEL" "$PAGE_ELEMENTS_PIPELINE"
+get_metrics "graphic-el" $PORT_GRAPHIC_ELEMENTS "$GRAPHIC_ELEMENTS_MODEL" "$GRAPHIC_ELEMENTS_PIPELINE"
+get_metrics "table-str" $PORT_TABLE_STRUCTURE "$TABLE_STRUCTURE_MODEL" "$TABLE_STRUCTURE_PIPELINE"
+get_metrics "ocr-det" $PORT_OCR "$OCR_DETECTION_MODEL" "$OCR_PIPELINE"
+get_metrics "ocr-rec" $PORT_OCR "$OCR_RECOGNITION_MODEL" "$OCR_PIPELINE"
+get_metrics "embedding" $PORT_EMBEDDING "$EMBEDDING_MODEL" "$EMBEDDING_PIPELINE"
+
+# ═══ BOTTLENECK SUMMARY ═══
+echo -e "\n${Y}▸ BOTTLENECK SUMMARY${R} (which component dominates latency)"
+printf "  %-11s %8s %9s %8s %8s   %-20s\n" "Model" "PipeQ" "PipeCp" "InfQ" "InfCp" "Bottleneck"
+
+show_bottleneck() {
+    local name=$1 port=$2 model=$3 pipe_model=$4
+    metrics=$(curl -s "http://localhost:${port}/metrics" 2>/dev/null)
+
+    execs=$(echo "$metrics" | grep "nv_inference_exec_count{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    pipe_execs=$(echo "$metrics" | grep "nv_inference_exec_count{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+
+    pipe_queue_us=$(echo "$metrics" | grep "nv_inference_queue_duration_us{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    pipe_compute_us=$(echo "$metrics" | grep "nv_inference_compute_infer_duration_us{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    inf_queue_us=$(echo "$metrics" | grep "nv_inference_queue_duration_us{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    inf_compute_us=$(echo "$metrics" | grep "nv_inference_compute_infer_duration_us{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+
+    avg_pipe_q="0"; avg_pipe_c="0"; avg_inf_q="0"; avg_inf_c="0"
+    [ "${execs:-0}" -gt 0 ] && {
+        avg_inf_q=$(echo "scale=0; $inf_queue_us/$execs/1000" | bc 2>/dev/null)
+        avg_inf_c=$(echo "scale=0; $inf_compute_us/$execs/1000" | bc 2>/dev/null)
+    }
+    [ "${pipe_execs:-0}" -gt 0 ] && {
+        avg_pipe_q=$(echo "scale=0; $pipe_queue_us/$pipe_execs/1000" | bc 2>/dev/null)
+        avg_pipe_c=$(echo "scale=0; $pipe_compute_us/$pipe_execs/1000" | bc 2>/dev/null)
+    }
+
+    max=${avg_pipe_q:-0}; bn="${Y}PipeQ (upstream)${R}"
+    [ "${avg_pipe_c:-0}" -gt "$max" ] && { max=$avg_pipe_c; bn="${M}PipeCp (pre/post)${R}"; }
+    [ "${avg_inf_q:-0}" -gt "$max" ] && { max=$avg_inf_q; bn="${C}InfQ (GPU busy)${R}"; }
+    [ "${avg_inf_c:-0}" -gt "$max" ] && { max=$avg_inf_c; bn="${G}InfCp (compute)${R}"; }
+    [ "$max" -eq 0 ] && bn="-"
+
+    printf "  %-11s %7sms %8sms %7sms %7sms   %b\n" "$name" "$avg_pipe_q" "$avg_pipe_c" "$avg_inf_q" "$avg_inf_c" "$bn"
+}
+
+show_bottleneck "page-elem" $PORT_PAGE_ELEMENTS "$PAGE_ELEMENTS_MODEL" "$PAGE_ELEMENTS_PIPELINE"
+show_bottleneck "graphic-el" $PORT_GRAPHIC_ELEMENTS "$GRAPHIC_ELEMENTS_MODEL" "$GRAPHIC_ELEMENTS_PIPELINE"
+show_bottleneck "table-str" $PORT_TABLE_STRUCTURE "$TABLE_STRUCTURE_MODEL" "$TABLE_STRUCTURE_PIPELINE"
+show_bottleneck "ocr-det" $PORT_OCR "$OCR_DETECTION_MODEL" "$OCR_PIPELINE"
+show_bottleneck "ocr-rec" $PORT_OCR "$OCR_RECOGNITION_MODEL" "$OCR_PIPELINE"
+show_bottleneck "embedding" $PORT_EMBEDDING "$EMBEDDING_MODEL" "$EMBEDDING_PIPELINE"
+
+# ═══ BATCHING EFFICIENCY ═══
+echo -e "\n${Y}▸ BATCHING EFFICIENCY${R} (images per request to NIM)"
+printf "  %-11s %10s %10s %8s\n" "Model" "Requests" "Items" "Ratio"
+
+show_batching() {
+    local name=$1 port=$2 model=$3 pipe_model=$4
+    metrics=$(curl -s "http://localhost:${port}/metrics" 2>/dev/null)
+
+    pipeline_req=$(echo "$metrics" | grep "nv_inference_request_success{" | grep "model=\"${pipe_model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+    inference_items=$(echo "$metrics" | grep "nv_inference_count{" | grep "model=\"${model}\"" | grep -oE '[0-9.]+$' | awk '{s+=$1}END{print s+0}')
+
+    if [ "${pipeline_req:-0}" -gt 0 ]; then
+        ratio=$(echo "scale=1; ${inference_items:-0}/$pipeline_req" | bc 2>/dev/null || echo "0")
+    else
+        ratio="0"
+    fi
+
+    printf "  %-11s %10s %10s %7sx\n" "$name" "$(format_num $pipeline_req)" "$(format_num $inference_items)" "$ratio"
+}
+
+show_batching "page-elem" $PORT_PAGE_ELEMENTS "$PAGE_ELEMENTS_MODEL" "$PAGE_ELEMENTS_PIPELINE"
+show_batching "graphic-el" $PORT_GRAPHIC_ELEMENTS "$GRAPHIC_ELEMENTS_MODEL" "$GRAPHIC_ELEMENTS_PIPELINE"
+show_batching "table-str" $PORT_TABLE_STRUCTURE "$TABLE_STRUCTURE_MODEL" "$TABLE_STRUCTURE_PIPELINE"
+show_batching "ocr" $PORT_OCR "$OCR_DETECTION_MODEL" "$OCR_PIPELINE"
+
+# ═══ RAY PIPELINE ═══
+echo -e "\n${Y}▸ RAY PIPELINE${R} (Repl=Replicas, Pend=Pending tasks, Queue=Task queue depth)"
+TMPFILE=$(mktemp)
+curl -s "http://localhost:9411/api/v2/traces?serviceName=nv-ingest&limit=50&minDuration=1000" 2>/dev/null > "$TMPFILE"
+curl -s "http://localhost:8265/logical/actors" 2>/dev/null | ZIPKIN_FILE="$TMPFILE" python3 -c "
+import sys,json,os
+from collections import defaultdict
+raw=sys.stdin.read()
+if raw.startswith('<!'):raw=raw[raw.find('{'):]
+
+stage_times=defaultdict(list)
+try:
+    with open(os.environ.get('ZIPKIN_FILE',''),'r') as f:traces=json.load(f)
+    for t in traces:
+        for s in t:
+            n,d=s.get('name',''),s.get('duration',0)/1000
+            if d<100000 and len(n)!=36 and not n.endswith('-v2') and '_channel_in' not in n:stage_times[n].append(d)
+except:pass
+
+m={'PDFExtractorStage':'pdf_extractor','TableExtractorStage':'table_extractor','ChartExtractorStage':'chart_extractor',
+   'InfographicExtractorStage':'infographic_extractor','TextEmbeddingTransformStage':'text_embedder'}
+try:
+    d=json.loads(raw);actors=d.get('data',{}).get('actors',{})
+    stats=defaultdict(lambda:{'p':0,'q':0,'e':0,'c':0})
+    for a in actors.values():
+        if a.get('state')!='ALIVE':continue
+        c=a.get('actorClass','')
+        stats[c]['p']+=a.get('numPendingTasks',0);stats[c]['q']+=a.get('taskQueueLength',0)
+        stats[c]['e']+=a.get('numExecutedTasks',0);stats[c]['c']+=1
+
+    print(f'  {\"Stage\":<12} {\"Repl\":>4} {\"Pend\":>4} {\"Queue\":>5} {\"Done\":>6} {\"AvgTime\":>8} {\"P95\":>8}')
+    tp,tq=0,0
+    for cls,nm in [('PDFExtractorStage','PDF'),('TableExtractorStage','Table'),('ChartExtractorStage','Chart'),
+                   ('InfographicExtractorStage','Infograph'),('TextEmbeddingTransformStage','Embed')]:
+        if cls in stats:
+            s=stats[cls];tp+=s['p'];tq+=s['q']
+            ts=sorted(stage_times.get(m.get(cls,''),[]))
+            avg=f'{sum(ts)/len(ts):>6.0f}ms' if ts else '      -'
+            p95=f'{ts[int(len(ts)*0.95)] if ts else 0:>6.0f}ms' if ts else '      -'
+            w=s['p']>0 or s['q']>0
+            if w:print(f'  \033[33m{nm:<12} {s[\"c\"]:>4} {s[\"p\"]:>4} {s[\"q\"]:>5} {s[\"e\"]:>6} {avg} {p95}\033[0m')
+            else:print(f'  {nm:<12} {s[\"c\"]:>4} {s[\"p\"]:>4} {s[\"q\"]:>5} {s[\"e\"]:>6} {avg} {p95}')
+    if tp>0 or tq>0:print(f'  \033[33mBackpressure: {tp} pending, {tq} queued\033[0m')
+except Exception as e:print(f'  Error: {e}')
+"
+rm -f "$TMPFILE"
+
+# ═══ REPLICAS & CPU ═══
+echo -e "\n${Y}▸ REPLICAS${R} (alive/total actors per stage)"
+curl -s "http://localhost:8265/logical/actors" 2>/dev/null | python3 -c "
+import sys,json
+from collections import Counter
+raw=sys.stdin.read()
+if raw.startswith('<!'):raw=raw[raw.find('{'):]
+try:
+    d=json.loads(raw);actors=d.get('data',{}).get('actors',{})
+    alive,total=Counter(),Counter()
+    for a in actors.values():
+        c=a.get('actorClass','?');total[c]+=1
+        if a.get('state')=='ALIVE':alive[c]+=1
+    parts=[]
+    for cls,nm in [('PDFExtractorStage','PDF'),('TableExtractorStage','Table'),('ChartExtractorStage','Chart'),
+                   ('InfographicExtractorStage','Infograph'),('TextEmbeddingTransformStage','Embed')]:
+        if cls in total:parts.append(f'{nm}:{alive[cls]}/{total[cls]}')
+    print('  '+' | '.join(parts)+f' | Total:{sum(alive.values())}/{len(actors)}')
+except Exception as e:print(f'  Error:{e}')
+"
+
+echo -e "\n${Y}▸ CPU (top 3)${R}"
+docker stats --no-stream --format "{{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}" 2>/dev/null | grep "^nv-ingest" | sort -t$'\t' -k2 -rn | head -3 | while read line; do
+    name=$(echo "$line" | awk -F'\t' '{print $1}' | sed 's/nv-ingest-//' | sed 's/-1$//')
+    cpu=$(echo "$line" | awk -F'\t' '{print $2}')
+    mem=$(echo "$line" | awk -F'\t' '{print $3}' | cut -d'/' -f1)
+    printf "  %-25s %8s %12s\n" "$name" "$cpu" "$mem"
+done
+echo ""
diff --git a/tools/harness/nemotron-nightly.txt b/tools/harness/nemotron-nightly.txt
new file mode 100644
index 000000000..bddd02119
--- /dev/null
+++ b/tools/harness/nemotron-nightly.txt
@@ -0,0 +1,9 @@
+# Nemotron nightly/dev packages from Test PyPI. For vanilla pip: harness env already has these
+# packages; install this file on top with --force-reinstall --no-deps to pull them from Test PyPI.
+# Usage: pip install -r tools/harness/nemotron-nightly.txt --force-reinstall --no-deps
+--index-url https://test.pypi.org/simple/
+
+nemotron-page-elements-v3>=0.dev0
+nemotron-graphic-elements-v1>=0.dev0
+nemotron-table-structure-v1>=0.dev0
+nemotron-ocr>=0.dev0
diff --git a/tools/harness/nightly_config.yaml b/tools/harness/nightly_config.yaml
index d3eb3afc4..f0113b315 100644
--- a/tools/harness/nightly_config.yaml
+++ b/tools/harness/nightly_config.yaml
@@ -34,6 +34,8 @@ sinks:
   slack:
     enabled: true
     # webhook_url: Set via SLACK_WEBHOOK_URL environment variable
+    # users_to_tag: List of user names to tag in Slack notifications (must match PIC_DICT keys)
+    users_to_tag: [randy]
 
   history:
     enabled: true
@@ -41,10 +43,8 @@ sinks:
     retention_days: 90  # Auto-prune runs older than 90 days
 
 # Infrastructure
+# Note: Infrastructure settings (compose/helm profiles, readiness_timeout, etc.)
+# are configured in test_configs.yaml under the 'active' section.
+# This section only contains nightly-specific settings.
 infrastructure:
-  fresh_start: true  # Run nv-clean && nv-start before benchmarks
-  readiness_timeout: 600  # Seconds to wait for services to be ready
-  profiles:  # Docker compose profiles to start
-    - retrieval
-    - table-structure
-    - reranker  # Required for recall evaluation
+  fresh_start: true  # Restart services before running nightly benchmarks (mutually exclusive with --managed)
diff --git a/tools/harness/NIGHTLY.md b/tools/harness/plans/NIGHTLY.md
similarity index 92%
rename from tools/harness/NIGHTLY.md
rename to tools/harness/plans/NIGHTLY.md
index cd605352d..768680a30 100644
--- a/tools/harness/NIGHTLY.md
+++ b/tools/harness/plans/NIGHTLY.md
@@ -7,6 +7,13 @@ Automated benchmarks with Slack reporting and historical tracking.
 ```bash
 cd tools/harness
 
+# Install the harness
+uv pip install -e .
+
+# Vanilla pip: install the harness with pip, then add nightly Nemotron from Test PyPI:
+#   pip install -e .   # (after installing nv-ingest, nv-ingest-api, nv-ingest-client)
+#   pip install -r nemotron-nightly.txt --force-reinstall --no-deps
+
 export SLACK_WEBHOOK_URL="https://hooks.slack.com/services/..."
 uv run nv-ingest-harness-nightly
 
@@ -178,6 +185,15 @@ uv run nv-ingest-harness-nightly \
 
 ## CI/CD
 
+### Installation
+
+```bash
+cd tools/harness
+uv pip install -e .
+```
+
+### GitHub Actions
+
 ```yaml
 # GitHub Actions
 jobs:
@@ -187,12 +203,15 @@ jobs:
       SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}
     steps:
       - uses: actions/checkout@v4
-      - run: cd tools/harness && uv sync && uv run nv-ingest-harness-nightly
+      - run: cd tools/harness && uv pip install -e . && uv run nv-ingest-harness-nightly
 ```
 
+### Cron
+
 ```bash
 # Cron (2 AM daily)
 0 2 * * * cd /path/to/tools/harness && source ~/setup_env.sh && \
+  uv pip install -e . && \
   SLACK_WEBHOOK_URL="..." uv run nv-ingest-harness-nightly >> /var/log/nightly.log 2>&1
 ```
 
diff --git a/tools/harness/plans/SERVICE_MANAGER.md b/tools/harness/plans/SERVICE_MANAGER.md
new file mode 100644
index 000000000..38ba9c59a
--- /dev/null
+++ b/tools/harness/plans/SERVICE_MANAGER.md
@@ -0,0 +1,868 @@
+# Service Manager Implementation
+
+This document describes the service manager architecture for managing Docker Compose and Helm deployments in the nv-ingest test harness.
+
+## Status: ✅ Implemented
+
+The service manager has been fully implemented and is actively used for managing both Docker Compose and Helm-based deployments.
+
+## Architecture
+
+The service management logic uses a Strategy Pattern with the following components:
+
+### File Structure
+
+```
+tools/harness/src/nv_ingest_harness/service_manager/
+├── __init__.py          # Factory function and exports
+├── base.py              # Abstract ServiceManager base class
+├── docker_compose.py    # Docker Compose implementation
+└── helm.py              # Helm implementation (with port-forward support)
+```
+
+### Components
+
+1. **ServiceManager (base.py)**: Abstract base class defining the interface for all service managers
+   - `start(no_build: bool) -> int`: Start services
+   - `stop(clean: bool) -> int`: Stop and cleanup services (clean=True removes volumes/namespace)
+   - `restart(build: bool, clean: bool, timeout: int) -> int`: Restart services (stop, start, wait for readiness)
+   - `check_readiness(timeout_s: int, check_milvus: bool) -> bool`: Poll for service readiness
+   - `get_service_url(service: str) -> str`: Get service endpoint URLs
+   - `dump_logs(artifacts_dir: Path) -> int`: Dump service logs to artifacts directory (abstract method)
+
+2. **DockerComposeManager (docker_compose.py)**: Manages services using Docker Compose
+   - Uses profiles from config to enable/disable service groups
+   - Supports `--no-build` flag to skip building Docker images
+   - Polls health endpoint for main service and optionally Milvus
+   - Cleans up containers and volumes on stop
+   - **SKU Override Support**: Accepts `sku` parameter to load GPU-specific override files
+   - **Log Dumping**: Implements `dump_logs()` to capture container logs
+     - Dumps individual container logs: `container_<name>.log`
+     - Dumps combined logs: `docker_compose_combined.log`
+     - Includes timestamps and handles errors gracefully
+
+3. **HelmManager (helm.py)**: Manages services using Helm
+   - Installs/upgrades Helm releases with version support
+   - Supports both remote charts (from Helm repos) and local `./helm` chart
+   - Supports custom values files and inline values
+   - **SKU override**: Optional `helm/overrides/values-<sku>.yaml` via `-f` when `--sku` is set
+   - **Port-forwarding**: Automatically sets up resilient `kubectl port-forward` for services
+   - **Wildcard matching**: Supports dynamic service name patterns (e.g., `*embed*`)
+   - **Auto-restart**: Port-forwards automatically restart on pod restarts/failures
+   - **Cleanup**: Port-forwards always cleaned up (even with `--keep-up`)
+   - Polls health endpoint for readiness
+   - **Log Dumping**: Implements `dump_logs()` to capture pod logs
+     - Dumps logs for each container in each pod: `pod_<name>_<container>.log`
+     - Captures previous logs if container restarted: `pod_<name>_<container>_previous.log`
+     - Dumps pod status: `pod_status.txt`
+     - Dumps pod events: `pod_events.txt`
+     - Includes timestamps and handles multi-container pods
+
+4. **create_service_manager()**: Factory function that creates the appropriate manager based on `deployment_type` config
+   - Accepts `sku` parameter; passes it to `DockerComposeManager` or `HelmManager` for GPU-specific overrides
+
+## SKU Override Support
+
+The service manager supports GPU-specific configuration overrides via the `--sku` CLI option for both Docker Compose and Helm deployments.
+
+### Implementation Details
+
+#### CLI Layer (`cli/run.py`, `cli/nightly.py`)
+- Both CLIs accept `--sku` parameter (e.g., `--sku=a10g`)
+- Parameter is passed through to `create_service_manager()`
+- Subprocess calls (in nightly.py) include `--sku` argument
+
+#### Service Manager Factory (`service_manager/__init__.py`)
+- `create_service_manager()` accepts `sku` parameter
+- Passes `sku` to `DockerComposeManager` (Compose) or `HelmManager` (Helm)
+
+#### Docker Compose Manager (`service_manager/docker_compose.py`)
+- Accepts `sku` parameter in `__init__()`
+- Checks for override file: `docker-compose.<sku>.yaml`
+- Prints warning if specified but not found
+- Uses `_build_compose_cmd()` helper to construct commands
+- All docker compose commands include override file via multiple `-f` flags
+
+#### Helm Manager (`service_manager/helm.py`)
+- Accepts `sku` parameter in `__init__()`
+- In `start()`, if `sku` is set and `helm/overrides/values-<sku>.yaml` exists, adds `-f <path>` to the `helm upgrade --install` command
+- Prints warning if override file is specified but not found
+
+### SKU Parameter Flow
+
+**Compose:**
+```
+CLI (run.py/nightly.py)
+  └─> --sku=a10g
+       └─> create_service_manager(config, repo_root, sku)
+            └─> DockerComposeManager(config, repo_root, sku)
+                 └─> Check: docker-compose.a10g.yaml exists?
+                      └─> _build_compose_cmd() adds: -f docker-compose.yaml -f docker-compose.a10g.yaml
+                           └─> Used by: start(), stop(), dump_logs()
+```
+
+**Helm:**
+```
+CLI (run.py/nightly.py)
+  └─> --sku=a10g
+       └─> create_service_manager(config, repo_root, sku)
+            └─> HelmManager(config, repo_root, sku)
+                 └─> start(): if helm/overrides/values-a10g.yaml exists, add -f <path> to helm upgrade --install
+```
+
+### Available SKU Override Files
+- **Compose:** `docker-compose.a10g.yaml`, `docker-compose.l40s.yaml`, `docker-compose.a100-40gb.yaml` (repo root)
+- **Helm:** `helm/overrides/values-a10g.yaml`, `helm/overrides/values-l40s.yaml`, `helm/overrides/values-a100-40gb.yaml`
+
+### Usage Examples
+
+```bash
+# Run with A10G GPU settings
+python -m nv_ingest_harness.cli.run \
+  --dataset=bo767 \
+  --case=e2e \
+  --managed \
+  --deployment-type=compose \
+  --sku=a10g
+
+# Nightly benchmarks with L40S settings
+python -m nv_ingest_harness.cli.nightly \
+  --deployment-type=compose \
+  --managed \
+  --sku=l40s
+
+# Helm with A10G GPU override (loads helm/overrides/values-a10g.yaml)
+python -m nv_ingest_harness.cli.run \
+  --dataset=bo767 --case=e2e --managed \
+  --deployment-type=helm \
+  --sku=a10g
+```
+
+### Override File Structure
+
+Override files typically contain GPU-specific tuning parameters:
+
+```yaml
+# docker-compose.a10g.yaml
+services:
+  page-elements:
+    environment:
+      - NIM_TRITON_MAX_BATCH_SIZE=1
+  
+  graphic-elements:
+    environment:
+      - NIM_TRITON_MAX_BATCH_SIZE=1
+```
+
+Docker Compose automatically merges the base file with the override file, with the override taking precedence.
+
+## Service Log Dumping
+
+The service manager automatically captures logs from managed services to the artifacts directory when tests complete.
+
+### Implementation Details
+
+#### Base Service Manager (`service_manager/base.py`)
+- Added abstract method `dump_logs(artifacts_dir: Path) -> int`
+- Required for all service manager implementations
+- Returns exit code (0 = success)
+
+#### Docker Compose Log Dumping (`service_manager/docker_compose.py`)
+- Lists all containers using `docker compose ps -q`
+- Dumps individual container logs with container names: `container_<name>.log`
+- Dumps combined logs from all services: `docker_compose_combined.log`
+- **Dumps environment variables for each container**: `container_<name>_env.txt`
+- Includes timestamps and handles errors gracefully
+- Uses `docker logs` for individual containers and `docker compose logs` for combined output
+- Uses `docker inspect` to capture container environment variables
+- Timeouts: 60s per container, 120s for combined logs, 30s for env vars
+- Continues on errors to ensure cleanup completes
+
+#### Helm Log Dumping (`service_manager/helm.py`)
+- Lists all pods in namespace using `kubectl get pods`
+- Dumps logs for each container in each pod: `pod_<name>_<container>.log`
+- Captures previous logs if container restarted: `pod_<name>_<container>_previous.log`
+- Dumps pod status: `pod_status.txt`
+- Dumps pod events: `pod_events.txt`
+- **Dumps environment variables for each container**: `pod_<name>_<container>_env.txt`
+- Includes timestamps in all logs
+- Handles multi-container pods correctly
+- Uses `kubectl exec ... env` to capture runtime environment variables
+- Falls back to pod spec env vars if exec fails
+- Timeouts: 60s per container/pod, 120s for status/events, 30s for env vars
+- Continues on errors to ensure cleanup completes
+
+#### CLI Integration (`cli/run.py`, `cli/nightly.py`)
+
+**run.py:**
+- Determines log directory:
+  - `<session_dir>/service_logs/` if using session directory
+  - `<artifact_dir>/service_logs/` as fallback
+  - Timestamped directory in artifacts root if no other location available
+- Calls `service_manager.dump_logs(logs_dir)` before stopping services
+- Log dumping occurs before port-forward cleanup and service shutdown
+
+**nightly.py:**
+- Dumps logs to `<session_dir>/service_logs/`
+- Integrated into existing service lifecycle management
+- Logs captured before cleanup in main orchestration loop
+
+### Log Directory Structure
+
+#### Docker Compose
+```
+service_logs/
+├── container_nv-ingest-1.log
+├── container_nv-ingest-1_env.txt
+├── container_redis-1.log
+├── container_redis-1_env.txt
+├── container_milvus-standalone-1.log
+├── container_milvus-standalone-1_env.txt
+├── container_embedding-1.log
+├── container_embedding-1_env.txt
+└── docker_compose_combined.log
+```
+
+#### Helm (Kubernetes)
+```
+service_logs/
+├── pod_nv-ingest-ms-runtime-abc123_nv-ingest.log
+├── pod_nv-ingest-ms-runtime-abc123_nv-ingest_env.txt
+├── pod_nv-ingest-ms-runtime-abc123_nv-ingest_previous.log
+├── pod_redis-master-0_redis.log
+├── pod_redis-master-0_redis_env.txt
+├── pod_milvus-standalone-xyz789_milvus.log
+├── pod_milvus-standalone-xyz789_milvus_env.txt
+├── pod_status.txt
+└── pod_events.txt
+```
+
+### Usage Examples
+
+Log dumping happens automatically when running in managed mode:
+
+```bash
+# Single dataset with managed services
+python -m nv_ingest_harness.cli.run --case=e2e --dataset=bo767 --managed --deployment-type=compose
+# Logs saved to: artifacts/bo767_compose_<timestamp>/service_logs/
+
+# Multiple datasets with session directory
+python -m nv_ingest_harness.cli.run --case=e2e --dataset=bo767,earnings --managed --session-name=test_session
+# Logs saved to: artifacts/test_session/service_logs/
+
+# Nightly benchmarks with Helm
+python -m nv_ingest_harness.cli.nightly --managed --deployment-type=helm
+# Logs saved to: artifacts/nightly_<timestamp>/service_logs/
+```
+
+### Benefits
+
+1. **Debugging**: Complete service logs and environment variables preserved for post-mortem analysis
+2. **Automatic**: No manual log or env var collection needed
+3. **Organized**: Logs and env vars stored with test artifacts for easy correlation
+4. **Comprehensive**: Captures all container/pod logs, environment variables, statuses, and events
+5. **Configuration Visibility**: Environment variables help diagnose configuration-related issues
+6. **Failure Analysis**: Helps diagnose infrastructure and configuration issues in test failures
+7. **Non-blocking**: Continues on errors to ensure cleanup completes
+
+### Error Handling
+
+- Timeouts handled with subprocess timeout parameters
+- Missing or failed log captures print warnings but don't fail the test
+- Directory creation errors handled gracefully
+- Process errors (return codes) logged but don't stop cleanup
+
+## Configuration
+
+The service manager can be configured in two ways:
+
+1. **CLI flag** (highest priority): `--deployment-type=helm` or `--deployment-type=compose`
+2. **YAML config** (default): Set `deployment_type` in `test_configs.yaml`
+
+**Precedence**: CLI args > Environment variables > YAML config
+
+### Docker Compose Configuration
+
+```yaml
+active:
+  # Optional: Set deployment type default (defaults to 'compose' if not specified)
+  # Can be overridden with --deployment-type CLI flag
+  deployment_type: compose
+  
+  # Docker Compose-specific settings
+  profiles:
+    - retrieval
+    - reranker
+    # Add other profiles as needed
+  
+  hostname: localhost  # Default hostname for service URLs
+  readiness_timeout: 600  # Seconds to wait for services to become ready
+```
+
+### Helm Configuration
+
+```yaml
+active:
+  # Optional: Set deployment type default to 'helm'
+  # Can be overridden with --deployment-type CLI flag
+  deployment_type: helm
+  
+  # Helm-specific settings
+  helm_bin: helm  # Helm binary (e.g., "helm", "microk8s helm", "k3s helm")
+  helm_sudo: false  # Use sudo for Helm commands (set to true if needed)
+  helm_chart: nim-nvstaging/nv-ingest  # Remote chart (set to null for local ./helm)
+  helm_chart_version: 26.1.0-RC7  # Chart version (required for remote charts)
+  helm_release: nv-ingest  # Helm release name
+  helm_namespace: nv-ingest  # Kubernetes namespace
+  helm_values_file: .helm-env  # Optional: path to values file
+  # helm_values:  # Optional: inline Helm values (dict)
+  #   api:
+  #     enabled: true
+  
+  # kubectl configuration (for port-forwarding)
+  kubectl_bin: kubectl  # kubectl binary (e.g., "kubectl", "microk8s kubectl")
+  kubectl_sudo: null  # Defaults to same as helm_sudo if not set
+  
+  # Port forwarding configuration
+  helm_port_forwards:
+    - service: nv-ingest  # Service name (supports wildcards)
+      local_port: 7670
+      remote_port: 7670
+    - service: nv-ingest-milvus
+      local_port: 19530
+      remote_port: 19530
+    - service: "*embed*"  # Wildcard: matches any service with "embed" in name
+      local_port: 8012
+      remote_port: 8000
+  
+  hostname: localhost  # Hostname for port-forwarded services
+  readiness_timeout: 600  # Seconds to wait for services to become ready
+```
+
+## Usage
+
+### CLI Options
+
+The service manager is controlled via CLI flags:
+
+- `--managed`: Enable managed mode (starts/stops services automatically)
+- `--deployment-type=<type>`: Set deployment type (`compose` or `helm`)
+  - Overrides `deployment_type` in YAML config
+  - Defaults to `compose` if not specified in either place
+- `--sku=<sku>`: GPU-specific override (Compose: `docker-compose.<sku>.yaml`; Helm: `helm/overrides/values-<sku>.yaml`). e.g. `a10g`, `l40s`, `a100-40gb`
+- `--no-build`: Skip building Docker images (Docker Compose only)
+- `--keep-up`: Keep services running after test completes (does not apply to port-forwards)
+- `--doc-analysis`: Show per-document element breakdown in results
+
+### Docker Compose (Default)
+
+```bash
+# Default behavior uses Docker Compose (no need to specify deployment type)
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed
+
+# Explicitly specify Docker Compose (same as default)
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --deployment-type=compose
+
+# With GPU-specific settings (SKU override)
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --sku=a10g
+
+# Skip rebuilding images
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --no-build
+
+# Keep services running after test
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --keep-up
+```
+
+### Helm with Remote Chart
+
+**Option 1: CLI flag (no YAML changes needed)**
+```bash
+# Override deployment type via CLI
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --deployment-type=helm
+```
+
+**Option 2: Set default in YAML**
+
+1. Configure Helm as default in `test_configs.yaml`:
+   ```yaml
+   active:
+     deployment_type: helm  # Set Helm as default
+     helm_bin: helm  # Use "microk8s helm" for MicroK8s, "k3s helm" for K3s
+     helm_chart: nim-nvstaging/nv-ingest
+     helm_chart_version: 26.1.0-RC7
+     helm_release: nv-ingest
+     helm_namespace: nv-ingest
+     helm_values_file: .helm-env
+   ```
+
+2. Run tests (uses Helm from YAML config):
+   ```bash
+   uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed
+   ```
+
+### Helm with Local Chart
+
+Configure for local chart in `test_configs.yaml`:
+```yaml
+active:
+  deployment_type: helm  # Optional: set as default
+  helm_chart: null  # Use local ./helm chart
+  helm_release: nv-ingest
+  helm_namespace: nv-ingest
+  helm_values_file: .helm-env
+```
+
+Run tests:
+```bash
+# Use YAML config default
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed
+
+# Or explicitly override to Helm
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767 --managed --deployment-type=helm
+```
+
+### Multiple Datasets
+
+Run tests across multiple datasets sequentially (services start once):
+
+```bash
+uv run nv-ingest-harness-run --case=e2e --dataset=bo767,earnings --managed
+```
+
+## Benefits
+
+- **Clean separation**: Each orchestrator has its own implementation
+- **Extensible**: Easy to add new deployment types (Kubernetes manifests, Nomad, etc.)
+- **Testable**: Each manager can be tested in isolation
+- **Configuration-driven**: Switch between Docker Compose and Helm via config
+- **Backward compatible**: Existing Docker Compose workflows continue to work
+
+## Key Implementation Details
+
+### Integration in CLI (run.py)
+
+The `run_datasets()` function uses the service manager as follows:
+
+1. **Initialization**: Creates service manager via factory based on `deployment_type`
+   ```python
+   service_manager = create_service_manager(config, REPO_ROOT)
+   ```
+
+2. **Startup**: Starts services and waits for readiness
+   ```python
+   service_manager.start(no_build=no_build)
+   service_manager.check_readiness(timeout_s)
+   ```
+
+3. **Testing**: Runs test cases while services remain up
+
+4. **Cleanup**: Handles port-forwards and service shutdown
+   ```python
+   # Always cleanup port forwards (prevents orphaned processes)
+   service_manager._stop_port_forwards()
+   
+   # Only uninstall services if not keeping up
+   if not keep_up:
+       service_manager.stop()
+   else:
+       # Print commands to manually recreate port forwards
+       service_manager.print_port_forward_commands()
+   ```
+
+### Docker Compose Implementation
+
+The `DockerComposeManager`:
+
+- Builds command with multiple `--profile` flags
+- Supports `--build` or `--no-build` flag
+- Uses `docker compose down -v --remove-orphans` for cleanup
+- Checks both main service (`/v1/health/ready`) and optionally Milvus health endpoints
+
+### Helm Implementation
+
+The `HelmManager`:
+
+- Supports multi-word commands (`microk8s helm`, `k3s helm`)
+- Optional sudo for both Helm and kubectl commands
+- Handles both remote and local charts
+- Merges values from files and inline values
+- **Port-forwarding**:
+  - Wrapped in resilient bash loop for auto-restart
+  - Creates new process group for clean termination
+  - Retries on pod not ready errors
+  - Wildcard service matching via `kubectl get services`
+  - Always cleaned up (even with `--keep-up`)
+  - Provides recreation commands for manual use
+
+## Helm Binary and sudo Configuration
+
+The `helm_bin` and `helm_sudo` configuration options support different Helm installations:
+
+### Standard Helm (no sudo)
+```yaml
+helm_bin: helm
+helm_sudo: false
+```
+
+### MicroK8s with sudo
+If you need root privileges for MicroK8s:
+```yaml
+helm_bin: microk8s helm
+helm_sudo: true  # Runs: sudo microk8s helm ...
+```
+
+**Note**: Using `helm_sudo: true` allows the main Python process to run as your user (with access to your venv), while only the Helm commands run with sudo. This avoids running the entire harness as root.
+
+**Alternative**: Add your user to the microk8s group to avoid needing sudo:
+```bash
+sudo usermod -a -G microk8s $USER
+newgrp microk8s
+```
+Then set `helm_sudo: false`.
+
+### K3s
+```yaml
+helm_bin: k3s helm
+helm_sudo: true  # If needed
+```
+
+### Custom Path
+```yaml
+helm_bin: /usr/local/bin/helm
+helm_sudo: false
+```
+
+### kubectl Configuration
+
+The `kubectl_bin` and `kubectl_sudo` settings work the same way:
+
+```yaml
+kubectl_bin: kubectl  # or "microk8s kubectl", "k3s kubectl"
+kubectl_sudo: null  # Defaults to same as helm_sudo if not set
+```
+
+### Environment Variables
+
+You can also set these via environment variables (useful for CI/CD):
+```bash
+export HELM_BIN="microk8s helm"
+export HELM_SUDO="true"
+export KUBECTL_BIN="microk8s kubectl"
+uv run nv-ingest-harness-run --dataset=bo20 --case=e2e --managed --deployment-type=helm
+```
+
+The commands are split on spaces, so multi-word commands like `microk8s helm` work correctly.
+
+## Docker Compose Profiles vs Helm Values
+
+**Important**: Docker Compose "profiles" are specific to Docker Compose and are **not** used in Helm deployments.
+
+### Docker Compose
+
+Uses `profiles` to enable/disable service groups defined in `docker-compose.yaml`:
+```yaml
+profiles:
+  - retrieval
+  - reranker
+```
+
+These map to services marked with `profiles:` in the Docker Compose file.
+
+### Helm
+
+Uses `helm_values_file` or `helm_values` to configure which services to enable:
+```yaml
+helm_values_file: .helm-env
+# Or use inline values:
+helm_values:
+  api:
+    enabled: true
+  redis:
+    enabled: true
+  yolox:
+    enabled: true
+```
+
+For Helm deployments, configure services through your values file or inline `helm_values` according to your Helm chart's schema (typically under `<service>.enabled`).
+
+## Port Forwarding for Helm Deployments
+
+The Helm manager automatically sets up **resilient** `kubectl port-forward` for multiple services to make them accessible on localhost. Port-forwards are wrapped in auto-restart loops to handle pod restarts and failures.
+
+### Configuration
+
+```yaml
+helm_port_forwards:
+  # Simple service forward
+  - service: nv-ingest
+    local_port: 7670
+    remote_port: 7670
+  
+  # Milvus vector database
+  - service: nv-ingest-milvus
+    local_port: 19530
+    remote_port: 19530
+  
+  # Wildcard pattern for dynamic service names
+  - service: "*embed*"  # Matches any service with "embed" in the name
+    local_port: 8012
+    remote_port: 8000
+```
+
+### Default Configuration
+
+If `helm_port_forwards` is not specified, the manager defaults to forwarding only the main service:
+```yaml
+helm_port_forwards:
+  - service: nv-ingest  # Uses helm_release value
+    local_port: 7670
+    remote_port: 7670
+```
+
+### Wildcard Service Matching
+
+Port-forwards support wildcards (`*`) in service names to match dynamic service names:
+
+- `"*embed*"` - Matches any service with "embed" in the name (e.g., `nv-ingest-embed-nim`, `embed-service`)
+- `"nv-ingest-*"` - Matches services starting with "nv-ingest-"
+- `"*-milvus"` - Matches services ending with "-milvus"
+
+The manager queries `kubectl get services` to find matches and starts port-forward for each matching service.
+
+### Auto-Restart Behavior
+
+Each port-forward is wrapped in a resilient bash loop:
+
+```bash
+while true; do
+    echo "[$(date)] Starting port-forward for <service>..." >&2
+    kubectl port-forward -n <namespace> service/<service> <local>:<remote>
+    EXIT_CODE=$?
+    echo "[$(date)] Port-forward exited with code $EXIT_CODE, restarting in 5s..." >&2
+    sleep 5
+done
+```
+
+This ensures port-forwards automatically recover from:
+- Pod restarts
+- Node failures
+- Network interruptions
+- Any other transient failures
+
+### Lifecycle
+
+1. **After Helm install**: Automatically starts port-forward for all configured services
+   ```bash
+   $ kubectl port-forward -n nv-ingest service/nv-ingest 7670:7670 (background, auto-restart)
+   Waiting for nv-ingest pod to be ready (timeout: 120s)...
+   Port forwarding started for nv-ingest (7670:7670) (PID: 12345, auto-restart enabled)
+   ```
+
+2. **Retry logic**: If pods are not ready yet (Pending status), retries every 5 seconds for up to 120 seconds
+
+3. **During tests**: Services are accessible at their configured local ports
+   - Main API: `http://localhost:7670`
+   - Milvus: `localhost:19530`
+   - Embedding: `http://localhost:8012`
+
+4. **On cleanup**: All port-forward processes and their children are terminated (always, regardless of `--keep-up`)
+
+### Cleanup Behavior
+
+Port-forwards are **always** cleaned up at the end to prevent orphaned processes:
+
+- Uses process group termination (`killpg`) to stop bash wrapper and all kubectl children
+- Fallback cleanup via `pgrep` to catch any orphaned processes in the namespace
+- Graceful SIGTERM followed by force SIGKILL if needed
+- Works with or without sudo
+
+### Orphaned Process Detection
+
+If port-forwards are not properly tracked, the manager performs a fallback cleanup:
+
+```bash
+Checking for orphaned port-forward processes in namespace 'nv-ingest'...
+  Found 2 orphaned port-forward process(es), cleaning up...
+    Killing PID 12345...
+    Killing PID 12346...
+  Orphaned process cleanup complete
+```
+
+This uses `pgrep -f "port-forward.*-n <namespace>"` to find and terminate any orphaned processes.
+
+## Port Forwards and `--keep-up`
+
+**Important**: Port-forward processes are **always** cleaned up at the end, even when using `--keep-up`:
+
+- `--keep-up` keeps the **Helm release** installed (services continue running in Kubernetes)
+- Port-forwards are **always terminated** to prevent orphaned processes and port conflicts
+- Helpful commands are printed to manually recreate port-forwards if needed
+
+### Why Clean Up Port Forwards?
+
+1. **Prevents port conflicts** - Next run can bind to the same ports without conflicts
+2. **No orphaned processes** - Avoids accumulating background processes across multiple runs
+3. **Clean state** - Each run starts fresh with its own port-forwards
+4. **Easy to recreate** - Commands are provided if manual access is needed after test
+
+### Example with `--keep-up`
+
+```bash
+uv run nv-ingest-harness-run --case=e2e --dataset=bo20 --managed --deployment-type=helm --keep-up
+```
+
+Output at the end:
+```
+Stopping 3 port forward(s)...
+  Stopping nv-ingest (7670:7670) (PID: 12345)...
+  Stopping nv-ingest-milvus (19530:19530) (PID: 12346)...
+  Stopping nv-ingest-embed-nim (8012:8000) (PID: 12347)...
+
+============================================================
+Services are kept running (--keep-up enabled)
+Port forwards have been cleaned up to prevent orphaned processes.
+
+To manually recreate port forwards (with auto-restart), run:
+============================================================
+  # Auto-restarting port-forward for nv-ingest:
+  while true; do kubectl port-forward -n nv-ingest service/nv-ingest 7670:7670; sleep 5; done &
+
+  # Auto-restarting port-forward for nv-ingest-milvus:
+  while true; do kubectl port-forward -n nv-ingest service/nv-ingest-milvus 19530:19530; sleep 5; done &
+
+  # Auto-restarting port-forward for nv-ingest-embed-nim:
+  while true; do kubectl port-forward -n nv-ingest service/nv-ingest-embed-nim 8012:8000; sleep 5; done &
+
+============================================================
+```
+
+The provided commands include the auto-restart loop for resilience against pod restarts.
+
+## Benefits
+
+- **Clean separation**: Each orchestrator has its own implementation
+- **Extensible**: Easy to add new deployment types (Kubernetes manifests, Nomad, etc.)
+- **Testable**: Each manager can be tested in isolation
+- **Configuration-driven**: Switch between Docker Compose and Helm via config
+- **Backward compatible**: Existing Docker Compose workflows continue to work
+- **Resilient port-forwarding**: Auto-restart on failures for Helm deployments
+- **Clean cleanup**: Prevents orphaned processes and port conflicts
+- **Flexible**: Supports various Kubernetes distributions (standard, MicroK8s, K3s)
+
+## Advanced Features
+
+### Multiple Port Forwards per Service
+
+You can forward multiple ports from the same service:
+
+```yaml
+helm_port_forwards:
+  - service: nv-ingest
+    local_port: 7670
+    remote_port: 7670
+  - service: nv-ingest  # Same service, different port
+    local_port: 8080
+    remote_port: 8080
+```
+
+The implementation consolidates these into a single port-forward command:
+```bash
+kubectl port-forward -n nv-ingest service/nv-ingest 7670:7670 8080:8080
+```
+
+### Readiness Checks
+
+Both managers support health checking:
+
+- **Main service**: `http://localhost:7670/v1/health/ready`
+- **Milvus** (optional): `http://localhost:9091/healthz`
+
+Configure timeout and Milvus checking:
+```yaml
+readiness_timeout: 600  # Seconds to wait
+# Milvus check is enabled by default in check_readiness()
+```
+
+### Session Management
+
+The service manager integrates with the harness's session management:
+
+- Artifacts stored per dataset in structured session directories
+- Results consolidated into `results.json` with metadata
+- Session summary generated with all test outcomes
+- Compatible with nightly runner for automated testing
+
+## Troubleshooting
+
+### Port-forward fails to establish
+
+If you see timeout errors during port-forward setup:
+
+1. **Check pod status**:
+   ```bash
+   kubectl get pods -n nv-ingest
+   ```
+
+2. **Check service exists**:
+   ```bash
+   kubectl get services -n nv-ingest
+   ```
+
+3. **Manually test port-forward**:
+   ```bash
+   kubectl port-forward -n nv-ingest service/nv-ingest 7670:7670
+   ```
+
+4. **Check permissions** (if using sudo):
+   - Ensure your user has sudo access
+   - Or add user to k8s group (microk8s, k3s)
+
+### Services not becoming ready
+
+If `check_readiness()` times out:
+
+1. **Check pod logs**:
+   ```bash
+   kubectl logs -n nv-ingest -l app=nv-ingest
+   ```
+
+2. **Check pod events**:
+   ```bash
+   kubectl describe pod -n nv-ingest
+   ```
+
+3. **Increase timeout**:
+   ```yaml
+   readiness_timeout: 1200  # 20 minutes
+   ```
+
+### Orphaned port-forward processes
+
+If you see port conflicts on subsequent runs:
+
+1. **Check for orphaned processes**:
+   ```bash
+   ps aux | grep port-forward
+   ```
+
+2. **Kill manually**:
+   ```bash
+   pkill -f "port-forward.*nv-ingest"
+   ```
+
+The manager automatically attempts cleanup, but manual intervention may be needed in rare cases.
+
+## Future Enhancements
+
+Potential improvements for future iterations:
+
+1. ✅ ~~Add support for Kubernetes manifest files~~ (could be added as `KubernetesManager`)
+2. ✅ ~~Implement kubectl-based readiness checks for Helm~~ (currently uses HTTP endpoint, could add `kubectl wait`)
+3. ✅ ~~Add support for port-forwarding in Helm manager~~ (implemented with auto-restart)
+4. ✅ ~~Add retry logic for transient failures~~ (implemented for port-forwards and pod readiness)
+5. ✅ ~~Support for multiple service endpoints~~ (implemented with wildcard matching)
+6. Add support for NodePort/LoadBalancer service types (alternative to port-forwarding)
+7. Add Prometheus/Grafana port-forwards for observability
+8. Support for custom health check endpoints per service
+9. Integration with kubectl context switching for multi-cluster support
+10. Support for Helm chart dependencies and pre-install hooks
diff --git a/tools/harness/pyproject.toml b/tools/harness/pyproject.toml
index e6b3bffdd..002479426 100644
--- a/tools/harness/pyproject.toml
+++ b/tools/harness/pyproject.toml
@@ -5,14 +5,20 @@ description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12"
 dependencies = [
+    "click>=8.1.8",
     "docker>=7.1.0",
-    "milvus-lite==2.4.12",
-    "nv-ingest",
-    "nv-ingest-api",
-    "nv-ingest-client",
     "pyyaml>=6.0",
     "requests>=2.31.0",
     "pynvml>=11.5.0",
+    "nv-ingest",
+    "nv-ingest-api",
+    "nv-ingest-client",
+    "milvus-lite==2.4.12",
+    "pypdfium2>=4.30.0,<5.0.0",
+    "nemotron-page-elements-v3>=0.dev0",
+    "nemotron-graphic-elements-v1>=0.dev0",
+    "nemotron-table-structure-v1>=0.dev0",
+    "nemotron-ocr>=0.dev0",
 ]
 
 [project.scripts]
@@ -23,13 +29,6 @@ nv-ingest-harness-nightly = "nv_ingest_harness.cli.nightly:main"
 nv-ingest-harness-compare = "nv_ingest_harness.cli.compare:main"
 nv-ingest-harness-stats = "nv_ingest_harness.cli.stats:main"
 
-[dependency-groups]
-dev = [
-    "nv-ingest",
-    "nv-ingest-api",
-    "nv-ingest-client",
-]
-
 [tool.uv]
 package = true
 
@@ -37,3 +36,12 @@ package = true
 nv-ingest = { path = "../../src", editable = true }
 nv-ingest-api = { path = "../../api/", editable = true }
 nv-ingest-client = { path = "../../client/", editable = true }
+nemotron-page-elements-v3 = { index = "test-pypi" }
+nemotron-graphic-elements-v1 = { index = "test-pypi" }
+nemotron-table-structure-v1 = { index = "test-pypi" }
+nemotron-ocr = { index = "test-pypi" }
+
+[[tool.uv.index]]
+name = "test-pypi"
+url = "https://test.pypi.org/simple/"
+explicit = true
diff --git a/tools/harness/src/nv_ingest_harness/cases/e2e.py b/tools/harness/src/nv_ingest_harness/cases/e2e.py
index 8c3be66af..8e2eb4e4d 100644
--- a/tools/harness/src/nv_ingest_harness/cases/e2e.py
+++ b/tools/harness/src/nv_ingest_harness/cases/e2e.py
@@ -8,7 +8,9 @@
 from nv_ingest_client.util.document_analysis import analyze_document_chunks
 from nv_ingest_client.util.milvus import nvingest_retrieval
 
-from nv_ingest_harness.utils.interact import embed_info, kv_event_log, milvus_chunks, segment_results, pdf_page_count
+from nv_ingest_harness.utils.interact import embed_info, kv_event_log, segment_results
+from nv_ingest_harness.utils.milvus import milvus_chunks
+from nv_ingest_harness.utils.pdf import pdf_page_count
 from nv_ingest_harness.utils.vdb import get_lancedb_path
 
 # Future: Will integrate with modular nv-ingest-harness-ingest when VDB upload is separated
@@ -51,6 +53,7 @@ def main(config=None, log_path: str = "test_results") -> int:
         collection_name = get_recall_collection_name(test_name)
     hostname = config.hostname
     sparse = config.sparse
+    hybrid = config.hybrid
     gpu_search = config.gpu_search
 
     # API version configuration
@@ -82,6 +85,9 @@ def main(config=None, log_path: str = "test_results") -> int:
     print(f"Dataset: {data_dir}")
     print(f"Collection: {collection_name}")
     print(f"Embed: {model_name} (dim={dense_dim}, sparse={sparse})")
+    print(f"VDB Backend: {config.vdb_backend}")
+    if config.vdb_backend == "lancedb":
+        print(f"Hybrid: {hybrid}")
 
     # Extraction config
     extractions = []
@@ -199,11 +205,17 @@ def main(config=None, log_path: str = "test_results") -> int:
     vdb_backend = config.vdb_backend
     lancedb_path = None
     if vdb_backend == "lancedb":
+        timing_path = os.path.join(log_path, "lancedb_timings.jsonl")
+        os.environ["NV_INGEST_LANCEDB_TIMING_PATH"] = timing_path
+        if os.path.exists(timing_path):
+            os.remove(timing_path)
+        print(f"LanceDB timings: {timing_path}")
         lancedb_path = get_lancedb_path(config, collection_name)
         ingestor = ingestor.vdb_upload(
             vdb_op="lancedb",
             uri=lancedb_path,
             table_name=collection_name,
+            hybrid=hybrid,
             purge_results_after_upload=False,
         )
     else:
@@ -269,9 +281,10 @@ def main(config=None, log_path: str = "test_results") -> int:
         except ImportError as exc:
             print(f"Warning: LanceDB retrieval not available ({exc}). Skipping retrieval sanity check.")
         else:
-            lancedb_client = LanceDB(uri=lancedb_path, table_name=collection_name)
+            lancedb_client = LanceDB(uri=lancedb_path, table_name=collection_name, hybrid=hybrid)
             _ = lancedb_client.retrieval(
                 queries,
+                hybrid=hybrid,
                 embedding_endpoint=f"http://{hostname}:8012/v1",
                 model_name=model_name,
                 top_k=5,
@@ -329,6 +342,8 @@ def main(config=None, log_path: str = "test_results") -> int:
             "retrieval_time_s": retrieval_time,
         },
     }
+    if vdb_backend == "lancedb":
+        test_results["results"]["lancedb_timings_file"] = "lancedb_timings.jsonl"
 
     # Add split config if enabled
     if enable_split:
diff --git a/tools/harness/src/nv_ingest_harness/cases/e2e_with_llm_summary.py b/tools/harness/src/nv_ingest_harness/cases/e2e_with_llm_summary.py
index 7e02b123f..66b6bfbcc 100644
--- a/tools/harness/src/nv_ingest_harness/cases/e2e_with_llm_summary.py
+++ b/tools/harness/src/nv_ingest_harness/cases/e2e_with_llm_summary.py
@@ -12,11 +12,11 @@
 from nv_ingest_harness.utils.cases import get_repo_root
 from nv_ingest_harness.utils.interact import (
     embed_info,
-    milvus_chunks,
     segment_results,
     kv_event_log,
-    pdf_page_count,
 )  # noqa: E402
+from nv_ingest_harness.utils.milvus import milvus_chunks
+from nv_ingest_harness.utils.pdf import pdf_page_count
 
 # Future: Will integrate with modular nv-ingest-harness-ingest when VDB upload is separated
 
@@ -63,6 +63,7 @@ def main(config=None, log_path: str = "test_results") -> int:
         collection_name = get_recall_collection_name(test_name)
     hostname = config.hostname
     sparse = config.sparse
+    hybrid = config.hybrid
     gpu_search = config.gpu_search
 
     # Extraction configuration
@@ -93,6 +94,9 @@ def main(config=None, log_path: str = "test_results") -> int:
     print(f"Embed model: {model_name}, dim: {dense_dim}")
     print(f"LLM Summarize Model: {llm_model}")
     print(f"Sparse: {sparse}, GPU search: {gpu_search}")
+    print(f"VDB Backend: {config.vdb_backend}")
+    if config.vdb_backend == "lancedb":
+        print(f"Hybrid: {hybrid}")
     print(f"Extract text: {extract_text}, tables: {extract_tables}, charts: {extract_charts}")
     print(f"Extract images: {extract_images}, infographics: {extract_infographics}")
     print(f"Text depth: {text_depth}, table format: {table_output_format}")
diff --git a/tools/harness/src/nv_ingest_harness/cases/graphic_elements.py b/tools/harness/src/nv_ingest_harness/cases/graphic_elements.py
new file mode 100644
index 000000000..7d8665c03
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/cases/graphic_elements.py
@@ -0,0 +1,232 @@
+"""
+Graphic elements detection benchmark test case.
+
+This test case benchmarks the Nemotron graphic elements model for detecting
+chart and graphic elements in images.
+
+Uses torch.utils.benchmark for accurate timing with automatic CUDA synchronization
+and warmup handling.
+
+Usage:
+    uv run nv-ingest-harness-run --case=graphic_elements --dataset=/path/to/chart_images
+
+Requirements:
+    - nemotron_graphic_elements_v1 package installed
+    - GPU with CUDA support
+"""
+
+import json
+import os
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.utils.benchmark import Timer
+from PIL import Image
+from tqdm import tqdm
+
+from nv_ingest_harness.utils.interact import kv_event_log
+
+
+def get_image_paths(input_path: str, extensions: tuple = (".png", ".jpg", ".jpeg", ".webp")) -> list[Path]:
+    """Get all image paths from a directory or return single file path."""
+    path = Path(input_path)
+    if path.is_file():
+        return [path]
+    elif path.is_dir():
+        image_paths = []
+        for ext in extensions:
+            image_paths.extend(path.rglob(f"*{ext}"))
+        return sorted(image_paths)
+    else:
+        raise ValueError(f"Invalid path: {input_path}")
+
+
+def benchmark_inference(model, img: np.ndarray, num_repeats: int = 1) -> tuple[dict, float]:
+    """
+    Run inference on a single image using torch.utils.benchmark.Timer.
+
+    Includes both preprocessing and forward pass in the timing.
+
+    Args:
+        model: The loaded model
+        img: Image as numpy array
+        num_repeats: Number of times to run inference for timing (default: 1)
+
+    Returns:
+        Tuple of (predictions dict, mean inference time in seconds)
+    """
+    # Timer measures preprocessing + forward pass together
+    timer = Timer(
+        stmt="model(model.preprocess(img), img.shape)[0]",
+        globals={"model": model, "img": img},
+        num_threads=1,
+    )
+
+    # Run timed inference
+    measurement = timer.timeit(num_repeats)
+
+    # Run once more to get the actual predictions
+    with torch.inference_mode():
+        with torch.autocast(device_type="cuda"):
+            x = model.preprocess(img)
+            preds = model(x, img.shape)[0]
+
+    return preds, measurement.mean
+
+
+def main(config=None, log_path: str = "test_results") -> int:
+    """
+    Main test entry point for graphic elements benchmarking.
+
+    Args:
+        config: TestConfig object with all settings
+        log_path: Path for logging output
+
+    Returns:
+        Exit code (0 = success)
+    """
+    # Import here to avoid loading model at module import time
+    from nemotron_graphic_elements_v1.model import define_model
+    from nemotron_graphic_elements_v1.utils import postprocess_preds_graphic_element
+
+    # Handle config
+    if config is None:
+        print("ERROR: No configuration provided")
+        print("This test case requires a config object from the test runner")
+        return 2
+
+    # Get dataset directory from config
+    data_dir = config.dataset_dir
+    num_repeats = getattr(config, "num_repeats", 1)
+
+    print("=== Graphic Elements Benchmark ===")
+    print(f"Dataset: {data_dir}")
+    print(f"Timing repeats per image: {num_repeats}")
+    print("Using torch.utils.benchmark.Timer")
+    print("==================================")
+
+    # Get image paths
+    image_paths = get_image_paths(data_dir)
+    num_images = len(image_paths)
+    print(f"Found {num_images} image(s) to process")
+    kv_event_log("num_images", num_images, log_path)
+
+    if num_images == 0:
+        print("ERROR: No images found in dataset directory")
+        return 1
+
+    # Load model
+    print("Loading model...")
+    model_load_start = time.perf_counter()
+    model = define_model("graphic_element_v1")
+    model_load_time = time.perf_counter() - model_load_start
+    print(f"Model loaded in {model_load_time:.2f}s")
+    print(f"Available labels: {model.labels}")
+    kv_event_log("model_load_time_s", model_load_time, log_path)
+
+    # Warmup using torch.utils.benchmark (handles CUDA init automatically)
+    print("Running warmup with torch.utils.benchmark...")
+    warmup_img = np.array(Image.open(image_paths[0]).convert("RGB"))
+    warmup_timer = Timer(
+        stmt="model(model.preprocess(img), img.shape)[0]",
+        globals={"model": model, "img": warmup_img},
+        num_threads=1,
+    )
+    # blocked_autorange runs enough iterations to get stable timing
+    warmup_measurement = warmup_timer.blocked_autorange(min_run_time=0.5)
+    print(f"Warmup complete. Estimated per-image time: {warmup_measurement.mean * 1000:.2f} ms")
+
+    # Process each image
+    results = []
+    inference_times = []
+    total_detections = 0
+
+    for img_path in tqdm(image_paths, desc="Processing images", unit="page"):
+        # Load image
+        img = Image.open(img_path).convert("RGB")
+        img = np.array(img)
+
+        # Run benchmarked inference
+        preds, inference_time = benchmark_inference(model, img, num_repeats=num_repeats)
+
+        # Post-processing
+        boxes, labels, scores = postprocess_preds_graphic_element(preds, model.threshold, model.labels)
+
+        num_detections = len(boxes)
+        total_detections += num_detections
+        inference_times.append(inference_time * 1000)  # Convert to ms
+
+        # Store result
+        result = {
+            "image_path": str(img_path),
+            "image_name": img_path.name,
+            "inference_time_ms": inference_time * 1000,
+            "num_detections": num_detections,
+        }
+        results.append(result)
+
+    # Calculate statistics
+    times = np.array(inference_times)
+    mean_time = np.mean(times)
+    std_time = np.std(times)
+    min_time = np.min(times)
+    max_time = np.max(times)
+    median_time = np.median(times)
+    total_time = np.sum(times)
+    throughput = num_images / (total_time / 1000) if total_time > 0 else 0
+
+    # Calculate IQR (interquartile range) - useful stat from torch.utils.benchmark
+    q75, q25 = np.percentile(times, [75, 25])
+    iqr_time = q75 - q25
+
+    # Log metrics
+    kv_event_log("total_detections", total_detections, log_path)
+    kv_event_log("mean_inference_time_ms", mean_time, log_path)
+    kv_event_log("std_inference_time_ms", std_time, log_path)
+    kv_event_log("min_inference_time_ms", min_time, log_path)
+    kv_event_log("max_inference_time_ms", max_time, log_path)
+    kv_event_log("median_inference_time_ms", median_time, log_path)
+    kv_event_log("iqr_inference_time_ms", iqr_time, log_path)
+    kv_event_log("total_inference_time_ms", total_time, log_path)
+    kv_event_log("throughput_images_per_sec", throughput, log_path)
+
+    # Build test results for consolidation
+    test_name = config.test_name or os.path.basename(data_dir.rstrip("/"))
+
+    test_results = {
+        "test_config": {
+            "test_name": test_name,
+            "dataset_dir": data_dir,
+            "num_repeats": num_repeats,
+            "model": "graphic_element_v1",
+            "benchmark_method": "torch.utils.benchmark.Timer",
+        },
+        "results": {
+            "num_images": num_images,
+            "total_detections": total_detections,
+            "mean_inference_time_ms": mean_time,
+            "std_inference_time_ms": std_time,
+            "min_inference_time_ms": min_time,
+            "max_inference_time_ms": max_time,
+            "median_inference_time_ms": median_time,
+            "iqr_inference_time_ms": iqr_time,
+            "total_inference_time_ms": total_time,
+            "throughput_images_per_sec": throughput,
+            "model_load_time_s": model_load_time,
+        },
+        "per_image_results": results,
+    }
+
+    # Write test results
+    os.makedirs(log_path, exist_ok=True)
+    results_file = os.path.join(log_path, "_test_results.json")
+    with open(results_file, "w") as f:
+        json.dump(test_results, f, indent=2)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/harness/src/nv_ingest_harness/cases/ocr.py b/tools/harness/src/nv_ingest_harness/cases/ocr.py
new file mode 100644
index 000000000..922b9eaf6
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/cases/ocr.py
@@ -0,0 +1,216 @@
+"""
+Nemotron OCR benchmark test case.
+
+This test case benchmarks the Nemotron OCR model for optical character recognition
+on document images.
+
+Uses torch.utils.benchmark for accurate timing with automatic CUDA synchronization
+and warmup handling.
+
+Usage:
+     uv run nv-ingest-harness-run --case=ocr --dataset=/path/to/images
+
+Requirements:
+    - nemotron_ocr package installed
+    - GPU with CUDA support
+"""
+
+import json
+import os
+import time
+from pathlib import Path
+
+import numpy as np
+from torch.utils.benchmark import Timer
+from tqdm import tqdm
+
+from nv_ingest_harness.utils.interact import kv_event_log
+
+
+def get_image_paths(input_path: str, extensions: tuple = (".png", ".jpg", ".jpeg", ".webp")) -> list[Path]:
+    """Get all image paths from a directory or return single file path."""
+    path = Path(input_path)
+    if path.is_file():
+        return [path]
+    elif path.is_dir():
+        image_paths = []
+        for ext in extensions:
+            image_paths.extend(path.rglob(f"*{ext}"))
+        return sorted(image_paths)
+    else:
+        raise ValueError(f"Invalid path: {input_path}")
+
+
+def benchmark_inference(ocr, img_path: str, num_repeats: int = 1) -> tuple[list, float]:
+    """
+    Run OCR inference on a single image using torch.utils.benchmark.Timer.
+
+    Args:
+        ocr: The loaded NemotronOCR model
+        img_path: Path to the image file
+        num_repeats: Number of times to run inference for timing (default: 1)
+
+    Returns:
+        Tuple of (predictions list, mean inference time in seconds)
+    """
+    # Timer measures the full OCR pipeline
+    timer = Timer(
+        stmt="ocr(img_path)",
+        globals={"ocr": ocr, "img_path": img_path},
+        num_threads=1,
+    )
+
+    # Run timed inference
+    measurement = timer.timeit(num_repeats)
+
+    # Run once more to get the actual predictions
+    predictions = ocr(img_path)
+
+    return predictions, measurement.mean
+
+
+def main(config=None, log_path: str = "test_results") -> int:
+    """
+    Main test entry point for Nemotron OCR benchmarking.
+
+    Args:
+        config: TestConfig object with all settings
+        log_path: Path for logging output
+
+    Returns:
+        Exit code (0 = success)
+    """
+    # Import here to avoid loading model at module import time
+    from nemotron_ocr.inference.pipeline import NemotronOCR
+
+    # Handle config
+    if config is None:
+        print("ERROR: No configuration provided")
+        print("This test case requires a config object from the test runner")
+        return 2
+
+    # Get dataset directory from config
+    data_dir = config.dataset_dir
+    num_repeats = getattr(config, "num_repeats", 1)
+
+    print("=== Nemotron OCR Benchmark ===")
+    print(f"Dataset: {data_dir}")
+    print(f"Timing repeats per image: {num_repeats}")
+    print("Using torch.utils.benchmark.Timer")
+    print("===============================")
+
+    # Get image paths
+    image_paths = get_image_paths(data_dir)
+    num_images = len(image_paths)
+    print(f"Found {num_images} image(s) to process")
+    kv_event_log("num_images", num_images, log_path)
+
+    if num_images == 0:
+        print("ERROR: No images found in dataset directory")
+        return 1
+
+    # Load model
+    print("Loading OCR model...")
+    model_load_start = time.perf_counter()
+    ocr = NemotronOCR()
+    model_load_time = time.perf_counter() - model_load_start
+    print(f"Model loaded in {model_load_time:.2f}s")
+    kv_event_log("model_load_time_s", model_load_time, log_path)
+
+    # Warmup using torch.utils.benchmark (handles CUDA init automatically)
+    print("Running warmup with torch.utils.benchmark...")
+    warmup_path = str(image_paths[0])
+    warmup_timer = Timer(
+        stmt="ocr(img_path)",
+        globals={"ocr": ocr, "img_path": warmup_path},
+        num_threads=1,
+    )
+    # blocked_autorange runs enough iterations to get stable timing
+    warmup_measurement = warmup_timer.blocked_autorange(min_run_time=0.5)
+    print(f"Warmup complete. Estimated per-image time: {warmup_measurement.mean * 1000:.2f} ms")
+
+    # Process each image
+    results = []
+    inference_times = []
+    total_text_regions = 0
+
+    for img_path in tqdm(image_paths, desc="Processing images", unit="img"):
+        # Run benchmarked inference
+        predictions, inference_time = benchmark_inference(ocr, str(img_path), num_repeats=num_repeats)
+
+        num_regions = len(predictions)
+        total_text_regions += num_regions
+        inference_times.append(inference_time * 1000)  # Convert to ms
+
+        # Store result (without full predictions to keep results.json manageable)
+        result = {
+            "image_path": str(img_path),
+            "image_name": img_path.name,
+            "inference_time_ms": inference_time * 1000,
+            "num_text_regions": num_regions,
+        }
+        results.append(result)
+
+    # Calculate statistics
+    times = np.array(inference_times)
+    mean_time = np.mean(times)
+    std_time = np.std(times)
+    min_time = np.min(times)
+    max_time = np.max(times)
+    median_time = np.median(times)
+    total_time = np.sum(times)
+    throughput = num_images / (total_time / 1000) if total_time > 0 else 0
+
+    # Calculate IQR (interquartile range) - useful stat from torch.utils.benchmark
+    q75, q25 = np.percentile(times, [75, 25])
+    iqr_time = q75 - q25
+
+    # Log metrics
+    kv_event_log("total_text_regions", total_text_regions, log_path)
+    kv_event_log("mean_inference_time_ms", mean_time, log_path)
+    kv_event_log("std_inference_time_ms", std_time, log_path)
+    kv_event_log("min_inference_time_ms", min_time, log_path)
+    kv_event_log("max_inference_time_ms", max_time, log_path)
+    kv_event_log("median_inference_time_ms", median_time, log_path)
+    kv_event_log("iqr_inference_time_ms", iqr_time, log_path)
+    kv_event_log("total_inference_time_ms", total_time, log_path)
+    kv_event_log("throughput_images_per_sec", throughput, log_path)
+
+    # Build test results for consolidation
+    test_name = config.test_name or os.path.basename(data_dir.rstrip("/"))
+
+    test_results = {
+        "test_config": {
+            "test_name": test_name,
+            "dataset_dir": data_dir,
+            "num_repeats": num_repeats,
+            "model": "ocr",
+            "benchmark_method": "torch.utils.benchmark.Timer",
+        },
+        "results": {
+            "num_images": num_images,
+            "total_text_regions": total_text_regions,
+            "mean_inference_time_ms": mean_time,
+            "std_inference_time_ms": std_time,
+            "min_inference_time_ms": min_time,
+            "max_inference_time_ms": max_time,
+            "median_inference_time_ms": median_time,
+            "iqr_inference_time_ms": iqr_time,
+            "total_inference_time_ms": total_time,
+            "throughput_images_per_sec": throughput,
+            "model_load_time_s": model_load_time,
+        },
+        "per_image_results": results,
+    }
+
+    # Write test results
+    os.makedirs(log_path, exist_ok=True)
+    results_file = os.path.join(log_path, "_test_results.json")
+    with open(results_file, "w") as f:
+        json.dump(test_results, f, indent=2)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/harness/src/nv_ingest_harness/cases/page_elements.py b/tools/harness/src/nv_ingest_harness/cases/page_elements.py
new file mode 100644
index 000000000..528d124c1
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/cases/page_elements.py
@@ -0,0 +1,394 @@
+"""
+Page elements detection benchmark test case.
+
+This test case benchmarks the Nemotron page elements model for detecting
+document layout elements (tables, figures, text blocks, etc.) in images.
+
+Uses torch.utils.benchmark for accurate timing with automatic CUDA synchronization
+and warmup handling.
+
+Usage:
+    uv run nv-ingest-harness-run --case=page_elements --dataset=/path/to/page_images
+
+Requirements:
+    - nemotron_page_elements_v3 package installed
+    - GPU with CUDA support
+"""
+
+import base64
+import json
+import os
+import time
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import requests
+import torch
+from PIL import Image
+from torch.utils.benchmark import Timer
+from tqdm import tqdm
+
+from nv_ingest_harness.utils.interact import kv_event_log
+
+
+def get_image_paths(input_path: str, extensions: tuple = (".png", ".jpg", ".jpeg", ".webp")) -> list[Path]:
+    """Get all image paths from a directory or return single file path."""
+    path = Path(input_path)
+    if path.is_file():
+        return [path]
+    elif path.is_dir():
+        image_paths = []
+        for ext in extensions:
+            image_paths.extend(path.rglob(f"*{ext}"))
+        return sorted(image_paths)
+    else:
+        raise ValueError(f"Invalid path: {input_path}")
+
+
+def benchmark_inference(model, img: np.ndarray, num_repeats: int = 1) -> tuple[dict, float, float, float]:
+    """
+    Run inference on a single image using torch.utils.benchmark.Timer.
+
+    Includes both preprocessing and forward pass in the timing.
+
+    Args:
+        model: The loaded model
+        img: Image as numpy array
+        num_repeats: Number of times to run inference for timing (default: 1)
+
+    Returns:
+        Tuple of (predictions dict, total mean inference time in seconds,
+        preprocess mean time in seconds, forward mean time in seconds)
+    """
+    # Timer measures preprocessing only
+    preprocess_timer = Timer(
+        stmt="model.preprocess(img)",
+        globals={"model": model, "img": img},
+        num_threads=1,
+    )
+    _preprocess_measurement = preprocess_timer.timeit(num_repeats)  # noqa: F841
+
+    # # Timer measures forward pass only using a preprocessed tensor
+    # # Move the numpy array to CUDA device (if available)
+    # if torch.cuda.is_available():
+    #     img = torch.as_tensor(img).to(torch.uint8).to("cuda")
+
+    # x = model.preprocess(img)
+    # forward_timer = Timer(
+    #     stmt="model(x, img_shape)[0]",
+    #     globals={"model": model, "x": x, "img_shape": img.shape},
+    #     num_threads=1,
+    # )
+    # forward_measurement = forward_timer.timeit(num_repeats)
+
+    # Run once more to get the actual predictions
+    with torch.inference_mode():
+        with torch.autocast(device_type="cuda"):
+            x = model.preprocess(img)
+            preds = model(x, img.shape)[0]
+
+    # total_inference_mean = preprocess_measurement.mean + forward_measurement.mean
+    # return preds, total_inference_mean, preprocess_measurement.mean, forward_measurement.mean
+    return preds, 0.0, 0.0, 0.0
+
+
+def _encode_image_to_base64_png(img: np.ndarray) -> str:
+    """Encode RGB numpy image to base64 PNG payload string."""
+    buf = BytesIO()
+    Image.fromarray(img.astype(np.uint8)).save(buf, format="PNG")
+    return base64.b64encode(buf.getvalue()).decode()
+
+
+def benchmark_remote_inference(
+    invoke_url: str,
+    img: np.ndarray,
+    *,
+    api_key: str | None = None,
+    timeout_s: float = 120.0,
+    num_repeats: int = 1,
+) -> tuple[dict, float]:
+    """Benchmark HTTP POST inference and return response JSON + mean latency."""
+    image_b64 = _encode_image_to_base64_png(img)
+    headers = {"Accept": "application/json"}
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+    payload = {
+        "input": [
+            {
+                "type": "image_url",
+                "url": f"data:image/png;base64,{image_b64}",
+            }
+        ]
+    }
+
+    response_json: dict[str, Any] = {}
+    t0 = time.perf_counter()
+    for _ in range(int(num_repeats)):
+        resp = requests.post(invoke_url, headers=headers, json=payload, timeout=float(timeout_s))
+        resp.raise_for_status()
+        response_json = resp.json()
+    elapsed = time.perf_counter() - t0
+    return response_json, (elapsed / max(int(num_repeats), 1))
+
+
+def count_detections_from_remote_response(response_json: dict) -> int:
+    """Best-effort count from common remote payload shapes."""
+    if not isinstance(response_json, dict):
+        return 0
+
+    if isinstance(response_json.get("detections"), list):
+        return len(response_json["detections"])
+
+    data = response_json.get("data")
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        if isinstance(data[0].get("detections"), list):
+            return len(data[0]["detections"])
+        if all(isinstance(v, list) for v in data[0].values()):
+            return int(sum(len(v) for v in data[0].values()))
+
+    if all(isinstance(v, list) for v in response_json.values()):
+        return int(sum(len(v) for v in response_json.values()))
+
+    return 0
+
+
+def main(config=None, log_path: str = "test_results") -> int:
+    """
+    Main test entry point for page elements benchmarking.
+
+    Args:
+        config: TestConfig object with all settings
+        log_path: Path for logging output
+
+    Returns:
+        Exit code (0 = success)
+    """
+    # Handle config
+    if config is None:
+        print("ERROR: No configuration provided")
+        print("This test case requires a config object from the test runner")
+        return 2
+
+    # Get dataset directory from config
+    data_dir = config.dataset_dir
+    num_repeats = getattr(config, "num_repeats", 1)
+    invoke_url = (getattr(config, "page_elements_invoke_url", None) or "").strip()
+    request_timeout_s = float(getattr(config, "page_elements_request_timeout_s", 120.0) or 120.0)
+    api_key = (getattr(config, "page_elements_api_key", None) or os.getenv("NVIDIA_API_KEY", "")).strip() or None
+    use_remote = bool(invoke_url)
+
+    print("=== Page Elements Benchmark ===")
+    print(f"Dataset: {data_dir}")
+    print(f"Timing repeats per image: {num_repeats}")
+    if use_remote:
+        print(f"Using remote endpoint: {invoke_url}")
+    else:
+        print("Using torch.utils.benchmark.Timer")
+    print("================================")
+
+    # Get image paths
+    image_paths = get_image_paths(data_dir)
+    num_images = len(image_paths)
+    print(f"Found {num_images} image(s) to process")
+    kv_event_log("num_images", num_images, log_path)
+
+    if num_images == 0:
+        print("ERROR: No images found in dataset directory")
+        return 1
+
+    model = None
+    model_load_time = 0.0
+    postprocess_preds_page_element = None
+    if use_remote:
+        print("Remote mode enabled: skipping local model load")
+        kv_event_log("model_load_time_s", model_load_time, log_path)
+        # Single untimed warmup request to pre-establish TLS/session and reduce first-sample bias.
+        warmup_img = np.array(Image.open(image_paths[0]).convert("RGB"))
+        try:
+            _resp, _ = benchmark_remote_inference(
+                invoke_url,
+                warmup_img,
+                api_key=api_key,
+                timeout_s=request_timeout_s,
+                num_repeats=1,
+            )
+            print("Remote warmup complete")
+        except Exception as e:
+            print(f"WARNING: Remote warmup failed: {e}")
+    else:
+        # Import here to avoid loading model at module import time
+        from nemotron_page_elements_v3.model import define_model
+        from nemotron_page_elements_v3.utils import postprocess_preds_page_element
+
+        print("Loading model...")
+        model_load_start = time.perf_counter()
+        model = define_model("page_element_v3")
+        model.to("cuda").eval()
+        model_load_time = time.perf_counter() - model_load_start
+        print(f"Model loaded in {model_load_time:.2f}s")
+        print(f"Available labels: {model.labels}")
+        kv_event_log("model_load_time_s", model_load_time, log_path)
+
+        # Warmup using torch.utils.benchmark (handles CUDA init automatically)
+        print("Running warmup with torch.utils.benchmark...")
+        warmup_img = np.array(Image.open(image_paths[0]).convert("RGB"))
+        warmup_timer = Timer(
+            stmt="model(model.preprocess(img), img.shape)[0]",
+            globals={"model": model, "img": warmup_img},
+            num_threads=1,
+        )
+        # blocked_autorange runs enough iterations to get stable timing
+        warmup_measurement = warmup_timer.blocked_autorange(min_run_time=0.5)
+        print(f"Warmup complete. Estimated per-image time: {warmup_measurement.mean * 1000:.2f} ms")
+
+    # Process each image
+    results = []
+    inference_times = []
+    preprocess_times = []
+    postprocess_times = []
+    total_detections = 0
+
+    start_time = time.perf_counter()
+
+    for img_path in tqdm(image_paths, desc="Processing images", unit="page"):
+        # Load image
+        img = Image.open(img_path).convert("RGB")
+        img = np.array(img)
+
+        if use_remote:
+            response_json, inference_time = benchmark_remote_inference(
+                invoke_url,
+                img,
+                api_key=api_key,
+                timeout_s=request_timeout_s,
+                num_repeats=num_repeats,
+            )
+            num_detections = count_detections_from_remote_response(response_json)
+            preprocess_time = 0.0
+            postprocess_time = 0.0
+        else:
+            # Run benchmarked inference
+            preds, inference_time, preprocess_time, _forward_time = benchmark_inference(
+                model, img, num_repeats=num_repeats
+            )
+
+            # Post-processing
+            postprocess_start = time.perf_counter()
+            boxes, labels, scores = postprocess_preds_page_element(preds, model.thresholds_per_class, model.labels)
+            postprocess_time = time.perf_counter() - postprocess_start
+            num_detections = len(boxes)
+        total_detections += num_detections
+        inference_times.append(inference_time * 1000)  # Convert to ms
+        preprocess_times.append(preprocess_time * 1000)  # Convert to ms
+        postprocess_times.append(postprocess_time * 1000)  # Convert to ms
+
+        # Store result
+        result = {
+            "image_path": str(img_path),
+            "image_name": img_path.name,
+            "inference_time_ms": inference_time * 1000,
+            "preprocess_time_ms": preprocess_time * 1000,
+            "postprocess_time_ms": postprocess_time * 1000,
+            "num_detections": num_detections,
+        }
+        results.append(result)
+
+    end_time = time.perf_counter()
+    total_time = end_time - start_time
+
+    # Calculate statistics
+    times = np.array(inference_times)
+    mean_time = np.mean(times)
+    std_time = np.std(times)
+    min_time = np.min(times)
+    max_time = np.max(times)
+    median_time = np.median(times)
+    # total_time = np.sum(times)
+    throughput = num_images / (total_time / 1000) if total_time > 0 else 0
+
+    # Calculate IQR (interquartile range) - useful stat from torch.utils.benchmark
+    q75, q25 = np.percentile(times, [75, 25])
+    iqr_time = q75 - q25
+
+    preprocess_mean_time = None
+    preprocess_total_time = None
+    postprocess_mean_time = None
+    postprocess_total_time = None
+    if not use_remote:
+        preprocess_np = np.array(preprocess_times)
+        postprocess_np = np.array(postprocess_times)
+        preprocess_mean_time = float(np.mean(preprocess_np))
+        preprocess_total_time = float(np.sum(preprocess_np))
+        postprocess_mean_time = float(np.mean(postprocess_np))
+        postprocess_total_time = float(np.sum(postprocess_np))
+
+    # Log metrics
+    kv_event_log("total_detections", total_detections, log_path)
+    kv_event_log("mean_inference_time_ms", mean_time, log_path)
+    kv_event_log("std_inference_time_ms", std_time, log_path)
+    kv_event_log("min_inference_time_ms", min_time, log_path)
+    kv_event_log("max_inference_time_ms", max_time, log_path)
+    kv_event_log("median_inference_time_ms", median_time, log_path)
+    kv_event_log("iqr_inference_time_ms", iqr_time, log_path)
+    kv_event_log("total_inference_time_ms", total_time, log_path)
+    kv_event_log("throughput_images_per_sec", throughput, log_path)
+    if preprocess_mean_time is not None and preprocess_total_time is not None:
+        kv_event_log("mean_preprocess_time_ms", preprocess_mean_time, log_path)
+        kv_event_log("total_preprocess_time_ms", preprocess_total_time, log_path)
+    if postprocess_mean_time is not None and postprocess_total_time is not None:
+        kv_event_log("mean_postprocess_time_ms", postprocess_mean_time, log_path)
+        kv_event_log("total_postprocess_time_ms", postprocess_total_time, log_path)
+
+    if not use_remote:
+        print("=== Local Runtime Breakdown ===")
+        print(f"Pre-processing mean: {preprocess_mean_time:.3f} ms")
+        print(f"Pre-processing total: {preprocess_total_time:.3f} ms")
+        print(f"Post-processing mean: {postprocess_mean_time:.3f} ms")
+        print(f"Post-processing total: {postprocess_total_time:.3f} ms")
+        print("================================")
+
+    # Build test results for consolidation
+    test_name = config.test_name or os.path.basename(data_dir.rstrip("/"))
+
+    test_results = {
+        "test_config": {
+            "test_name": test_name,
+            "dataset_dir": data_dir,
+            "num_repeats": num_repeats,
+            "model": invoke_url if use_remote else "page_element_v3",
+            "benchmark_method": "http.post" if use_remote else "torch.utils.benchmark.Timer",
+            "page_elements_invoke_url": invoke_url or None,
+        },
+        "results": {
+            "num_images": num_images,
+            "total_detections": total_detections,
+            "mean_inference_time_ms": mean_time,
+            "std_inference_time_ms": std_time,
+            "min_inference_time_ms": min_time,
+            "max_inference_time_ms": max_time,
+            "median_inference_time_ms": median_time,
+            "iqr_inference_time_ms": iqr_time,
+            "total_inference_time_ms": total_time,
+            "throughput_images_per_sec": throughput,
+            "model_load_time_s": model_load_time,
+            "mean_preprocess_time_ms": preprocess_mean_time,
+            "total_preprocess_time_ms": preprocess_total_time,
+            "mean_postprocess_time_ms": postprocess_mean_time,
+            "total_postprocess_time_ms": postprocess_total_time,
+        },
+        "per_image_results": results,
+    }
+
+    # Write test results
+    os.makedirs(log_path, exist_ok=True)
+    results_file = os.path.join(log_path, "_test_results.json")
+    with open(results_file, "w") as f:
+        json.dump(test_results, f, indent=2)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/harness/src/nv_ingest_harness/cases/recall.py b/tools/harness/src/nv_ingest_harness/cases/recall.py
index 62c4fd1c5..a92f93ab2 100644
--- a/tools/harness/src/nv_ingest_harness/cases/recall.py
+++ b/tools/harness/src/nv_ingest_harness/cases/recall.py
@@ -65,6 +65,7 @@ def main(config=None, log_path: str = "test_results") -> int:
 
     hostname = config.hostname
     sparse = config.sparse
+    hybrid = config.hybrid
     gpu_search = config.gpu_search
     model_name, dense_dim = embed_info()
 
@@ -107,6 +108,8 @@ def main(config=None, log_path: str = "test_results") -> int:
     print(f"Test Name: {test_name}")
     print(f"Collection: {collection_name}")
     print(f"VDB Backend: {vdb_backend}")
+    if vdb_backend == "lancedb":
+        print(f"Hybrid: {hybrid}")
     if lancedb_path:
         print(f"LanceDB Path: {lancedb_path}")
     print(f"Reranker Mode: {reranker_mode}")
@@ -131,6 +134,7 @@ def main(config=None, log_path: str = "test_results") -> int:
             "hostname": hostname,
             "sparse": sparse,
             "model_name": model_name,
+            "hybrid": hybrid,
             "top_k": recall_top_k,
             "gpu_search": gpu_search,
             "ground_truth_dir": ground_truth_dir,
@@ -139,7 +143,6 @@ def main(config=None, log_path: str = "test_results") -> int:
             "nv_ranker_model_name": "nvidia/llama-3.2-nv-rerankqa-1b-v2",
         }
         if vdb_backend == "lancedb":
-            evaluation_params["sparse"] = False  # LanceDB doesn't support hybrid search
             evaluation_params["table_path"] = lancedb_path
 
         # Run without reranker (if mode is "none" or "both")
diff --git a/tools/harness/src/nv_ingest_harness/cases/table_structure.py b/tools/harness/src/nv_ingest_harness/cases/table_structure.py
new file mode 100644
index 000000000..3a46afc4c
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/cases/table_structure.py
@@ -0,0 +1,232 @@
+"""
+Table structure detection benchmark test case.
+
+This test case benchmarks the Nemotron table structure model for detecting
+table cells, rows, and columns in table images.
+
+Uses torch.utils.benchmark for accurate timing with automatic CUDA synchronization
+and warmup handling.
+
+Usage:
+    uv run nv-ingest-harness-run --case=table_structure --dataset=/path/to/table_images
+
+Requirements:
+    - nemotron_table_structure_v1 package installed
+    - GPU with CUDA support
+"""
+
+import json
+import os
+import time
+from pathlib import Path
+
+import numpy as np
+import torch
+from torch.utils.benchmark import Timer
+from PIL import Image
+from tqdm import tqdm
+
+from nv_ingest_harness.utils.interact import kv_event_log
+
+
+def get_image_paths(input_path: str, extensions: tuple = (".png", ".jpg", ".jpeg", ".webp")) -> list[Path]:
+    """Get all image paths from a directory or return single file path."""
+    path = Path(input_path)
+    if path.is_file():
+        return [path]
+    elif path.is_dir():
+        image_paths = []
+        for ext in extensions:
+            image_paths.extend(path.rglob(f"*{ext}"))
+        return sorted(image_paths)
+    else:
+        raise ValueError(f"Invalid path: {input_path}")
+
+
+def benchmark_inference(model, img: np.ndarray, num_repeats: int = 1) -> tuple[dict, float]:
+    """
+    Run inference on a single image using torch.utils.benchmark.Timer.
+
+    Includes both preprocessing and forward pass in the timing.
+
+    Args:
+        model: The loaded model
+        img: Image as numpy array
+        num_repeats: Number of times to run inference for timing (default: 1)
+
+    Returns:
+        Tuple of (predictions dict, mean inference time in seconds)
+    """
+    # Timer measures preprocessing + forward pass together
+    timer = Timer(
+        stmt="model(model.preprocess(img), img.shape)[0]",
+        globals={"model": model, "img": img},
+        num_threads=1,
+    )
+
+    # Run timed inference
+    measurement = timer.timeit(num_repeats)
+
+    # Run once more to get the actual predictions
+    with torch.inference_mode():
+        with torch.autocast(device_type="cuda"):
+            x = model.preprocess(img)
+            preds = model(x, img.shape)[0]
+
+    return preds, measurement.mean
+
+
+def main(config=None, log_path: str = "test_results") -> int:
+    """
+    Main test entry point for table structure benchmarking.
+
+    Args:
+        config: TestConfig object with all settings
+        log_path: Path for logging output
+
+    Returns:
+        Exit code (0 = success)
+    """
+    # Import here to avoid loading model at module import time
+    from nemotron_table_structure_v1.model import define_model
+    from nemotron_table_structure_v1.utils import postprocess_preds_table_structure
+
+    # Handle config
+    if config is None:
+        print("ERROR: No configuration provided")
+        print("This test case requires a config object from the test runner")
+        return 2
+
+    # Get dataset directory from config
+    data_dir = config.dataset_dir
+    num_repeats = getattr(config, "num_repeats", 1)
+
+    print("=== Table Structure Benchmark ===")
+    print(f"Dataset: {data_dir}")
+    print(f"Timing repeats per image: {num_repeats}")
+    print("Using torch.utils.benchmark.Timer")
+    print("=================================")
+
+    # Get image paths
+    image_paths = get_image_paths(data_dir)
+    num_images = len(image_paths)
+    print(f"Found {num_images} image(s) to process")
+    kv_event_log("num_images", num_images, log_path)
+
+    if num_images == 0:
+        print("ERROR: No images found in dataset directory")
+        return 1
+
+    # Load model
+    print("Loading model...")
+    model_load_start = time.perf_counter()
+    model = define_model("table_structure_v1")
+    model_load_time = time.perf_counter() - model_load_start
+    print(f"Model loaded in {model_load_time:.2f}s")
+    print(f"Available labels: {model.labels}")
+    kv_event_log("model_load_time_s", model_load_time, log_path)
+
+    # Warmup using torch.utils.benchmark (handles CUDA init automatically)
+    print("Running warmup with torch.utils.benchmark...")
+    warmup_img = np.array(Image.open(image_paths[0]).convert("RGB"))
+    warmup_timer = Timer(
+        stmt="model(model.preprocess(img), img.shape)[0]",
+        globals={"model": model, "img": warmup_img},
+        num_threads=1,
+    )
+    # blocked_autorange runs enough iterations to get stable timing
+    warmup_measurement = warmup_timer.blocked_autorange(min_run_time=0.5)
+    print(f"Warmup complete. Estimated per-image time: {warmup_measurement.mean * 1000:.2f} ms")
+
+    # Process each image
+    results = []
+    inference_times = []
+    total_detections = 0
+
+    for img_path in tqdm(image_paths, desc="Processing images", unit="table"):
+        # Load image
+        img = Image.open(img_path).convert("RGB")
+        img = np.array(img)
+
+        # Run benchmarked inference
+        preds, inference_time = benchmark_inference(model, img, num_repeats=num_repeats)
+
+        # Post-processing
+        boxes, labels, scores = postprocess_preds_table_structure(preds, model.threshold, model.labels)
+
+        num_detections = len(boxes)
+        total_detections += num_detections
+        inference_times.append(inference_time * 1000)  # Convert to ms
+
+        # Store result
+        result = {
+            "image_path": str(img_path),
+            "image_name": img_path.name,
+            "inference_time_ms": inference_time * 1000,
+            "num_detections": num_detections,
+        }
+        results.append(result)
+
+    # Calculate statistics
+    times = np.array(inference_times)
+    mean_time = np.mean(times)
+    std_time = np.std(times)
+    min_time = np.min(times)
+    max_time = np.max(times)
+    median_time = np.median(times)
+    total_time = np.sum(times)
+    throughput = num_images / (total_time / 1000) if total_time > 0 else 0
+
+    # Calculate IQR (interquartile range) - useful stat from torch.utils.benchmark
+    q75, q25 = np.percentile(times, [75, 25])
+    iqr_time = q75 - q25
+
+    # Log metrics
+    kv_event_log("total_detections", total_detections, log_path)
+    kv_event_log("mean_inference_time_ms", mean_time, log_path)
+    kv_event_log("std_inference_time_ms", std_time, log_path)
+    kv_event_log("min_inference_time_ms", min_time, log_path)
+    kv_event_log("max_inference_time_ms", max_time, log_path)
+    kv_event_log("median_inference_time_ms", median_time, log_path)
+    kv_event_log("iqr_inference_time_ms", iqr_time, log_path)
+    kv_event_log("total_inference_time_ms", total_time, log_path)
+    kv_event_log("throughput_images_per_sec", throughput, log_path)
+
+    # Build test results for consolidation
+    test_name = config.test_name or os.path.basename(data_dir.rstrip("/"))
+
+    test_results = {
+        "test_config": {
+            "test_name": test_name,
+            "dataset_dir": data_dir,
+            "num_repeats": num_repeats,
+            "model": "table_structure_v1",
+            "benchmark_method": "torch.utils.benchmark.Timer",
+        },
+        "results": {
+            "num_images": num_images,
+            "total_detections": total_detections,
+            "mean_inference_time_ms": mean_time,
+            "std_inference_time_ms": std_time,
+            "min_inference_time_ms": min_time,
+            "max_inference_time_ms": max_time,
+            "median_inference_time_ms": median_time,
+            "iqr_inference_time_ms": iqr_time,
+            "total_inference_time_ms": total_time,
+            "throughput_images_per_sec": throughput,
+            "model_load_time_s": model_load_time,
+        },
+        "per_image_results": results,
+    }
+
+    # Write test results
+    os.makedirs(log_path, exist_ok=True)
+    results_file = os.path.join(log_path, "_test_results.json")
+    with open(results_file, "w") as f:
+        json.dump(test_results, f, indent=2)
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/tools/harness/src/nv_ingest_harness/cli/nightly.py b/tools/harness/src/nv_ingest_harness/cli/nightly.py
index be329ed2d..68a41f9e1 100644
--- a/tools/harness/src/nv_ingest_harness/cli/nightly.py
+++ b/tools/harness/src/nv_ingest_harness/cli/nightly.py
@@ -15,12 +15,13 @@
 from nv_ingest_harness.config import load_config
 from nv_ingest_harness.reporting.baselines import validate_results, check_all_passed, get_expected_counts
 from nv_ingest_harness.reporting.environment import get_environment_data
+from nv_ingest_harness.service_manager import create_service_manager
 from nv_ingest_harness.sinks import SlackSink, HistorySink
 from nv_ingest_harness.utils.cases import now_timestr
-from nv_ingest_harness.utils.docker import restart_services
 from nv_ingest_harness.utils.session import create_session_dir, write_session_summary
 
 DEFAULT_CONFIG_PATH = Path(__file__).parents[3] / "nightly_config.yaml"
+REPO_ROOT = Path(__file__).resolve().parents[5]
 
 
 def load_nightly_config(config_path: Path) -> dict[str, Any]:
@@ -30,7 +31,15 @@ def load_nightly_config(config_path: Path) -> dict[str, Any]:
         return yaml.safe_load(f)
 
 
-def run_harness(dataset: str, case: str = "e2e", session_dir: Path | None = None) -> tuple[int, Path | None]:
+def run_harness(
+    dataset: str,
+    case: str = "e2e",
+    session_dir: Path | None = None,
+    deployment_type: str = "compose",
+    managed: bool = False,
+    sku: str | None = None,
+    test_config_path: str | None = None,
+) -> tuple[int, Path | None]:
     """Run a single harness test."""
     cmd = [
         sys.executable,
@@ -38,11 +47,21 @@ def run_harness(dataset: str, case: str = "e2e", session_dir: Path | None = None
         "nv_ingest_harness.cli.run",
         f"--case={case}",
         f"--dataset={dataset}",
+        f"--deployment-type={deployment_type}",
     ]
 
+    if managed:
+        cmd.append("--managed")
+
     if session_dir:
         cmd.append(f"--session-dir={str(session_dir)}")
 
+    if sku:
+        cmd.append(f"--sku={sku}")
+
+    if test_config_path:
+        cmd.append(f"--test-config={test_config_path}")
+
     print(f"\n{'='*60}")
     print(f"Running: {' '.join(cmd)}")
     print(f"{'='*60}\n")
@@ -62,7 +81,7 @@ def run_harness(dataset: str, case: str = "e2e", session_dir: Path | None = None
                 if artifact_dir.exists() and (artifact_dir / "results.json").exists():
                     return result.returncode, artifact_dir
 
-        cfg = load_config(case=case, dataset=dataset)
+        cfg = load_config(config_file=test_config_path or "test_configs.yaml", case=case, dataset=dataset)
         artifact_name = cfg.test_name or dataset
         candidate = session_dir / artifact_name
         if candidate.exists() and (candidate / "results.json").exists():
@@ -106,6 +125,23 @@ def load_results(artifact_dir: Path) -> dict:
     default=None,
     help="Path to nightly config YAML (default: nightly_config.yaml)",
 )
+@click.option(
+    "--deployment-type",
+    type=click.Choice(["compose", "helm"], case_sensitive=False),
+    default="compose",
+    help="Deployment type for services (compose or helm)",
+)
+@click.option(
+    "--managed",
+    is_flag=True,
+    help="Manage services (start/stop). If enabled, services are started before tests and stopped after (unless"
+    " --keep-up)",
+)
+@click.option(
+    "--keep-up",
+    is_flag=True,
+    help="Keep services running after nightly run completes (only with --managed)",
+)
 @click.option(
     "--skip-slack",
     is_flag=True,
@@ -119,7 +155,7 @@ def load_results(artifact_dir: Path) -> dict:
 @click.option(
     "--skip-fresh-start",
     is_flag=True,
-    help="Skip service restart (overrides config)",
+    help="Skip service restart (overrides config, mutually exclusive with --managed)",
 )
 @click.option(
     "--dry-run",
@@ -139,14 +175,39 @@ def load_results(artifact_dir: Path) -> dict:
     default=None,
     help="Optional note to attach to the session summary and Slack output",
 )
+@click.option(
+    "--sku",
+    type=str,
+    default=None,
+    help="GPU SKU for Docker Compose override file (e.g., a10g, a100-40gb, l40s). Only applies to managed Compose "
+    "services.",
+)
+@click.option(
+    "--dump-logs/--no-dump-logs",
+    default=True,
+    help="Dump service logs to artifacts directory before cleanup. Default: enabled",
+)
+@click.option(
+    "--test-config",
+    "test_config_path",
+    type=click.Path(exists=True),
+    default=None,
+    help="Path to test config YAML (default: tools/harness/test_configs.yaml)",
+)
 def main(
     config_path: Path | None,
+    deployment_type: str,
+    managed: bool,
+    keep_up: bool,
     skip_slack: bool,
     skip_history: bool,
     skip_fresh_start: bool,
     dry_run: bool,
     replay_dirs: tuple[Path, ...],
     note: str | None,
+    sku: str | None,
+    dump_logs: bool,
+    test_config_path: str | None,
 ):
     """Run nightly benchmarks and post results."""
     if replay_dirs:
@@ -168,6 +229,13 @@ def main(
     recall_datasets = runs_config.get("e2e_recall", [])
     reranker_mode = recall_config.get("reranker_mode", "both")
     fresh_start = infra_config.get("fresh_start", True) and not skip_fresh_start
+
+    # Validate mutually exclusive options: fresh_start and managed
+    if fresh_start and managed:
+        print("Error: Cannot use both --managed and fresh_start=true in config.")
+        print("  Either set infrastructure.fresh_start=false in config or use --skip-fresh-start flag")
+        return 1
+
     session_name = f"nightly_{now_timestr()}"
     session_dir = create_session_dir(session_name)
 
@@ -180,6 +248,10 @@ def main(
     print(f"E2E datasets: {e2e_datasets}")
     print(f"Recall datasets: {recall_datasets}")
     print(f"Reranker mode: {reranker_mode}")
+    print(f"Deployment type: {deployment_type}")
+    print(f"Managed mode: {managed}")
+    if managed:
+        print(f"Keep services up: {keep_up}")
     print(f"Fresh start: {fresh_start}")
     if note:
         print(f"Note: {note}")
@@ -217,18 +289,81 @@ def main(
     for sink in sinks:
         sink.initialize(session_name, env_data)
 
+    service_manager = None
+
+    # Handle service lifecycle based on mode
     if fresh_start:
-        timeout = infra_config.get("readiness_timeout", 600)
-        profiles = infra_config.get("profiles")  # None uses DEFAULT_PROFILES
-        rc = restart_services(profiles=profiles, timeout=timeout, build=False, clean=True)
+        # fresh_start mode: restart services once using config deployment_type
+        print("\n" + "=" * 60)
+        print(f"Fresh start: Restarting services using {deployment_type}")
+        print("=" * 60)
+
+        # Load config to get profiles and settings
+        first_dataset = e2e_datasets[0] if e2e_datasets else (recall_datasets[0] if recall_datasets else None)
+        if not first_dataset:
+            print("Error: No datasets configured")
+            return 1
+
+        service_config = load_config(
+            config_file=test_config_path or "test_configs.yaml",
+            case="e2e",
+            dataset=first_dataset,
+            deployment_type=deployment_type,
+        )
+
+        service_manager = create_service_manager(service_config, REPO_ROOT, sku=sku)
+        rc = service_manager.restart(build=False, clean=True, timeout=service_config.readiness_timeout)
         if rc != 0:
             print(f"Warning: Service restart returned {rc}")
 
+    elif managed:
+        # managed mode: start services, run tests, stop at end if not keep_up
+        print("\n" + "=" * 60)
+        print(f"Managed mode: Starting services using {deployment_type}")
+        print("=" * 60)
+
+        # Load config to get profiles and settings
+        first_dataset = e2e_datasets[0] if e2e_datasets else (recall_datasets[0] if recall_datasets else None)
+        if not first_dataset:
+            print("Error: No datasets configured")
+            return 1
+
+        service_config = load_config(
+            config_file=test_config_path or "test_configs.yaml",
+            case="e2e",
+            dataset=first_dataset,
+            deployment_type=deployment_type,
+        )
+
+        service_manager = create_service_manager(service_config, REPO_ROOT, sku=sku)
+
+        # Start services
+        if service_manager.start(no_build=True) != 0:
+            print("Failed to start services")
+            return 1
+
+        # Wait for readiness
+        if not service_manager.check_readiness(service_config.readiness_timeout):
+            print("Services failed to become ready")
+            service_manager.stop()
+            return 1
+
+        print("Services ready!")
+
     all_results = []
 
+    # Run all datasets - services stay up across all iterations
     for dataset in e2e_datasets:
         print(f"\n--- Running e2e for {dataset} ---")
-        rc, artifact_dir = run_harness(dataset, case="e2e", session_dir=session_dir)
+        rc, artifact_dir = run_harness(
+            dataset,
+            case="e2e",
+            session_dir=session_dir,
+            deployment_type=deployment_type,
+            managed=False,  # Don't manage per-dataset, already managed at nightly level
+            sku=sku,
+            test_config_path=test_config_path,
+        )
         result = _process_result(dataset, rc, artifact_dir, case="e2e")
         all_results.append(result)
 
@@ -237,13 +372,53 @@ def main(
 
     for dataset in recall_datasets:
         print(f"\n--- Running e2e_recall for {dataset} ---")
-        rc, artifact_dir = run_harness(dataset, case="e2e_recall", session_dir=session_dir)
+        rc, artifact_dir = run_harness(
+            dataset,
+            case="e2e_recall",
+            session_dir=session_dir,
+            deployment_type=deployment_type,
+            managed=False,  # Don't manage per-dataset, already managed at nightly level
+            sku=sku,
+            test_config_path=test_config_path,
+        )
         result = _process_result(dataset, rc, artifact_dir, case="e2e_recall")
         all_results.append(result)
 
         for sink in sinks:
             sink.process_result(result)
 
+    # Cleanup services and port forwards if needed
+    if service_manager:
+        # Dump logs before stopping services if enabled
+        if dump_logs:
+            logs_dir = session_dir / "service_logs"
+            print(f"\n{'='*60}")
+            print("Dumping service logs...")
+            print(f"{'='*60}")
+            service_manager.dump_logs(logs_dir)
+
+        # Always cleanup port forwards for helm deployments (prevents orphaned processes)
+        if hasattr(service_manager, "_stop_port_forwards"):
+            service_manager._stop_port_forwards()
+
+        if managed and not keep_up:
+            # Stop services in managed mode without keep_up
+            print("\n" + "=" * 60)
+            print("Stopping managed services")
+            print("=" * 60)
+            service_manager.stop()
+        else:
+            # Services are kept running (managed with keep_up, or fresh_start)
+            print("\n" + "=" * 60)
+            if managed:
+                print("Services are kept running (--keep-up enabled)")
+            else:
+                print("Services are running (fresh_start mode)")
+            print("Port forwards have been cleaned up to prevent orphaned processes.")
+            if hasattr(service_manager, "print_port_forward_commands"):
+                service_manager.print_port_forward_commands()
+            print("=" * 60)
+
     for sink in sinks:
         sink.finalize()
 
@@ -260,6 +435,8 @@ def main(
             "e2e": e2e_datasets,
             "e2e_recall": recall_datasets,
         },
+        infrastructure="managed" if managed else ("fresh_start" if fresh_start else "attach"),
+        deployment_type=deployment_type,
     )
 
     print("\n" + "=" * 60)
diff --git a/tools/harness/src/nv_ingest_harness/cli/run.py b/tools/harness/src/nv_ingest_harness/cli/run.py
index 80617258f..6c13e55b0 100644
--- a/tools/harness/src/nv_ingest_harness/cli/run.py
+++ b/tools/harness/src/nv_ingest_harness/cli/run.py
@@ -6,57 +6,67 @@
 import click
 
 from nv_ingest_harness.config import load_config
+from nv_ingest_harness.service_manager import create_service_manager
 from nv_ingest_harness.utils.cases import last_commit, now_timestr
-from nv_ingest_harness.utils.docker import (
-    stop_services,
-    start_services,
-    readiness_wait,
-)
 from nv_ingest_harness.utils.session import (
     create_session_dir,
     get_artifact_path,
     write_session_summary,
 )
 
-CASES = ["e2e", "e2e_with_llm_summary", "recall", "e2e_recall"]
+REPO_ROOT = Path(__file__).resolve().parents[5]
+CASES = [
+    "e2e",
+    "e2e_with_llm_summary",
+    "recall",
+    "e2e_recall",
+    "page_elements",
+    "table_structure",
+    "graphic_elements",
+    "ocr",
+]
 
 
 def run_datasets(
     case,
     dataset_list,
     managed,
+    deployment_type,
     no_build,
     keep_up,
     doc_analysis,
     session_dir: str | None = None,
+    sku: str | None = None,
+    dump_logs: bool = True,
+    config_file: str | None = None,
 ) -> int:
     """Run test for one or more datasets sequentially."""
     results = []
+    service_manager = None
     session_summary_path = None
 
     # Start services once if managed mode
     if managed:
         # Load config for first dataset to get profiles
         first_config = load_config(
+            config_file=config_file or "test_configs.yaml",
             case=case,
             dataset=dataset_list[0],
+            deployment_type=deployment_type,
         )
 
-        # Start services
-        profile_list = first_config.profiles
-        if not profile_list:
-            print("No profiles specified")
-            return 1
+        # Create appropriate service manager based on config
+        service_manager = create_service_manager(first_config, REPO_ROOT, sku=sku)
 
-        build = not no_build
-        if start_services(profiles=profile_list, build=build) != 0:
+        # Start services
+        if service_manager.start(no_build=no_build) != 0:
             print("Failed to start services")
             return 1
 
         # Wait for readiness
-        if not readiness_wait(first_config.readiness_timeout):
+        if not service_manager.check_readiness(first_config.readiness_timeout):
             print("Services failed to become ready")
-            stop_services()
+            service_manager.stop()
             return 1
 
     # Run each dataset
@@ -68,8 +78,10 @@ def run_datasets(
         # Load config for this dataset (applies dataset-specific extraction configs)
         try:
             config = load_config(
+                config_file=config_file or "test_configs.yaml",
                 case=case,
                 dataset=dataset_name,
+                deployment_type=deployment_type,
             )
         except (FileNotFoundError, ValueError) as e:
             print(f"Configuration error for {dataset_name}: {e}", file=sys.stderr)
@@ -81,7 +93,12 @@ def run_datasets(
         if not artifact_name:
             artifact_name = os.path.basename(config.dataset_dir.rstrip("/"))
 
-        out_dir = get_artifact_path(session_dir, artifact_name, base_dir=config.artifacts_dir)
+        out_dir = get_artifact_path(
+            session_dir,
+            artifact_name,
+            base_dir=config.artifacts_dir,
+            deployment_type=deployment_type if managed else None,
+        )
         stdout_path = os.path.join(out_dir, "stdout.txt")
 
         print(f"Dataset: {config.dataset_dir}")
@@ -176,9 +193,43 @@ def run_datasets(
             }
         )
 
-    # Stop services if managed mode and not keeping up
-    if managed and not keep_up:
-        stop_services()
+    # Cleanup managed services
+    if managed and service_manager:
+        # Dump logs before stopping services if enabled
+        if dump_logs:
+            # Determine where to dump logs
+            if session_dir:
+                # Dump to session directory if using sessions
+                logs_dir = Path(session_dir) / "service_logs"
+            else:
+                # Dump to first result's artifact directory as fallback
+                if results and results[0].get("artifact_dir") != "N/A":
+                    logs_dir = Path(results[0]["artifact_dir"]) / "service_logs"
+                else:
+                    # Last resort: create a timestamped directory in artifacts root
+                    from nv_ingest_harness.utils.session import get_default_artifacts_root
+
+                    logs_dir = get_default_artifacts_root() / f"service_logs_{now_timestr()}"
+
+            print(f"\n{'='*60}")
+            print("Dumping service logs...")
+            print(f"{'='*60}")
+            service_manager.dump_logs(logs_dir)
+
+        # Always cleanup port forwards (prevents orphaned processes)
+        if hasattr(service_manager, "_stop_port_forwards"):
+            service_manager._stop_port_forwards()
+
+        # Only uninstall services if not keeping up
+        if not keep_up:
+            service_manager.stop()
+        else:
+            print("\n" + "=" * 60)
+            print("Services are kept running (--keep-up enabled)")
+            print("Port forwards have been cleaned up to prevent orphaned processes.")
+            if hasattr(service_manager, "print_port_forward_commands"):
+                service_manager.print_port_forward_commands()
+            print("=" * 60)
 
     # Write session summary if using a session
     if session_dir:
@@ -274,8 +325,12 @@ def close(self):
 
 @click.command()
 @click.option("--case", default="e2e", help="Test case name to run")
+@click.option("--managed", is_flag=True, help="Manage services (start/stop). Default: attach to existing services")
 @click.option(
-    "--managed", is_flag=True, help="Manage Docker services (start/stop). Default: attach to existing services"
+    "--deployment-type",
+    type=click.Choice(["compose", "helm"], case_sensitive=False),
+    default="compose",
+    help="Deployment type for managed services (managed mode only)",
 )
 @click.option(
     "--dataset", help="Dataset name(s) - single name, comma-separated list, or path (e.g., bo767 or bo767,earnings)"
@@ -295,15 +350,38 @@ def close(self):
     default=None,
     help="Name for session directory (auto-created when multiple datasets or this option provided)",
 )
+@click.option(
+    "--sku",
+    type=str,
+    default=None,
+    help="GPU SKU for override file (Compose: docker-compose.<sku>.yaml; Helm: helm/overrides/values-<sku>.yaml). "
+    "Applies to managed Compose and Helm deployments (e.g., a10g, a100-40gb, l40s).",
+)
+@click.option(
+    "--dump-logs/--no-dump-logs",
+    default=True,
+    help="Dump service logs to artifacts directory before cleanup (managed mode only). Default: enabled",
+)
+@click.option(
+    "--test-config",
+    "test_config_path",
+    type=click.Path(exists=True),
+    default=None,
+    help="Path to test config YAML (default: tools/harness/test_configs.yaml)",
+)
 def main(
     case,
     managed,
+    deployment_type,
     dataset,
     no_build,
     keep_up,
     doc_analysis,
     session_dir,
     session_name,
+    sku,
+    dump_logs,
+    test_config_path,
 ):
 
     if not dataset:
@@ -331,10 +409,14 @@ def main(
         case=case,
         dataset_list=dataset_list,
         managed=managed,
+        deployment_type=deployment_type,
         no_build=no_build,
         keep_up=keep_up,
         doc_analysis=doc_analysis,
         session_dir=str(session_dir) if session_dir else None,
+        sku=sku,
+        dump_logs=dump_logs,
+        config_file=test_config_path,
     )
 
 
diff --git a/tools/harness/src/nv_ingest_harness/config.py b/tools/harness/src/nv_ingest_harness/config.py
index 1cc383f29..420533525 100644
--- a/tools/harness/src/nv_ingest_harness/config.py
+++ b/tools/harness/src/nv_ingest_harness/config.py
@@ -33,14 +33,31 @@ class TestConfig:
     # Infrastructure
     hostname: str = "localhost"
     readiness_timeout: int = 600
-    profiles: List[str] = field(default_factory=lambda: ["retrieval", "table-structure"])
+    profiles: List[str] = field(default_factory=lambda: ["retrieval", "reranker"])  # Docker Compose only
+
+    # Deployment configuration
+    deployment_type: str = "compose"  # Options: compose, helm
+
+    # Helm-specific configuration
+    helm_bin: str = "helm"  # Helm binary command (e.g., "helm", "microk8s helm", "k3s helm")
+    helm_sudo: bool = False  # Prepend sudo to helm commands (useful for microk8s, k3s)
+    kubectl_bin: str = "kubectl"  # kubectl binary command (e.g., "kubectl", "microk8s kubectl")
+    kubectl_sudo: Optional[bool] = None  # Prepend sudo to kubectl commands (defaults to helm_sudo if not set)
+    helm_chart: Optional[str] = None  # Remote chart reference (e.g., "nim-nvstaging/nv-ingest"), None = use local chart
+    helm_chart_version: Optional[str] = None  # Chart version (e.g., "26.1.0-RC7")
+    helm_release: str = "nv-ingest"
+    helm_namespace: str = "nv-ingest"
+    helm_values_file: Optional[str] = None
+    helm_values: Optional[dict] = None
+    helm_port_forwards: Optional[List[dict]] = None  # List of {service, local_port, remote_port}
 
     # Runtime configuration
-    sparse: bool = True
+    sparse: bool = False
     gpu_search: bool = False
     embedding_model: str = "auto"
     llm_summarization_model: str = "nvdev/nvidia/llama-3.1-nemotron-70b-instruct"
-    vdb_backend: str = "milvus"
+    vdb_backend: str = "lancedb"
+    hybrid: bool = False
 
     # Extraction configuration
     extract_text: bool = True
@@ -107,6 +124,10 @@ def validate(self) -> List[str]:
         if self.api_version not in ["v1", "v2"]:
             errors.append(f"api_version must be 'v1' or 'v2', got '{self.api_version}'")
 
+        # Check deployment_type is valid
+        if self.deployment_type not in ["compose", "helm"]:
+            errors.append(f"deployment_type must be 'compose' or 'helm', got '{self.deployment_type}'")
+
         # Check reranker_mode is valid
         if self.reranker_mode not in ["none", "with", "both"]:
             errors.append(f"reranker_mode must be 'none', 'with', or 'both', got '{self.reranker_mode}'")
@@ -174,7 +195,9 @@ def load_config(config_file: str = "test_configs.yaml", case: Optional[str] = No
         FileNotFoundError: If config file doesn't exist
         ValueError: If configuration validation fails
     """
-    config_path = Path(__file__).resolve().parents[2] / config_file
+    config_path = Path(config_file)
+    if not config_path.is_absolute():
+        config_path = Path(__file__).resolve().parents[2] / config_file
 
     if not config_path.exists():
         raise FileNotFoundError(f"Config file not found: {config_path}\n")
@@ -188,6 +211,27 @@ def load_config(config_file: str = "test_configs.yaml", case: Optional[str] = No
     if not config_dict:
         raise ValueError("Config file must have 'active' section")
 
+    # Flatten nested deployment configurations (compose and helm)
+    # This allows cleaner YAML organization while keeping flat config structure
+    if "compose" in config_dict:
+        compose_config = config_dict.pop("compose")
+        if isinstance(compose_config, dict):
+            # Keys from compose section are used as-is (e.g., profiles)
+            for key, value in compose_config.items():
+                config_dict[key] = value
+
+    if "helm" in config_dict:
+        helm_config = config_dict.pop("helm")
+        if isinstance(helm_config, dict):
+            # Map helm section keys to their config field names
+            for key, value in helm_config.items():
+                # Keys that already have a prefix (kubectl_*) don't need helm_ prefix
+                if key.startswith("kubectl_"):
+                    config_dict[key] = value
+                else:
+                    # Other keys get helm_ prefix
+                    config_dict[f"helm_{key}"] = value
+
     # Merge recall section when running recall test cases
     # The recall section provides additional configuration for recall evaluation
     if case in ("recall", "e2e_recall"):
@@ -264,7 +308,18 @@ def parse_list(value: str) -> List[str]:
         "HOSTNAME": ("hostname", str),
         "READINESS_TIMEOUT": ("readiness_timeout", parse_int),
         "PROFILES": ("profiles", parse_list),
+        "DEPLOYMENT_TYPE": ("deployment_type", str),
+        "HELM_BIN": ("helm_bin", str),
+        "HELM_SUDO": ("helm_sudo", parse_bool),
+        "KUBECTL_BIN": ("kubectl_bin", str),
+        "KUBECTL_SUDO": ("kubectl_sudo", parse_bool),
+        "HELM_CHART": ("helm_chart", str),
+        "HELM_CHART_VERSION": ("helm_chart_version", str),
+        "HELM_RELEASE": ("helm_release", str),
+        "HELM_NAMESPACE": ("helm_namespace", str),
+        "HELM_VALUES_FILE": ("helm_values_file", str),
         "SPARSE": ("sparse", parse_bool),
+        "HYBRID": ("hybrid", parse_bool),
         "GPU_SEARCH": ("gpu_search", parse_bool),
         "EMBEDDING_NIM_MODEL_NAME": ("embedding_model", str),
         "LLM_SUMMARIZATION_MODEL": ("llm_summarization_model", str),
diff --git a/tools/harness/src/nv_ingest_harness/reporting/baselines.py b/tools/harness/src/nv_ingest_harness/reporting/baselines.py
index c6869427e..75c3d51b3 100644
--- a/tools/harness/src/nv_ingest_harness/reporting/baselines.py
+++ b/tools/harness/src/nv_ingest_harness/reporting/baselines.py
@@ -31,6 +31,10 @@
             "min": 0.80,  # observed: 0.910
         },
     },
+    "jp20": {
+        "result_count": {"expected": 20, "required": True},
+        "failure_count": {"expected": 0, "required": True},
+    },
     "earnings": {
         "result_count": {"expected": 514, "required": True},
         "total_pages": {"expected": 12988, "required": True},
diff --git a/tools/harness/src/nv_ingest_harness/service_manager/__init__.py b/tools/harness/src/nv_ingest_harness/service_manager/__init__.py
new file mode 100644
index 000000000..1f10d7e9b
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/service_manager/__init__.py
@@ -0,0 +1,36 @@
+"""Service manager factory and exports."""
+
+from pathlib import Path
+
+from nv_ingest_harness.service_manager.base import ServiceManager
+from nv_ingest_harness.service_manager.docker_compose import DockerComposeManager
+from nv_ingest_harness.service_manager.helm import HelmManager
+
+
+def create_service_manager(config, repo_root: Path, sku: str | None = None) -> ServiceManager:
+    """
+    Factory to create the appropriate service manager based on config.
+
+    Args:
+        config: Configuration object with deployment_type attribute
+        repo_root: Path to the repository root
+        sku: Optional GPU SKU for override file (Compose: docker-compose.<sku>.yaml;
+            Helm: helm/overrides/values-<sku>.yaml)
+
+    Returns:
+        ServiceManager instance (DockerComposeManager or HelmManager)
+
+    Raises:
+        ValueError: If deployment_type is unknown
+    """
+    deployment_type = getattr(config, "deployment_type", "compose")
+
+    if deployment_type == "compose":
+        return DockerComposeManager(config, repo_root, sku=sku)
+    elif deployment_type == "helm":
+        return HelmManager(config, repo_root, sku=sku)
+    else:
+        raise ValueError(f"Unknown deployment_type: {deployment_type}. Must be 'compose' or 'helm'")
+
+
+__all__ = ["ServiceManager", "create_service_manager", "DockerComposeManager", "HelmManager"]
diff --git a/tools/harness/src/nv_ingest_harness/service_manager/base.py b/tools/harness/src/nv_ingest_harness/service_manager/base.py
new file mode 100644
index 000000000..02368d635
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/service_manager/base.py
@@ -0,0 +1,119 @@
+"""Base class for service orchestration managers."""
+
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+
+class ServiceManager(ABC):
+    """Abstract base for service orchestration managers."""
+
+    def __init__(self, config, repo_root: Path):
+        """
+        Initialize the service manager.
+
+        Args:
+            config: Configuration object with deployment settings
+            repo_root: Path to the repository root
+        """
+        self.config = config
+        self.repo_root = repo_root
+
+    @abstractmethod
+    def start(self, no_build: bool = False) -> int:
+        """
+        Start services.
+
+        Args:
+            no_build: If True, skip building images/charts
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        pass
+
+    @abstractmethod
+    def stop(self, clean: bool = False) -> int:
+        """
+        Stop and cleanup services.
+
+        Args:
+            clean: If True, perform full cleanup (volumes, etc.)
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        pass
+
+    @abstractmethod
+    def check_readiness(self, timeout_s: int, check_milvus: bool = True, check_embedding: bool = True) -> bool:
+        """
+        Check if services are ready.
+
+        Args:
+            timeout_s: Timeout in seconds
+            check_milvus: If True, also check Milvus health endpoint
+            check_embedding: If True, also check embedding service health endpoint
+
+        Returns:
+            True when ready, False on timeout
+        """
+        pass
+
+    @abstractmethod
+    def get_service_url(self, service: str = "api") -> str:
+        """
+        Get the URL for a service endpoint.
+
+        Args:
+            service: Service name (e.g., "api", "health")
+
+        Returns:
+            URL string
+        """
+        pass
+
+    @abstractmethod
+    def dump_logs(self, artifacts_dir: Path) -> int:
+        """
+        Dump logs of all managed containers/pods to artifacts directory.
+
+        Args:
+            artifacts_dir: Directory to write log files to
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        pass
+
+    def restart(self, build: bool = False, clean: bool = True, timeout: int = 600) -> int:
+        """
+        Restart services (stop, clean, start, wait for readiness).
+
+        Args:
+            build: If True, rebuild images/charts
+            clean: If True, perform full cleanup (volumes, etc.)
+            timeout: Readiness timeout in seconds
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        print("Restarting services" + (" (with build)" if build else ""))
+
+        # Stop and clean services
+        rc = self.stop(clean=clean)
+        if rc != 0:
+            print(f"Warning: Service stop returned {rc}")
+
+        # Start services
+        rc = self.start(no_build=not build)
+        if rc != 0:
+            print(f"Failed to start services (exit code: {rc})")
+            return rc
+
+        # Wait for readiness
+        if not self.check_readiness(timeout):
+            print("Services failed to become ready within timeout")
+            return 1
+
+        print("Services restarted successfully!")
+        return 0
diff --git a/tools/harness/src/nv_ingest_harness/service_manager/docker_compose.py b/tools/harness/src/nv_ingest_harness/service_manager/docker_compose.py
new file mode 100644
index 000000000..0a0a1285a
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/service_manager/docker_compose.py
@@ -0,0 +1,279 @@
+"""Docker Compose service manager implementation."""
+
+import subprocess
+import time
+import urllib.request
+from pathlib import Path
+
+from nv_ingest_harness.service_manager.base import ServiceManager
+from nv_ingest_harness.utils.interact import run_cmd
+
+
+class DockerComposeManager(ServiceManager):
+    """Manages services using Docker Compose."""
+
+    def __init__(self, config, repo_root: Path, sku: str | None = None):
+        """
+        Initialize Docker Compose manager.
+
+        Args:
+            config: Configuration object with profiles and settings
+            repo_root: Path to the repository root
+            sku: Optional GPU SKU for override file (e.g., a10g, a100-40gb, l40s)
+        """
+        super().__init__(config, repo_root)
+        self.compose_file = str(repo_root / "docker-compose.yaml")
+        self.sku = sku
+        self.override_file = None
+
+        # Set override file path if sku is provided
+        if self.sku:
+            override_path = repo_root / f"docker-compose.{self.sku}.yaml"
+            if override_path.exists():
+                self.override_file = str(override_path)
+                print(f"Using Docker Compose override file: {self.override_file}")
+            else:
+                print(f"Warning: Override file not found: {override_path}")
+
+    def _build_compose_cmd(self, base_cmd: list[str]) -> list[str]:
+        """
+        Build docker compose command with compose file and optional override file.
+
+        Args:
+            base_cmd: Base command to start with (e.g., ["docker", "compose"])
+
+        Returns:
+            Command list with -f flags for compose file(s)
+        """
+        cmd = base_cmd + ["-f", self.compose_file]
+        if self.override_file:
+            cmd += ["-f", self.override_file]
+        return cmd
+
+    def start(self, no_build: bool = False) -> int:
+        """
+        Start Docker Compose services with profiles.
+
+        Args:
+            no_build: If True, skip building Docker images
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        profile_list = self.config.profiles
+        if not profile_list:
+            print("No profiles specified")
+            return 1
+
+        # Build command with all profiles
+        cmd = self._build_compose_cmd(["docker", "compose"])
+        cmd += ["--profile", profile_list[0]]
+        for p in profile_list[1:]:
+            cmd += ["--profile", p]
+
+        # Add up command with or without build
+        if not no_build:
+            cmd += ["up", "--build", "-d"]
+        else:
+            cmd += ["up", "-d"]
+
+        return run_cmd(cmd)
+
+    def stop(self, clean: bool = False) -> int:
+        """
+        Stop Docker Compose services.
+
+        Args:
+            clean: If True, also remove volumes and orphans
+
+        Returns:
+            0 on success
+        """
+        print("Performing Docker Compose cleanup...")
+
+        # Stop all services
+        down_cmd = self._build_compose_cmd(["docker", "compose"])
+        down_cmd += ["--profile", "*", "down"]
+
+        # Add cleanup flags if clean mode
+        if clean:
+            down_cmd += ["-v", "--remove-orphans"]
+
+        rc = run_cmd(down_cmd)
+        if rc != 0:
+            print(f"Warning: docker compose down returned {rc}")
+
+        # Remove containers forcefully
+        rm_cmd = self._build_compose_cmd(["docker", "compose"])
+        rm_cmd += ["--profile", "*", "rm", "--force"]
+        rc2 = run_cmd(rm_cmd)
+        if rc2 != 0:
+            print(f"Warning: docker compose rm returned {rc2}")
+
+        return 0
+
+    def check_readiness(self, timeout_s: int, check_milvus: bool = True, check_embedding: bool = True) -> bool:
+        """
+        Poll the health endpoint until ready.
+
+        Args:
+            timeout_s: Timeout in seconds
+            check_milvus: If True, also check Milvus health endpoint
+            check_embedding: If True, also check embedding service health endpoint
+
+        Returns:
+            True if ready, False on timeout
+        """
+        url = self.get_service_url("health")
+        deadline = time.time() + timeout_s
+
+        while time.time() < deadline:
+            try:
+                # Check main service health
+                with urllib.request.urlopen(url, timeout=5) as resp:
+                    if resp.status == 200:
+                        all_services_ready = True
+
+                        # If Milvus check is enabled, verify it's also ready
+                        if check_milvus:
+                            hostname = getattr(self.config, "hostname", "localhost")
+                            milvus_url = f"http://{hostname}:9091/healthz"
+                            try:
+                                with urllib.request.urlopen(milvus_url, timeout=5) as milvus_resp:
+                                    if milvus_resp.status != 200:
+                                        all_services_ready = False
+                            except Exception:
+                                all_services_ready = False
+
+                        # If embedding check is enabled, verify it's also ready
+                        if check_embedding:
+                            hostname = getattr(self.config, "hostname", "localhost")
+                            embedding_url = f"http://{hostname}:8012/v1/health/ready"
+                            try:
+                                with urllib.request.urlopen(embedding_url, timeout=5) as embedding_resp:
+                                    if embedding_resp.status != 200:
+                                        all_services_ready = False
+                            except Exception:
+                                all_services_ready = False
+
+                        if all_services_ready:
+                            return True
+            except Exception:
+                pass
+            time.sleep(3)
+        return False
+
+    def get_service_url(self, service: str = "api") -> str:
+        """
+        Get service URL for Docker Compose (localhost).
+
+        Args:
+            service: Service name ("api" or "health")
+
+        Returns:
+            URL string
+        """
+        hostname = getattr(self.config, "hostname", "localhost")
+        if service == "health":
+            return f"http://{hostname}:7670/v1/health/ready"
+        return f"http://{hostname}:7670"
+
+    def dump_logs(self, artifacts_dir: Path) -> int:
+        """
+        Dump logs of all Docker Compose containers to artifacts directory.
+
+        Args:
+            artifacts_dir: Directory to write log files to
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        print(f"Dumping Docker Compose logs to {artifacts_dir}...")
+
+        # Ensure artifacts directory exists
+        artifacts_dir = Path(artifacts_dir)
+        artifacts_dir.mkdir(parents=True, exist_ok=True)
+
+        # Get list of running containers from this compose project
+        ps_cmd = self._build_compose_cmd(["docker", "compose"])
+        ps_cmd += ["--profile", "*", "ps", "-q"]
+        try:
+            result = subprocess.run(ps_cmd, capture_output=True, text=True, timeout=30)
+            if result.returncode != 0:
+                print(f"Warning: Could not list containers: {result.stderr.strip()}")
+                return result.returncode
+
+            container_ids = [cid.strip() for cid in result.stdout.strip().split("\n") if cid.strip()]
+
+            if not container_ids:
+                print("No containers found to dump logs from")
+                return 0
+
+            print(f"Found {len(container_ids)} container(s) to dump logs from")
+
+            # Dump logs for each container individually with container name
+            for container_id in container_ids:
+                # Get container name
+                inspect_cmd = ["docker", "inspect", "--format", "{{.Name}}", container_id]
+                name_result = subprocess.run(inspect_cmd, capture_output=True, text=True, timeout=10)
+                if name_result.returncode == 0:
+                    container_name = name_result.stdout.strip().lstrip("/")
+                else:
+                    container_name = container_id[:12]  # Use short ID as fallback
+
+                log_file = artifacts_dir / f"container_{container_name}.log"
+                print(f"  Dumping logs for {container_name} to {log_file.name}")
+
+                # Dump container logs
+                logs_cmd = ["docker", "logs", container_id]
+                with open(log_file, "w") as f:
+                    log_result = subprocess.run(logs_cmd, stdout=f, stderr=subprocess.STDOUT, timeout=60)
+                    if log_result.returncode != 0:
+                        print(f"    Warning: Failed to dump logs for {container_name}")
+
+            # Also dump combined logs from all services
+            combined_log_file = artifacts_dir / "docker_compose_combined.log"
+            print(f"  Dumping combined logs to {combined_log_file.name}")
+            logs_cmd = self._build_compose_cmd(["docker", "compose"])
+            logs_cmd += ["--profile", "*", "logs", "--no-color"]
+            with open(combined_log_file, "w") as f:
+                combined_result = subprocess.run(logs_cmd, stdout=f, stderr=subprocess.STDOUT, timeout=120)
+                if combined_result.returncode != 0:
+                    print("    Warning: Failed to dump combined logs")
+
+            # Dump environment variables for each container
+            print("  Dumping container environment variables...")
+            for container_id in container_ids:
+                # Get container name
+                inspect_cmd = ["docker", "inspect", "--format", "{{.Name}}", container_id]
+                name_result = subprocess.run(inspect_cmd, capture_output=True, text=True, timeout=10)
+                if name_result.returncode == 0:
+                    container_name = name_result.stdout.strip().lstrip("/")
+                else:
+                    container_name = container_id[:12]  # Use short ID as fallback
+
+                env_file = artifacts_dir / f"container_{container_name}_env.txt"
+                print(f"    Dumping env vars for {container_name} to {env_file.name}")
+
+                # Dump container environment variables using docker inspect
+                env_cmd = [
+                    "docker",
+                    "inspect",
+                    "--format",
+                    "{{range .Config.Env}}{{println .}}{{end}}",
+                    container_id,
+                ]
+                with open(env_file, "w") as f:
+                    env_result = subprocess.run(env_cmd, stdout=f, stderr=subprocess.STDOUT, timeout=30)
+                    if env_result.returncode != 0:
+                        print(f"      Warning: Failed to dump env vars for {container_name}")
+
+            print("Log dump complete")
+            return 0
+
+        except subprocess.TimeoutExpired:
+            print("Error: Timeout while dumping logs")
+            return 1
+        except Exception as e:
+            print(f"Error: Failed to dump logs: {e}")
+            return 1
diff --git a/tools/harness/src/nv_ingest_harness/service_manager/helm.py b/tools/harness/src/nv_ingest_harness/service_manager/helm.py
new file mode 100644
index 000000000..0fc8d7ba1
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/service_manager/helm.py
@@ -0,0 +1,884 @@
+"""Helm service manager implementation."""
+
+import json
+import os
+import signal
+import subprocess
+import time
+import urllib.request
+from pathlib import Path
+
+import yaml
+
+from nv_ingest_harness.service_manager.base import ServiceManager
+from nv_ingest_harness.utils.interact import run_cmd
+
+
+class HelmManager(ServiceManager):
+    """Manages services using Helm."""
+
+    @staticmethod
+    def _flatten_dict(data: dict, parent_key: str = "", sep: str = ".") -> dict:
+        """
+        Flatten a nested dictionary into dot-notation keys.
+
+        Args:
+            data: The dictionary to flatten
+            parent_key: The parent key prefix
+            sep: The separator to use between keys
+
+        Returns:
+            Flattened dictionary with dot-notation keys
+        """
+        items = []
+        for key, value in data.items():
+            new_key = f"{parent_key}{sep}{key}" if parent_key else key
+
+            if isinstance(value, dict):
+                items.extend(HelmManager._flatten_dict(value, new_key, sep=sep).items())
+            elif isinstance(value, list):
+                # For lists, we need to use indexed notation or JSON
+                # Store as-is for JSON encoding
+                items.append((new_key, value))
+            else:
+                items.append((new_key, value))
+        return dict(items)
+
+    @staticmethod
+    def _add_values_to_command(cmd: list, values_dict: dict) -> list:
+        """
+        Add values from a dictionary to a Helm command using --set and --set-json.
+
+        Args:
+            cmd: The command list to append to
+            values_dict: The flattened values dictionary
+
+        Returns:
+            Updated command list
+        """
+        for key, value in values_dict.items():
+            # Use --set-json for complex types (lists, dicts, booleans, null)
+            if isinstance(value, (list, dict)):
+                cmd += ["--set-json", f"{key}={json.dumps(value)}"]
+            elif isinstance(value, bool):
+                # Helm expects lowercase boolean strings
+                cmd += ["--set", f"{key}={str(value).lower()}"]
+            elif value is None:
+                cmd += ["--set-json", f"{key}=null"]
+            else:
+                # Use --set for simple strings and numbers
+                # Escape commas and backslashes in string values
+                str_value = str(value).replace("\\", "\\\\").replace(",", "\\,")
+                cmd += ["--set", f"{key}={str_value}"]
+        return cmd
+
+    def __init__(self, config, repo_root: Path, sku: str | None = None):
+        """
+        Initialize Helm manager.
+
+        Args:
+            config: Configuration object with Helm settings
+            repo_root: Path to the repository root
+            sku: Optional GPU SKU for values override file (e.g., a10g, a100-40gb, l40s)
+        """
+        super().__init__(config, repo_root)
+        self.sku = sku
+        # Helm binary command (supports "helm", "microk8s helm", "k3s helm", etc.)
+        helm_bin = getattr(config, "helm_bin", "helm")
+        helm_sudo = getattr(config, "helm_sudo", False)
+
+        # Build base command with optional sudo prefix
+        if helm_sudo:
+            self.helm_cmd = ["sudo"] + helm_bin.split()
+        else:
+            self.helm_cmd = helm_bin.split()  # Split to support multi-word commands
+
+        # Use remote chart if specified, otherwise fall back to local chart
+        self.chart_ref = getattr(config, "helm_chart", None)
+        if not self.chart_ref:
+            # Default to local chart path if no remote chart specified
+            self.chart_ref = str(repo_root / "helm")
+        self.chart_version = getattr(config, "helm_chart_version", None)
+        self.release_name = getattr(config, "helm_release", "nv-ingest")
+        self.namespace = getattr(config, "helm_namespace", "nv-ingest")
+        self.values_file = getattr(config, "helm_values_file", None)
+
+        # Port forwarding processes (list of tuples: (process, description))
+        self.port_forward_processes: list[tuple[subprocess.Popen, str]] = []
+
+        # kubectl command (for port forwarding)
+        kubectl_bin = getattr(config, "kubectl_bin", "kubectl")
+        self.kubectl_sudo = getattr(config, "kubectl_sudo") or helm_sudo  # Default to same as helm_sudo
+
+        if self.kubectl_sudo:
+            self.kubectl_cmd = ["sudo"] + kubectl_bin.split()
+        else:
+            self.kubectl_cmd = kubectl_bin.split()
+
+    def start(self, no_build: bool = False) -> int:
+        """
+        Install or upgrade Helm release.
+
+        Args:
+            no_build: Not applicable for Helm (ignored)
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        cmd = self.helm_cmd + [
+            "upgrade",
+            "--install",
+            self.release_name,
+            self.chart_ref,
+            "--namespace",
+            self.namespace,
+            "--create-namespace",
+        ]
+
+        # Add version if specified (only valid for remote charts)
+        if self.chart_version:
+            cmd += ["--version", self.chart_version]
+
+        # Add GPU SKU values override file if specified (helm/overrides/values-<sku>.yaml)
+        if self.sku:
+            sku_values_path = self.repo_root / "helm" / "overrides" / f"values-{self.sku}.yaml"
+            if sku_values_path.exists():
+                cmd += ["-f", str(sku_values_path)]
+                print(f"Using Helm values override: {sku_values_path}")
+            else:
+                print(f"Warning: Helm SKU override file not found: {sku_values_path}")
+
+        # Parse and add values from YAML file if specified
+        if self.values_file:
+            values_path = self.repo_root / self.values_file
+            if values_path.exists():
+                try:
+                    print(f"Loading values from {values_path}...")
+                    with open(values_path, "r") as f:
+                        values_data = yaml.safe_load(f)
+
+                    if values_data:
+                        # Flatten the YAML structure
+                        flattened_values = self._flatten_dict(values_data)
+                        print(f"Parsed {len(flattened_values)} value(s) from {self.values_file}")
+
+                        # Add to command using --set and --set-json
+                        cmd = self._add_values_to_command(cmd, flattened_values)
+                    else:
+                        print(f"Warning: Values file {values_path} is empty")
+                except yaml.YAMLError as e:
+                    print(f"Error: Failed to parse YAML file {values_path}: {e}")
+                    return 1
+                except Exception as e:
+                    print(f"Error: Failed to read values file {values_path}: {e}")
+                    return 1
+            else:
+                print(f"Warning: Values file {values_path} not found, skipping")
+
+        # Add inline values from config
+        if hasattr(self.config, "helm_values") and self.config.helm_values:
+            for key, value in self.config.helm_values.items():
+                cmd += ["--set", f"{key}={value}"]
+
+        rc = run_cmd(cmd)
+
+        if rc == 0:
+            # Start port forwarding for all configured services
+            self._start_port_forwards()
+
+        return rc
+
+    def _find_services_by_pattern(self, pattern: str) -> list[str]:
+        """
+        Find services matching a pattern (supports wildcards).
+
+        Args:
+            pattern: Service name or pattern (e.g., "nv-ingest", "*embed*")
+
+        Returns:
+            List of matching service names
+        """
+        # If no wildcards, return as-is
+        if "*" not in pattern:
+            return [pattern]
+
+        # Query kubectl for services in the namespace
+        cmd = self.kubectl_cmd + ["get", "services", "-n", self.namespace, "-o", "name"]
+
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=10)
+            if result.returncode != 0:
+                print(f"Warning: Could not list services: {result.stderr.strip()}")
+                return []
+
+            # Parse output (format: "service/name")
+            service_names = [line.split("/")[-1] for line in result.stdout.strip().split("\n") if line]
+
+            # Convert pattern to regex-like matching
+            import re
+
+            regex_pattern = pattern.replace("*", ".*")
+            matches = [svc for svc in service_names if re.search(regex_pattern, svc)]
+
+            return matches
+        except Exception as e:
+            print(f"Warning: Error finding services: {e}")
+            return []
+
+    def _start_port_forwards(self) -> None:
+        """Start port forwarding for all configured services."""
+        # Get port forward configuration
+        port_forwards = getattr(self.config, "helm_port_forwards", None)
+
+        if not port_forwards:
+            # Default: forward main service only (port 7670)
+            port_forwards = [
+                {
+                    "service": self.release_name,
+                    "local_port": 7670,
+                    "remote_port": 7670,
+                }
+            ]
+
+        # Group port forwards by service (after resolving patterns)
+        # Map: service_name -> [(local_port, remote_port), ...]
+        service_port_map = {}
+
+        for pf_config in port_forwards:
+            service_pattern = pf_config.get("service")
+            local_port = pf_config.get("local_port")
+            remote_port = pf_config.get("remote_port")
+
+            if not all([service_pattern, local_port, remote_port]):
+                print(f"Warning: Invalid port forward config: {pf_config}")
+                continue
+
+            # Find matching services
+            service_names = self._find_services_by_pattern(service_pattern)
+
+            if not service_names:
+                print(f"Warning: No services found matching pattern '{service_pattern}'")
+                continue
+
+            # Add ports to each matching service
+            for service_name in service_names:
+                if service_name not in service_port_map:
+                    service_port_map[service_name] = []
+                service_port_map[service_name].append((local_port, remote_port))
+
+        # Start consolidated port forwards
+        for service_name, port_pairs in service_port_map.items():
+            self._start_single_port_forward(
+                service_name=service_name,
+                port_pairs=port_pairs,
+            )
+
+    def _start_single_port_forward(
+        self, service_name: str, port_pairs: list[tuple[int, int]], timeout: int = 120, retry_interval: int = 5
+    ) -> None:
+        """
+        Start kubectl port-forward for a single service with multiple ports and retry logic.
+
+        The port-forward is wrapped in a resilient shell loop that automatically restarts
+        if the connection drops (e.g., due to pod restarts).
+
+        Args:
+            service_name: Name of the service to forward
+            port_pairs: List of (local_port, remote_port) tuples
+            timeout: Maximum time to wait for port-forward to succeed (seconds)
+            retry_interval: Time between retry attempts (seconds)
+        """
+        # Build base kubectl port-forward command
+        kubectl_cmd_str = " ".join(self.kubectl_cmd)
+        port_strs = [f"{local}:{remote}" for local, remote in port_pairs]
+        ports_arg = " ".join(port_strs)
+
+        # Create a resilient wrapper script that auto-restarts on failure
+        # This handles pod restarts and transient failures
+        wrapper_script = f"""
+while true; do
+    echo "[$(date)] Starting port-forward for {service_name}..." >&2
+    {kubectl_cmd_str} port-forward -n {self.namespace} service/{service_name} {ports_arg}
+    EXIT_CODE=$?
+    echo "[$(date)] Port-forward exited with code $EXIT_CODE, restarting in {retry_interval}s..." >&2
+    sleep {retry_interval}
+done
+"""
+
+        # Build description
+        ports_desc = " ".join(port_strs)
+        description = f"{service_name} ({ports_desc})"
+        print(
+            f"$ {kubectl_cmd_str} port-forward -n {self.namespace} service/{service_name} "
+            f"{ports_arg} (background, auto-restart)"
+        )
+        print(f"Waiting for {service_name} pod to be ready (timeout: {timeout}s)...")
+
+        start_time = time.time()
+        attempt = 1
+
+        while time.time() - start_time < timeout:
+            try:
+                # Start resilient port-forward wrapper in background
+                # Create new process group so we can kill all children later
+                process = subprocess.Popen(
+                    ["bash", "-c", wrapper_script],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                    preexec_fn=os.setsid,  # Create new process group
+                )
+
+                # Give it a moment to establish
+                time.sleep(2)
+
+                # Check if wrapper process is still running
+                poll_result = process.poll()
+                if poll_result is not None:
+                    # Wrapper exited unexpectedly, read error output
+                    _, stderr = process.communicate()
+                    error_msg = stderr.decode("utf-8").strip() if stderr else f"exit code {poll_result}"
+
+                    # Check if it's a "pod not running" error that we should retry
+                    if "pod is not running" in error_msg or "Pending" in error_msg or "not found" in error_msg:
+                        elapsed = int(time.time() - start_time)
+                        print(f"  Attempt {attempt}: Pod not ready yet (elapsed: {elapsed}s)")
+                        time.sleep(retry_interval)
+                        attempt += 1
+                        continue
+                    else:
+                        # Different error, don't retry initial setup
+                        print(f"Error: Port forwarding for {service_name} failed: {error_msg}")
+                        return
+                else:
+                    # Success! Wrapper process is running (it will auto-restart kubectl inside)
+                    self.port_forward_processes.append((process, description))
+                    print(f"Port forwarding started for {description} (PID: {process.pid}, auto-restart enabled)")
+                    return
+
+            except Exception as e:
+                print(f"Error: Failed to start port forwarding for {service_name}: {e}")
+                return
+
+        # Timeout reached
+        print(f"Error: Port forwarding for {service_name} failed to establish after {timeout}s (pod may not be ready)")
+
+    def _stop_port_forwards(self) -> None:
+        """Stop all port-forward processes and their children."""
+        if not self.port_forward_processes:
+            # Even if we don't have tracked processes, clean up any orphaned ones
+            self._cleanup_orphaned_port_forwards()
+            return
+
+        print(f"Stopping {len(self.port_forward_processes)} port forward(s)...")
+
+        for process, description in self.port_forward_processes:
+            try:
+                print(f"  Stopping {description} (PID: {process.pid})...")
+                # Kill the entire process group (bash wrapper + kubectl children)
+                pgid = os.getpgid(process.pid)
+                os.killpg(pgid, signal.SIGTERM)
+
+                # Wait for graceful termination
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    print("    Port forward didn't terminate, force killing...")
+                    # Force kill if necessary
+                    try:
+                        os.killpg(pgid, signal.SIGKILL)
+                        process.wait(timeout=2)
+                    except Exception:
+                        pass
+            except ProcessLookupError:
+                # Process already terminated
+                print(f"    Process {process.pid} already terminated")
+            except Exception as e:
+                print(f"    Warning: Error stopping port forward: {e}")
+                # Fallback: try to kill just the parent process
+                try:
+                    process.kill()
+                except Exception:
+                    pass
+
+        self.port_forward_processes = []
+
+        # Final cleanup: kill any orphaned port-forward processes for this namespace
+        self._cleanup_orphaned_port_forwards()
+
+    def _cleanup_orphaned_port_forwards(self) -> None:
+        """
+        Clean up any orphaned port-forward processes for this namespace.
+
+        This is a fallback cleanup that searches for and kills any remaining
+        kubectl port-forward processes that are forwarding services in our namespace.
+        """
+        print(f"Checking for orphaned port-forward processes in namespace '{self.namespace}'...")
+
+        try:
+            # Find all port-forward processes for this namespace
+            # The command line will contain: "port-forward -n <namespace>"
+            search_pattern = f"port-forward.*-n {self.namespace}"
+
+            # Use pgrep to find matching processes
+            pgrep_cmd = ["pgrep", "-f", search_pattern]
+            result = subprocess.run(pgrep_cmd, capture_output=True, text=True)
+
+            if result.returncode == 0 and result.stdout.strip():
+                pids = result.stdout.strip().split("\n")
+                print(f"  Found {len(pids)} orphaned port-forward process(es), cleaning up...")
+
+                for pid in pids:
+                    try:
+                        pid_int = int(pid)
+                        print(f"    Killing PID {pid_int}...")
+
+                        # Use sudo if configured (same as kubectl commands)
+                        if self.kubectl_sudo:
+                            # Kill with sudo
+                            subprocess.run(["sudo", "kill", "-TERM", str(pid_int)], stderr=subprocess.DEVNULL)
+                            time.sleep(1)
+                            # Force kill if still running
+                            subprocess.run(["sudo", "kill", "-9", str(pid_int)], stderr=subprocess.DEVNULL)
+                        else:
+                            # Kill without sudo - try process group first
+                            try:
+                                pgid = os.getpgid(pid_int)
+                                os.killpg(pgid, signal.SIGTERM)
+                                time.sleep(1)
+                                # Force kill if still running
+                                try:
+                                    os.killpg(pgid, signal.SIGKILL)
+                                except ProcessLookupError:
+                                    pass  # Already dead
+                            except (ProcessLookupError, PermissionError):
+                                # Process group kill failed, try individual process
+                                try:
+                                    os.kill(pid_int, signal.SIGTERM)
+                                    time.sleep(1)
+                                    os.kill(pid_int, signal.SIGKILL)
+                                except ProcessLookupError:
+                                    pass  # Already dead
+                                except PermissionError:
+                                    print("      Permission denied (sudo not enabled in config)")
+                    except (ValueError, Exception) as e:
+                        print(f"      Warning: Could not kill PID {pid}: {e}")
+
+                print("  Orphaned process cleanup complete")
+            else:
+                print("  No orphaned port-forward processes found")
+
+        except FileNotFoundError:
+            # pgrep not available, try alternative method with ps
+            print("  pgrep not found, trying ps...")
+            try:
+                ps_cmd = ["ps", "aux"]
+                result = subprocess.run(ps_cmd, capture_output=True, text=True)
+
+                if result.returncode == 0:
+                    lines = result.stdout.split("\n")
+                    pids_to_kill = []
+
+                    for line in lines:
+                        if "port-forward" in line and f"-n {self.namespace}" in line:
+                            # Extract PID (second column in ps aux output)
+                            parts = line.split()
+                            if len(parts) >= 2:
+                                try:
+                                    pids_to_kill.append(int(parts[1]))
+                                except ValueError:
+                                    continue
+
+                    if pids_to_kill:
+                        print(f"  Found {len(pids_to_kill)} orphaned port-forward process(es), cleaning up...")
+                        for pid in pids_to_kill:
+                            try:
+                                print(f"    Killing PID {pid}...")
+
+                                # Use sudo if configured (same as kubectl commands)
+                                if self.kubectl_sudo:
+                                    # Kill with sudo
+                                    subprocess.run(["sudo", "kill", "-TERM", str(pid)], stderr=subprocess.DEVNULL)
+                                    time.sleep(0.5)
+                                    subprocess.run(["sudo", "kill", "-9", str(pid)], stderr=subprocess.DEVNULL)
+                                else:
+                                    # Kill without sudo
+                                    try:
+                                        os.kill(pid, signal.SIGTERM)
+                                        time.sleep(0.5)
+                                        try:
+                                            os.kill(pid, signal.SIGKILL)
+                                        except ProcessLookupError:
+                                            pass
+                                    except PermissionError:
+                                        print("      Permission denied (sudo not enabled in config)")
+                                    except ProcessLookupError:
+                                        pass
+                            except Exception as e:
+                                print(f"      Warning: Could not kill PID {pid}: {e}")
+                        print("  Orphaned process cleanup complete")
+                    else:
+                        print("  No orphaned port-forward processes found")
+            except Exception as e:
+                print(f"  Warning: Could not check for orphaned processes: {e}")
+        except Exception as e:
+            print(f"  Warning: Error during orphaned process cleanup: {e}")
+
+    def print_port_forward_commands(self) -> None:
+        """Print commands to manually recreate port forwards."""
+        port_forwards = getattr(self.config, "helm_port_forwards", None)
+        if not port_forwards:
+            port_forwards = [
+                {
+                    "service": self.release_name,
+                    "local_port": 7670,
+                    "remote_port": 7670,
+                }
+            ]
+
+        # Group port forwards by service (same as _start_port_forwards)
+        service_port_map = {}
+
+        for pf in port_forwards:
+            service_pattern = pf.get("service")
+            local = pf.get("local_port")
+            remote = pf.get("remote_port")
+
+            if not all([service_pattern, local, remote]):
+                continue
+
+            # Find matching services
+            service_names = self._find_services_by_pattern(service_pattern)
+
+            # Add ports to each matching service
+            for service_name in service_names:
+                if service_name not in service_port_map:
+                    service_port_map[service_name] = []
+                service_port_map[service_name].append((local, remote))
+
+        print("\nTo manually recreate port forwards (with auto-restart), run:")
+        print("=" * 60)
+        for service_name, port_pairs in service_port_map.items():
+            port_strs = [f"{local}:{remote}" for local, remote in port_pairs]
+            kubectl_cmd_str = " ".join(self.kubectl_cmd)
+            ports_arg = " ".join(port_strs)
+            # Show resilient version with auto-restart loop
+            print(f"  # Auto-restarting port-forward for {service_name}:")
+            print(
+                (
+                    f"  while true; do {kubectl_cmd_str} port-forward -n {self.namespace} "
+                    f"service/{service_name} {ports_arg}; sleep 5; done &"
+                )
+            )
+            print()
+        print("=" * 60)
+
+    def stop(self, clean: bool = False) -> int:
+        """
+        Uninstall Helm release.
+
+        Note: Port forwards should be stopped separately via _stop_port_forwards()
+        to allow keeping services up while cleaning up port-forward processes.
+
+        Args:
+            clean: If True, also delete the namespace (full cleanup)
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        print(f"Uninstalling Helm release {self.release_name}...")
+
+        # Stop port forwards first
+        self._stop_port_forwards()
+
+        cmd = self.helm_cmd + ["uninstall", self.release_name, "--namespace", self.namespace]
+
+        rc = run_cmd(cmd)
+        if rc != 0:
+            print(f"Warning: helm uninstall returned {rc}")
+
+        # If clean mode, also delete the namespace for a complete cleanup
+        if clean:
+            print(f"Deleting namespace {self.namespace}...")
+            kubectl_cmd = self.kubectl_cmd + ["delete", "namespace", self.namespace, "--ignore-not-found"]
+            rc2 = run_cmd(kubectl_cmd)
+            if rc2 != 0:
+                print(f"Warning: kubectl delete namespace returned {rc2}")
+
+        return 0
+
+    def check_readiness(self, timeout_s: int, check_milvus: bool = True, check_embedding: bool = True) -> bool:
+        """
+        Check readiness by polling HTTP endpoint.
+
+        Args:
+            timeout_s: Timeout in seconds
+            check_milvus: If True, also check Milvus health endpoint
+            check_embedding: If True, also check embedding service health endpoint
+
+        Returns:
+            True if ready, False on timeout
+        """
+        url = self.get_service_url("health")
+        deadline = time.time() + timeout_s
+
+        while time.time() < deadline:
+            try:
+                # Check main service health
+                with urllib.request.urlopen(url, timeout=5) as resp:
+                    if resp.status == 200:
+                        all_services_ready = True
+
+                        # If Milvus check is enabled, verify it's also ready
+                        if check_milvus:
+                            hostname = getattr(self.config, "hostname", "localhost")
+                            milvus_url = f"http://{hostname}:9091/healthz"
+                            try:
+                                with urllib.request.urlopen(milvus_url, timeout=5) as milvus_resp:
+                                    if milvus_resp.status != 200:
+                                        all_services_ready = False
+                            except Exception:
+                                all_services_ready = False
+
+                        # If embedding check is enabled, verify it's also ready
+                        if check_embedding:
+                            hostname = getattr(self.config, "hostname", "localhost")
+                            embedding_url = f"http://{hostname}:8012/v1/health/ready"
+                            try:
+                                with urllib.request.urlopen(embedding_url, timeout=5) as embedding_resp:
+                                    if embedding_resp.status != 200:
+                                        all_services_ready = False
+                            except Exception:
+                                all_services_ready = False
+
+                        if all_services_ready:
+                            return True
+            except Exception:
+                pass
+            time.sleep(3)
+        return False
+
+    def get_service_url(self, service: str = "api") -> str:
+        """
+        Get service URL for Helm deployment.
+
+        Args:
+            service: Service name ("api" or "health")
+
+        Returns:
+            URL string
+        """
+        # Use hostname from config
+        # For Helm deployments, this is the port-forwarded localhost
+        hostname = getattr(self.config, "hostname", "localhost")
+
+        if service == "health":
+            return f"http://{hostname}:7670/v1/health/ready"
+        return f"http://{hostname}:7670"
+
+    def dump_logs(self, artifacts_dir: Path) -> int:
+        """
+        Dump logs of all Helm-managed pods to artifacts directory.
+
+        Args:
+            artifacts_dir: Directory to write log files to
+
+        Returns:
+            0 on success, non-zero on failure
+        """
+        print(f"Dumping Helm pod logs to {artifacts_dir}...")
+
+        # Ensure artifacts directory exists
+        artifacts_dir = Path(artifacts_dir)
+        artifacts_dir.mkdir(parents=True, exist_ok=True)
+
+        # Get list of pods in the namespace
+        get_pods_cmd = self.kubectl_cmd + [
+            "get",
+            "pods",
+            "-n",
+            self.namespace,
+            "-o",
+            'jsonpath={range .items[*]}{.metadata.name}{"\\n"}{end}',
+        ]
+
+        try:
+            result = subprocess.run(get_pods_cmd, capture_output=True, text=True, timeout=30)
+            if result.returncode != 0:
+                print(f"Warning: Could not list pods: {result.stderr.strip()}")
+                return result.returncode
+
+            pod_names = [name.strip() for name in result.stdout.strip().split("\n") if name.strip()]
+
+            if not pod_names:
+                print(f"No pods found in namespace {self.namespace}")
+                return 0
+
+            print(f"Found {len(pod_names)} pod(s) to dump logs from")
+
+            # Dump logs for each pod
+            for pod_name in pod_names:
+                # Get containers in the pod
+                get_containers_cmd = self.kubectl_cmd + [
+                    "get",
+                    "pod",
+                    pod_name,
+                    "-n",
+                    self.namespace,
+                    "-o",
+                    "jsonpath={.spec.containers[*].name}",
+                ]
+                containers_result = subprocess.run(get_containers_cmd, capture_output=True, text=True, timeout=10)
+
+                if containers_result.returncode != 0:
+                    print(f"  Warning: Could not list containers for pod {pod_name}")
+                    container_names = [""]  # Try to get logs without specifying container
+                else:
+                    container_names = containers_result.stdout.strip().split()
+
+                # Dump logs for each container in the pod
+                for container_name in container_names:
+                    if container_name:
+                        log_file = artifacts_dir / f"pod_{pod_name}_{container_name}.log"
+                        print(f"  Dumping logs for pod {pod_name}, container {container_name} to {log_file.name}")
+                        logs_cmd = self.kubectl_cmd + [
+                            "logs",
+                            pod_name,
+                            "-n",
+                            self.namespace,
+                            "-c",
+                            container_name,
+                            "--timestamps",
+                        ]
+                    else:
+                        log_file = artifacts_dir / f"pod_{pod_name}.log"
+                        print(f"  Dumping logs for pod {pod_name} to {log_file.name}")
+                        logs_cmd = self.kubectl_cmd + ["logs", pod_name, "-n", self.namespace, "--timestamps"]
+
+                    with open(log_file, "w") as f:
+                        log_result = subprocess.run(logs_cmd, stdout=f, stderr=subprocess.STDOUT, timeout=60)
+                        if log_result.returncode != 0:
+                            print(f"    Warning: Failed to dump logs for {pod_name}/{container_name or 'default'}")
+
+                    # Also try to get previous logs if container restarted
+                    if container_name:
+                        prev_log_file = artifacts_dir / f"pod_{pod_name}_{container_name}_previous.log"
+                        prev_logs_cmd = self.kubectl_cmd + [
+                            "logs",
+                            pod_name,
+                            "-n",
+                            self.namespace,
+                            "-c",
+                            container_name,
+                            "--previous",
+                            "--timestamps",
+                        ]
+                    else:
+                        prev_log_file = artifacts_dir / f"pod_{pod_name}_previous.log"
+                        prev_logs_cmd = self.kubectl_cmd + [
+                            "logs",
+                            pod_name,
+                            "-n",
+                            self.namespace,
+                            "--previous",
+                            "--timestamps",
+                        ]
+
+                    # Try to get previous logs (will fail if container hasn't restarted)
+                    prev_result = subprocess.run(
+                        prev_logs_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=60
+                    )
+                    if prev_result.returncode == 0 and prev_result.stdout:
+                        with open(prev_log_file, "wb") as f:
+                            f.write(prev_result.stdout)
+                        print(f"    Also dumped previous logs to {prev_log_file.name}")
+
+            # Dump pod status information
+            status_file = artifacts_dir / "pod_status.txt"
+            print(f"  Dumping pod status to {status_file.name}")
+            status_cmd = self.kubectl_cmd + ["get", "pods", "-n", self.namespace, "-o", "wide"]
+            with open(status_file, "w") as f:
+                subprocess.run(status_cmd, stdout=f, stderr=subprocess.STDOUT, timeout=30)
+
+            # Dump pod events
+            events_file = artifacts_dir / "pod_events.txt"
+            print(f"  Dumping pod events to {events_file.name}")
+            events_cmd = self.kubectl_cmd + ["get", "events", "-n", self.namespace, "--sort-by=.lastTimestamp"]
+            with open(events_file, "w") as f:
+                subprocess.run(events_cmd, stdout=f, stderr=subprocess.STDOUT, timeout=30)
+
+            # Dump environment variables for each pod
+            print("  Dumping pod environment variables...")
+            for pod_name in pod_names:
+                # Get containers in the pod
+                get_containers_cmd = self.kubectl_cmd + [
+                    "get",
+                    "pod",
+                    pod_name,
+                    "-n",
+                    self.namespace,
+                    "-o",
+                    "jsonpath={.spec.containers[*].name}",
+                ]
+                containers_result = subprocess.run(get_containers_cmd, capture_output=True, text=True, timeout=10)
+
+                if containers_result.returncode != 0:
+                    print(f"    Warning: Could not list containers for pod {pod_name}")
+                    container_names = []
+                else:
+                    container_names = containers_result.stdout.strip().split()
+
+                # Dump env vars for each container in the pod
+                for container_name in container_names:
+                    env_file = artifacts_dir / f"pod_{pod_name}_{container_name}_env.txt"
+                    print(f"    Dumping env vars for pod {pod_name}, container {container_name} to {env_file.name}")
+
+                    # Get environment variables using kubectl exec
+                    # Note: We use 'env' command which is typically available in most containers
+                    env_cmd = self.kubectl_cmd + [
+                        "exec",
+                        pod_name,
+                        "-n",
+                        self.namespace,
+                        "-c",
+                        container_name,
+                        "--",
+                        "env",
+                    ]
+
+                    with open(env_file, "w") as f:
+                        env_result = subprocess.run(env_cmd, stdout=f, stderr=subprocess.STDOUT, timeout=30)
+                        if env_result.returncode != 0:
+                            # If exec fails, try to get env from pod spec instead
+                            print("      Warning: Could not exec into container, trying to get env from pod spec...")
+                            spec_env_cmd = self.kubectl_cmd + [
+                                "get",
+                                "pod",
+                                pod_name,
+                                "-n",
+                                self.namespace,
+                                "-o",
+                                f"jsonpath={{.spec.containers[?(@.name=='{container_name}')].env[*]}}",
+                            ]
+                            spec_result = subprocess.run(
+                                spec_env_cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, timeout=30
+                            )
+                            if spec_result.returncode == 0 and spec_result.stdout:
+                                with open(env_file, "wb") as spec_f:
+                                    spec_f.write(
+                                        b"# Environment variables from pod spec (may not include all runtime env "
+                                        b"vars)\n"
+                                    )
+                                    spec_f.write(spec_result.stdout)
+                                print(f"      Dumped env vars from pod spec to {env_file.name}")
+                            else:
+                                print(f"      Warning: Failed to dump env vars for {pod_name}/{container_name}")
+
+            print("Log dump complete")
+            return 0
+
+        except subprocess.TimeoutExpired:
+            print("Error: Timeout while dumping logs")
+            return 1
+        except Exception as e:
+            print(f"Error: Failed to dump logs: {e}")
+            return 1
diff --git a/tools/harness/src/nv_ingest_harness/sinks/slack.py b/tools/harness/src/nv_ingest_harness/sinks/slack.py
index 03476436c..c5e0adba0 100644
--- a/tools/harness/src/nv_ingest_harness/sinks/slack.py
+++ b/tools/harness/src/nv_ingest_harness/sinks/slack.py
@@ -28,6 +28,11 @@
     "recall_multimodal_@5_reranker",
 ]
 
+# Slack user ID mapping for tagging users in notifications
+PIC_DICT = {
+    "randy": "U9TBF6WT0",
+}
+
 
 class SlackSink(Sink):
     """Slack sink that posts table-formatted results using Block Kit."""
@@ -43,6 +48,8 @@ def __init__(self, sink_config: dict[str, Any]):
             self.enabled = False
 
         self.default_metrics = sink_config.get("default_metrics", DEFAULT_METRICS)
+        # Users to tag in Slack notifications (list of names from PIC_DICT)
+        self.users_to_tag = sink_config.get("users_to_tag", [])
         self.session_name: str | None = None
         self.env_data: dict[str, Any] = {}
         self.results_to_report: list[dict[str, Any]] = []
@@ -173,21 +180,45 @@ def _post(self) -> bool:
 
         table_dict = {"type": "table", "rows": rows}
         exec_summary = f"Session: `{self.session_name}`"
+
+        blocks = [
+            {
+                "type": "header",
+                "text": {"type": "plain_text", "text": "nv-ingest Nightly Benchmark Summary"},
+            },
+            {
+                "type": "section",
+                "text": {"type": "mrkdwn", "text": exec_summary},
+            },
+            {"type": "divider"},
+            table_dict,
+        ]
+
+        # Add user mentions if configured
+        if self.users_to_tag:
+            user_mentions = []
+            for user_name in self.users_to_tag:
+                if user_name in PIC_DICT:
+                    user_id = PIC_DICT[user_name]
+                    user_mentions.append(f"<@{user_id}>")
+
+            if user_mentions:
+                blocks.append(
+                    {
+                        "type": "context",
+                        "elements": [
+                            {
+                                "type": "mrkdwn",
+                                "text": f"cc {' '.join(user_mentions)}",
+                            }
+                        ],
+                    }
+                )
+
         payload = {
             "username": "nv-ingest Benchmark Runner",
             "icon_emoji": ":rocket:",
-            "blocks": [
-                {
-                    "type": "header",
-                    "text": {"type": "plain_text", "text": "nv-ingest Nightly Benchmark Summary"},
-                },
-                {
-                    "type": "section",
-                    "text": {"type": "mrkdwn", "text": exec_summary},
-                },
-                {"type": "divider"},
-                table_dict,
-            ],
+            "blocks": blocks,
         }
         return self._post_payload(payload)
 
diff --git a/tools/harness/src/nv_ingest_harness/utils/docker.py b/tools/harness/src/nv_ingest_harness/utils/docker.py
deleted file mode 100644
index b5a88c91a..000000000
--- a/tools/harness/src/nv_ingest_harness/utils/docker.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# Copyright (c) 2025, NVIDIA CORPORATION.
-# SPDX-License-Identifier: Apache-2.0
-"""Shared Docker service management utilities."""
-
-import subprocess
-import time
-import urllib.request
-from pathlib import Path
-
-REPO_ROOT = Path(__file__).resolve().parents[5]
-COMPOSE_FILE = REPO_ROOT / "docker-compose.yaml"
-HEALTH_URL = "http://localhost:7670/v1/health/ready"
-
-# Default profiles for nv-ingest services
-DEFAULT_PROFILES = ["retrieval", "table-structure"]
-
-
-def run_cmd(cmd: list[str], cwd: Path | None = None) -> int:
-    print("$", " ".join(str(c) for c in cmd))
-    return subprocess.call(cmd, cwd=cwd)
-
-
-def stop_services(profiles: list[str] | None = None) -> int:
-    print("Stopping services...")
-    profile_args = _build_profile_args(profiles or ["*"])
-
-    down_cmd = ["docker", "compose", "-f", str(COMPOSE_FILE)] + profile_args + ["down"]
-    rc = run_cmd(down_cmd, cwd=REPO_ROOT)
-    if rc != 0:
-        print(f"Warning: docker compose down returned {rc}")
-
-    rm_cmd = ["docker", "compose", "-f", str(COMPOSE_FILE)] + profile_args + ["rm", "--force"]
-    rc = run_cmd(rm_cmd, cwd=REPO_ROOT)
-    if rc != 0:
-        print(f"Warning: docker compose rm returned {rc}")
-
-    return 0
-
-
-def clean_services() -> int:
-    print("Cleaning up containers, networks, and volumes...")
-    cmd = ["docker", "compose", "-f", str(COMPOSE_FILE), "--profile", "*", "down", "-v", "--remove-orphans"]
-    run_cmd(cmd, cwd=REPO_ROOT)
-
-    rm_cmd = ["docker", "compose", "-f", str(COMPOSE_FILE), "--profile", "*", "rm", "--force"]
-    run_cmd(rm_cmd, cwd=REPO_ROOT)
-
-    print("Cleanup completed!")
-    return 0
-
-
-def start_services(profiles: list[str] | None = None, build: bool = False) -> int:
-    profiles = profiles or DEFAULT_PROFILES
-    profile_args = _build_profile_args(profiles)
-
-    cmd = ["docker", "compose", "-f", str(COMPOSE_FILE)] + profile_args
-    if build:
-        cmd += ["up", "--force-recreate", "--build", "-d"]
-    else:
-        cmd += ["up", "--force-recreate", "-d"]
-
-    print(f"Starting services with profiles: {profiles}")
-    return run_cmd(cmd, cwd=REPO_ROOT)
-
-
-def readiness_wait(timeout_s: int = 600, check_milvus: bool = True) -> bool:
-    print(f"Waiting for nv-ingest to be ready (timeout: {timeout_s}s)...")
-    deadline = time.time() + timeout_s
-
-    while time.time() < deadline:
-        try:
-            with urllib.request.urlopen(HEALTH_URL, timeout=5) as resp:
-                if resp.status == 200:
-                    print("nv-ingest is ready!")
-                    break
-        except Exception:
-            pass
-        time.sleep(3)
-    else:
-        print("Warning: nv-ingest did not become ready within timeout")
-        return False
-
-    if check_milvus:
-        if not milvus_readiness_wait(timeout_s=min(60, int(deadline - time.time()))):
-            return False
-
-    return True
-
-
-def milvus_readiness_wait(timeout_s: int = 60, uri: str = "http://localhost:19530") -> bool:
-    print(f"Waiting for Milvus to be ready (timeout: {timeout_s}s)...")
-    deadline = time.time() + timeout_s
-
-    while time.time() < deadline:
-        try:
-            from pymilvus import MilvusClient
-
-            client = MilvusClient(uri=uri)
-            client.list_collections()
-            client.close()
-            print("Milvus is ready!")
-            return True
-        except Exception:
-            pass
-        time.sleep(2)
-
-    print("Warning: Milvus did not become ready within timeout")
-    return False
-
-
-def restart_services(
-    profiles: list[str] | None = None,
-    build: bool = False,
-    timeout: int = 600,
-    clean: bool = True,
-) -> int:
-    print("Restarting services" + (" (with build)" if build else ""))
-
-    if clean:
-        clean_services()
-    else:
-        stop_services(profiles)
-
-    rc = start_services(profiles, build=build)
-    if rc != 0:
-        print(f"Failed to start services (exit code: {rc})")
-        return rc
-
-    if not readiness_wait(timeout):
-        return 1
-
-    return 0
-
-
-def _build_profile_args(profiles: list[str]) -> list[str]:
-    args = []
-    for p in profiles:
-        args += ["--profile", p]
-    return args
diff --git a/tools/harness/src/nv_ingest_harness/utils/interact.py b/tools/harness/src/nv_ingest_harness/utils/interact.py
index cd387036d..5a29f3bb5 100644
--- a/tools/harness/src/nv_ingest_harness/utils/interact.py
+++ b/tools/harness/src/nv_ingest_harness/utils/interact.py
@@ -1,5 +1,3 @@
-import docker
-
 import glob
 import inspect
 import json
@@ -7,55 +5,93 @@
 import shutil
 import time
 import zipfile
+import urllib.request
+import urllib.error
 
 from pathlib import Path
 
-from pymilvus import MilvusClient
-
-import pypdfium2 as pdfium
 import subprocess
 import datetime
 import socket
 
 
-def check_container_running(container_name):
-    """Check if a container with the specified name is currently running.
+def run_cmd(cmd: list[str], cwd: Path | None = None) -> int:
+    print("$", " ".join(str(c) for c in cmd))
+    return subprocess.call(cmd, cwd=cwd)
+
+
+def embed_info(
+    max_retries: int = 5,
+    initial_backoff: float = 1.0,
+    backoff_multiplier: float = 2.0,
+    request_timeout: float = 2.0,
+):
+    """Get embedding model information from the embedding service.
+
+    This function attempts to query the embedding service API at localhost:8012
+    to get the model name with retry logic and exponential backoff.
 
     Args:
-        container_name (str): The name or partial name to search for in container image tags.
+        max_retries: Maximum number of retry attempts (default: 5)
+        initial_backoff: Initial backoff time in seconds (default: 1.0)
+        backoff_multiplier: Multiplier for exponential backoff (default: 2.0)
+        request_timeout: Timeout for each request in seconds (default: 2.0)
 
     Returns:
-        bool: True if a container with the specified name is running, False otherwise.
+        tuple: A tuple containing (model_name: str, embedding_dimension: int).
+               Returns a default model if the embedding service is not available after retries.
     """
-    client = docker.from_env()
-    containers = client.containers.list()
-
-    for container in containers:
-        if container.image.tags and container_name in container.image.tags[0]:
-            return True
+    # Model name to embedding dimension mapping
+    MODEL_DIMENSIONS = {
+        "nvidia/llama-3.2-nemoretriever-1b-vlm-embed-v1": 2048,
+        "nvidia/llama-3.2-nv-embedqa-1b-v2": 2048,
+        "nvidia/llama-3.2-nemoretriever-300m-embed-v1": 2048,
+        "nvidia/nv-embedqa-e5-v5": 1024,
+    }
 
-    return False
+    # Default model
+    DEFAULT_MODEL = "nvidia/nv-embedqa-e5-v5"
+    DEFAULT_DIMENSION = 1024
 
+    url = "http://localhost:8012/v1/models"
 
-def embed_info():
-    """Get embedding model information based on currently running containers.
+    # Try to fetch model info from embedding service API with retry/backoff
+    for attempt in range(max_retries):
+        should_retry = False
 
-    This function checks for specific embedding model containers and returns
-    the appropriate model name and embedding dimension based on which container
-    is currently running.
-
-    Returns:
-        tuple: A tuple containing (model_name: str, embedding_dimension: int).
-               Returns a default model if no specific containers are found.
-    """
-    if check_container_running("llama-3.2-nemoretriever-1b-vlm-embed-v1"):
-        return "nvidia/llama-3.2-nemoretriever-1b-vlm-embed-v1", 2048
-    elif check_container_running("llama-3.2-nv-embedqa-1b-v2"):
-        return "nvidia/llama-3.2-nv-embedqa-1b-v2", 2048
-    elif check_container_running("llama-3.2-nemoretriever-300m-embed-v1"):
-        return "nvidia/llama-3.2-nemoretriever-300m-embed-v1", 2048
-    else:
-        return "nvidia/nv-embedqa-e5-v5", 1024
+        try:
+            with urllib.request.urlopen(url, timeout=request_timeout) as response:
+                # Check if we got a successful response
+                if response.status != 200:
+                    # Non-200 response should trigger retry
+                    should_retry = True
+                else:
+                    data = json.loads(response.read().decode("utf-8"))
+                    # Check if we got valid data
+                    if data.get("data") and len(data["data"]) > 0:
+                        model_name = data["data"][0].get("id")
+                        if model_name:
+                            dimension = MODEL_DIMENSIONS.get(model_name, DEFAULT_DIMENSION)
+                            return model_name, dimension
+                    # Got 200 but incomplete/invalid data - retry
+                    should_retry = True
+
+        except Exception:
+            # Any exception should trigger retry
+            should_retry = True
+
+        # If we need to retry and haven't exhausted attempts, backoff and continue
+        if should_retry:
+            if attempt == max_retries - 1:
+                # Last attempt failed, fall back to defaults
+                return DEFAULT_MODEL, DEFAULT_DIMENSION
+
+            # Calculate backoff time with exponential increase
+            backoff_time = initial_backoff * (backoff_multiplier**attempt)
+            time.sleep(backoff_time)
+
+    # Fallback if we somehow exit the loop without returning
+    return DEFAULT_MODEL, DEFAULT_DIMENSION
 
 
 def clean_spill(path: str):
@@ -231,129 +267,6 @@ def kv_event_log(key, val, log_path: str = "test_results"):
         json.dump(data, fp, indent=2)
 
 
-def unload_collection(milvus_uri: str, collection_name: str):
-    """Unload/release a Milvus collection from memory.
-
-    This function connects to a Milvus instance and releases the specified
-    collection from memory, freeing up resources.
-
-    Args:
-      milvus_uri (str): The URI connection string for the Milvus instance.
-      collection_name (str): The name of the collection to unload.
-    """
-    try:
-        client = MilvusClient(uri=milvus_uri)
-        client.release_collection(collection_name=collection_name)
-    except Exception as e:
-        kv_event_log(f"{collection_name}_unload_error", str(e))
-        print(f"Error unloading collection {collection_name}: {e}")
-
-
-def load_collection(milvus_uri: str, collection_name: str):
-    """Load a Milvus collection into memory.
-
-    This function connects to a Milvus instance and loads the specified
-    collection into memory for querying and operations.
-
-    Args:
-      milvus_uri (str): The URI connection string for the Milvus instance.
-      collection_name (str): The name of the collection to load.
-    """
-    try:
-        client = MilvusClient(uri=milvus_uri)
-        client.load_collection(collection_name)
-    except Exception as e:
-        kv_event_log(f"{collection_name}_load_error", str(e))
-        print(f"Error loading collection {collection_name}: {e}")
-
-
-def milvus_chunks(milvus_uri: str, collection_name: str):
-    """Get and log statistics about chunks in a Milvus collection.
-
-    This function connects to a Milvus instance, retrieves collection statistics,
-    logs the chunk information using the event logging system, and closes the connection.
-
-    Args:
-      milvus_uri (str): The URI connection string for the Milvus instance.
-      collection_name (str): The name of the collection to get statistics for.
-
-    Returns:
-      dict: A dictionary containing the collection statistics.
-    """
-    try:
-        client = MilvusClient(uri=milvus_uri)
-        stats = client.get_collection_stats(collection_name)
-        kv_event_log(f"{collection_name}_chunks", f"{stats}")
-        client.close()
-    except Exception as e:
-        kv_event_log(f"{collection_name}_chunks_error", str(e))
-        print(f"Error getting collection stats for {collection_name}: {e}")
-        stats = {}
-    return stats
-
-
-def pdf_page_count_glob(pattern: str) -> int:
-    """Count the total number of pages in all PDF files matching a glob pattern.
-
-    This function searches for PDF files using a glob pattern and counts the total
-    number of pages across all matching files.
-
-    Args:
-        pattern (str): A glob pattern to match PDF files (supports recursive search).
-
-    Returns:
-        int: The total number of pages across all matching PDF files.
-    """
-    total_pages = 0
-    for filepath in glob.glob(pattern, recursive=True):
-        if filepath.lower().endswith(".pdf"):
-            pdf = pdfium.PdfDocument(filepath)
-            total_pages += len(pdf)
-    return total_pages
-
-
-def pdf_page_count(path: str) -> int:
-    """Count the total number of pages in PDF file(s).
-
-    This function handles both single PDF files and directories containing PDFs.
-    For a file path, it counts pages in that specific PDF.
-    For a directory path, it recursively scans for all PDF files and counts total pages.
-    If a PDF file cannot be processed, an error message is printed and the file is skipped.
-
-    Args:
-        path (str): Path to a PDF file or directory containing PDF files.
-
-    Returns:
-        int: The total number of pages across all PDF files.
-    """
-    total_pages = 0
-
-    # Handle single file
-    if os.path.isfile(path):
-        if path.lower().endswith(".pdf"):
-            try:
-                pdf = pdfium.PdfDocument(path)
-                total_pages = len(pdf)
-            except Exception as e:
-                print(f"{path} failed: {e}")
-        return total_pages
-
-    # Handle directory - recursively search for PDFs
-    if os.path.isdir(path):
-        for root, _, files in os.walk(path):
-            for filename in files:
-                if filename.lower().endswith(".pdf"):
-                    filepath = os.path.join(root, filename)
-                    try:
-                        pdf = pdfium.PdfDocument(filepath)
-                        total_pages += len(pdf)
-                    except Exception as e:
-                        print(f"{filepath} failed: {e}")
-                        continue
-
-    return total_pages
-
-
 def segment_results(results):
     """Segment nv-ingest results into text, table, and chart categories.
 
diff --git a/tools/harness/src/nv_ingest_harness/utils/milvus.py b/tools/harness/src/nv_ingest_harness/utils/milvus.py
new file mode 100644
index 000000000..56ab87a6f
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/utils/milvus.py
@@ -0,0 +1,70 @@
+"""Milvus-specific utility functions.
+
+This module contains utilities that depend on pymilvus and are only needed
+for ingestion benchmarking workflows.
+"""
+
+from pymilvus import MilvusClient
+
+from nv_ingest_harness.utils.interact import kv_event_log
+
+
+def unload_collection(milvus_uri: str, collection_name: str):
+    """Unload/release a Milvus collection from memory.
+
+    This function connects to a Milvus instance and releases the specified
+    collection from memory, freeing up resources.
+
+    Args:
+      milvus_uri (str): The URI connection string for the Milvus instance.
+      collection_name (str): The name of the collection to unload.
+    """
+    try:
+        client = MilvusClient(uri=milvus_uri)
+        client.release_collection(collection_name=collection_name)
+    except Exception as e:
+        kv_event_log(f"{collection_name}_unload_error", str(e))
+        print(f"Error unloading collection {collection_name}: {e}")
+
+
+def load_collection(milvus_uri: str, collection_name: str):
+    """Load a Milvus collection into memory.
+
+    This function connects to a Milvus instance and loads the specified
+    collection into memory for querying and operations.
+
+    Args:
+      milvus_uri (str): The URI connection string for the Milvus instance.
+      collection_name (str): The name of the collection to load.
+    """
+    try:
+        client = MilvusClient(uri=milvus_uri)
+        client.load_collection(collection_name)
+    except Exception as e:
+        kv_event_log(f"{collection_name}_load_error", str(e))
+        print(f"Error loading collection {collection_name}: {e}")
+
+
+def milvus_chunks(milvus_uri: str, collection_name: str):
+    """Get and log statistics about chunks in a Milvus collection.
+
+    This function connects to a Milvus instance, retrieves collection statistics,
+    logs the chunk information using the event logging system, and closes the connection.
+
+    Args:
+      milvus_uri (str): The URI connection string for the Milvus instance.
+      collection_name (str): The name of the collection to get statistics for.
+
+    Returns:
+      dict: A dictionary containing the collection statistics.
+    """
+    try:
+        client = MilvusClient(uri=milvus_uri)
+        stats = client.get_collection_stats(collection_name)
+        kv_event_log(f"{collection_name}_chunks", f"{stats}")
+        client.close()
+    except Exception as e:
+        kv_event_log(f"{collection_name}_chunks_error", str(e))
+        print(f"Error getting collection stats for {collection_name}: {e}")
+        stats = {}
+    return stats
diff --git a/tools/harness/src/nv_ingest_harness/utils/pdf.py b/tools/harness/src/nv_ingest_harness/utils/pdf.py
new file mode 100644
index 000000000..8755e5043
--- /dev/null
+++ b/tools/harness/src/nv_ingest_harness/utils/pdf.py
@@ -0,0 +1,72 @@
+"""PDF utility functions using pypdfium2.
+
+This module contains utilities that depend on pypdfium2 and are only needed
+for PDF-based benchmarking workflows.
+"""
+
+import glob
+import os
+
+import pypdfium2 as pdfium
+
+
+def pdf_page_count_glob(pattern: str) -> int:
+    """Count the total number of pages in all PDF files matching a glob pattern.
+
+    This function searches for PDF files using a glob pattern and counts the total
+    number of pages across all matching files.
+
+    Args:
+        pattern (str): A glob pattern to match PDF files (supports recursive search).
+
+    Returns:
+        int: The total number of pages across all matching PDF files.
+    """
+    total_pages = 0
+    for filepath in glob.glob(pattern, recursive=True):
+        if filepath.lower().endswith(".pdf"):
+            pdf = pdfium.PdfDocument(filepath)
+            total_pages += len(pdf)
+    return total_pages
+
+
+def pdf_page_count(path: str) -> int:
+    """Count the total number of pages in PDF file(s).
+
+    This function handles both single PDF files and directories containing PDFs.
+    For a file path, it counts pages in that specific PDF.
+    For a directory path, it recursively scans for all PDF files and counts total pages.
+    If a PDF file cannot be processed, an error message is printed and the file is skipped.
+
+    Args:
+        path (str): Path to a PDF file or directory containing PDF files.
+
+    Returns:
+        int: The total number of pages across all PDF files.
+    """
+    total_pages = 0
+
+    # Handle single file
+    if os.path.isfile(path):
+        if path.lower().endswith(".pdf"):
+            try:
+                pdf = pdfium.PdfDocument(path)
+                total_pages = len(pdf)
+            except Exception as e:
+                print(f"{path} failed: {e}")
+        return total_pages
+
+    # Handle directory - recursively search for PDFs
+    if os.path.isdir(path):
+        for root, _, files in os.walk(path):
+            for filename in files:
+                if filename.lower().endswith(".pdf"):
+                    filepath = os.path.join(root, filename)
+                    try:
+                        pdf = pdfium.PdfDocument(filepath)
+                        total_pages += len(pdf)
+                    except Exception as e:
+                        print(f"{filepath} failed: {e}")
+                        continue
+
+    return total_pages
diff --git a/tools/harness/src/nv_ingest_harness/utils/recall.py b/tools/harness/src/nv_ingest_harness/utils/recall.py
index 47b05469c..d5b20d863 100644
--- a/tools/harness/src/nv_ingest_harness/utils/recall.py
+++ b/tools/harness/src/nv_ingest_harness/utils/recall.py
@@ -9,6 +9,7 @@
 import numpy as np
 import pandas as pd
 from collections import defaultdict
+from functools import partial
 from typing import Dict, Optional, Callable
 
 from nv_ingest_client.util.milvus import nvingest_retrieval
@@ -20,17 +21,18 @@ def _get_retrieval_func(
     vdb_backend: str,
     table_path: Optional[str] = None,
     table_name: Optional[str] = None,
+    hybrid: bool = False,
 ):
     """
     Get the retrieval function for the specified VDB backend.
 
-    For LanceDB, creates a single client instance that is reused across all
-    retrieval calls, avoiding repeated database/table opens.
+    For LanceDB, returns a partial of lancedb_retrieval with table_path pre-filled.
+    For Milvus, returns nvingest_retrieval directly.
 
     Args:
         vdb_backend: "milvus" or "lancedb"
         table_path: Path to LanceDB database directory (required for lancedb)
-        table_name: Table/collection name (used to pre-initialize LanceDB client)
+        table_name: Table/collection name (optional, can be passed at call time)
 
     Returns:
         Retrieval function that accepts (queries, **kwargs) and returns results.
@@ -38,16 +40,16 @@ def _get_retrieval_func(
     if vdb_backend == "lancedb":
         if not table_path:
             raise ValueError("table_path required for lancedb backend")
-        from nv_ingest_client.util.vdb.lancedb import LanceDB
-
-        # Create client once, reuse for all retrieval calls
-        lancedb_client = LanceDB(uri=table_path, table_name=table_name or "nv-ingest")
+        if hybrid:
+            from nv_ingest_client.util.vdb.lancedb import lancedb_hybrid_retrieval as lancedb_retrieval
+        else:
+            from nv_ingest_client.util.vdb.lancedb import lancedb_retrieval
 
-        def lancedb_retrieval(queries, **kwargs):
-            # table_name already set on client, but can be overridden via kwargs
-            return lancedb_client.retrieval(queries, **kwargs)
+        kwargs = {"table_path": table_path}
+        if table_name:
+            kwargs["table_name"] = table_name
+        return partial(lancedb_retrieval, **kwargs)
 
-        return lancedb_retrieval
     return nvingest_retrieval
 
 
@@ -56,6 +58,7 @@ def get_recall_scores(
     collection_name: str,
     hostname: str = "localhost",
     sparse: bool = True,
+    hybrid: bool = False,
     model_name: str = None,
     top_k: int = 10,
     gpu_search: bool = False,
@@ -90,7 +93,6 @@ def get_recall_scores(
 
     Returns:
         Dictionary mapping k values (1, 3, 5, 10) to recall scores (float 0.0-1.0).
-        Only includes k values where k <= top_k.
     """
     hits = defaultdict(list)
     queries = query_df["query"].to_list()
@@ -100,7 +102,12 @@ def get_recall_scores(
 
     # Create retrieval function once, outside the batch loop
     if vdb_backend == "lancedb":
-        retrieval_func = _get_retrieval_func("lancedb", table_path, table_name=collection_name)
+        retrieval_func = _get_retrieval_func(
+            "lancedb",
+            table_path,
+            table_name=collection_name,
+            hybrid=hybrid,
+        )
     else:
         retrieval_func = None  # Use nvingest_retrieval directly
 
@@ -158,6 +165,7 @@ def get_recall_scores_pdf_only(
     collection_name: str,
     hostname: str = "localhost",
     sparse: bool = False,
+    hybrid: bool = False,
     model_name: str = None,
     top_k: int = 10,
     gpu_search: bool = False,
@@ -180,7 +188,7 @@ def get_recall_scores_pdf_only(
                   expected_pdf format: PDF filename without extension (e.g., '3M_2018_10K').
         collection_name: Collection/table name to query.
         hostname: Service hostname for embedding endpoint.
-        sparse: Enable hybrid sparse-dense retrieval if True. Default False for finance_bench.
+        sparse: Enable hybrid sparse-dense retrieval if True (Milvus only).
         model_name: Embedding model name for query encoding.
         top_k: Maximum number of results to retrieve and evaluate.
         gpu_search: Use GPU acceleration for Milvus search.
@@ -194,11 +202,9 @@ def get_recall_scores_pdf_only(
 
     Returns:
         Dictionary mapping k values (1, 5, 10) to recall scores (float 0.0-1.0).
-        Only includes k values where k <= top_k.
     """
     hits = defaultdict(list)
 
-    # Prepare reranker kwargs if custom endpoint/model provided
     reranker_kwargs = {}
     if nv_ranker:
         if nv_ranker_endpoint:
@@ -215,7 +221,12 @@ def get_recall_scores_pdf_only(
 
     # Create retrieval function once, outside the batch loop
     if vdb_backend == "lancedb":
-        retrieval_func = _get_retrieval_func("lancedb", table_path, table_name=collection_name)
+        retrieval_func = _get_retrieval_func(
+            "lancedb",
+            table_path,
+            table_name=collection_name,
+            hybrid=hybrid,
+        )
     else:
         retrieval_func = None  # Use nvingest_retrieval directly
 
@@ -274,44 +285,47 @@ def evaluate_recall_orchestrator(
     collection_name: str,
     hostname: str = "localhost",
     sparse: bool = False,
+    hybrid: bool = False,
     model_name: str = None,
     top_k: int = 10,
     gpu_search: bool = False,
     nv_ranker: bool = False,
     ground_truth_dir: Optional[str] = None,
+    vdb_backend: str = "milvus",
+    table_path: Optional[str] = None,
     **scorer_kwargs,
 ) -> Dict[int, float]:
     """
     Generic orchestrator for recall evaluation.
 
-    Centralizes the common pattern: load ground truth → score → return results.
-    All parameters are passed through to the scorer function, preserving config-driven behavior.
-
     Args:
-        loader_func: Function that loads ground truth DataFrame from optional directory.
-        scorer_func: Function that calculates recall scores (get_recall_scores or get_recall_scores_pdf_only).
-        collection_name: Milvus collection name to query.
+        loader_func: Function that loads ground truth DataFrame.
+        scorer_func: Function that calculates recall scores.
+        collection_name: Collection/table name to query.
         hostname: Service hostname for embedding endpoint.
-        sparse: Enable hybrid sparse-dense retrieval if True. Passed from config.
-        model_name: Embedding model name for query encoding.
-        top_k: Maximum number of results to retrieve and evaluate.
-        gpu_search: Use GPU acceleration for Milvus search.
-        nv_ranker: Enable NVIDIA reranker for result reranking.
-        ground_truth_dir: Directory containing ground truth files (optional).
-        **scorer_kwargs: Additional kwargs to pass to scorer_func (e.g., nv_ranker_endpoint, nv_ranker_model_name).
+        sparse: Enable hybrid retrieval (Milvus only).
+        model_name: Embedding model name.
+        top_k: Maximum results to retrieve.
+        gpu_search: Use GPU for search (Milvus only).
+        nv_ranker: Enable reranker.
+        ground_truth_dir: Directory containing ground truth files.
+        vdb_backend: VDB backend ("milvus" or "lancedb").
+        table_path: Path to LanceDB database.
+        **scorer_kwargs: Additional kwargs for scorer_func.
 
     Returns:
-        Dictionary mapping k values to recall scores (float 0.0-1.0).
+        Dictionary mapping k values to recall scores.
     """
-    # 1. Load ground truth using dataset-specific loader
     query_df = loader_func(ground_truth_dir)
 
-    # 2. Calculate recall scores using dataset-specific scorer
     scores = scorer_func(
         query_df,
         collection_name,
         hostname=hostname,
         sparse=sparse,
+        hybrid=hybrid,
+        vdb_backend=vdb_backend,
+        table_path=table_path,
         model_name=model_name,
         top_k=top_k,
         gpu_search=gpu_search,
@@ -357,6 +371,7 @@ def bo767_recall(
     collection_name: str,
     hostname: str = "localhost",
     sparse: bool = True,
+    hybrid: bool = False,
     model_name: str = None,
     top_k: int = 10,
     gpu_search: bool = False,
@@ -397,6 +412,7 @@ def bo767_recall(
         collection_name=collection_name,
         hostname=hostname,
         sparse=sparse,
+        hybrid=hybrid,
         model_name=model_name,
         top_k=top_k,
         gpu_search=gpu_search,
@@ -459,7 +475,8 @@ def finance_bench_load_ground_truth(ground_truth_dir: Optional[str] = None) -> p
 def finance_bench_recall(
     collection_name: str,
     hostname: str = "localhost",
-    sparse: bool = False,  # Default False (hybrid=False) for finance_bench
+    sparse: bool = False,
+    hybrid: bool = False,
     model_name: str = None,
     top_k: int = 10,
     gpu_search: bool = False,
@@ -500,6 +517,7 @@ def finance_bench_recall(
         collection_name=collection_name,
         hostname=hostname,
         sparse=sparse,
+        hybrid=hybrid,
         model_name=model_name,
         top_k=top_k,
         gpu_search=gpu_search,
@@ -561,6 +579,7 @@ def earnings_recall(
     collection_name: str,
     hostname: str = "localhost",
     sparse: bool = True,
+    hybrid: bool = False,
     model_name: str = None,
     top_k: int = 10,
     gpu_search: bool = False,
@@ -601,6 +620,7 @@ def earnings_recall(
         collection_name=collection_name,
         hostname=hostname,
         sparse=sparse,
+        hybrid=hybrid,
         model_name=model_name,
         top_k=top_k,
         gpu_search=gpu_search,
@@ -653,10 +673,22 @@ def bo10k_load_ground_truth(ground_truth_dir: Optional[str] = None) -> pd.DataFr
     return df.reset_index(drop=True)
 
 
+def jp20_load_ground_truth(ground_truth_dir: Optional[str] = None) -> pd.DataFrame:
+    """Load bo10k ground truth filtered to jp20 documents."""
+    df = bo10k_load_ground_truth(ground_truth_dir=ground_truth_dir)
+
+    dataset_dir = os.environ.get("JP20_DATASET_DIR") or os.path.join(get_repo_root(), "data", "jp20")
+    jp20_pdfs = {os.path.splitext(name)[0] for name in os.listdir(dataset_dir) if name.lower().endswith(".pdf")}
+    filtered = df[df["pdf"].isin(jp20_pdfs)].reset_index(drop=True)
+
+    return filtered
+
+
 def bo10k_recall(
     collection_name: str,
     hostname: str = "localhost",
     sparse: bool = True,
+    hybrid: bool = False,
     model_name: str = None,
     top_k: int = 10,
     gpu_search: bool = False,
@@ -674,6 +706,42 @@ def bo10k_recall(
         collection_name=collection_name,
         hostname=hostname,
         sparse=sparse,
+        hybrid=hybrid,
+        model_name=model_name,
+        top_k=top_k,
+        gpu_search=gpu_search,
+        nv_ranker=nv_ranker,
+        ground_truth_dir=ground_truth_dir,
+        nv_ranker_endpoint=nv_ranker_endpoint,
+        nv_ranker_model_name=nv_ranker_model_name,
+        vdb_backend=vdb_backend,
+        table_path=table_path,
+    )
+
+
+def jp20_recall(
+    collection_name: str,
+    hostname: str = "localhost",
+    sparse: bool = True,
+    hybrid: bool = False,
+    model_name: str = None,
+    top_k: int = 10,
+    gpu_search: bool = False,
+    nv_ranker: bool = False,
+    ground_truth_dir: Optional[str] = None,
+    nv_ranker_endpoint: Optional[str] = None,
+    nv_ranker_model_name: Optional[str] = None,
+    vdb_backend: str = "milvus",
+    table_path: Optional[str] = None,
+) -> Dict[int, float]:
+    """Evaluate recall@k for jp20 dataset (bo10k subset)."""
+    return evaluate_recall_orchestrator(
+        loader_func=jp20_load_ground_truth,
+        scorer_func=get_recall_scores,
+        collection_name=collection_name,
+        hostname=hostname,
+        sparse=sparse,
+        hybrid=hybrid,
         model_name=model_name,
         top_k=top_k,
         gpu_search=gpu_search,
@@ -720,6 +788,7 @@ def get_dataset_evaluator(dataset_name: str) -> Optional[Callable]:
         "earnings": earnings_recall,
         "audio": audio_recall,
         "bo10k": bo10k_recall,
+        "jp20": jp20_recall,
     }
 
     return evaluators.get(dataset_name.lower())
diff --git a/tools/harness/src/nv_ingest_harness/utils/session.py b/tools/harness/src/nv_ingest_harness/utils/session.py
index f82ea50d6..c93d77f76 100644
--- a/tools/harness/src/nv_ingest_harness/utils/session.py
+++ b/tools/harness/src/nv_ingest_harness/utils/session.py
@@ -41,6 +41,7 @@ def get_artifact_path(
     session_dir: Path | str | None,
     dataset_name: str,
     base_dir: Path | str | None = None,
+    deployment_type: str | None = None,
 ) -> Path:
     """
     Get artifact path for a dataset.
@@ -52,6 +53,7 @@ def get_artifact_path(
         session_dir: Session directory path, or None for standalone artifacts.
         dataset_name: Name of the dataset (e.g., 'bo767').
         base_dir: Base directory for artifacts when not using session_dir.
+        deployment_type: Deployment type ('compose' or 'helm') for managed runs, or None for attach mode.
 
     Returns:
         Path to the artifact directory (created if needed).
@@ -59,11 +61,21 @@ def get_artifact_path(
     dataset_name = dataset_name or "unknown"
 
     if session_dir:
-        path = Path(session_dir) / dataset_name
+        # Include deployment type in path if provided (managed mode)
+        if deployment_type:
+            path = Path(session_dir) / f"{dataset_name}_{deployment_type}"
+        else:
+            path = Path(session_dir) / f"{dataset_name}_attach"
     else:
         root = Path(base_dir) if base_dir else get_default_artifacts_root()
         timestamp = now_timestr()
-        dirname = f"{dataset_name}_{timestamp}" if dataset_name else timestamp
+        # Include deployment type in standalone artifacts if provided
+        if deployment_type:
+            dirname = (
+                f"{dataset_name}_{deployment_type}_{timestamp}" if dataset_name else f"{deployment_type}_{timestamp}"
+            )
+        else:
+            dirname = f"{dataset_name}_attach_{timestamp}" if dataset_name else f"attach_{timestamp}"
         path = root / dirname
 
     path.mkdir(parents=True, exist_ok=True)
diff --git a/tools/harness/test_configs.yaml b/tools/harness/test_configs.yaml
index f6b2315cb..00bfb374d 100644
--- a/tools/harness/test_configs.yaml
+++ b/tools/harness/test_configs.yaml
@@ -14,15 +14,53 @@ active:
   # Infrastructure
   hostname: localhost
   readiness_timeout: 600
-  profiles:
-    - retrieval
-    - table-structure
+
+  # Docker Compose configuration
+  compose:
+    profiles:
+      - retrieval
+      - reranker  # Required for recall evaluation
+
+  # Helm configuration
+  helm:
+    bin: microk8s helm  # Helm binary command (e.g., "helm", "microk8s helm", "k3s helm")
+    sudo: true  # Prepend sudo to helm commands (needed for microk8s/k3s without user in group)
+    kubectl_bin: microk8s kubectl  # kubectl binary command (e.g., "kubectl", "microk8s kubectl")
+    kubectl_sudo: null  # Prepend sudo to kubectl commands (null = same as helm_sudo)
+    chart: nemo-microservices/nv-ingest  # Remote chart reference (set to null to use local chart from ./helm)
+    chart_version: 26.1.2  # Chart version (required for remote charts)
+    release: nv-ingest
+    namespace: nv-ingest
+    values_file: .helm-env  # Optional: path to values file
+    # Multiple port forwards for Helm services
+    port_forwards:
+      - service: nv-ingest
+        local_port: 7670
+        remote_port: 7670
+      - service: nv-ingest-milvus
+        local_port: 19530
+        remote_port: 19530
+      - service: nv-ingest-milvus
+        local_port: 9091
+        remote_port: 9091
+      - service: nv-ingest-minio
+        local_port: 9000
+        remote_port: 9000
+      - service: "*embed*"  # Wildcard pattern to match embedding services
+        local_port: 8012
+        remote_port: 8000
+      - service: "*rerank*"  # Wildcard pattern to match reranker services
+        local_port: 8020
+        remote_port: 8000
+    values:  # inline Helm values
+      nimOperator.llama_3_2_nv_rerankqa_1b_v2.enabled: true
 
   # Runtime configuration
-  sparse: false  # Use sparse embeddings
+  sparse: false  # Use sparse embeddings (Milvus only)
   gpu_search: false  # Use GPU for search
   embedding_model: auto  # auto-detect or specify model name
-  vdb_backend: milvus  # milvus or lancedb
+  vdb_backend: lancedb  # milvus or lancedb
+  hybrid: false  # LanceDB hybrid retrieval (FTS + vector)
 
   # Extraction configuration
   extract_text: true
@@ -56,7 +94,7 @@ active:
 # docker compose --profile reranker up -d
 recall:
   recall_dataset: null
-  reranker_mode: none  # Options: "none", "with", "both"
+  reranker_mode: both  # Options: "none", "with", "both"
 
   # Recall evaluation settings
   recall_top_k: 10
@@ -130,3 +168,12 @@ datasets:
     extract_images: false
     extract_infographics: true
     recall_dataset: bo10k
+
+  jp20:
+    path: /path/to/jp20
+    extract_text: true
+    extract_tables: true
+    extract_charts: true
+    extract_images: false
+    extract_infographics: true
+    recall_dataset: jp20