# How much GPU memory do you need to serve a 70B model?

Short answer for Llama 3.1 70B: about **141 GB for BF16 weights alone**, so plan on 2 x 80 GB GPUs as the bare minimum and 4 x 80 GB for comfortable serving. With FP8 it squeezes onto one 80 GB GPU for light traffic; with 4-bit it fits on one 80 GB GPU (or two 48 GB GPUs) with useful KV space. Here is the full calculation so you can redo it for any model.

## Step 1: weights
Llama 3.1 70B has 70.6B parameters.
- BF16: 70.6B x 2 bytes = **141.2 GB** (131.5 GiB)
- FP8/INT8: 70.6B x 1 = **70.6 GB** (65.8 GiB)
- INT4: 70.6B x 0.5 = **35.3 GB**, plus a few percent for quantization scales

## Step 2: KV cache per token
From the model's config: 80 layers, 8 KV heads (grouped-query attention), head_dim 128.

KV per token = 2 x 80 x 8 x 128 x 2 bytes = 327,680 bytes = **320 KiB** (BF16), or 160 KiB with an FP8 KV cache.

Per sequence:
- 4,096 tokens: 1.25 GiB
- 8,192 tokens: 2.5 GiB
- 32,768 tokens: 10 GiB
- 128K tokens (the model's maximum, 131,072): 40 GiB

## Step 3: overhead
Engines reserve memory for activations, CUDA graphs, and the CUDA context. Budget roughly 1 to 3 GiB per GPU, and remember engines like vLLM only use a fraction you set (`--gpu-memory-utilization`, default 0.9).

## Step 4: put it together
Usable memory per 80 GB GPU at 0.9 utilization ~= 72 GB = 67 GiB, minus ~2 GiB overhead = ~65 GiB.

| Setup | Usable | Weights | Left for KV | Tokens of KV (BF16) | 8K-token sequences |
|---|---|---|---|---|---|
| 1 x 80 GB, BF16 | 65 GiB | 131.5 GiB | does not fit | - | - |
| 2 x 80 GB, BF16 | 130 GiB | 131.5 GiB | does not fit at 0.9 | - | - |
| 2 x 80 GB, BF16, util 0.95 | ~138 GiB | 131.5 GiB | ~6 GiB | ~20K | ~2 |
| 4 x 80 GB, BF16 | ~260 GiB | 131.5 GiB | ~129 GiB | ~420K | ~51 |
| 1 x 80 GB, FP8 weights + FP8 KV | ~65 GiB | 65.8 GiB | does not fit at 0.9 | - | - |
| 1 x 80 GB, INT4 weights | ~65 GiB | ~34 GiB | ~31 GiB | ~100K | ~12 |

(Numbers from the formulas above; "8K-token sequences" = KV left / 2.5 GiB.) The FP8 row shows why "70B in FP8 fits on one H100" is only just true: you need to raise utilization close to 1.0 and keep context short. A 141 GB H200 holds FP8 70B comfortably (~50 GiB left for KV at 0.9 utilization).

## Step 5: choose by workload
- **Few users, short prompts, budget-limited:** INT4 on one 80 GB GPU.
- **Production chat at moderate scale:** BF16 or FP8 with tensor parallelism across 4 GPUs, or FP8 on 2 GPUs.
- **Long context (32K+) for many users:** KV dominates; use FP8 KV cache, more GPUs, and prefix caching.

## Do it for any model
Read `config.json` and use:
- weights = params x bytes per param
- KV/token = 2 x num_hidden_layers x num_key_value_heads x (hidden_size / num_attention_heads) x bytes
- concurrent tokens = (usable memory - weights) / KV per token

Our zero-dependency calculator does this for you: [kv_calc.py](https://github.com/inference-engineering-academy/inference-engineering-notes).

---
*If you want to go deeper, the free Foundations course at [Inference Engineering Academy](https://www.inference-engineering.xyz/) covers these topics with browser labs. Disclosure: written by the academy team.*