Instructions to use ressl/MiniMax-M3-uncensored-NVFP4 with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use ressl/MiniMax-M3-uncensored-NVFP4 with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="ressl/MiniMax-M3-uncensored-NVFP4", trust_remote_code=True)
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("ressl/MiniMax-M3-uncensored-NVFP4", trust_remote_code=True)
model = AutoModelForMultimodalLM.from_pretrained("ressl/MiniMax-M3-uncensored-NVFP4", trust_remote_code=True, device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use ressl/MiniMax-M3-uncensored-NVFP4 with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "ressl/MiniMax-M3-uncensored-NVFP4"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ressl/MiniMax-M3-uncensored-NVFP4",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/ressl/MiniMax-M3-uncensored-NVFP4

SGLang

How to use ressl/MiniMax-M3-uncensored-NVFP4 with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "ressl/MiniMax-M3-uncensored-NVFP4" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ressl/MiniMax-M3-uncensored-NVFP4",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "ressl/MiniMax-M3-uncensored-NVFP4" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "ressl/MiniMax-M3-uncensored-NVFP4",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use ressl/MiniMax-M3-uncensored-NVFP4 with Docker Model Runner:
```
docker model run hf.co/ressl/MiniMax-M3-uncensored-NVFP4
```

MiniMax-M3-uncensored-NVFP4

TL;DR: ressl/MiniMax-M3-uncensored, compressed from 854.2 GB BF16 to 260.4 GB with NVIDIA ModelOpt NVFP4 routed-expert weights. It was validated end to end on 4x NVIDIA RTX PRO 6000 Blackwell 96 GB with SGLang at about 88.5 tokens/s for a warmed-up single-request decode.

This release preserves the uncensored MiniMax-M3 checkpoint while making the 428B-total, 23B-active MoE practical on one four-GPU Blackwell workstation. Text generation, reasoning parsing, tool calls, multimodal input, 20k-token context, and two concurrent requests were tested on the exported files.

Warning: this model is genuinely uncensored and can comply with requests that a stock model refuses. It is intended for lawful security research, red-teaming, penetration testing, malware and exploit analysis, detection engineering, and other legitimate research. You are responsible for how you use it.

Facts and figures


Source checkpoint	ressl/MiniMax-M3-uncensored, revision `f5faea4659cc3834b1dc3793173db9aa533e3aa7`
Method	ModelOpt NVFP4, routed expert `w1`/`w2`/`w3` weights only, block size 16, two-level scaling
Precision retained	BF16 attention, router, dense and shared experts, embeddings, LM head, vision tower, and projectors
KV cache	BF16 in the validated runtime, not quantized in the checkpoint
Size	260.4 GB (242.5 GiB), down from 854.2 GB (795.5 GiB), 69.5% smaller
Export layout	116 safetensors shards, 89,080 indexed tensors
Conversion	147.1 seconds with 4 workers on 4x RTX PRO 6000 Blackwell 96 GB
Serving validation	SGLang TP=4, 32,768-token configured context, two concurrent requests
Measured decode	About 88.5 tokens/s, warmed-up batch 1, short prompts, CUDA graph enabled
Long-context probe	Exact sentinel recall from a 20,212-token prompt
Multimodal probes	Correct red/blue spatial classification and exact OCR of `M3 VISION 7429`
Uncensored smoke test	0/16 hard refusals on the same harmful-prompt sample, 96-token continuations
ModelOpt revision	`f479e7890f0d276e061d69b5a0d70d477ec863f2`

Quantization recipe

The conversion streams every source shard and quantizes all 21,888 routed-expert projection tensors. It uses ModelOpt's NVFP4QTensor max quantizer with 16-value blocks. w1 and w3 share the second-level FP32 scale required by the fused gate/up runtime layout. The exported weights use packed U8 data, FP8 E4M3 block scales, and FP32 global scales. No calibration dataset was used; the activation input scale is 1.0 and runtime block scaling remains dynamic. Shared experts deliberately remain BF16.

Structural validation checked every index entry, shard header, dtype, shape, expert triplet, input scale, and gate/up shared scale. A sampled dequantization comparison against BF16 measured cosine similarity 0.99539 to 0.99544 and relative RMSE 0.0954 to 0.0963 across w1, w2, and w3.

Run it with SGLang on RTX PRO 6000 Blackwell

This exact image and command were validated on four SM120 GPUs. The two mounted patch files are part of this repository. They make SGLang's ModelOpt Cutlass path forward MiniMax-M3's parameterized clamped-SwiGLU values. The TRTLLM MoE path is intentionally not used.

MODEL_DIR=/path/to/MiniMax-M3-uncensored-NVFP4

docker run --rm --runtime=nvidia --gpus all --ipc=host --shm-size 32g \
  -v "$MODEL_DIR:/model:ro" \
  -v "$MODEL_DIR/sglang_patch/modelopt_quant.py:/sgl-workspace/sglang/python/sglang/srt/layers/quantization/modelopt_quant.py:ro" \
  -v "$MODEL_DIR/sglang_patch/flashinfer_trtllm.py:/sgl-workspace/sglang/python/sglang/srt/layers/moe/moe_runner/flashinfer_trtllm.py:ro" \
  -p 30000:30000 \
  lmsysorg/sglang@sha256:8cc6e6f90bf803e9817800b679173d0b526f2b42b2c61b7ecafecdadb610eb55 \
  python3 -m sglang.launch_server \
    --model-path /model \
    --served-model-name ressl/MiniMax-M3-uncensored-NVFP4 \
    --host 0.0.0.0 --port 30000 \
    --tp-size 4 \
    --quantization modelopt_fp4 \
    --trust-remote-code \
    --dtype auto \
    --context-length 32768 \
    --mem-fraction-static 0.90 \
    --max-running-requests 2 \
    --chunked-prefill-size 16384 \
    --page-size 128 \
    --tool-call-parser minimax-m3 \
    --reasoning-parser minimax-m3 \
    --moe-runner-backend flashinfer_cutlass \
    --fp4-gemm-backend flashinfer_cutlass \
    --attention-backend flashinfer \
    --disable-flashinfer-autotune \
    --disable-prefill-cuda-graph \
    --disable-shared-experts-fusion \
    --disable-custom-all-reduce

--page-size 128 is required by MiniMax Sparse Attention. --disable-shared-experts-fusion is required because this release keeps shared experts in BF16 while routed experts use NVFP4.

Recommended generation settings from the source checkpoint are temperature 1.0 and top-p 0.95.

Validation and limitations

This artifact passed serving smoke tests and targeted functional probes, not a full academic capability benchmark. No benchmark score from another checkpoint is claimed here.
The throughput number is a measured short-request decode rate after warmup. Prompt length, concurrency, sampling, and output length will change it.
The production validation used 32,768 tokens. The base architecture supports longer contexts, but longer configurations were not validated for this export on this four-GPU node.
The vision tower is BF16. Color localization and OCR passed, but no full multimodal benchmark was run.
vLLM was not accepted for this deployment: the tested SM120 fallback loaded the checkpoint but did not correctly execute MiniMax-M3's parameterized clamped-SwiGLU path. Use the validated SGLang setup.
Engine support is recent and image-specific. Keep the pinned image and patch checksums for reproducible behavior.

Provenance

Source repo: ressl/MiniMax-M3-uncensored
Source revision: f5faea4659cc3834b1dc3793173db9aa533e3aa7
Quantization recipe: streaming/nvfp4_experts_only_input_scale1-kv_none
Weight quantization: ModelOpt NVFP4 max, block 16
Routed expert projections: 21,888
Activation calibration samples: 0
Activation input scale: 1.0
KV-cache quantization: none
Conversion hardware: 4x NVIDIA RTX PRO 6000 Blackwell Workstation Edition, 96 GB
Serving hardware: the same four GPUs, tensor parallel size 4

The machine-readable run-manifest.json records the exact source revision, ModelOpt revision, recipe, counts, sizes, validation result, and wall time. The files in sglang_patch/ are copied from Mapika/MiniMax-M3-NVFP4, revision 668435825700a0047399441720f430bdd8eca0ab, and are included with their original attribution.

License and credits

The MiniMax license is inherited from the base model by MiniMaxAI. Uncensoring, quantization, and validation by Robert Ressl (Hugging Face, Website, LinkedIn, Patreon).

Built with NVIDIA TensorRT Model Optimizer and SGLang. The SGLang compatibility patch is credited to Mapika.

Support this work: if these models are useful to you, consider supporting development on Patreon. More projects are available at ressl.ch.

Downloads last month: 3,803

Safetensors

Model size

246B params

Tensor type

BF16

F32

F8_E4M3

Model tree for ressl/MiniMax-M3-uncensored-NVFP4

Base model

MiniMaxAI/MiniMax-M3

Finetuned

ressl/MiniMax-M3-uncensored

Quantized

(2)

this model