diff --git a/.github/workflows/config/.secrets.baseline b/.github/workflows/config/.secrets.baseline
index ae1e36e5fe..b889b24a82 100644
--- a/.github/workflows/config/.secrets.baseline
+++ b/.github/workflows/config/.secrets.baseline
@@ -354,6 +354,29 @@
         "is_verified": false,
         "line_number": 670
       }
+    ],
+    "nemo_curator/models/nemotron_h_vl.py": [
+      {
+        "type": "Hex High Entropy String",
+        "filename": "nemo_curator/models/nemotron_h_vl.py",
+        "hashed_secret": "7e44041c8ec081054af6ccf0758efa3771e99123",
+        "is_verified": false,
+        "line_number": 52
+      },
+      {
+        "type": "Hex High Entropy String",
+        "filename": "nemo_curator/models/nemotron_h_vl.py",
+        "hashed_secret": "f1a89dd2b19e1d30ac4fc1a8d1f4993796c9d1e6",
+        "is_verified": false,
+        "line_number": 54
+      },
+      {
+        "type": "Hex High Entropy String",
+        "filename": "nemo_curator/models/nemotron_h_vl.py",
+        "hashed_secret": "d7f11e2581dd9d25522592e7cfb9346a749f51f3",
+        "is_verified": false,
+        "line_number": 55
+      }
     ]
   },
   "generated_at": "2026-03-17T21:09:47Z"
diff --git a/nemo_curator/models/cosmos_embed1.py b/nemo_curator/models/cosmos_embed1.py
index 758c0021f3..c3771944bc 100644
--- a/nemo_curator/models/cosmos_embed1.py
+++ b/nemo_curator/models/cosmos_embed1.py
@@ -32,9 +32,9 @@
 }
 
 COSMOS_EMBED1_MODEL_REVISION_INFO: Final = {
-    "224p": "85f5627",
-    "336p": "5d8309d",
-    "448p": "9f4ff4d",
+    "224p": "787e0b9",
+    "336p": "0e8a28f",
+    "448p": "f60ec73",
 }
 
 
@@ -201,7 +201,9 @@ def download_weights_on_node(cls, model_dir: str, variant: Literal["224p", "336p
         logger.info(f"CosmosEmbed1 {variant} weights downloaded to: {model_dir_path}")
 
     @classmethod
-    def download_processor_config_on_node(cls, model_dir: str, variant: Literal["224p", "336p", "448p"] = "336p") -> None:
+    def download_processor_config_on_node(
+        cls, model_dir: str, variant: Literal["224p", "336p", "448p"] = "336p"
+    ) -> None:
         """Download the processor config for the CosmosEmbed1 model on the node."""
         model_dir_path = Path(model_dir) / _COSMOS_EMBED1_VARIANTS_INFO[variant]
         model_dir_path.mkdir(parents=True, exist_ok=True)
diff --git a/nemo_curator/models/nemotron_h_vl.py b/nemo_curator/models/nemotron_h_vl.py
new file mode 100644
index 0000000000..fb9d5bced1
--- /dev/null
+++ b/nemo_curator/models/nemotron_h_vl.py
@@ -0,0 +1,274 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from pathlib import Path
+from typing import Any, Final, Literal
+
+from loguru import logger
+
+from nemo_curator.models.base import ModelInterface
+from nemo_curator.utils import grouping
+from nemo_curator.utils.hf_download_utils import download_model_from_hf
+
+# Constants for prompt processing
+VIDEO_TAG_SPLIT_MAX = 1
+EXPECTED_VIDEO_TAG_PARTS = 2
+
+try:
+    from vllm import LLM, SamplingParams
+
+    VLLM_AVAILABLE = True
+except ImportError:
+    VLLM_AVAILABLE = False
+
+    class LLM:
+        pass
+
+    class SamplingParams:
+        pass
+
+
+# HuggingFace model IDs for Nemotron Nano V2 VL variants
+# Available variants: BF16 (default), FP8, NVFP4-QAD
+_NEMOTRON_VARIANTS_INFO: Final = {
+    "nemotron": "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16",  # Default BF16 variant
+    "nemotron-bf16": "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16",
+    "nemotron-fp8": "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-FP8",
+    "nemotron-nvfp4": "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-NVFP4-QAD",
+}
+
+_NEMOTRON_REVISION_INFO: Final = {
+    "nemotron": "5d250e2e111dc5e1434131bdf3d590c27a878ade",  # BF16 default
+    "nemotron-bf16": "5d250e2e111dc5e1434131bdf3d590c27a878ade",
+    "nemotron-fp8": "7394488badb786e1decc0e00e308de1cab9560e6",
+    "nemotron-nvfp4": "b8d3c170d9ee3a078917ef9bfd508eff988d6de7",
+}
+
+NemotronVariant = Literal["nemotron", "nemotron-bf16", "nemotron-fp8", "nemotron-nvfp4"]
+
+
+class NemotronHVL(ModelInterface):
+    """NemotronH hybrid Mamba-Attention VLM for video captioning.
+
+    Supports multiple checkpoint variants from HuggingFace:
+    - nemotron / nemotron-bf16: BF16 precision (default)
+    - nemotron-fp8: FP8 quantized
+    - nemotron-nvfp4: NVFP4 quantized
+
+    Models are automatically downloaded from HuggingFace on first use.
+    """
+
+    def __init__(  # noqa: PLR0913
+        self,
+        model_dir: str,
+        model_variant: NemotronVariant = "nemotron",
+        caption_batch_size: int = 8,
+        max_output_tokens: int = 512,
+        stage2_prompt_text: str | None = None,
+        verbose: bool = False,
+    ):
+        """Initialize NemotronHVL model.
+
+        Args:
+            model_dir: Base directory for model weights. Models will be downloaded
+                to subdirectories named after the HuggingFace model ID.
+            model_variant: Model variant to use. Options:
+                - "nemotron" or "nemotron-bf16": BF16 precision (default)
+                - "nemotron-fp8": FP8 quantized
+                - "nemotron-nvfp4": NVFP4 quantized
+            caption_batch_size: Batch size for caption generation.
+            max_output_tokens: Maximum number of tokens to generate.
+            stage2_prompt_text: Optional prompt text for stage 2 caption refinement.
+            verbose: Whether to enable verbose logging.
+        """
+        # Normalize variant name - treat "nemotron" as "nemotron-bf16"
+        if model_variant == "nemotron":
+            self._normalized_variant: NemotronVariant = "nemotron-bf16"
+        else:
+            self._normalized_variant = model_variant  # type: ignore[assignment]
+
+        if self._normalized_variant not in _NEMOTRON_VARIANTS_INFO:
+            valid_variants = ", ".join(_NEMOTRON_VARIANTS_INFO.keys())
+            msg = f"Invalid model_variant: {model_variant}. Valid options are: {valid_variants}"
+            raise ValueError(msg)
+
+        self.model_dir = model_dir
+        self.model_variant = model_variant
+        self.caption_batch_size = caption_batch_size
+        self.max_output_tokens = max_output_tokens
+        self.stage2_prompt = stage2_prompt_text if stage2_prompt_text else "Please refine this caption: "
+        self.verbose = verbose
+
+        # Set weight file path using HuggingFace model ID
+        self._hf_model_id = _NEMOTRON_VARIANTS_INFO[self._normalized_variant]
+        self.weight_file = str(Path(model_dir) / self._hf_model_id)
+
+    @property
+    def model_id_names(self) -> list[str]:
+        """Return HuggingFace model ID for the selected variant."""
+        return [self._hf_model_id]
+
+    def setup(self) -> None:
+        if not VLLM_AVAILABLE:
+            msg = "vllm is required for NemotronHVL but is not installed. Please install vllm: pip install vllm"
+            raise ImportError(msg)
+
+        # Determine quantization and dtype based on variant
+        # See: https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-FP8
+        #      https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-NVFP4-QAD
+        quantization = None
+        dtype = "bfloat16"  # BF16 variant requires explicit dtype
+        if self._normalized_variant == "nemotron-fp8":
+            quantization = "modelopt"  # vllm serve uses: --quantization modelopt
+            dtype = "auto"  # FP8 determines dtype from quantization
+        elif self._normalized_variant == "nemotron-nvfp4":
+            quantization = "modelopt_fp4"  # vllm serve uses: --quantization modelopt_fp4
+            dtype = "auto"  # FP4 determines dtype from quantization
+
+        self.model = LLM(
+            model=self.weight_file,
+            trust_remote_code=True,
+            dtype=dtype,
+            tensor_parallel_size=1,
+            gpu_memory_utilization=0.9,
+            max_model_len=32768,
+            limit_mm_per_prompt={"video": 1},
+            quantization=quantization,
+            video_pruning_rate=0,  # Disable video pruning
+        )
+
+        self.sampling_params = SamplingParams(
+            temperature=0.6,
+            max_tokens=self.max_output_tokens,
+            top_p=0.95,
+            stop=["</s>", "<|endoftext|>", "<SPECIAL_12>", "</think>"],
+        )
+
+        logger.info(
+            f"NemotronHVL initialized: variant={self.model_variant}, "
+            f"quantization={quantization}, TP=1, GPU_util=0.9, max_len=32768"
+        )
+
+    def _refine_caption_prompt(self, original_prompt: str, refinement_text: str) -> str:
+        """Create a refined prompt for stage 2 captioning."""
+        if "<video>" not in original_prompt:
+            return refinement_text
+
+        parts = original_prompt.split("<video>", VIDEO_TAG_SPLIT_MAX)
+        if len(parts) != EXPECTED_VIDEO_TAG_PARTS:
+            return refinement_text
+
+        prefix = parts[0] + "<video>"
+
+        # Find where the user message ends
+        suffix_markers = ["<SPECIAL_11>Assistant", "<|im_end|>", "</s>"]
+        suffix_start = len(parts[1])
+        for marker in suffix_markers:
+            if marker in parts[1]:
+                suffix_start = parts[1].index(marker)
+                break
+
+        suffix = parts[1][suffix_start:]
+        return prefix + "\n" + refinement_text + suffix
+
+    def generate(
+        self,
+        videos: list[dict[str, Any]],
+        generate_stage2_caption: bool = False,
+        batch_size: int = 16,
+    ) -> list[str]:
+        generated_text = []
+
+        for batch_videos in grouping.split_by_chunk_size(videos, batch_size):
+            model_inputs = list(batch_videos)
+            try:
+                # PASS 1: Generate initial captions
+                outputs = self.model.generate(
+                    model_inputs,
+                    sampling_params=self.sampling_params,
+                    use_tqdm=False,
+                )
+
+                # PASS 2: Refine captions if requested
+                if generate_stage2_caption:
+                    for i, out in enumerate(outputs):
+                        initial_caption = out.outputs[0].text
+                        refinement_text = self.stage2_prompt + initial_caption
+                        original_prompt = model_inputs[i]["prompt"]
+                        model_inputs[i]["prompt"] = self._refine_caption_prompt(original_prompt, refinement_text)
+
+                    outputs = self.model.generate(
+                        model_inputs,
+                        sampling_params=self.sampling_params,
+                        use_tqdm=False,
+                    )
+
+                generated_text.extend(out.outputs[0].text for out in outputs)
+
+                if self.verbose:
+                    for i, out in enumerate(outputs):
+                        logger.info(f"Generated caption {i}: {out.outputs[0].text[:100]}...")
+
+            except Exception as e:
+                logger.error(f"Error generating caption for batch: {e}")
+                raise
+
+        return generated_text
+
+    @classmethod
+    def download_weights_on_node(
+        cls,
+        model_dir: str,
+        variant: NemotronVariant = "nemotron",
+    ) -> None:
+        """Download NemotronH VL weights from HuggingFace.
+
+        Models are automatically downloaded from HuggingFace Hub on first use.
+        Supports multiple quantization variants for different performance/memory tradeoffs.
+
+        Args:
+            model_dir: Base directory for model weights. The model will be downloaded
+                to a subdirectory named after the HuggingFace model ID.
+            variant: Model variant to download. Options:
+                - "nemotron" or "nemotron-bf16": BF16 precision (default)
+                - "nemotron-fp8": FP8 quantized
+                - "nemotron-nvfp4": NVFP4 quantized
+        """
+        # Normalize variant name
+        normalized_variant: NemotronVariant = "nemotron-bf16" if variant == "nemotron" else variant
+
+        if normalized_variant not in _NEMOTRON_VARIANTS_INFO:
+            valid_variants = ", ".join(_NEMOTRON_VARIANTS_INFO.keys())
+            msg = f"Invalid variant: {variant}. Valid options are: {valid_variants}"
+            raise ValueError(msg)
+
+        hf_model_id = _NEMOTRON_VARIANTS_INFO[normalized_variant]
+        revision = _NEMOTRON_REVISION_INFO.get(normalized_variant)
+
+        model_dir_path = Path(model_dir) / hf_model_id
+        model_dir_path.mkdir(parents=True, exist_ok=True)
+
+        # Check if already downloaded
+        if model_dir_path.exists() and any(model_dir_path.glob("*.safetensors")):
+            logger.info(f"NemotronH {variant} checkpoint already exists at: {model_dir_path}")
+            return
+
+        # Download from HuggingFace
+        logger.info(f"Downloading NemotronH {variant} from HuggingFace: {hf_model_id}")
+        download_model_from_hf(
+            model_id=hf_model_id,
+            local_dir=model_dir_path,
+            revision=revision,
+        )
+        logger.info(f"NemotronH {variant} weights downloaded to: {model_dir_path}")
diff --git a/nemo_curator/models/prompt_formatter.py b/nemo_curator/models/prompt_formatter.py
index 3405f6b5a7..d41589785c 100644
--- a/nemo_curator/models/prompt_formatter.py
+++ b/nemo_curator/models/prompt_formatter.py
@@ -14,58 +14,86 @@
 
 from typing import Any
 
+import numpy as np
 import torch
 from transformers import AutoProcessor
 
-VARIANT_MAPPING = {
+from nemo_curator.models.nemotron_h_vl import _NEMOTRON_VARIANTS_INFO
+
+# Mapping of variants to their HuggingFace model IDs
+VARIANT_MAPPING: dict[str, str] = {
     "qwen": "Qwen/Qwen2.5-VL-7B-Instruct",
+    **_NEMOTRON_VARIANTS_INFO,
 }
 
 
 class PromptFormatter:
+    """Unified prompt formatter for VLM models using HuggingFace AutoProcessor.
+
+    Supports both Qwen and Nemotron model variants. Uses AutoProcessor.from_pretrained()
+    to load the appropriate tokenizer and chat template from HuggingFace Hub.
+    """
+
     def __init__(self, prompt_variant: str):
+        """Initialize the prompt formatter.
+
+        Args:
+            prompt_variant: Model variant to use (e.g., "qwen", "nemotron", "nemotron-fp8").
+        """
         if prompt_variant not in VARIANT_MAPPING:
             msg = f"Invalid prompt variant: {prompt_variant}. Valid variants are: {', '.join(VARIANT_MAPPING.keys())}"
             raise ValueError(msg)
 
         self.prompt_variant = prompt_variant
         self.text_prompt = None
-        self.processor = AutoProcessor.from_pretrained(VARIANT_MAPPING[self.prompt_variant])
+
+        # Load processor from HuggingFace (auto-downloads and caches)
+        hf_model_id = VARIANT_MAPPING[prompt_variant]
+        self.processor = AutoProcessor.from_pretrained(hf_model_id, trust_remote_code=True)
 
     def generate_inputs(
         self,
         prompt: str,
-        video_inputs: torch.Tensor | None = None,
+        video_inputs: torch.Tensor | np.ndarray | None = None,
         *,
         override_text_prompt: bool = False,
+        fps: float = 2.0,
     ) -> dict[str, Any]:
         """Generate inputs for video and text data based on prompt_variant.
 
-        Processes video and text inputs to create the input for the model. It handles both video and
-        image inputs, decoding video and applying preprocessing if needed, and creates a structured
-        input dictionary containing the processed prompt and multimodal data.
-
         Args:
             prompt: Text prompt to be included with the input.
-            fps: Frames per second of the input video.
-            preprocess_dtype: Data type to use for preprocessing the video/image inputs.
-            num_frames_to_use: Number of frames to extract from the video. If 0, uses all frames.
-            flip_input: Whether to flip the input video/image horizontally.
-            video_inputs: Pre-processed video inputs. If None, and video data is to be passed to
-                          the model, then video cannot be None.
-            override_text_prompt: whether the text prompt should be overridden
+            video_inputs: Pre-processed video inputs (tensor or numpy array).
+            override_text_prompt: Whether to regenerate the text prompt even if cached.
+            fps: Frames per second of the input video (used for Nemotron metadata).
 
         Returns:
             dict containing:
                 - "prompt": The processed text prompt with chat template applied
-                - "multi_modal_data": Dictionary containing processed "image" and/or "video" inputs
+                - "multi_modal_data": Dictionary containing processed "video" inputs
 
         """
-        message = self.create_message(prompt)
+        if self.prompt_variant == "qwen":
+            return self._generate_qwen_inputs(prompt, video_inputs, override_text_prompt)
+
+        if self.prompt_variant.startswith("nemotron"):
+            return self._generate_nemotron_inputs(prompt, video_inputs, fps)
+
+        msg = f"Unsupported prompt variant: {self.prompt_variant}"
+        raise ValueError(msg)
+
+    def _generate_qwen_inputs(
+        self,
+        prompt: str,
+        video_inputs: torch.Tensor | None,
+        override_text_prompt: bool,
+    ) -> dict[str, Any]:
+        """Generate inputs for Qwen models."""
+        message = self._create_qwen_message(prompt)
         if self.text_prompt is None or override_text_prompt:
             self.text_prompt = self.processor.apply_chat_template(
                 message,
-                tokenizer=False,
+                tokenize=False,
                 add_generation_prompt=True,
             )
         return {
@@ -73,27 +101,68 @@ def generate_inputs(
             "multi_modal_data": {"video": video_inputs},
         }
 
-    def create_message(self, prompt: str) -> list[dict[str, Any]]:
-        """Create a message.
+    def _generate_nemotron_inputs(
+        self,
+        prompt: str,
+        video_inputs: torch.Tensor | np.ndarray | None,
+        fps: float,
+    ) -> dict[str, Any]:
+        """Generate inputs for Nemotron models.
+
+        Nemotron requires video metadata (fps, frames_indices) for vLLM processing.
+        """
+        # Format messages for Nemotron
+        messages = [
+            {"role": "system", "content": "You are a helpful assistant."},
+            {"role": "user", "content": [{"type": "text", "text": f"<video>\n{prompt}"}]},
+        ]
+
+        formatted_prompt = self.processor.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+        )
+
+        # Handle video metadata (vLLM's Nemotron processor requires this tuple format)
+        video_with_metadata = None
+        if video_inputs is not None:
+            video_np = self._convert_to_numpy(video_inputs)
+            num_frames = video_np.shape[0]
+            video_with_metadata = (
+                video_np,
+                {"fps": fps, "frames_indices": list(range(num_frames))},
+            )
+
+        return {
+            "prompt": formatted_prompt,
+            "multi_modal_data": {"video": video_with_metadata},
+        }
+
+    def _convert_to_numpy(self, video_inputs: torch.Tensor | np.ndarray) -> np.ndarray:
+        """Convert video inputs to numpy array in (T, H, W, C) format."""
+        if isinstance(video_inputs, torch.Tensor):
+            # Assume tensor is (T, C, H, W), convert to (T, H, W, C)
+            video_np = video_inputs.permute(0, 2, 3, 1).cpu().numpy()
+        else:
+            video_np = video_inputs
 
-        Args:
-            text_input: The text input to create a message for.
+        # Normalize to uint8 if needed
+        if video_np.dtype != np.uint8:
+            if np.issubdtype(video_np.dtype, np.floating) and video_np.max() <= 1.0:
+                video_np = (video_np * 255).astype(np.uint8)
+            else:
+                video_np = video_np.astype(np.uint8)
 
-        Returns:
-            List of messages for the VLM model including the text prompt and video.
+        return video_np
 
-        """
+    def _create_qwen_message(self, prompt: str) -> list[dict[str, Any]]:
+        """Create a message for Qwen models."""
         return [
             {
                 "role": "user",
                 "content": [
-                    {
-                        "type": "video",
-                    },
-                    {
-                        "type": "text",
-                        "text": prompt,
-                    },
+                    {"type": "video"},
+                    {"type": "text", "text": prompt},
                 ],
             },
         ]
diff --git a/nemo_curator/models/qwen_vl.py b/nemo_curator/models/qwen_vl.py
index 0605216b53..6b683405dd 100644
--- a/nemo_curator/models/qwen_vl.py
+++ b/nemo_curator/models/qwen_vl.py
@@ -67,7 +67,7 @@ def __init__(  # noqa: PLR0913
         self.max_output_tokens = max_output_tokens
         self.model_does_preprocess = model_does_preprocess
         self.disable_mmcache = disable_mmcache
-        self.stage2_prompt = stage2_prompt_text
+        self.stage2_prompt = stage2_prompt_text if stage2_prompt_text else "Please refine this caption: "
         self.verbose = verbose
         self.weight_file = str(pathlib.Path(model_dir) / _QWEN_VARIANTS_INFO[model_variant])
         # Default pattern for stage2 caption generation - matches (.*)(user_prompt)(.*)
diff --git a/nemo_curator/stages/video/caption/caption_generation.py b/nemo_curator/stages/video/caption/caption_generation.py
index 03f5666c22..e9716dc68f 100644
--- a/nemo_curator/stages/video/caption/caption_generation.py
+++ b/nemo_curator/stages/video/caption/caption_generation.py
@@ -19,6 +19,7 @@
 from loguru import logger
 
 from nemo_curator.backends.base import NodeInfo, WorkerMetadata
+from nemo_curator.models.nemotron_h_vl import NemotronHVL
 from nemo_curator.models.qwen_vl import QwenVL
 from nemo_curator.stages.base import ProcessingStage
 from nemo_curator.stages.resources import Resources
@@ -62,6 +63,15 @@ def _initialize_model(self) -> None:
                 model_does_preprocess=self.model_does_preprocess,
                 disable_mmcache=self.disable_mmcache,
             )
+        elif self.model_variant.startswith("nemotron"):
+            self.model = NemotronHVL(
+                model_dir=self.model_dir,
+                model_variant=self.model_variant,
+                caption_batch_size=self.caption_batch_size,
+                max_output_tokens=self.max_output_tokens,
+                stage2_prompt_text=self.stage2_prompt_text,
+                verbose=self.verbose,
+            )
         else:
             msg = f"Unsupported model variant: {self.model_variant}"
             raise ValueError(msg)
@@ -69,7 +79,10 @@ def _initialize_model(self) -> None:
 
     def setup_on_node(self, node_info: NodeInfo, worker_metadata: WorkerMetadata) -> None:  # noqa: ARG002
         """Download weights and initialize vLLM once per node to avoid torch.compile race conditions."""
-        QwenVL.download_weights_on_node(self.model_dir)
+        if self.model_variant == "qwen":
+            QwenVL.download_weights_on_node(self.model_dir)
+        elif self.model_variant.startswith("nemotron"):
+            NemotronHVL.download_weights_on_node(self.model_dir, variant=self.model_variant)
         self._initialize_model()
 
     def setup(self, worker_metadata: WorkerMetadata | None = None) -> None:  # noqa: ARG002
@@ -89,12 +102,17 @@ def process(self, task: VideoTask) -> VideoTask:
                 logger.warning(f"Clip {clip.uuid} has no windows")
                 clip.errors["windows"] = "empty"
             for window_idx, window in enumerate(clip.windows):
-                if window.qwen_llm_input is None:
-                    logger.error(f"Clip {clip.uuid} window {window_idx} has no prepared inputs.")
-                    clip.errors[f"window-{window_idx}"] = "empty"
+                llm_input = window.llm_inputs.get(self.model_variant)
+
+                if llm_input is None:
+                    logger.error(
+                        f"Clip {clip.uuid} window {window_idx} has no prepared inputs for {self.model_variant}."
+                    )
+                    clip.errors[f"window-{window_idx}"] = f"no_{self.model_variant}_input"
                     continue
+
                 mapping[idx] = (clip_idx, window_idx)
-                inputs.append(window.qwen_llm_input)
+                inputs.append(llm_input)
                 idx += 1
 
         captions = self.model.generate(
@@ -128,5 +146,6 @@ def _assign_captions(
         # Clear caption inputs
         for clip in video.clips:
             for window in clip.windows:
-                window.qwen_llm_input = None
+                if self.model_variant in window.llm_inputs:
+                    del window.llm_inputs[self.model_variant]
                 window.mp4_bytes = None
diff --git a/nemo_curator/stages/video/caption/caption_preparation.py b/nemo_curator/stages/video/caption/caption_preparation.py
index 8a034631fd..91777e3a5a 100644
--- a/nemo_curator/stages/video/caption/caption_preparation.py
+++ b/nemo_curator/stages/video/caption/caption_preparation.py
@@ -95,7 +95,19 @@ def inputs(self) -> tuple[list[str], list[str]]:
     def outputs(self) -> tuple[list[str], list[str]]:
         return [], []
 
+    def __post_init__(self) -> None:
+        self._skip_intermediate_resize = False
+        if self.model_variant.startswith("nemotron"):
+            if not self.model_does_preprocess:
+                logger.warning(
+                    f"model_variant={self.model_variant!r}: overriding model_does_preprocess=True. "
+                    "Nemotron uses vLLM's internal preprocessing; CLIP normalization must not be applied beforehand."
+                )
+                self.model_does_preprocess = True
+            self._skip_intermediate_resize = True
+
     def setup(self, worker_metadata: WorkerMetadata | None = None) -> None:  # noqa: ARG002
+        # PromptFormatter uses AutoProcessor from HuggingFace (auto-downloads/caches)
         self.prompt_formatter = PromptFormatter(self.model_variant)
 
     def process(self, task: VideoTask) -> VideoTask:
@@ -115,6 +127,7 @@ def process(self, task: VideoTask) -> VideoTask:
                     sampling_fps=self.sampling_fps,
                     model_does_preprocess=self.model_does_preprocess,
                     preprocess_dtype=self.preprocess_dtype,
+                    skip_resize=self._skip_intermediate_resize,
                     return_bytes=self.generate_previews,
                     num_threads=max(int(self.resources.cpus), 1),
                 ),
@@ -127,19 +140,20 @@ def process(self, task: VideoTask) -> VideoTask:
                     llm_input = self.prompt_formatter.generate_inputs(
                         prompt=prompt,
                         video_inputs=window_frames,
+                        fps=self.sampling_fps,
                     )
                 except Exception as e:  # noqa: BLE001
                     logger.error(f"Error in Caption preparation: {e}")
                     clip.errors[f"{self.model_variant}_input"] = str(e)
                     continue
 
-                clip.windows.append(
-                    _Window(
-                        window_frame_info.start,
-                        window_frame_info.end,
-                        mp4_bytes=window_bytes,
-                        qwen_llm_input=llm_input,
-                    ),
+                window = _Window(
+                    window_frame_info.start,
+                    window_frame_info.end,
+                    mp4_bytes=window_bytes,
                 )
+                window.llm_inputs[self.model_variant] = llm_input
+
+                clip.windows.append(window)
 
         return task
diff --git a/nemo_curator/stages/video/io/clip_writer.py b/nemo_curator/stages/video/io/clip_writer.py
index 22ab0d01af..eb62d17774 100644
--- a/nemo_curator/stages/video/io/clip_writer.py
+++ b/nemo_curator/stages/video/io/clip_writer.py
@@ -176,7 +176,7 @@ def process(self, task: VideoTask) -> VideoTask:
                 clip.cosmos_embed1_embedding = None
                 for window in clip.windows:
                     window.mp4_bytes = None
-                    window.qwen_llm_input = None
+                    window.llm_inputs.clear()
                     window.caption.clear()
                     window.enhanced_caption.clear()
                     window.webp_bytes = None
diff --git a/nemo_curator/tasks/video.py b/nemo_curator/tasks/video.py
index e07d6f26c6..cefbfc3640 100644
--- a/nemo_curator/tasks/video.py
+++ b/nemo_curator/tasks/video.py
@@ -41,8 +41,7 @@ class _Window:
     end_frame: int
     # MP4 bytes for this window
     mp4_bytes: bytes | None = None
-    # Qwen LLM input for this window
-    qwen_llm_input: dict[str, Any] | None = None
+    llm_inputs: dict[str, dict[str, Any]] = field(default_factory=dict)
     # X1 model input for this window
     x1_input: Any | None = None
     # `caption: {model_name: caption}`
@@ -61,7 +60,7 @@ def get_major_size(self) -> int:
         total_size = 0
         total_size += len(self.mp4_bytes) if self.mp4_bytes else 0
         # TODO: this is probably inaccurate
-        total_size += sys.getsizeof(self.qwen_llm_input) if self.qwen_llm_input else 0
+        total_size += sum(sys.getsizeof(v) for v in self.llm_inputs.values())
         total_size += sys.getsizeof(self.caption)
         total_size += sys.getsizeof(self.enhanced_caption)
         total_size += len(self.webp_bytes) if self.webp_bytes else 0
diff --git a/nemo_curator/utils/windowing_utils.py b/nemo_curator/utils/windowing_utils.py
index 1666bd5a75..dce926f823 100644
--- a/nemo_curator/utils/windowing_utils.py
+++ b/nemo_curator/utils/windowing_utils.py
@@ -84,6 +84,7 @@ def split_video_into_windows(  # noqa: PLR0913
     *,
     model_does_preprocess: bool = False,
     preprocess_dtype: str = "uint8",
+    skip_resize: bool = False,
     flip_input: bool = False,
     num_frames_to_use: int = 0,
     return_bytes: bool = False,
@@ -135,6 +136,7 @@ def split_video_into_windows(  # noqa: PLR0913
                 preprocess_dtype=preprocess_dtype,
                 num_frames_to_use=num_frames_to_use,
                 flip_input=flip_input,
+                skip_resize=skip_resize,
             )
 
             index = 0
@@ -293,7 +295,7 @@ def read_video_cpu(
     return video, frame_counts
 
 
-def fetch_video(  # noqa: C901, PLR0911, PLR0913
+def fetch_video(  # noqa: C901, PLR0911, PLR0912, PLR0913
     video_path: str,
     sampling_fps: float = 2.0,
     window_range: list[WindowFrameInfo] | None = None,
@@ -302,6 +304,7 @@ def fetch_video(  # noqa: C901, PLR0911, PLR0913
     preprocess_dtype: str = "float32",
     num_frames_to_use: int = 0,
     flip_input: bool = False,
+    skip_resize: bool = False,
 ) -> tuple[torch.Tensor, list[int]]:
     """Load and preprocess video frames from a file.
 
@@ -328,17 +331,18 @@ def fetch_video(  # noqa: C901, PLR0911, PLR0913
     )
     nframes, _, height, width = video.shape
 
-    max_pixels = max(
-        min(VIDEO_MAX_PIXELS, int(VIDEO_TOTAL_PIXELS / nframes * FRAME_FACTOR)),
-        int(VIDEO_MIN_PIXELS * 1.05),
-    )
-    resized_height, resized_width = smart_resize(
-        height,
-        width,
-        factor=IMAGE_FACTOR,
-        min_pixels=VIDEO_MIN_PIXELS,
-        max_pixels=max_pixels,
-    )
+    if do_preprocess or not skip_resize:
+        max_pixels = max(
+            min(VIDEO_MAX_PIXELS, int(VIDEO_TOTAL_PIXELS / nframes * FRAME_FACTOR)),
+            int(VIDEO_MIN_PIXELS * 1.05),
+        )
+        resized_height, resized_width = smart_resize(
+            height,
+            width,
+            factor=IMAGE_FACTOR,
+            min_pixels=VIDEO_MIN_PIXELS,
+            max_pixels=max_pixels,
+        )
 
     if do_preprocess:
         try:
@@ -368,12 +372,13 @@ def fetch_video(  # noqa: C901, PLR0911, PLR0913
         if preprocess_dtype == "uint8":
             return video.to(torch.uint8), frame_counts
         return video, frame_counts
-    video = transforms.functional.resize(
-        video,
-        [resized_height, resized_width],
-        interpolation=InterpolationMode.BICUBIC,
-        antialias=True,
-    )
+    if not skip_resize:
+        video = transforms.functional.resize(
+            video,
+            [resized_height, resized_width],
+            interpolation=InterpolationMode.BICUBIC,
+            antialias=True,
+        )
     if flip_input:
         video = [torch.flip(frame, dims=[1, 2]) for frame in video]  # type: ignore[assignment]
     if preprocess_dtype == "float32":
diff --git a/pyproject.toml b/pyproject.toml
index d736e936db..a0b6dd3580 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -249,12 +249,12 @@ override-dependencies = [
     "apex; sys_platform == 'never'",
     "distance; sys_platform == 'never'",
     "huggingface-hub>=0.34,<1.0", # Override huggingface-hub, transformers and data-designer require two different versions of hugging-face hub
+    "transformers>=4.56.0,<5.0", # Override nemo-toolkit[asr]'s <=4.52.0 constraint; required for Nemotron VL support
     "kaldiio;  sys_platform == 'never'",
     "levenshtein;  sys_platform == 'never'",
     "numpy>=2.0.0,<=2.2.0", # Override nemo-toolkits constraint of <2.0.0, upperbounds for Numba compatibility
     "protobuf>=5.29.5",  # Override nemo-toolkits constraint of ~=5.29.5
     "setuptools>=80.10.1", # Override setuptools range in other dependencies to address CVE GHSA-58pv-8j8x-9vj2
-    "transformers<=4.55.2", # Else Cosmos Embed imports fail
     "nixl-cu12>=0.10.0; (platform_machine == 'x86_64' and platform_system != 'Darwin')",  # Override ray[llm]'s unconditional nixl dep for ARM
 ]
 
diff --git a/tests/models/test_nemotron_h_vl.py b/tests/models/test_nemotron_h_vl.py
new file mode 100644
index 0000000000..ba413acc87
--- /dev/null
+++ b/tests/models/test_nemotron_h_vl.py
@@ -0,0 +1,398 @@
+# Copyright (c) 2025, NVIDIA CORPORATION.  All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import pathlib
+import tempfile
+from unittest.mock import Mock, patch
+
+import pytest
+
+from nemo_curator.models.nemotron_h_vl import (
+    _NEMOTRON_REVISION_INFO,
+    _NEMOTRON_VARIANTS_INFO,
+    NemotronHVL,
+    NemotronVariant,
+)
+
+
+class TestNemotronHVLVariantInfo:
+    """Test cases for variant info constants."""
+
+    def test_variants_info_contains_all_variants(self) -> None:
+        """Verify all expected variants are defined."""
+        expected_variants = {"nemotron", "nemotron-bf16", "nemotron-fp8", "nemotron-nvfp4"}
+        assert set(_NEMOTRON_VARIANTS_INFO.keys()) == expected_variants
+
+    def test_variants_info_hf_ids(self) -> None:
+        """Verify HuggingFace model IDs are correct."""
+        assert _NEMOTRON_VARIANTS_INFO["nemotron"] == "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16"
+        assert _NEMOTRON_VARIANTS_INFO["nemotron-bf16"] == "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16"
+        assert _NEMOTRON_VARIANTS_INFO["nemotron-fp8"] == "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-FP8"
+        assert _NEMOTRON_VARIANTS_INFO["nemotron-nvfp4"] == "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-NVFP4-QAD"
+
+    def test_revision_info_contains_all_variants(self) -> None:
+        """Verify revision info has entries for all variants."""
+        expected_variants = {"nemotron", "nemotron-bf16", "nemotron-fp8", "nemotron-nvfp4"}
+        assert set(_NEMOTRON_REVISION_INFO.keys()) == expected_variants
+
+
+class TestNemotronHVL:
+    def setup_method(self) -> None:
+        """Set up model and mocks for each test."""
+        self.vllm_patcher = patch("nemo_curator.models.nemotron_h_vl.VLLM_AVAILABLE", True)
+        self.vllm_patcher.start()
+
+        self.model_dir = "/test/model/dir"
+        self.model_variant: NemotronVariant = "nemotron"
+        self.caption_batch_size = 4
+        self.model = NemotronHVL(
+            model_dir=self.model_dir,
+            model_variant=self.model_variant,
+            caption_batch_size=self.caption_batch_size,
+            max_output_tokens=512,
+            stage2_prompt_text="Test stage2: ",
+            verbose=False,
+        )
+
+    def teardown_method(self) -> None:
+        """Tear down mocks after each test."""
+        self.vllm_patcher.stop()
+
+    def test_init_defaults(self) -> None:
+        """Verify default initialization values."""
+        model = NemotronHVL(model_dir=self.model_dir)
+        assert model.model_dir == self.model_dir
+        assert model.model_variant == "nemotron"
+        assert model._normalized_variant == "nemotron-bf16"
+        assert model.caption_batch_size == 8
+        assert model.max_output_tokens == 512
+        assert model.stage2_prompt == "Please refine this caption: "
+        assert model.verbose is False
+        # Weight file should include HF model ID path
+        expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-bf16"]
+        assert model.weight_file == str(pathlib.Path(self.model_dir) / expected_hf_id)
+
+    def test_init_bf16_variant(self) -> None:
+        """Verify BF16 variant initialization."""
+        model = NemotronHVL(model_dir=self.model_dir, model_variant="nemotron-bf16")
+        assert model.model_variant == "nemotron-bf16"
+        assert model._normalized_variant == "nemotron-bf16"
+        expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-bf16"]
+        assert model.weight_file == str(pathlib.Path(self.model_dir) / expected_hf_id)
+
+    def test_init_fp8_variant(self) -> None:
+        """Verify FP8 variant initialization."""
+        model = NemotronHVL(model_dir=self.model_dir, model_variant="nemotron-fp8")
+        assert model.model_variant == "nemotron-fp8"
+        assert model._normalized_variant == "nemotron-fp8"
+        expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-fp8"]
+        assert model.weight_file == str(pathlib.Path(self.model_dir) / expected_hf_id)
+
+    def test_init_nvfp4_variant(self) -> None:
+        """Verify NVFP4 variant initialization."""
+        model = NemotronHVL(model_dir=self.model_dir, model_variant="nemotron-nvfp4")
+        assert model.model_variant == "nemotron-nvfp4"
+        assert model._normalized_variant == "nemotron-nvfp4"
+        expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-nvfp4"]
+        assert model.weight_file == str(pathlib.Path(self.model_dir) / expected_hf_id)
+
+    def test_init_invalid_variant(self) -> None:
+        """Raise ValueError for invalid variant."""
+        with pytest.raises(ValueError, match="Invalid model_variant: invalid"):
+            NemotronHVL(model_dir=self.model_dir, model_variant="invalid")  # type: ignore[arg-type]
+
+    def test_model_id_names(self) -> None:
+        """Return HuggingFace model ID for selected variant."""
+        model = NemotronHVL(model_dir=self.model_dir, model_variant="nemotron-fp8")
+        expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-fp8"]
+        assert model.model_id_names == [expected_hf_id]
+
+    def test_setup_no_vllm(self) -> None:
+        """Raise ImportError when vLLM is unavailable."""
+        with patch("nemo_curator.models.nemotron_h_vl.VLLM_AVAILABLE", False):
+            model = NemotronHVL(model_dir=self.model_dir)
+            with pytest.raises(ImportError, match="vllm is required for NemotronHVL"):
+                model.setup()
+
+    @patch("nemo_curator.models.nemotron_h_vl.SamplingParams")
+    @patch("nemo_curator.models.nemotron_h_vl.LLM")
+    def test_setup_bf16(self, mock_llm: Mock, mock_sampling_params: Mock) -> None:
+        """Initialize LLM with BF16 settings (no quantization)."""
+        mock_llm_instance = Mock()
+        mock_llm.return_value = mock_llm_instance
+        mock_sampling_params_instance = Mock()
+        mock_sampling_params.return_value = mock_sampling_params_instance
+
+        model = NemotronHVL(model_dir=self.model_dir, model_variant="nemotron-bf16")
+        model.setup()
+
+        mock_llm.assert_called_once_with(
+            model=model.weight_file,
+            trust_remote_code=True,
+            dtype="bfloat16",
+            tensor_parallel_size=1,
+            gpu_memory_utilization=0.9,
+            max_model_len=32768,
+            limit_mm_per_prompt={"video": 1},
+            quantization=None,
+            video_pruning_rate=0,
+        )
+        mock_sampling_params.assert_called_once_with(
+            temperature=0.6,
+            max_tokens=model.max_output_tokens,
+            top_p=0.95,
+            stop=["</s>", "<|endoftext|>", "<SPECIAL_12>", "</think>"],
+        )
+        assert model.model is mock_llm_instance
+        assert model.sampling_params is mock_sampling_params_instance
+
+    @patch("nemo_curator.models.nemotron_h_vl.SamplingParams")
+    @patch("nemo_curator.models.nemotron_h_vl.LLM")
+    def test_setup_fp8(self, mock_llm: Mock, mock_sampling_params: Mock) -> None:
+        """Initialize LLM with FP8 quantization settings."""
+        mock_llm_instance = Mock()
+        mock_llm.return_value = mock_llm_instance
+        mock_sampling_params.return_value = Mock()
+
+        model = NemotronHVL(model_dir=self.model_dir, model_variant="nemotron-fp8")
+        model.setup()
+
+        mock_llm.assert_called_once_with(
+            model=model.weight_file,
+            trust_remote_code=True,
+            dtype="auto",
+            tensor_parallel_size=1,
+            gpu_memory_utilization=0.9,
+            max_model_len=32768,
+            limit_mm_per_prompt={"video": 1},
+            quantization="modelopt",
+            video_pruning_rate=0,
+        )
+
+    @patch("nemo_curator.models.nemotron_h_vl.SamplingParams")
+    @patch("nemo_curator.models.nemotron_h_vl.LLM")
+    def test_setup_nvfp4(self, mock_llm: Mock, mock_sampling_params: Mock) -> None:
+        """Initialize LLM with NVFP4 quantization settings."""
+        mock_llm_instance = Mock()
+        mock_llm.return_value = mock_llm_instance
+        mock_sampling_params.return_value = Mock()
+
+        model = NemotronHVL(model_dir=self.model_dir, model_variant="nemotron-nvfp4")
+        model.setup()
+
+        mock_llm.assert_called_once_with(
+            model=model.weight_file,
+            trust_remote_code=True,
+            dtype="auto",
+            tensor_parallel_size=1,
+            gpu_memory_utilization=0.9,
+            max_model_len=32768,
+            limit_mm_per_prompt={"video": 1},
+            quantization="modelopt_fp4",
+            video_pruning_rate=0,
+        )
+
+    @patch("nemo_curator.models.nemotron_h_vl.grouping.split_by_chunk_size")
+    def test_generate_basic(self, mock_split_by_chunk_size: Mock) -> None:
+        """Generate captions for a single batch without stage2."""
+        mock_model = Mock()
+        self.model.model = mock_model
+        self.model.sampling_params = Mock()
+
+        videos = [
+            {"prompt": "Describe this video", "multi_modal_data": {"video": "video1"}},
+            {"prompt": "What is happening?", "multi_modal_data": {"video": "video2"}},
+        ]
+        mock_split_by_chunk_size.return_value = [videos]
+
+        out1, out2 = Mock(), Mock()
+        out1.outputs = [Mock(text="Text 1")]
+        out2.outputs = [Mock(text="Text 2")]
+        mock_model.generate.return_value = [out1, out2]
+
+        result = self.model.generate(videos, batch_size=16)
+
+        assert result == ["Text 1", "Text 2"]
+        mock_split_by_chunk_size.assert_called_once_with(videos, 16)
+        assert mock_model.generate.call_count == 1
+        args, kwargs = mock_model.generate.call_args
+        assert args[0] == list(videos)
+        assert kwargs["sampling_params"] == self.model.sampling_params
+        assert kwargs["use_tqdm"] is False
+
+    @patch("nemo_curator.models.nemotron_h_vl.grouping.split_by_chunk_size")
+    def test_generate_batched(self, mock_split_by_chunk_size: Mock) -> None:
+        """Generate captions across multiple batches."""
+        mock_model = Mock()
+        self.model.model = mock_model
+        self.model.sampling_params = Mock()
+
+        videos = [{"prompt": f"Video {i}", "multi_modal_data": {"video": f"video{i}"}} for i in range(4)]
+        batch1, batch2 = videos[:2], videos[2:]
+        mock_split_by_chunk_size.return_value = [batch1, batch2]
+
+        def gen_outputs(batch_idx: int) -> list[Mock]:
+            return [Mock(outputs=[Mock(text=f"B{batch_idx} T{i}")]) for i in range(2)]
+
+        mock_model.generate.side_effect = [gen_outputs(1), gen_outputs(2)]
+
+        result = self.model.generate(videos, batch_size=2)
+        assert result == ["B1 T0", "B1 T1", "B2 T0", "B2 T1"]
+        assert mock_model.generate.call_count == 2
+
+    @patch("nemo_curator.models.nemotron_h_vl.grouping.split_by_chunk_size")
+    def test_generate_stage2(self, mock_split_by_chunk_size: Mock) -> None:
+        """Generate with stage2 refinement flow."""
+        mock_model = Mock()
+        self.model.model = mock_model
+        self.model.sampling_params = Mock()
+
+        videos = [{"prompt": "Human: <video>test<SPECIAL_11>Assistant", "multi_modal_data": {"video": "video1"}}]
+        mock_split_by_chunk_size.return_value = [videos]
+
+        out_stage1, out_stage2 = Mock(), Mock()
+        out_stage1.outputs = [Mock(text="Stage 1")]
+        out_stage2.outputs = [Mock(text="Stage 2")]
+        mock_model.generate.side_effect = [[out_stage1], [out_stage2]]
+
+        result = self.model.generate(videos, generate_stage2_caption=True, batch_size=16)
+        assert result == ["Stage 2"]
+
+        assert mock_model.generate.call_count == 2
+        second_args, _ = mock_model.generate.call_args
+        updated_inputs = second_args[0]
+        assert "Test stage2: Stage 1" in updated_inputs[0]["prompt"]
+        assert updated_inputs[0]["multi_modal_data"]["video"] == "video1"
+
+    def test_generate_empty(self) -> None:
+        """Return empty when no videos are provided."""
+        assert self.model.generate([]) == []
+
+    @patch("nemo_curator.models.nemotron_h_vl.logger")
+    @patch("nemo_curator.models.nemotron_h_vl.grouping.split_by_chunk_size")
+    def test_generate_error(self, mock_split_by_chunk_size: Mock, mock_logger: Mock) -> None:
+        """Log and raise on generation errors."""
+        mock_model = Mock()
+        self.model.model = mock_model
+        self.model.sampling_params = Mock()
+
+        videos = [{"prompt": "Test", "multi_modal_data": {"video": "video1"}}]
+        mock_split_by_chunk_size.return_value = [videos]
+
+        mock_model.generate.side_effect = Exception("Test error")
+
+        with pytest.raises(Exception, match="Test error"):
+            self.model.generate(videos)
+
+        mock_logger.error.assert_called_once()
+
+    @patch("nemo_curator.models.nemotron_h_vl.download_model_from_hf")
+    def test_download_weights_bf16(self, mock_download: Mock) -> None:
+        """Download BF16 weights from HuggingFace."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            NemotronHVL.download_weights_on_node(tmpdir, variant="nemotron-bf16")
+
+            expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-bf16"]
+            expected_path = pathlib.Path(tmpdir) / expected_hf_id
+
+            mock_download.assert_called_once_with(
+                model_id=expected_hf_id,
+                local_dir=expected_path,
+                revision=_NEMOTRON_REVISION_INFO["nemotron-bf16"],
+            )
+
+    @patch("nemo_curator.models.nemotron_h_vl.download_model_from_hf")
+    def test_download_weights_fp8(self, mock_download: Mock) -> None:
+        """Download FP8 weights from HuggingFace."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            NemotronHVL.download_weights_on_node(tmpdir, variant="nemotron-fp8")
+
+            expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-fp8"]
+            expected_path = pathlib.Path(tmpdir) / expected_hf_id
+
+            mock_download.assert_called_once_with(
+                model_id=expected_hf_id,
+                local_dir=expected_path,
+                revision=_NEMOTRON_REVISION_INFO["nemotron-fp8"],
+            )
+
+    @patch("nemo_curator.models.nemotron_h_vl.download_model_from_hf")
+    def test_download_weights_nvfp4(self, mock_download: Mock) -> None:
+        """Download NVFP4 weights from HuggingFace."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            NemotronHVL.download_weights_on_node(tmpdir, variant="nemotron-nvfp4")
+
+            expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-nvfp4"]
+            expected_path = pathlib.Path(tmpdir) / expected_hf_id
+
+            mock_download.assert_called_once_with(
+                model_id=expected_hf_id,
+                local_dir=expected_path,
+                revision=_NEMOTRON_REVISION_INFO["nemotron-nvfp4"],
+            )
+
+    @patch("nemo_curator.models.nemotron_h_vl.download_model_from_hf")
+    def test_download_weights_default_variant(self, mock_download: Mock) -> None:
+        """Download default variant (nemotron -> bf16) from HuggingFace."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            NemotronHVL.download_weights_on_node(tmpdir, variant="nemotron")
+
+            expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron"]
+            expected_path = pathlib.Path(tmpdir) / expected_hf_id
+
+            mock_download.assert_called_once_with(
+                model_id=expected_hf_id,
+                local_dir=expected_path,
+                revision=_NEMOTRON_REVISION_INFO["nemotron"],
+            )
+
+    def test_download_weights_already_exists(self) -> None:
+        """Skip download when weights already exist."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create the expected directory with a safetensors file
+            expected_hf_id = _NEMOTRON_VARIANTS_INFO["nemotron-bf16"]
+            model_path = pathlib.Path(tmpdir) / expected_hf_id
+            model_path.mkdir(parents=True)
+            (model_path / "model.safetensors").write_bytes(b"fake")
+
+            with patch("nemo_curator.models.nemotron_h_vl.download_model_from_hf") as mock_download:
+                NemotronHVL.download_weights_on_node(tmpdir, variant="nemotron-bf16")
+                mock_download.assert_not_called()
+
+    def test_download_weights_invalid_variant(self) -> None:
+        """Raise ValueError for invalid variant."""
+        with tempfile.TemporaryDirectory() as tmpdir, pytest.raises(ValueError, match="Invalid variant: invalid"):
+            NemotronHVL.download_weights_on_node(tmpdir, variant="invalid")  # type: ignore[arg-type]
+
+    def test_refine_caption_prompt_with_video_tag(self) -> None:
+        """Test _refine_caption_prompt with video tag in prompt."""
+        original_prompt = "Human: <video>original question<SPECIAL_11>Assistant"
+        refinement_text = "Please refine: initial caption"
+
+        result = self.model._refine_caption_prompt(original_prompt, refinement_text)
+
+        assert "<video>" in result
+        assert "Please refine: initial caption" in result
+        assert "<SPECIAL_11>Assistant" in result
+
+    def test_refine_caption_prompt_without_video_tag(self) -> None:
+        """Test _refine_caption_prompt without video tag returns refinement text."""
+        original_prompt = "Human: original question"
+        refinement_text = "Please refine: initial caption"
+
+        result = self.model._refine_caption_prompt(original_prompt, refinement_text)
+
+        assert result == refinement_text
diff --git a/tests/models/test_prompt_formatter.py b/tests/models/test_prompt_formatter.py
index ba2ff974b3..f48d98e795 100644
--- a/tests/models/test_prompt_formatter.py
+++ b/tests/models/test_prompt_formatter.py
@@ -16,14 +16,35 @@
 
 from unittest.mock import Mock, patch
 
+import numpy as np
 import pytest
 import torch
 
 from nemo_curator.models.prompt_formatter import VARIANT_MAPPING, PromptFormatter
 
 
-class TestPromptFormatter:
-    """Test cases for PromptFormatter class."""
+class TestPromptFormatterVariantMapping:
+    """Test cases for variant mapping constants."""
+
+    def test_variant_mapping_contains_all_variants(self) -> None:
+        """Test that all expected variants are in mapping."""
+        expected_variants = {"qwen", "nemotron", "nemotron-bf16", "nemotron-fp8", "nemotron-nvfp4"}
+        assert set(VARIANT_MAPPING.keys()) == expected_variants
+
+    def test_variant_mapping_qwen_hf_id(self) -> None:
+        """Test that Qwen variant has correct HuggingFace ID."""
+        assert VARIANT_MAPPING["qwen"] == "Qwen/Qwen2.5-VL-7B-Instruct"
+
+    def test_variant_mapping_nemotron_hf_ids(self) -> None:
+        """Test that Nemotron variants have correct HuggingFace IDs."""
+        assert VARIANT_MAPPING["nemotron"] == "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16"
+        assert VARIANT_MAPPING["nemotron-bf16"] == "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-BF16"
+        assert VARIANT_MAPPING["nemotron-fp8"] == "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-FP8"
+        assert VARIANT_MAPPING["nemotron-nvfp4"] == "nvidia/NVIDIA-Nemotron-Nano-12B-v2-VL-NVFP4-QAD"
+
+
+class TestPromptFormatterQwen:
+    """Test cases for PromptFormatter with Qwen variant."""
 
     def setup_method(self) -> None:
         """Set up test fixtures."""
@@ -33,11 +54,6 @@ def setup_method(self) -> None:
             self.formatter = PromptFormatter(prompt_variant="qwen")
             self.mock_processor = mock_processor_instance
 
-    def test_variant_mapping_constants(self) -> None:
-        """Test that variant mapping constants are correctly defined."""
-        assert "qwen" in VARIANT_MAPPING
-        assert VARIANT_MAPPING["qwen"] == "Qwen/Qwen2.5-VL-7B-Instruct"
-
     def test_initialization_valid_variant(self) -> None:
         """Test initialization with valid prompt variant."""
         with patch("nemo_curator.models.prompt_formatter.AutoProcessor") as mock_processor:
@@ -49,7 +65,7 @@ def test_initialization_valid_variant(self) -> None:
             assert formatter.prompt_variant == "qwen"
             assert formatter.text_prompt is None
             assert formatter.processor == mock_processor_instance
-            mock_processor.from_pretrained.assert_called_once_with(VARIANT_MAPPING["qwen"])
+            mock_processor.from_pretrained.assert_called_once_with(VARIANT_MAPPING["qwen"], trust_remote_code=True)
 
     def test_initialization_invalid_variant(self) -> None:
         """Test initialization with invalid prompt variant raises ValueError."""
@@ -59,19 +75,16 @@ def test_initialization_invalid_variant(self) -> None:
     @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
     def test_generate_inputs_first_time(self, mock_processor_class: Mock) -> None:
         """Test generate_inputs method when text_prompt is None (first time)."""
-        # Setup mock processor
         mock_processor_instance = Mock()
         mock_processor_class.from_pretrained.return_value = mock_processor_instance
         mock_processor_instance.apply_chat_template.return_value = "formatted_prompt"
 
         formatter = PromptFormatter(prompt_variant="qwen")
 
-        # Create mock video tensor
         video_tensor = torch.randn(1, 3, 224, 224)
 
         result = formatter.generate_inputs(prompt="Test prompt", video_inputs=video_tensor)
 
-        # Verify the result structure
         assert isinstance(result, dict)
         assert "prompt" in result
         assert "multi_modal_data" in result
@@ -81,7 +94,7 @@ def test_generate_inputs_first_time(self, mock_processor_class: Mock) -> None:
         # Verify processor was called correctly
         expected_message = [{"role": "user", "content": [{"type": "video"}, {"type": "text", "text": "Test prompt"}]}]
         mock_processor_instance.apply_chat_template.assert_called_once_with(
-            expected_message, tokenizer=False, add_generation_prompt=True
+            expected_message, tokenize=False, add_generation_prompt=True
         )
 
         # Verify text_prompt was cached
@@ -90,44 +103,36 @@ def test_generate_inputs_first_time(self, mock_processor_class: Mock) -> None:
     @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
     def test_generate_inputs_cached_prompt(self, mock_processor_class: Mock) -> None:
         """Test generate_inputs method when text_prompt is already cached."""
-        # Setup mock processor
         mock_processor_instance = Mock()
         mock_processor_class.from_pretrained.return_value = mock_processor_instance
 
         formatter = PromptFormatter(prompt_variant="qwen")
-        formatter.text_prompt = "cached_prompt"  # Pre-set cached prompt
+        formatter.text_prompt = "cached_prompt"
 
         video_tensor = torch.randn(1, 3, 224, 224)
 
         result = formatter.generate_inputs(prompt="Test prompt", video_inputs=video_tensor)
 
-        # Verify cached prompt is used
         assert result["prompt"] == "cached_prompt"
         assert result["multi_modal_data"]["video"] is video_tensor
-
-        # Verify processor was NOT called since prompt is cached
         mock_processor_instance.apply_chat_template.assert_not_called()
 
     @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
     def test_generate_inputs_override_text_prompt(self, mock_processor_class: Mock) -> None:
         """Test generate_inputs method with override_text_prompt=True."""
-        # Setup mock processor
         mock_processor_instance = Mock()
         mock_processor_class.from_pretrained.return_value = mock_processor_instance
         mock_processor_instance.apply_chat_template.return_value = "new_formatted_prompt"
 
         formatter = PromptFormatter(prompt_variant="qwen")
-        formatter.text_prompt = "old_cached_prompt"  # Pre-set cached prompt
+        formatter.text_prompt = "old_cached_prompt"
 
         video_tensor = torch.randn(1, 3, 224, 224)
 
         result = formatter.generate_inputs(prompt="Test prompt", video_inputs=video_tensor, override_text_prompt=True)
 
-        # Verify new prompt is generated and cached
         assert result["prompt"] == "new_formatted_prompt"
         assert formatter.text_prompt == "new_formatted_prompt"
-
-        # Verify processor was called even though prompt was cached
         mock_processor_instance.apply_chat_template.assert_called_once()
 
     @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
@@ -144,9 +149,9 @@ def test_generate_inputs_no_video_inputs(self, mock_processor_class: Mock) -> No
         assert result["prompt"] == "formatted_prompt"
         assert result["multi_modal_data"]["video"] is None
 
-    def test_create_message(self) -> None:
-        """Test create_message method creates correct message structure."""
-        result = self.formatter.create_message("Test prompt text")
+    def test_create_qwen_message(self) -> None:
+        """Test _create_qwen_message method creates correct message structure."""
+        result = self.formatter._create_qwen_message("Test prompt text")
 
         expected_message = [
             {"role": "user", "content": [{"type": "video"}, {"type": "text", "text": "Test prompt text"}]}
@@ -159,36 +164,168 @@ def test_create_message(self) -> None:
         assert len(result[0]["content"]) == 2
         assert result[0]["content"][0]["type"] == "video"
         assert result[0]["content"][1]["type"] == "text"
-        assert result[0]["content"][1]["text"] == "Test prompt text"
-
-    def test_create_message_empty_prompt(self) -> None:
-        """Test create_message method with empty prompt."""
-        result = self.formatter.create_message("")
 
+    def test_create_qwen_message_empty_prompt(self) -> None:
+        """Test _create_qwen_message method with empty prompt."""
+        result = self.formatter._create_qwen_message("")
         assert result[0]["content"][1]["text"] == ""
 
-    def test_create_message_special_characters(self) -> None:
-        """Test create_message method with special characters in prompt."""
+    def test_create_qwen_message_special_characters(self) -> None:
+        """Test _create_qwen_message method with special characters in prompt."""
         special_prompt = "Test with 特殊字符 and émojis 🎉"
-        result = self.formatter.create_message(special_prompt)
-
+        result = self.formatter._create_qwen_message(special_prompt)
         assert result[0]["content"][1]["text"] == special_prompt
 
+
+class TestPromptFormatterNemotron:
+    """Test cases for PromptFormatter with Nemotron variants."""
+
     @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
-    def test_processor_interaction(self, mock_processor_class: Mock) -> None:
-        """Test that the processor is correctly initialized and used."""
+    def test_initialization_nemotron(self, mock_processor_class: Mock) -> None:
+        """Test Nemotron initialization uses AutoProcessor from HuggingFace."""
         mock_processor_instance = Mock()
         mock_processor_class.from_pretrained.return_value = mock_processor_instance
 
-        # Create formatter and verify processor initialization
-        formatter = PromptFormatter(prompt_variant="qwen")
-        mock_processor_class.from_pretrained.assert_called_once_with(VARIANT_MAPPING["qwen"])
+        formatter = PromptFormatter(prompt_variant="nemotron")
 
-        # Test processor method call
-        mock_processor_instance.apply_chat_template.return_value = "test_output"
-        formatter.generate_inputs("test prompt")
+        assert formatter.prompt_variant == "nemotron"
+        assert formatter.processor == mock_processor_instance
+        mock_processor_class.from_pretrained.assert_called_once_with(
+            VARIANT_MAPPING["nemotron"], trust_remote_code=True
+        )
 
-        # Verify apply_chat_template was called with correct parameters
-        mock_processor_instance.apply_chat_template.assert_called_once_with(
-            formatter.create_message("test prompt"), tokenizer=False, add_generation_prompt=True
+    @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
+    def test_initialization_nemotron_fp8(self, mock_processor_class: Mock) -> None:
+        """Test nemotron-fp8 initialization uses correct HuggingFace model ID."""
+        mock_processor_instance = Mock()
+        mock_processor_class.from_pretrained.return_value = mock_processor_instance
+
+        formatter = PromptFormatter(prompt_variant="nemotron-fp8")
+
+        assert formatter.prompt_variant == "nemotron-fp8"
+        mock_processor_class.from_pretrained.assert_called_once_with(
+            VARIANT_MAPPING["nemotron-fp8"], trust_remote_code=True
         )
+
+    @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
+    def test_generate_inputs_nemotron(self, mock_processor_class: Mock) -> None:
+        """Test generate_inputs for Nemotron variant with video metadata."""
+        mock_processor_instance = Mock()
+        mock_processor_class.from_pretrained.return_value = mock_processor_instance
+        mock_processor_instance.apply_chat_template.return_value = "nemotron_formatted_prompt"
+
+        formatter = PromptFormatter(prompt_variant="nemotron")
+
+        # Create video tensor (T, C, H, W)
+        video_tensor = torch.randint(0, 255, (10, 3, 224, 224), dtype=torch.uint8)
+
+        result = formatter.generate_inputs(prompt="Test prompt", video_inputs=video_tensor, fps=2.0)
+
+        assert result["prompt"] == "nemotron_formatted_prompt"
+
+        # Verify video is returned as tuple with metadata
+        video_data = result["multi_modal_data"]["video"]
+        assert isinstance(video_data, tuple)
+        assert len(video_data) == 2
+
+        video_np, metadata = video_data
+        assert isinstance(video_np, np.ndarray)
+        assert video_np.shape == (10, 224, 224, 3)  # Converted to (T, H, W, C)
+        assert metadata["fps"] == 2.0
+        assert metadata["frames_indices"] == list(range(10))
+
+    @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
+    def test_generate_inputs_nemotron_no_video(self, mock_processor_class: Mock) -> None:
+        """Test generate_inputs for Nemotron variant without video."""
+        mock_processor_instance = Mock()
+        mock_processor_class.from_pretrained.return_value = mock_processor_instance
+        mock_processor_instance.apply_chat_template.return_value = "prompt"
+
+        formatter = PromptFormatter(prompt_variant="nemotron")
+
+        result = formatter.generate_inputs(prompt="Test prompt", video_inputs=None)
+
+        assert result["multi_modal_data"]["video"] is None
+
+    @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
+    def test_generate_inputs_nemotron_numpy_video(self, mock_processor_class: Mock) -> None:
+        """Test generate_inputs for Nemotron variant with numpy video."""
+        mock_processor_instance = Mock()
+        mock_processor_class.from_pretrained.return_value = mock_processor_instance
+        mock_processor_instance.apply_chat_template.return_value = "prompt"
+
+        formatter = PromptFormatter(prompt_variant="nemotron")
+
+        # Create numpy video (T, H, W, C) - already in correct format
+        rng = np.random.default_rng(42)
+        video_np = rng.integers(0, 255, (10, 224, 224, 3), dtype=np.uint8)
+
+        result = formatter.generate_inputs(prompt="Test", video_inputs=video_np, fps=4.0)
+
+        video_data = result["multi_modal_data"]["video"]
+        assert isinstance(video_data, tuple)
+        assert video_data[1]["fps"] == 4.0
+
+    @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
+    def test_generate_inputs_nemotron_message_format(self, mock_processor_class: Mock) -> None:
+        """Test that Nemotron uses correct message format with system prompt."""
+        mock_processor_instance = Mock()
+        mock_processor_class.from_pretrained.return_value = mock_processor_instance
+        mock_processor_instance.apply_chat_template.return_value = "prompt"
+
+        formatter = PromptFormatter(prompt_variant="nemotron")
+        formatter.generate_inputs(prompt="Describe this video")
+
+        # Verify message format passed to apply_chat_template
+        call_args = mock_processor_instance.apply_chat_template.call_args
+        messages = call_args[0][0]
+
+        assert len(messages) == 2
+        assert messages[0]["role"] == "system"
+        assert messages[0]["content"] == "You are a helpful assistant."
+        assert messages[1]["role"] == "user"
+        assert "<video>\nDescribe this video" in messages[1]["content"][0]["text"]
+
+
+class TestPromptFormatterConvertToNumpy:
+    """Test cases for _convert_to_numpy method."""
+
+    @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
+    def test_convert_tensor_to_numpy(self, mock_processor_class: Mock) -> None:
+        """Test converting torch tensor to numpy array."""
+        mock_processor_class.from_pretrained.return_value = Mock()
+        formatter = PromptFormatter(prompt_variant="nemotron")
+
+        # Tensor in (T, C, H, W) format
+        tensor = torch.randint(0, 255, (10, 3, 224, 224), dtype=torch.uint8)
+        result = formatter._convert_to_numpy(tensor)
+
+        assert isinstance(result, np.ndarray)
+        assert result.shape == (10, 224, 224, 3)  # Converted to (T, H, W, C)
+        assert result.dtype == np.uint8
+
+    @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
+    def test_convert_float_tensor_to_uint8(self, mock_processor_class: Mock) -> None:
+        """Test converting float tensor (0-1 range) to uint8."""
+        mock_processor_class.from_pretrained.return_value = Mock()
+        formatter = PromptFormatter(prompt_variant="nemotron")
+
+        # Float tensor in 0-1 range
+        tensor = torch.rand(10, 3, 224, 224, dtype=torch.float32)
+        result = formatter._convert_to_numpy(tensor)
+
+        assert result.dtype == np.uint8
+        assert result.max() <= 255
+
+    @patch("nemo_curator.models.prompt_formatter.AutoProcessor")
+    def test_passthrough_numpy_array(self, mock_processor_class: Mock) -> None:
+        """Test passing through numpy array."""
+        mock_processor_class.from_pretrained.return_value = Mock()
+        formatter = PromptFormatter(prompt_variant="nemotron")
+
+        rng = np.random.default_rng(42)
+        arr = rng.integers(0, 255, (10, 224, 224, 3), dtype=np.uint8)
+        result = formatter._convert_to_numpy(arr)
+
+        assert isinstance(result, np.ndarray)
+        assert result.dtype == np.uint8
diff --git a/tests/models/test_qwen_vl.py b/tests/models/test_qwen_vl.py
index f7c93fcc4e..0fcce7e975 100644
--- a/tests/models/test_qwen_vl.py
+++ b/tests/models/test_qwen_vl.py
@@ -71,7 +71,7 @@ def test_initialization_default_parameters(self) -> None:
         assert qwen_vl.max_output_tokens == 512
         assert qwen_vl.model_does_preprocess is False
         assert qwen_vl.disable_mmcache is False
-        assert qwen_vl.stage2_prompt is None
+        assert qwen_vl.stage2_prompt == "Please refine this caption: "
         assert qwen_vl.verbose is False
 
         expected_weight_file = str(pathlib.Path(self.model_dir) / _QWEN_VARIANTS_INFO[self.model_variant])
diff --git a/tests/stages/video/caption/test_caption_generation.py b/tests/stages/video/caption/test_caption_generation.py
index 6b50356389..e6b0b9dcdb 100644
--- a/tests/stages/video/caption/test_caption_generation.py
+++ b/tests/stages/video/caption/test_caption_generation.py
@@ -105,26 +105,26 @@ def _create_test_video_task(self) -> VideoTask:
         # Create clips with windows
         clip1 = Clip(uuid=uuid4(), source_video="test1.mp4", span=(0.0, 10.0), buffer=b"test_buffer_1")
 
-        # Add windows with qwen_llm_input
+        # Add windows with llm_inputs
         window1 = _Window(
             start_frame=0,
             end_frame=10,
-            qwen_llm_input={"prompt": "test prompt 1", "multi_modal_data": {"video": "test_data_1"}},
+            llm_inputs={"qwen": {"prompt": "test prompt 1", "multi_modal_data": {"video": "test_data_1"}}},
         )
         window2 = _Window(
             start_frame=10,
             end_frame=20,
-            qwen_llm_input={"prompt": "test prompt 2", "multi_modal_data": {"video": "test_data_2"}},
+            llm_inputs={"qwen": {"prompt": "test prompt 2", "multi_modal_data": {"video": "test_data_2"}}},
         )
         clip1.windows = [window1, window2]
 
         clip2 = Clip(uuid=uuid4(), source_video="test2.mp4", span=(10.0, 20.0), buffer=b"test_buffer_2")
 
-        # Add window with qwen_llm_input
+        # Add window with llm_inputs
         window3 = _Window(
             start_frame=0,
             end_frame=15,
-            qwen_llm_input={"prompt": "test prompt 3", "multi_modal_data": {"video": "test_data_3"}},
+            llm_inputs={"qwen": {"prompt": "test prompt 3", "multi_modal_data": {"video": "test_data_3"}}},
         )
         clip2.windows = [window3]
 
@@ -160,7 +160,7 @@ def test_process_successful_generation(self):
         # Verify cleanup
         for clip in result.data.clips:
             for window in clip.windows:
-                assert window.qwen_llm_input is None
+                assert "qwen" not in window.llm_inputs
                 assert window.mp4_bytes is None
 
     def test_process_with_verbose_logging(self):
@@ -176,7 +176,9 @@ def test_process_with_verbose_logging(self):
         video = Video(input_video=pathlib.Path("test.mp4"))
         clip = Clip(uuid=uuid4(), source_video="test.mp4", span=(0.0, 5.0), buffer=b"test_buffer")
         window = _Window(
-            start_frame=0, end_frame=5, qwen_llm_input={"prompt": "test", "multi_modal_data": {"video": "data"}}
+            start_frame=0,
+            end_frame=5,
+            llm_inputs={"qwen": {"prompt": "test", "multi_modal_data": {"video": "data"}}},
         )
         clip.windows = [window]
         video.clips = [clip]
@@ -210,7 +212,7 @@ def test_process_empty_windows(self, mock_logger: Mock):
 
     @patch("nemo_curator.stages.video.caption.caption_generation.logger")
     def test_process_window_without_input(self, mock_logger: Mock):
-        """Test process method with windows that have no qwen_llm_input."""
+        """Test process method with windows that have no llm_inputs."""
         mock_model = Mock()
         mock_model.generate.return_value = []
         self.stage.model = mock_model
@@ -219,8 +221,8 @@ def test_process_window_without_input(self, mock_logger: Mock):
 
         video = Video(input_video=pathlib.Path("test.mp4"))
         clip = Clip(uuid=uuid4(), source_video="test.mp4", span=(0.0, 5.0), buffer=b"test_buffer")
-        # Window without qwen_llm_input
-        window = _Window(start_frame=0, end_frame=5, qwen_llm_input=None)
+        # Window without llm_inputs
+        window = _Window(start_frame=0, end_frame=5)
         clip.windows = [window]
         video.clips = [clip]
         task = VideoTask(task_id="test", dataset_name="test", data=video)
@@ -228,8 +230,8 @@ def test_process_window_without_input(self, mock_logger: Mock):
         self.stage.process(task)
 
         # Verify error was logged and set
-        mock_logger.error.assert_called_once_with(f"Clip {clip.uuid} window 0 has no prepared inputs.")
-        assert clip.errors["window-0"] == "empty"
+        mock_logger.error.assert_called_once_with(f"Clip {clip.uuid} window 0 has no prepared inputs for qwen.")
+        assert clip.errors["window-0"] == "no_qwen_input"
 
     def test_assign_captions(self):
         """Test _assign_captions method."""
@@ -293,7 +295,9 @@ def test_process_with_stage2_caption(self):
         video = Video(input_video=pathlib.Path("test.mp4"))
         clip = Clip(uuid=uuid4(), source_video="test.mp4", span=(0.0, 5.0), buffer=b"test_buffer")
         window = _Window(
-            start_frame=0, end_frame=5, qwen_llm_input={"prompt": "test", "multi_modal_data": {"video": "data"}}
+            start_frame=0,
+            end_frame=5,
+            llm_inputs={"qwen": {"prompt": "test", "multi_modal_data": {"video": "data"}}},
         )
         clip.windows = [window]
         video.clips = [clip]
@@ -328,3 +332,73 @@ def test_stage_with_worker_metadata(self):
             worker_metadata = WorkerMetadata(worker_id="test")
             self.stage.setup(worker_metadata)
             assert hasattr(self.stage, "model")
+
+    @patch("nemo_curator.stages.video.caption.caption_generation.NemotronHVL")
+    def test_setup_nemotron_variant(self, mock_nemotron_vl: Mock):
+        """Test setup method with nemotron variant."""
+        mock_model = Mock()
+        mock_nemotron_vl.return_value = mock_model
+
+        stage = CaptionGenerationStage(
+            model_dir="test/models",
+            model_variant="nemotron",
+            caption_batch_size=2,
+            max_output_tokens=256,
+            verbose=True,
+        )
+        stage.setup()
+
+        mock_nemotron_vl.assert_called_once_with(
+            model_dir="test/models",
+            model_variant="nemotron",
+            caption_batch_size=2,
+            max_output_tokens=256,
+            stage2_prompt_text=None,
+            verbose=True,
+        )
+        mock_model.setup.assert_called_once()
+        assert stage.model == mock_model
+
+    def test_process_nemotron_with_generic_llm_inputs(self):
+        """Test process method with nemotron using generic llm_inputs."""
+        mock_model = Mock()
+        mock_model.generate.return_value = ["Nemotron caption 1", "Nemotron caption 2"]
+
+        stage = CaptionGenerationStage(
+            model_dir="test/models",
+            model_variant="nemotron",
+            caption_batch_size=2,
+        )
+        stage.model = mock_model
+
+        import pathlib
+
+        video = Video(input_video=pathlib.Path("test.mp4"))
+        clip = Clip(uuid=uuid4(), source_video="test.mp4", span=(0.0, 10.0), buffer=b"test_buffer")
+
+        # Create windows with nemotron llm_inputs
+        window1 = _Window(
+            start_frame=0,
+            end_frame=10,
+            llm_inputs={"nemotron": {"prompt": "nemotron prompt 1", "multi_modal_data": {"video": "data1"}}},
+        )
+
+        window2 = _Window(
+            start_frame=10,
+            end_frame=20,
+            llm_inputs={"nemotron": {"prompt": "nemotron prompt 2", "multi_modal_data": {"video": "data2"}}},
+        )
+
+        clip.windows = [window1, window2]
+        video.clips = [clip]
+        task = VideoTask(task_id="test", dataset_name="test", data=video)
+
+        result = stage.process(task)
+
+        # Verify captions were assigned with nemotron key
+        assert result.data.clips[0].windows[0].caption["nemotron"] == "Nemotron caption 1"
+        assert result.data.clips[0].windows[1].caption["nemotron"] == "Nemotron caption 2"
+
+        # Verify cleanup - nemotron inputs should be deleted
+        assert "nemotron" not in result.data.clips[0].windows[0].llm_inputs
+        assert "nemotron" not in result.data.clips[0].windows[1].llm_inputs
diff --git a/tests/stages/video/caption/test_caption_preparation.py b/tests/stages/video/caption/test_caption_preparation.py
index 0bce345b92..e158af74dc 100644
--- a/tests/stages/video/caption/test_caption_preparation.py
+++ b/tests/stages/video/caption/test_caption_preparation.py
@@ -216,11 +216,11 @@ def test_process_successful(self, mock_get_prompt: Mock, mock_split_video: Mock)
             assert window1.start_frame == 0
             assert window1.end_frame == 10
             assert window1.mp4_bytes == b"window1_bytes"
-            # Check structure of qwen_llm_input (can't compare tensors directly)
-            assert "prompt" in window1.qwen_llm_input
-            assert "multi_modal_data" in window1.qwen_llm_input
-            assert window1.qwen_llm_input["prompt"] == "test formatted prompt"
-            assert "video" in window1.qwen_llm_input["multi_modal_data"]
+            # Check structure of llm_inputs["qwen"] (can't compare tensors directly)
+            assert "prompt" in window1.llm_inputs["qwen"]
+            assert "multi_modal_data" in window1.llm_inputs["qwen"]
+            assert window1.llm_inputs["qwen"]["prompt"] == "test formatted prompt"
+            assert "video" in window1.llm_inputs["qwen"]["multi_modal_data"]
 
     @patch("nemo_curator.stages.video.caption.caption_preparation.logger")
     def test_process_clip_without_buffer(self, mock_logger: Mock):
@@ -417,3 +417,59 @@ def test_process_empty_windowing_result(self, mock_split_video: Mock):
 
             # Verify formatter was not called
             mock_formatter.generate_inputs.assert_not_called()
+
+
+class TestCaptionPreparationStageNemotron:
+    """Test cases for CaptionPreparationStage with Nemotron variants.
+
+    Note: Nemotron now uses AutoProcessor from HuggingFace, same as Qwen.
+    """
+
+    def test_init_nemotron_variant(self):
+        """Test initialization with nemotron variant."""
+        stage = CaptionPreparationStage(model_variant="nemotron")
+        assert stage.model_variant == "nemotron"
+
+    def test_init_nemotron_fp8_variant(self):
+        """Test initialization with nemotron-fp8 variant."""
+        stage = CaptionPreparationStage(model_variant="nemotron-fp8")
+        assert stage.model_variant == "nemotron-fp8"
+
+    def test_init_nemotron_nvfp4_variant(self):
+        """Test initialization with nemotron-nvfp4 variant."""
+        stage = CaptionPreparationStage(model_variant="nemotron-nvfp4")
+        assert stage.model_variant == "nemotron-nvfp4"
+
+    @patch("nemo_curator.stages.video.caption.caption_preparation.PromptFormatter")
+    def test_setup_nemotron_variant(self, mock_prompt_formatter: Mock):
+        """Test setup method with nemotron variant uses PromptFormatter."""
+        mock_formatter = Mock()
+        mock_prompt_formatter.return_value = mock_formatter
+
+        stage = CaptionPreparationStage(model_variant="nemotron")
+        stage.setup()
+
+        mock_prompt_formatter.assert_called_once_with("nemotron")
+        assert stage.prompt_formatter == mock_formatter
+
+    @patch("nemo_curator.stages.video.caption.caption_preparation.PromptFormatter")
+    def test_setup_nemotron_fp8_variant(self, mock_prompt_formatter: Mock):
+        """Test setup method with nemotron-fp8 variant."""
+        mock_formatter = Mock()
+        mock_prompt_formatter.return_value = mock_formatter
+
+        stage = CaptionPreparationStage(model_variant="nemotron-fp8")
+        stage.setup()
+
+        mock_prompt_formatter.assert_called_once_with("nemotron-fp8")
+
+    @patch("nemo_curator.stages.video.caption.caption_preparation.PromptFormatter")
+    def test_setup_nemotron_nvfp4_variant(self, mock_prompt_formatter: Mock):
+        """Test setup method with nemotron-nvfp4 variant."""
+        mock_formatter = Mock()
+        mock_prompt_formatter.return_value = mock_formatter
+
+        stage = CaptionPreparationStage(model_variant="nemotron-nvfp4")
+        stage.setup()
+
+        mock_prompt_formatter.assert_called_once_with("nemotron-nvfp4")
diff --git a/tests/stages/video/io/test_clip_writer.py b/tests/stages/video/io/test_clip_writer.py
index cfd6af8f43..ad2829c96c 100644
--- a/tests/stages/video/io/test_clip_writer.py
+++ b/tests/stages/video/io/test_clip_writer.py
@@ -696,7 +696,7 @@ def test_process_success(self, mock_executor_class: MagicMock):
                 assert clip.cosmos_embed1_embedding is None
                 for window in clip.windows:
                     assert window.mp4_bytes is None
-                    assert window.qwen_llm_input is None
+                    assert window.llm_inputs == {}
                     assert window.caption == {}
                     assert window.enhanced_caption == {}
                     assert window.webp_bytes is None
diff --git a/tests/tasks/test_video.py b/tests/tasks/test_video.py
index c622f4b92a..a1442e162f 100644
--- a/tests/tasks/test_video.py
+++ b/tests/tasks/test_video.py
@@ -47,7 +47,7 @@ def test_window_initialization(self) -> None:
         assert window.start_frame == 0
         assert window.end_frame == 10
         assert window.mp4_bytes is None
-        assert window.qwen_llm_input is None
+        assert window.llm_inputs == {}
         assert window.x1_input is None
         assert window.caption == {}
         assert window.enhanced_caption == {}
@@ -65,7 +65,7 @@ def test_window_initialization_with_data(self) -> None:
             start_frame=5,
             end_frame=15,
             mp4_bytes=mp4_data,
-            qwen_llm_input=qwen_input,
+            llm_inputs={"qwen": qwen_input},
             webp_bytes=webp_data,
             caption=caption,
             enhanced_caption=enhanced_caption,
@@ -74,7 +74,7 @@ def test_window_initialization_with_data(self) -> None:
         assert window.start_frame == 5
         assert window.end_frame == 15
         assert window.mp4_bytes == mp4_data
-        assert window.qwen_llm_input == qwen_input
+        assert window.llm_inputs["qwen"] == qwen_input
         assert window.webp_bytes == webp_data
         assert window.caption == caption
         assert window.enhanced_caption == enhanced_caption
@@ -99,7 +99,7 @@ def test_get_major_size_with_data(self) -> None:
             start_frame=0,
             end_frame=10,
             mp4_bytes=mp4_data,
-            qwen_llm_input=qwen_input,
+            llm_inputs={"qwen": qwen_input},
             webp_bytes=webp_data,
             caption=caption,
             enhanced_caption=enhanced_caption,
diff --git a/tutorials/video/getting-started/video_split_clip_example.py b/tutorials/video/getting-started/video_split_clip_example.py
index 1b6b34264c..0aa6423626 100644
--- a/tutorials/video/getting-started/video_split_clip_example.py
+++ b/tutorials/video/getting-started/video_split_clip_example.py
@@ -185,6 +185,7 @@ def create_video_splitting_pipeline(args: argparse.Namespace) -> Pipeline:  # no
                 )
             )
 
+        # All models now use the standard model_dir (auto-downloaded from HuggingFace)
         pipeline.add_stage(
             CaptionGenerationStage(
                 model_dir=args.model_dir,
@@ -267,15 +268,16 @@ def create_video_splitting_argparser() -> argparse.ArgumentParser:  # noqa: PLR0
         default="./models",
         help=(
             "Path to model directory containing required model weights. "
-            "Models will be automatically downloaded on first use if not present. "
+            "Models will be automatically downloaded from HuggingFace on first use if not present. "
             "Required models depend on selected algorithms:\n"
             "  - TransNetV2: For scene detection (--splitting-algorithm transnetv2)\n"
             "  - Cosmos-Embed1: For embeddings (--embedding-algorithm cosmos-embed1-*)\n"
-            "  - Qwen: For captioning (--generate-captions)\n"
+            "  - Qwen2.5-VL: For captioning (--captioning-algorithm qwen)\n"
+            "  - Nemotron Nano VL: For captioning (--captioning-algorithm nemotron[-bf16|-fp8|-nvfp4])\n"
             "  - Aesthetic models: For filtering (--aesthetic-threshold)\n"
             "Default: ./models\n"
             "Example: --model-dir /path/to/models or --model-dir ./models"
-        )
+        ),
     )
     parser.add_argument("--video-limit", type=int, default=None, help="Limit the number of videos to read")
     parser.add_argument("--verbose", action="store_true", default=False)
@@ -555,8 +557,14 @@ def create_video_splitting_argparser() -> argparse.ArgumentParser:  # noqa: PLR0
         "--captioning-algorithm",
         type=str,
         default="qwen",
-        choices=["qwen"],
-        help="Captioning algorithm to use in annotation pipeline.",
+        choices=["qwen", "nemotron", "nemotron-bf16", "nemotron-fp8", "nemotron-nvfp4"],
+        help=(
+            "Captioning algorithm to use. Options:\n"
+            "  - qwen: Qwen2.5-VL-7B-Instruct (default)\n"
+            "  - nemotron / nemotron-bf16: Nemotron Nano 12B v2 VL BF16 (auto-downloaded from HF)\n"
+            "  - nemotron-fp8: Nemotron Nano 12B v2 VL FP8 quantized\n"
+            "  - nemotron-nvfp4: Nemotron Nano 12B v2 VL NVFP4-QAD quantized"
+        ),
     )
     parser.add_argument(
         "--captioning-window-size",
@@ -617,25 +625,28 @@ def create_video_splitting_argparser() -> argparse.ArgumentParser:  # noqa: PLR0
         dest="captioning_stage2_caption",
         action="store_true",
         default=False,
-        help="If set, generated captions are used as input prompts again into QwenVL to refine them",
+        help="If set, generated captions are refined with a second model pass (works for both Qwen and Nemotron)",
     )
     parser.add_argument(
         "--captioning-stage2-prompt-text",
         type=str,
         default=None,
-        help="Specify the input prompt used to generate stage2 Qwen captions",
+        help="Specify the prompt used for stage2 caption refinement.",
     )
     parser.add_argument(
         "--captioning-batch-size",
         type=int,
         default=8,
-        help="Batch size for Qwen captioning stage.",
+        help="Batch size for captioning stage (applies to both Qwen and Nemotron).",
     )
     parser.add_argument(
         "--captioning-use-fp8-weights",
         action="store_true",
         default=False,
-        help="Whether to use fp8 weights for Qwen VL model or not.",
+        help=(
+            "Whether to use fp8 weights for Qwen VL model. "
+            "Note: For Nemotron, use --captioning-algorithm nemotron-fp8 instead."
+        ),
     )
     parser.add_argument(
         "--captioning-max-output-tokens",
diff --git a/uv.lock b/uv.lock
index e75509e9f3..0b8dbae5f0 100644
--- a/uv.lock
+++ b/uv.lock
@@ -55,7 +55,7 @@ overrides = [
     { name = "numpy", specifier = ">=2.0.0,<=2.2.0" },
     { name = "protobuf", specifier = ">=5.29.5" },
     { name = "setuptools", specifier = ">=80.10.1" },
-    { name = "transformers", specifier = "<=4.55.2" },
+    { name = "transformers", specifier = ">=4.56.0,<5.0" },
 ]
 
 [[package]]
@@ -2620,6 +2620,7 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/6a/33d1702184d94106d3cdd7bfb788e19723206fce152e303473ca3b946c7b/greenlet-3.3.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:6f8496d434d5cb2dce025773ba5597f71f5410ae499d5dd9533e0653258cdb3d", size = 273658, upload-time = "2025-12-04T14:23:37.494Z" },
     { url = "https://files.pythonhosted.org/packages/d6/b7/2b5805bbf1907c26e434f4e448cd8b696a0b71725204fa21a211ff0c04a7/greenlet-3.3.0-cp310-cp310-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b96dc7eef78fd404e022e165ec55327f935b9b52ff355b067eb4a0267fc1cffb", size = 574810, upload-time = "2025-12-04T14:50:04.154Z" },
     { url = "https://files.pythonhosted.org/packages/94/38/343242ec12eddf3d8458c73f555c084359883d4ddc674240d9e61ec51fd6/greenlet-3.3.0-cp310-cp310-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:73631cd5cccbcfe63e3f9492aaa664d278fda0ce5c3d43aeda8e77317e38efbd", size = 586248, upload-time = "2025-12-04T14:57:39.35Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d0/0ae86792fb212e4384041e0ef8e7bc66f59a54912ce407d26a966ed2914d/greenlet-3.3.0-cp310-cp310-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b299a0cb979f5d7197442dccc3aee67fce53500cd88951b7e6c35575701c980b", size = 597403, upload-time = "2025-12-04T15:07:10.831Z" },
     { url = "https://files.pythonhosted.org/packages/b6/a8/15d0aa26c0036a15d2659175af00954aaaa5d0d66ba538345bd88013b4d7/greenlet-3.3.0-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7dee147740789a4632cace364816046e43310b59ff8fb79833ab043aefa72fd5", size = 586910, upload-time = "2025-12-04T14:25:59.705Z" },
     { url = "https://files.pythonhosted.org/packages/e1/9b/68d5e3b7ccaba3907e5532cf8b9bf16f9ef5056a008f195a367db0ff32db/greenlet-3.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:39b28e339fc3c348427560494e28d8a6f3561c8d2bcf7d706e1c624ed8d822b9", size = 1547206, upload-time = "2025-12-04T15:04:21.027Z" },
     { url = "https://files.pythonhosted.org/packages/66/bd/e3086ccedc61e49f91e2cfb5ffad9d8d62e5dc85e512a6200f096875b60c/greenlet-3.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b3c374782c2935cc63b2a27ba8708471de4ad1abaa862ffdb1ef45a643ddbb7d", size = 1613359, upload-time = "2025-12-04T14:27:26.548Z" },
@@ -2627,6 +2628,7 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/1f/cb/48e964c452ca2b92175a9b2dca037a553036cb053ba69e284650ce755f13/greenlet-3.3.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e29f3018580e8412d6aaf5641bb7745d38c85228dacf51a73bd4e26ddf2a6a8e", size = 274908, upload-time = "2025-12-04T14:23:26.435Z" },
     { url = "https://files.pythonhosted.org/packages/28/da/38d7bff4d0277b594ec557f479d65272a893f1f2a716cad91efeb8680953/greenlet-3.3.0-cp311-cp311-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a687205fb22794e838f947e2194c0566d3812966b41c78709554aa883183fb62", size = 577113, upload-time = "2025-12-04T14:50:05.493Z" },
     { url = "https://files.pythonhosted.org/packages/3c/f2/89c5eb0faddc3ff014f1c04467d67dee0d1d334ab81fadbf3744847f8a8a/greenlet-3.3.0-cp311-cp311-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:4243050a88ba61842186cb9e63c7dfa677ec146160b0efd73b855a3d9c7fcf32", size = 590338, upload-time = "2025-12-04T14:57:41.136Z" },
+    { url = "https://files.pythonhosted.org/packages/80/d7/db0a5085035d05134f8c089643da2b44cc9b80647c39e93129c5ef170d8f/greenlet-3.3.0-cp311-cp311-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:670d0f94cd302d81796e37299bcd04b95d62403883b24225c6b5271466612f45", size = 601098, upload-time = "2025-12-04T15:07:11.898Z" },
     { url = "https://files.pythonhosted.org/packages/dc/a6/e959a127b630a58e23529972dbc868c107f9d583b5a9f878fb858c46bc1a/greenlet-3.3.0-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6cb3a8ec3db4a3b0eb8a3c25436c2d49e3505821802074969db017b87bc6a948", size = 590206, upload-time = "2025-12-04T14:26:01.254Z" },
     { url = "https://files.pythonhosted.org/packages/48/60/29035719feb91798693023608447283b266b12efc576ed013dd9442364bb/greenlet-3.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2de5a0b09eab81fc6a382791b995b1ccf2b172a9fec934747a7a23d2ff291794", size = 1550668, upload-time = "2025-12-04T15:04:22.439Z" },
     { url = "https://files.pythonhosted.org/packages/0a/5f/783a23754b691bfa86bd72c3033aa107490deac9b2ef190837b860996c9f/greenlet-3.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4449a736606bd30f27f8e1ff4678ee193bc47f6ca810d705981cfffd6ce0d8c5", size = 1615483, upload-time = "2025-12-04T14:27:28.083Z" },
@@ -2634,6 +2636,7 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f8/0a/a3871375c7b9727edaeeea994bfff7c63ff7804c9829c19309ba2e058807/greenlet-3.3.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:b01548f6e0b9e9784a2c99c5651e5dc89ffcbe870bc5fb2e5ef864e9cc6b5dcb", size = 276379, upload-time = "2025-12-04T14:23:30.498Z" },
     { url = "https://files.pythonhosted.org/packages/43/ab/7ebfe34dce8b87be0d11dae91acbf76f7b8246bf9d6b319c741f99fa59c6/greenlet-3.3.0-cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:349345b770dc88f81506c6861d22a6ccd422207829d2c854ae2af8025af303e3", size = 597294, upload-time = "2025-12-04T14:50:06.847Z" },
     { url = "https://files.pythonhosted.org/packages/a4/39/f1c8da50024feecd0793dbd5e08f526809b8ab5609224a2da40aad3a7641/greenlet-3.3.0-cp312-cp312-manylinux_2_24_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e8e18ed6995e9e2c0b4ed264d2cf89260ab3ac7e13555b8032b25a74c6d18655", size = 607742, upload-time = "2025-12-04T14:57:42.349Z" },
+    { url = "https://files.pythonhosted.org/packages/77/cb/43692bcd5f7a0da6ec0ec6d58ee7cddb606d055ce94a62ac9b1aa481e969/greenlet-3.3.0-cp312-cp312-manylinux_2_24_s390x.manylinux_2_28_s390x.whl", hash = "sha256:c024b1e5696626890038e34f76140ed1daf858e37496d33f2af57f06189e70d7", size = 622297, upload-time = "2025-12-04T15:07:13.552Z" },
     { url = "https://files.pythonhosted.org/packages/75/b0/6bde0b1011a60782108c01de5913c588cf51a839174538d266de15e4bf4d/greenlet-3.3.0-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:047ab3df20ede6a57c35c14bf5200fcf04039d50f908270d3f9a7a82064f543b", size = 609885, upload-time = "2025-12-04T14:26:02.368Z" },
     { url = "https://files.pythonhosted.org/packages/49/0e/49b46ac39f931f59f987b7cd9f34bfec8ef81d2a1e6e00682f55be5de9f4/greenlet-3.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2d9ad37fc657b1102ec880e637cccf20191581f75c64087a549e66c57e1ceb53", size = 1567424, upload-time = "2025-12-04T15:04:23.757Z" },
     { url = "https://files.pythonhosted.org/packages/05/f5/49a9ac2dff7f10091935def9165c90236d8f175afb27cbed38fb1d61ab6b/greenlet-3.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:83cd0e36932e0e7f36a64b732a6f60c2fc2df28c351bae79fbaf4f8092fe7614", size = 1636017, upload-time = "2025-12-04T14:27:29.688Z" },
@@ -8864,27 +8867,32 @@ wheels = [
 
 [[package]]
 name = "tokenizers"
-version = "0.21.4"
+version = "0.22.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "huggingface-hub" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c2/2f/402986d0823f8d7ca139d969af2917fefaa9b947d1fb32f6168c509f2492/tokenizers-0.21.4.tar.gz", hash = "sha256:fa23f85fbc9a02ec5c6978da172cdcbac23498c3ca9f3645c5c68740ac007880", size = 351253, upload-time = "2025-07-28T15:48:54.325Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/98/c6/fdb6f72bf6454f52eb4a2510be7fb0f614e541a2554d6210e370d85efff4/tokenizers-0.21.4-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:2ccc10a7c3bcefe0f242867dc914fc1226ee44321eb618cfe3019b5df3400133", size = 2863987, upload-time = "2025-07-28T15:48:44.877Z" },
-    { url = "https://files.pythonhosted.org/packages/8d/a6/28975479e35ddc751dc1ddc97b9b69bf7fcf074db31548aab37f8116674c/tokenizers-0.21.4-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:5e2f601a8e0cd5be5cc7506b20a79112370b9b3e9cb5f13f68ab11acd6ca7d60", size = 2732457, upload-time = "2025-07-28T15:48:43.265Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/8f/24f39d7b5c726b7b0be95dca04f344df278a3fe3a4deb15a975d194cbb32/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:39b376f5a1aee67b4d29032ee85511bbd1b99007ec735f7f35c8a2eb104eade5", size = 3012624, upload-time = "2025-07-28T13:22:43.895Z" },
-    { url = "https://files.pythonhosted.org/packages/58/47/26358925717687a58cb74d7a508de96649544fad5778f0cd9827398dc499/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2107ad649e2cda4488d41dfd031469e9da3fcbfd6183e74e4958fa729ffbf9c6", size = 2939681, upload-time = "2025-07-28T13:22:47.499Z" },
-    { url = "https://files.pythonhosted.org/packages/99/6f/cc300fea5db2ab5ddc2c8aea5757a27b89c84469899710c3aeddc1d39801/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c73012da95afafdf235ba80047699df4384fdc481527448a078ffd00e45a7d9", size = 3247445, upload-time = "2025-07-28T15:48:39.711Z" },
-    { url = "https://files.pythonhosted.org/packages/be/bf/98cb4b9c3c4afd8be89cfa6423704337dc20b73eb4180397a6e0d456c334/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f23186c40395fc390d27f519679a58023f368a0aad234af145e0f39ad1212732", size = 3428014, upload-time = "2025-07-28T13:22:49.569Z" },
-    { url = "https://files.pythonhosted.org/packages/75/c7/96c1cc780e6ca7f01a57c13235dd05b7bc1c0f3588512ebe9d1331b5f5ae/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cc88bb34e23a54cc42713d6d98af5f1bf79c07653d24fe984d2d695ba2c922a2", size = 3193197, upload-time = "2025-07-28T13:22:51.471Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/90/273b6c7ec78af547694eddeea9e05de771278bd20476525ab930cecaf7d8/tokenizers-0.21.4-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51b7eabb104f46c1c50b486520555715457ae833d5aee9ff6ae853d1130506ff", size = 3115426, upload-time = "2025-07-28T15:48:41.439Z" },
-    { url = "https://files.pythonhosted.org/packages/91/43/c640d5a07e95f1cf9d2c92501f20a25f179ac53a4f71e1489a3dcfcc67ee/tokenizers-0.21.4-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:714b05b2e1af1288bd1bc56ce496c4cebb64a20d158ee802887757791191e6e2", size = 9089127, upload-time = "2025-07-28T15:48:46.472Z" },
-    { url = "https://files.pythonhosted.org/packages/44/a1/dd23edd6271d4dca788e5200a807b49ec3e6987815cd9d0a07ad9c96c7c2/tokenizers-0.21.4-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:1340ff877ceedfa937544b7d79f5b7becf33a4cfb58f89b3b49927004ef66f78", size = 9055243, upload-time = "2025-07-28T15:48:48.539Z" },
-    { url = "https://files.pythonhosted.org/packages/21/2b/b410d6e9021c4b7ddb57248304dc817c4d4970b73b6ee343674914701197/tokenizers-0.21.4-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:3c1f4317576e465ac9ef0d165b247825a2a4078bcd01cba6b54b867bdf9fdd8b", size = 9298237, upload-time = "2025-07-28T15:48:50.443Z" },
-    { url = "https://files.pythonhosted.org/packages/b7/0a/42348c995c67e2e6e5c89ffb9cfd68507cbaeb84ff39c49ee6e0a6dd0fd2/tokenizers-0.21.4-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:c212aa4e45ec0bb5274b16b6f31dd3f1c41944025c2358faaa5782c754e84c24", size = 9461980, upload-time = "2025-07-28T15:48:52.325Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/d3/dacccd834404cd71b5c334882f3ba40331ad2120e69ded32cf5fda9a7436/tokenizers-0.21.4-cp39-abi3-win32.whl", hash = "sha256:6c42a930bc5f4c47f4ea775c91de47d27910881902b0f20e4990ebe045a415d0", size = 2329871, upload-time = "2025-07-28T15:48:56.841Z" },
-    { url = "https://files.pythonhosted.org/packages/41/f2/fd673d979185f5dcbac4be7d09461cbb99751554ffb6718d0013af8604cb/tokenizers-0.21.4-cp39-abi3-win_amd64.whl", hash = "sha256:475d807a5c3eb72c59ad9b5fcdb254f6e17f53dfcbb9903233b0dfa9c943b597", size = 2507568, upload-time = "2025-07-28T15:48:55.456Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/73/6f/f80cfef4a312e1fb34baf7d85c72d4411afde10978d4657f8cdd811d3ccc/tokenizers-0.22.2.tar.gz", hash = "sha256:473b83b915e547aa366d1eee11806deaf419e17be16310ac0a14077f1e28f917", size = 372115, upload-time = "2026-01-05T10:45:15.988Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/97/5dbfabf04c7e348e655e907ed27913e03db0923abb5dfdd120d7b25630e1/tokenizers-0.22.2-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:544dd704ae7238755d790de45ba8da072e9af3eea688f698b137915ae959281c", size = 3100275, upload-time = "2026-01-05T10:41:02.158Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/47/174dca0502ef88b28f1c9e06b73ce33500eedfac7a7692108aec220464e7/tokenizers-0.22.2-cp39-abi3-macosx_11_0_arm64.whl", hash = "sha256:1e418a55456beedca4621dbab65a318981467a2b188e982a23e117f115ce5001", size = 2981472, upload-time = "2026-01-05T10:41:00.276Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/84/7990e799f1309a8b87af6b948f31edaa12a3ed22d11b352eaf4f4b2e5753/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2249487018adec45d6e3554c71d46eb39fa8ea67156c640f7513eb26f318cec7", size = 3290736, upload-time = "2026-01-05T10:40:32.165Z" },
+    { url = "https://files.pythonhosted.org/packages/78/59/09d0d9ba94dcd5f4f1368d4858d24546b4bdc0231c2354aa31d6199f0399/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:25b85325d0815e86e0bac263506dd114578953b7b53d7de09a6485e4a160a7dd", size = 3168835, upload-time = "2026-01-05T10:40:38.847Z" },
+    { url = "https://files.pythonhosted.org/packages/47/50/b3ebb4243e7160bda8d34b731e54dd8ab8b133e50775872e7a434e524c28/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bfb88f22a209ff7b40a576d5324bf8286b519d7358663db21d6246fb17eea2d5", size = 3521673, upload-time = "2026-01-05T10:40:56.614Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/fa/89f4cb9e08df770b57adb96f8cbb7e22695a4cb6c2bd5f0c4f0ebcf33b66/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1c774b1276f71e1ef716e5486f21e76333464f47bece56bbd554485982a9e03e", size = 3724818, upload-time = "2026-01-05T10:40:44.507Z" },
+    { url = "https://files.pythonhosted.org/packages/64/04/ca2363f0bfbe3b3d36e95bf67e56a4c88c8e3362b658e616d1ac185d47f2/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:df6c4265b289083bf710dff49bc51ef252f9d5be33a45ee2bed151114a56207b", size = 3379195, upload-time = "2026-01-05T10:40:51.139Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/76/932be4b50ef6ccedf9d3c6639b056a967a86258c6d9200643f01269211ca/tokenizers-0.22.2-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:369cc9fc8cc10cb24143873a0d95438bb8ee257bb80c71989e3ee290e8d72c67", size = 3274982, upload-time = "2026-01-05T10:40:58.331Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/28/5f9f5a4cc211b69e89420980e483831bcc29dade307955cc9dc858a40f01/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:29c30b83d8dcd061078b05ae0cb94d3c710555fbb44861139f9f83dcca3dc3e4", size = 9478245, upload-time = "2026-01-05T10:41:04.053Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/fb/66e2da4704d6aadebf8cb39f1d6d1957df667ab24cff2326b77cda0dcb85/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:37ae80a28c1d3265bb1f22464c856bd23c02a05bb211e56d0c5301a435be6c1a", size = 9560069, upload-time = "2026-01-05T10:45:10.673Z" },
+    { url = "https://files.pythonhosted.org/packages/16/04/fed398b05caa87ce9b1a1bb5166645e38196081b225059a6edaff6440fac/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:791135ee325f2336f498590eb2f11dc5c295232f288e75c99a36c5dbce63088a", size = 9899263, upload-time = "2026-01-05T10:45:12.559Z" },
+    { url = "https://files.pythonhosted.org/packages/05/a1/d62dfe7376beaaf1394917e0f8e93ee5f67fea8fcf4107501db35996586b/tokenizers-0.22.2-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:38337540fbbddff8e999d59970f3c6f35a82de10053206a7562f1ea02d046fa5", size = 10033429, upload-time = "2026-01-05T10:45:14.333Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/18/a545c4ea42af3df6effd7d13d250ba77a0a86fb20393143bbb9a92e434d4/tokenizers-0.22.2-cp39-abi3-win32.whl", hash = "sha256:a6bf3f88c554a2b653af81f3204491c818ae2ac6fbc09e76ef4773351292bc92", size = 2502363, upload-time = "2026-01-05T10:45:20.593Z" },
+    { url = "https://files.pythonhosted.org/packages/65/71/0670843133a43d43070abeb1949abfdef12a86d490bea9cd9e18e37c5ff7/tokenizers-0.22.2-cp39-abi3-win_amd64.whl", hash = "sha256:c9ea31edff2968b44a88f97d784c2f16dc0729b8b143ed004699ebca91f05c48", size = 2747786, upload-time = "2026-01-05T10:45:18.411Z" },
+    { url = "https://files.pythonhosted.org/packages/72/f4/0de46cfa12cdcbcd464cc59fde36912af405696f687e53a091fb432f694c/tokenizers-0.22.2-cp39-abi3-win_arm64.whl", hash = "sha256:9ce725d22864a1e965217204946f830c37876eee3b2ba6fc6255e8e903d5fcbc", size = 2612133, upload-time = "2026-01-05T10:45:17.232Z" },
+    { url = "https://files.pythonhosted.org/packages/84/04/655b79dbcc9b3ac5f1479f18e931a344af67e5b7d3b251d2dcdcd7558592/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:753d47ebd4542742ef9261d9da92cd545b2cacbb48349a1225466745bb866ec4", size = 3282301, upload-time = "2026-01-05T10:40:34.858Z" },
+    { url = "https://files.pythonhosted.org/packages/46/cd/e4851401f3d8f6f45d8480262ab6a5c8cb9c4302a790a35aa14eeed6d2fd/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e10bf9113d209be7cd046d40fbabbaf3278ff6d18eb4da4c500443185dc1896c", size = 3161308, upload-time = "2026-01-05T10:40:40.737Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/6e/55553992a89982cd12d4a66dddb5e02126c58677ea3931efcbe601d419db/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:64d94e84f6660764e64e7e0b22baa72f6cd942279fdbb21d46abd70d179f0195", size = 3718964, upload-time = "2026-01-05T10:40:46.56Z" },
+    { url = "https://files.pythonhosted.org/packages/59/8c/b1c87148aa15e099243ec9f0cf9d0e970cc2234c3257d558c25a2c5304e6/tokenizers-0.22.2-pp310-pypy310_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f01a9c019878532f98927d2bacb79bbb404b43d3437455522a00a30718cdedb5", size = 3373542, upload-time = "2026-01-05T10:40:52.803Z" },
 ]
 
 [[package]]
@@ -9238,7 +9246,7 @@ wheels = [
 
 [[package]]
 name = "transformers"
-version = "4.55.2"
+version = "4.57.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "filelock" },
@@ -9252,9 +9260,9 @@ dependencies = [
     { name = "tokenizers" },
     { name = "tqdm" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/70/a5/d8b8a1f3a051daeb5f11253bb69fc241f193d1c0566e299210ed9220ff4e/transformers-4.55.2.tar.gz", hash = "sha256:a45ec60c03474fd67adbce5c434685051b7608b3f4f167c25aa6aeb1cad16d4f", size = 9571466, upload-time = "2025-08-13T18:25:43.767Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/c4/35/67252acc1b929dc88b6602e8c4a982e64f31e733b804c14bc24b47da35e6/transformers-4.57.6.tar.gz", hash = "sha256:55e44126ece9dc0a291521b7e5492b572e6ef2766338a610b9ab5afbb70689d3", size = 10134912, upload-time = "2026-01-16T10:38:39.284Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/db/5a/022ac010bedfb5119734cf9d743cf1d830cb4c604f53bb1552216f4344dc/transformers-4.55.2-py3-none-any.whl", hash = "sha256:097e3c2e2c0c9681db3da9d748d8f9d6a724c644514673d0030e8c5a1109f1f1", size = 11269748, upload-time = "2025-08-13T18:25:40.394Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b8/e484ef633af3887baeeb4b6ad12743363af7cce68ae51e938e00aaa0529d/transformers-4.57.6-py3-none-any.whl", hash = "sha256:4c9e9de11333ddfe5114bc872c9f370509198acf0b87a832a0ab9458e2bd0550", size = 11993498, upload-time = "2026-01-16T10:38:31.289Z" },
 ]
 
 [[package]]