Mistral Large 4 VRAM requirements at Q4 and 1M context

Mistral Large 4 needs about 713 GB in this Q4_K_M, 1,048,576 token, batch one scenario. Weights are 560 GB and the full context cache adds 87.9 GB. At 32K tokens the total falls to 619 GB.

Two numbers get attached to Mistral Large 4. About 1T parameters are stored, and about 52B (49B without the embeddings and output layers) run for each token. A server that keeps every expert loaded budgets for the first number, so Q4_K_M's 0.56 bytes per parameter gives 560 GB of weights. The cache is the second cost. At the full 1M context it comes to 87.9 GB, and a 65 GB allowance for the runtime brings the estimate to 713 GB. That's a planning figure for a single sequence with all experts resident. It doesn't reproduce a specific checkpoint, and it doesn't promise that your engine supports this architecture at Q4.

By TechCompare · Updated

Total VRAM required
713 GB
Mistral Large 4 1T (MoE) at Q4_K_M
Weights
560 GB
1000B params
KV cache
87.9 GB
1024K tokens, FP16 KV

Calculator

Estimated VRAM required

713 GB

1000B params at Q4_K_M, 1,048,576 token context, batch 1, inference.

Weights
560 GB
KV cache
87.9 GB
Overhead
64.8 GB

Estimate accuracy: Planning estimate. Rounded model counts, tensor formats, cache packing, and workspace can change actual allocation. Confirm the exact checkpoint and serving engine with a load test.

Mistral Large 4 has 72 indexed attention layers. Nine reuse another layer's latent cache, so 63 layers own a 576-value latent, and 44 also store a 128-value index key. This budget follows the Transformers implementation. Vision processing and serving workspace can need extra memory.

Hardware that fits

Apple entries show installed unified memory separately from a model budget based on an 8 GB reserve. That budget is a planning heuristic, not a fixed hardware limit.

No single GPU in our catalog has enough memory. Multi-GPU or CPU offload required.

How this is calculated

The model has 72 layers of indexed attention with hidden size 6,144. Its feed forward blocks use 128 routed experts with 4 chosen per token. What makes the cache unusual is how the layers share it. Nine layers reuse the latent cache of layer 35, so only 63 layers own a latent of 576 values (512 latent plus 64 rope). On top of that, 44 layers have their own indexer and also store a 128 value index key. Per token the cache therefore holds 83,840 bytes in FP16, which adds up to 87.9 GB across 1,048,576 tokens. The cache is 12% of the whole estimate, so it matters but doesn't dominate. Cutting the context to 32K shrinks the cache to 2.7 GB and the total to 619 GB. A supported 8-bit cache would bring the full context total to about 664 GB, though that needs backend support and isn't a feature of every engine. The estimate follows the Transformers implementation. It leaves out vision processing for image input, workspace for prompt processing, and any draft model for speculative decoding. The model can write up to 262,144 tokens in one reply, and generated tokens fill the cache like prompt tokens do, so size for prompt plus output.

Verdict

Eight cards of 80 GB give 640 GB, which doesn't hold the full context estimate. The total takes 9 cards of 80 GB, or 4 cards of 192 GB, before any sharding overhead. At 32K context the total of 619 GB falls under that single node pool on paper, but it leaves very little room for uneven shards or prefill workspace, so test it before counting on it. An eight card node of 192 GB cards offers 1536 GB, which clears the full context estimate on paper with room for the uneven parts. Serving a few users at once changes the math, because each sequence needs its own cache while the weights are shared. A middle context of 128K comes to 628 GB for one sequence, and many deployments never need the full million. Mistral also publishes an NVFP4 checkpoint aimed at Blackwell GPUs, and GGUF conversions come from ggml-org and unsloth. Compare their actual file sizes with the 560 GB used here, because real quantized files mix precisions. The weights use the Mistral Ecosystem Open-Weight License, so read it before you deploy commercially.

More Mistral scenarios

Kimi K3.1 Pro at Q4_K_M
A 2.78T expert pool with 24 latent attention layers and fixed state in the other 69.
View details ➜
Muse Spark Open at Q4_K_M
Only 16 of its 62 layers grow with context, and the other 46 hold a 2,048 token window.
View details ➜
Ling-3.1-flash at Q4_K_M
A 560B expert pool with 63 fixed state layers and 9 latent attention layers.
View details ➜

Frequently asked questions

How much VRAM does Mistral Large 4 need at Q4?
About 713 GB in this scenario: 560 GB of weights, 87.9 GB of FP16 cache at 1,048,576 tokens and 65 GB of runtime allowance. At 32K tokens it's about 619 GB. Both assume one sequence and every expert loaded, so treat them as planning numbers and check them against the file sizes of the checkpoint you pick.
Can Mistral Large 4 run on eight 80 GB GPUs?
Eight cards of 80 GB offer 640 GB in total. That's under the full context estimate of 713 GB, so a 1M session doesn't fit at Q4 without offloading or a smaller weight format. A 32K session at 619 GB is under the pool on paper, but the margin is thin once shards are uneven and prefill needs workspace. Measure peak memory per card before you rely on it.
Why is the 1M cache smaller than I'd expect for 72 layers?
The model stores a compressed latent instead of full keys and values, and nine layers reuse layer 35's latent instead of making their own. Only 63 layers own a 576 value latent, plus a 128 value index key in 44 of them. That works out to 83,840 bytes per token in FP16, or 87.9 GB at 1M tokens.
Does the 52B active parameter count lower the memory I need?
No. The 52B figure is the compute for one token. The router can pick different experts for the next token, so a fast server keeps the whole 1T pool in memory. Moving idle experts to system memory is possible in some stacks, but then bandwidth sets your speed, and this calculator's all-resident mode doesn't model it.
Is there an NVFP4 or GGUF version of Mistral Large 4?
Mistral publishes an NVFP4 checkpoint aimed at Blackwell GPUs, and GGUF versions come from ggml-org and unsloth. This page's Q4_K_M weight budget of 560 GB is a sizing assumption, not any one of those files. Read the model card and the file listing for the real sizes, then add cache and workspace on top.
What does this estimate leave out?
Image input needs a vision path with its own activations, prompt processing needs temporary workspace, and speculative decoding needs a draft buffer. The 65 GB allowance is a 10% cushion, not a measurement of any of them. Test with your real prompts, image sizes and output length, and watch the peak allocation instead of the steady state.