MiniMax-H3-FL2VA-FP8 (Optimized & Quantized)

This repository provides an optimized, pre-quantized FP8 version of the MiniMax-H3 Text-to-Video & Image-to-Video (FL2VA / T2VA) partition, structured natively for seamless high-performance serving with vLLM-Omni (vllm serve --omni).

Tailored specifically to run efficiently on single-GPU enterprise setups (such as an NVIDIA A100 40GB), it leverages native FP8 weights and layer-wise offloading (--enable-layerwise-offload) to fit heavy multimodal requirements into strict VRAM budgets.

🔗 References & Credits

Original Model Base: MiniMaxAI/MiniMax-H3
Architecture: MiniMax-H3 Omni Multimodal Architecture (Dense 33B Diffusion Transformer with AdaLN caching, Qwen3-VL text/vision encoder backend, and Visual VAE components).

⚖️ License & Compliance Notice

License Agreement: This model is a derivative work based on MiniMaxAI/MiniMax-H3 and is governed by the MiniMax H3 Community License Agreement.
Commercial Terms: The community license permits royalty-free use provided your commercial products and services generate no more than $20 million in yearly revenue (refer to the official License Document for full details and territory compliance terms).
Attribution Requirement: In compliance with Section IV of the license, any application, commercial product, or public service utilizing this work must prominently display "MiniMax H3" on its user interface.

⚠️ Requirements & Installation Note

This model requires vllm >= 0.32.0 and vllm-omni >= 0.32.0. As of today, vllm-omni for this specific architecture may be in pre-release status and should be installed directly from source or via pre-release channels if not yet fully published on PyPI.

🚀 How to Serve with vLLM-Omni

You can serve this model directly using vllm with the multi-modal omni backend:

vllm serve "ParisNeo/MiniMax-H3-FL2VA-FP8" \
  --host "127.0.0.1" \
  --port "8002" \
  --tensor-parallel-size 1 \
  --max-model-len 4096 \
  --gpu-memory-utilization 0.90 \
  --init-timeout 1200 \
  --stage-init-timeout 1200 \
  --omni \
  --task-type fl2va \
  --trust-remote-code \
  --vae-use-slicing \
  --vae-use-tiling \
  --enable-layerwise-offload \
  --cache-backend cache_dit

📋 MiniMax-H3 Parameter Rules

When calling the vLLM-Omni endpoint for MiniMax-H3, ensure your request adheres to the model's strict validation constraints:

Parameter	Required Value / Format	Notes
`fps`	`24`	Fixed strictly at 24 FPS by the MiniMax-H3 architecture.
`aspect_ratio`	`"16:9"`, `"9:16"`, `"1:1"`, `"4:3"`, `"21:9"`	Mandatory for text-to-video (`t2va`).
`duration`	`4.0` to `15.0`	Passed inside `extra_params` as decimal seconds (e.g. `15.0` = 360 frames at 24 FPS).
`task`	`"t2va"` or `"fl2va"`	Passed inside `extra_params`. Must match your target generation mode.
`input_reference`	`@file;type=image/png`	Field name for single image input (I2V mode).
`input_references`	Repeated `@file` fields	Field name for multiple images (First/Last frame interpolation).
`frame_indices`	`[0, -1]`	Array passed inside `extra_params` to explicitly anchor first and last frames.

🔌 API Usage (Synchronous vs. Asynchronous Modes)

vLLM-Omni provides two distinct interaction models for generating videos:

Mode 1: Synchronous API (`/v1/videos/sync`)

Best for short interactive scripts, testing, and benchmarks. It blocks execution until rendering completes and returns raw video bytes directly.

💡 Pro-Tip for Long Generations (up to 15s): Rendering long videos (e.g., duration: 15.0) takes significant compute time. Always pass an extended socket timeout (e.g., --max-time 900 in curl) to prevent socket drops from cancelling the request mid-render.

curl --max-time 900 -X POST http://127.0.0.1:8002/v1/videos/sync \
  -F "prompt=A cinematic tracking shot of a mountain lake at sunrise, highly detailed" \
  -F "aspect_ratio=16:9" \
  -F "fps=24" \
  -F "num_inference_steps=30" \
  -F 'extra_params={"task":"t2va","duration":15.0}' \
  -o t2v_output_15s.mp4

Mode 2: Asynchronous Job Queue API (`/v1/videos`)

Recommended for production workflows and long 15-second generation runs. This decouples request submission from execution, avoiding HTTP timeout drops by handling processing in a background job queue.

Step A: Submit an Async Video Job

create_response=$(curl -s http://127.0.0.1:8002/v1/videos \
  -F "prompt=A cinematic tracking shot of a mountain lake at sunrise, highly detailed" \
  -F "aspect_ratio=16:9" \
  -F "fps=24" \
  -F "num_inference_steps=30" \
  -F 'extra_params={"task":"t2va","duration":15.0}')

# Extract the unique job ID
video_id=$(echo "${create_response}" | jq -r '.id')
echo "Created background video job ID: ${video_id}"

Step B: Poll Job Status & Metadata

curl -s "http://127.0.0.1:8002/v1/videos/${video_id}" | jq .

Step C: Download Content Once Completed

Once processing finishes, download the final MP4 payload directly from the server storage endpoint:

curl -L "http://127.0.0.1:8002/v1/videos/$video_id}/content" -o async_output_15s.mp4

🛠️ Using with LoLLMs (Lord of Large Language Models)

You can seamlessly connect this deployed model to LoLLMs to generate videos directly from your chat UI or agent workflows:

Launch your vLLM-Omni Server locally or on your remote GPU node (e.g., http://127.0.0.1:8002).
Open LoLLMs and navigate to Settings ➔ Bindings.
Select Binding:

Select the dedicated MiniMax-H3 Omni TTV binding (supports remote connection or self-managed server control).

Configure Endpoint:

Set the API Base URL to http://127.0.0.1:8002/v1.
Set Model Name to ParisNeo/MiniMax-H3-FL2VA-FP8.

Generate: Prompt LoLLMs or pass images directly in chat attachments to produce video clips within your workflows while running entirely on your local infrastructure!

Downloads last month: 30