DeepSeek R1 Hardware Requirements: Full Model and Distills
The DeepSeek R1 hardware requirements split into two very different problems. The full R1 model has 671 billion parameters and needs a multi-GPU server: about 400 GB of memory at 4-bit, and about 700 GB at its native 8-bit precision. The distilled versions, which are much smaller models trained on R1's outputs, run on one GPU: about 26 GB for the 32B distill and 52 GB for the 70B distill at 4-bit with a 16K context.
Many guides blur the two. Running "DeepSeek R1" on a laptop means running a distill, which is a Qwen or Llama model fine-tuned on R1's reasoning, not R1 itself. DeepSeek says so on each distill's model card. Both are useful, but they have different hardware bills.
One caution before the numbers: DeepSeek has published newer revisions since the original January 2025 release. The architecture has stayed the same across the R1 line, so the sizing below holds, but check the model card for the release you plan to deploy.
The full 671B model
R1 is a mixture-of-experts model: 671 billion parameters in total, about 37 billion active per token. As with any such model, the active count sets the speed and the total count sets the memory, because every expert has to be loaded.
| Format | Weights | Fits on |
|---|---|---|
| FP8 (native) | ~700 GB | 8x H200 (1,128 GB total) |
| Q8_0 GGUF | ~713 GB | 8x H200 |
| Q4_K_M GGUF | ~404 GB | 8x H100 or A100 80GB (640 GB total) |
| ~1.6-bit dynamic quant | ~131 GB | 2x 80 GB cards, with quality loss |
Eight 80 GB cards total 640 GB, which cannot hold the 700 GB of FP8 weights, so a server of that size needs a 4-bit build. The 1.6-bit figure comes from Unsloth's dynamic quantization write-up; it makes the model small enough to try on modest hardware, at a cost in answer quality that you should test on your own tasks.
The KV cache is unusually small
R1 uses multi-head latent attention, which stores a compressed representation of each token instead of full keys and values. For R1's 61 layers that is about 70 KB per token, compared to 320 KB per token for a dense 70B Llama. A 128K context costs around 9 GB of cache per user rather than 40 GB. Whether you get that saving depends on your inference server supporting the compressed layout, so confirm it in the server's documentation.
Speed on CPU
People do run the heavily quantized model from system RAM on high-memory CPU servers. Community reports are in the low single digits of tokens per second. That is enough to experiment and not enough for a team: a typical answer from a reasoning model is thousands of tokens long.
The distilled models
The distills are dense models, so the usual sizing rules apply. The architecture and therefore the KV cache come from the base model: Qwen2.5 for the 1.5B, 7B, 14B and 32B, and Llama for the 8B and 70B.
Reasoning models write long chains of thought before the answer, so size the context for 16K tokens rather than the 2K to 8K you might use for plain chat. These totals use Q4_K_M weights, a 16K cache for one user and 10% overhead:
| Distill | Q4_K_M weights | KV cache per token | Total, 1 user at 16K |
|---|---|---|---|
| R1-Distill-Qwen-7B | ~4.7 GB | 56 KB | ~6 GB |
| R1-Distill-Llama-8B | ~4.9 GB | 128 KB | ~8 GB |
| R1-Distill-Qwen-14B | ~9 GB | 192 KB | ~13 GB |
| R1-Distill-Qwen-32B | ~20 GB | 256 KB | ~26 GB |
| R1-Distill-Llama-70B | ~42.5 GB | 320 KB | ~52 GB |
A 24 GB card is just short of the 32B distill at Q4_K_M; a 48 GB card runs it at Q8_0 or Q4_K_M with several users. The 70B distill wants an 80 GB card or two 48 GB cards. Llama 70B VRAM requirements has the full breakdown for that size, since the distill shares its architecture.
If you serve several people, multiply the cache by concurrent users. Ten people on the 32B distill at 16K add about 40 GB of cache on top of the weights.
Choosing between R1 and a distill
Run the full R1 when you need its quality on hard reasoning and you can justify an eight-GPU server. At that scale the self-hosted LLM cost break-even changes: the hardware is a six-figure purchase or a steep hourly rental, so volume has to be high or the data too sensitive for an API.
For most teams the 32B or 70B distill is the sensible starting point. Test it against your actual prompts first; reasoning models are slower per answer than standard ones because they think before replying, and for simple extraction or classification a non-reasoning model of the same size is faster and cheaper. The LLM routing post covers sending only the hard requests to the reasoning model.
Licensing: DeepSeek releases R1 and the distills under the MIT license, but the distills inherit conditions from their base models (Apache 2.0 for Qwen, the Llama license for Llama). Read the card for the exact model.
Where AI Refinery fits
AI Refinery, a self-hosted LLM platform, sizes plans by model parameters. The 70B and smaller distills fall within Professional, which covers up to 70B; the full 671B model needs Enterprise, which has no size limit. You provide the GPUs in either case, and the catalog shows measured GPU memory per quantization, counted at the full context window, so the console number will be larger than the 16K figures above. Which DeepSeek models are in the catalog at a given time is shown in the console.
Because models are exposed through an OpenAI-compatible API, existing applications can point at a distill the same way they point at any other model. See plans and pricing for the tier details, or the overview at AI Refinery.
Figures are estimates from public file sizes and configs. Test on your own hardware before committing to a purchase.