Self-host MiniMax-M3

MiniMax-M3 is a native multimodal Mixture-of-Experts model with approximately 428B total parameters, approximately 23B activated parameters per token, and a 1M-token model context limit. This page covers server-class self-hosting with SGLang, not consumer-device local inference.

Deployment status: Experimental. As reviewed on August 26, 2026, MiniMax-M3 support is still delivered through an SGLang development image rather than a tagged SGLang release. Pin both the model revision and image digest below, validate them on your workload, and do not treat this recipe as a production SLA.

Status and reference baseline

Item	Reference value
Deployment status	Experimental
Last documentation review	August 26, 2026
Reference hardware	8 × NVIDIA B200, single node, TP 8
Weights	`MiniMaxAI/MiniMax-M3-MXFP8`
Model revision	`c5454eb03678d8710e54a4e0fc681b9f3b4a3dba`
Weight repository size	Approximately 444 GB at the pinned revision
SGLang image	`lmsysorg/sglang@sha256:de63ac56df5d7b064451e21147eaab89634a02332d830ca8c01cb8c033b3a78f`
Runtime	Linux and Docker with the NVIDIA Container Toolkit; Python and CUDA are supplied by the pinned image
Validation source	SGLang MiniMax-M3 Cookbook

The official sources do not publish a minimum host-memory requirement, peak GPU-memory measurement, minimum NVIDIA driver version, or complete production disk margin for this recipe. Confirm driver compatibility with the CUDA runtime in the pinned image and provision more disk than the weight repository size before deployment.

The complete weights must be loaded or sharded. “23B activated parameters” does not mean that the deployment only needs memory for 23B parameters.

Hardware configurations

The following table reports SGLang’s current support matrix. “Validated” means validated by the SGLang Cookbook, not independently benchmarked by MiniMax in this document.

Hardware	Weights	GPUs / TP	SGLang status	Weight storage	Peak GPU memory	Host memory	Topology
NVIDIA B200	MXFP8	8 / 8	Validated; reference baseline	Approximately 444 GB	Not published	Not published	Single node
NVIDIA B300	MXFP8	4 / 4	Validated	Approximately 444 GB	Not published	Not published	Single node
NVIDIA GB300	MXFP8	4 / 4	Validated	Approximately 444 GB	Not published	Not published	Single node
NVIDIA GB200	MXFP8	4 / 4	Inferred by SGLang; not directly benchmarked	Approximately 444 GB	Not published	Not published	Single node
NVIDIA H200	BF16	8 / 8	Validated	Approximately 854 GB	Not published	Not published	Single node
AMD MI355X	MXFP8	8 / 8	Validated for text workloads	Approximately 444 GB	Not published	Not published	Single node
AMD MI300X	MXFP8 converted at load to block FP8	8 / 8	Validated for text workloads	Approximately 444 GB	Not published	Not published	Single node
AMD MI350X / MI325X	MXFP8	8 / 8	Inferred from the same-architecture GPU	Approximately 444 GB	Not published	Not published	Single node

Use the SGLang configuration generator for the exact B300, GB-series, H200, or AMD command. Do not substitute those commands into this B200 baseline without revalidation.

Quickstart: 8 × B200

Before starting, verify that the host has enough free disk for the approximately 444 GB checkpoint, the container image, and caches.

1. Pull the pinned runtime

docker pull lmsysorg/sglang@sha256:de63ac56df5d7b064451e21147eaab89634a02332d830ca8c01cb8c033b3a78f

2. Verify GPU access

The output must list all eight B200 GPUs:

docker run --rm --gpus all \
  lmsysorg/sglang@sha256:de63ac56df5d7b064451e21147eaab89634a02332d830ca8c01cb8c033b3a78f \
  nvidia-smi

3. Start the server

docker run --rm --name minimax-m3 \
  --gpus all \
  --shm-size 32g \
  --ipc=host \
  -p 127.0.0.1:30000:30000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  lmsysorg/sglang@sha256:de63ac56df5d7b064451e21147eaab89634a02332d830ca8c01cb8c033b3a78f \
  sglang serve \
  --trust-remote-code \
  --model-path MiniMaxAI/MiniMax-M3-MXFP8 \
  --revision c5454eb03678d8710e54a4e0fc681b9f3b4a3dba \
  --reasoning-parser auto \
  --tool-call-parser auto \
  --tp 8 \
  --attention-backend fa4 \
  --mm-attention-backend flashinfer_cudnn \
  --moe-runner-backend deep_gemm \
  --chunked-prefill-size 8192 \
  --mem-fraction-static 0.65 \
  --host 0.0.0.0 \
  --port 30000

The process listens on all interfaces inside the container, but -p 127.0.0.1:30000:30000 publishes it only on the host loopback interface. The first start downloads approximately 444 GB of weights and may take a long time, depending on storage and network throughput.

4. Check readiness

Run this command in another terminal after the server log reports that it is ready:

curl --fail --silent --show-error http://127.0.0.1:30000/health

A successful check exits with status 0. If it fails, keep the server process running and inspect its logs before sending inference requests.

5. Verify text generation

curl http://127.0.0.1:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMaxAI/MiniMax-M3-MXFP8",
    "messages": [
      {"role": "user", "content": "Explain sparse attention in one sentence."}
    ],
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 1024
  }'

A successful response contains a non-empty choices[0].message.content. When the model emits a reasoning trace, SGLang returns it separately in choices[0].message.reasoning_content.

6. Verify image input

curl http://127.0.0.1:30000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "MiniMaxAI/MiniMax-M3-MXFP8",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "Describe this image in one sentence."},
        {"type": "image_url", "image_url": {"url": "https://raw.githubusercontent.com/sgl-project/sglang/2511743bd784e69e5a81ca3d926a000711dae4ab/examples/assets/example_image.png"}}
      ]
    }],
    "temperature": 1.0,
    "top_p": 0.95,
    "max_tokens": 1024
  }'

This example uses an image maintained by the SGLang project. In production, accept only trusted or allowlisted remote URLs, or send a Base64 data URI after validating the file at your gateway.

Capability boundary

Capability	Model-native capability	This B200 SGLang recipe	Notes
Text input and output	Supported	Validated by SGLang	OpenAI-compatible chat completions
Reasoning	Supported	Validated by SGLang	Requires `--reasoning-parser auto`
Tool calls	Supported	Validated by SGLang	Requires `--tool-call-parser auto`; single, parallel, object, and array arguments are covered upstream
Image input	Supported	URL and Base64 inputs validated by SGLang	Blackwell requires `--mm-attention-backend flashinfer_cudnn`
Video input	Supported by the model	Not validated in this SGLang recipe	Do not advertise video serving from this recipe without your own validation
Context length	Up to 1M tokens	SGLang reports validation from 1K to 128K input tokens	1M is a model limit, not the validated production default for this configuration

On AMD, SGLang has validated text chat, reasoning separation, and tool calling. Vision has not been exercised on the ROCm path.

Published performance data

SGLang reports the following serving measurements. These are upstream reference results, not MiniMax performance guarantees.

Hardware	Weights / TP	Workload	Mean TTFT	Mean TPOT	Throughput per GPU
8 × B200	MXFP8 / TP 8	Random; 2,048 input, 256 output, concurrency 64, 128 prompts	1,580 ms	24.1 ms	2,385 tokens/s
8 × H200	BF16 / TP 8	Random; 2,048 input, 256 output, concurrency 64, 128 prompts	1,054 ms	70.8 ms	1,044 tokens/s

Both measurements use SGLang PR #27944, CUDA graphs, a flushed cache, and warm steady-state runs. Peak GPU memory, host memory, cold-start time, and a production concurrency recommendation were not published. Benchmark your prompt lengths, output lengths, multimodal ratio, and concurrency before capacity planning.

Weights, cache, and offline deployment

The runtime downloads Hugging Face files to /root/.cache/huggingface in the container, mapped to ~/.cache/huggingface on the host by the Quickstart command. To prepare an offline copy, install the Hugging Face CLI on a connected machine and download the pinned revision:

hf download MiniMaxAI/MiniMax-M3-MXFP8 \
  --revision c5454eb03678d8710e54a4e0fc681b9f3b4a3dba \
  --local-dir /data/models/MiniMax-M3-MXFP8

Copy that directory to the deployment host, then start without Hub access:

docker run --rm --name minimax-m3 \
  --gpus all \
  --shm-size 32g \
  --ipc=host \
  -p 127.0.0.1:30000:30000 \
  -e HF_HUB_OFFLINE=1 \
  -v /data/models/MiniMax-M3-MXFP8:/models/MiniMax-M3-MXFP8:ro \
  lmsysorg/sglang@sha256:de63ac56df5d7b064451e21147eaab89634a02332d830ca8c01cb8c033b3a78f \
  sglang serve \
  --trust-remote-code \
  --model-path /models/MiniMax-M3-MXFP8 \
  --reasoning-parser auto \
  --tool-call-parser auto \
  --tp 8 \
  --attention-backend fa4 \
  --mm-attention-backend flashinfer_cudnn \
  --moe-runner-backend deep_gemm \
  --chunked-prefill-size 8192 \
  --mem-fraction-static 0.65 \
  --host 0.0.0.0 \
  --port 30000

Official ModelScope mirrors are available at MiniMax/MiniMax-M3-MXFP8 and MiniMax/MiniMax-M3. The ModelScope pages do not identify snapshots with the Hugging Face commit used by this baseline, so revalidate the files before substituting a mirror in a revision-pinned deployment. If a download is interrupted, rerun hf download with the same revision and directory; the client resumes from its cache. If loading reports missing or corrupt shards, verify available disk space and redownload the affected revision before changing runtime parameters.

Production and security

Keep the loopback binding for development. Before exposing the service to another host:

Set an unpredictable SGLang --api-key and send it as Authorization: Bearer <key>.
Terminate TLS at a reverse proxy or trusted ingress, restrict source networks with a firewall or security group, and add request-rate and concurrency limits.
Do not log API keys, full prompts, Base64 media, or model outputs unless your data policy explicitly permits it.
Reject arbitrary remote media URLs at the gateway. Apply a domain allowlist, block private and link-local destinations, limit redirects, download time, byte size, image pixels, and video duration, and validate media types before forwarding a request.
Monitor GPU memory, queue depth, request latency, error rates, process health, and disk utilization. A successful /health response alone is not a production readiness test.

SGLang accepts --api-key, but the current MiniMax-M3 Cookbook does not provide a complete remote-media security policy. Enforce those controls in your gateway and network layer.

Troubleshooting

Symptom	Likely cause	Shortest corrective action
`CUDA out of memory` during startup or prefill	Insufficient activation headroom or an oversized prefill chunk	Reduce `--mem-fraction-static` below `0.65`, then reduce `--chunked-prefill-size` to `4096` or `2048`; this reduces KV capacity or prefill speed, so benchmark again
Weights fail to load or a shard is missing	Incomplete download, insufficient disk, or a different revision	Confirm the model path, free disk, and revision; rerun `hf download` with the pinned revision
`AttributeError: Module has no function 'plan'` during CUDA graph capture	Multiple TP ranks raced while JIT-compiling the MSA kernel	Run the SGLang Cookbook’s single-process `msa_available()` gate once in the same image and cache, then restart the server
MSA is not active on B200	Wrong image, unsupported GPU architecture, or missing `fa4` backend	Confirm the pinned image and `--attention-backend fa4`; follow the Cookbook gate check and expect `True`
NCCL initialization hangs or times out	Not all GPUs are visible, insufficient shared memory, or a topology/driver problem	Verify eight GPUs with `nvidia-smi`, preserve `--ipc=host` and `--shm-size 32g`, then enable `NCCL_DEBUG=INFO` and inspect the first failing rank
Raw `<mm:think>` or MiniMax tool-call tokens appear in `content`	The corresponding parser was not enabled or the runtime differs from the pinned image	Restore `--reasoning-parser auto` and `--tool-call-parser auto`, then restart with the pinned digest
`/health` fails after the process starts	The model is still downloading/loading, a worker exited, or port publication is incorrect	Inspect container logs, verify host disk and GPU state, and confirm `127.0.0.1:30000:30000` is published
A remote image request fails	The server cannot reach the URL, or the gateway blocks it	Use an allowlisted URL or a validated Base64 data URI; do not disable network protections globally

License and use restrictions

The BF16 and MXFP8 weights are released under the MiniMax Community License. It includes attribution requirements, commercial notice or authorization requirements, and prohibited uses. Read the complete license and complete the applicable process before production or commercial use; this page is not legal advice.

Resources

SGLang MiniMax-M3 Cookbook

Review the upstream hardware matrix, configuration generator, benchmark conditions, and advanced tuning.

MiniMax-M3 model card

Review the official weights, model capabilities, inference parameters, and license.

MiniMax-M3 MXFP8 weights

Open the MXFP8 checkpoint used by the reference deployment.

MiniMax Sparse Attention

Review the MSA kernel source and Blackwell requirements.

Get started

Use Guides

FAQs

Terms & Policy

Status and reference baseline

Hardware configurations

Quickstart: 8 × B200

1. Pull the pinned runtime

2. Verify GPU access

3. Start the server

4. Check readiness

5. Verify text generation

6. Verify image input

Capability boundary

Published performance data

Weights, cache, and offline deployment

Production and security

Troubleshooting

License and use restrictions

Resources

SGLang MiniMax-M3 Cookbook

MiniMax-M3 model card

MiniMax-M3 MXFP8 weights

MiniMax Sparse Attention

​Status and reference baseline

​Hardware configurations

​Quickstart: 8 × B200

​1. Pull the pinned runtime

​2. Verify GPU access

​3. Start the server

​4. Check readiness

​5. Verify text generation

​6. Verify image input

​Capability boundary

​Published performance data

​Weights, cache, and offline deployment

​Production and security

​Troubleshooting

​License and use restrictions

​Resources

SGLang MiniMax-M3 Cookbook

MiniMax-M3 model card

MiniMax-M3 MXFP8 weights

MiniMax Sparse Attention

Status and reference baseline

Hardware configurations

Quickstart: 8 × B200

1. Pull the pinned runtime

2. Verify GPU access

3. Start the server

4. Check readiness

5. Verify text generation

6. Verify image input

Capability boundary

Published performance data

Weights, cache, and offline deployment

Production and security

Troubleshooting

License and use restrictions

Resources