DeepSeek R1 is an open reasoning model, and its weights are free to download. That makes it tempting to run on your own GPUs, close to your data. So the question teams bring to this page is practical. Can we deploy DeepSeek R1 on our own GPUs in Europe, and how many do we need? It comes up when a customer asks where prompts are processed, or when a hosted API's bill grows.
What DeepSeek R1 needs in GPU memory
DeepSeek R1 has 671B parameters in total, and 37B of them are active for each token. It is a mixture of experts (MoE): each token runs through only a few of its 256 expert networks. That keeps the compute per token low. It does not shrink the memory, because every expert must sit on a GPU.
The weights ship in FP8, a number format that stores each parameter in one byte. The model's weight files add up to 688.6 GB on Hugging Face (read 23 October 2026). Its context window, the text one request can hold, is 128K tokens.
The weights are only the first part of the memory bill. The second part is the KV cache (key-value cache). For every token a model reads, its attention layers compute two lists of numbers, called keys and values. The model keeps them so it does not recompute them for each new token. The KV cache grows with every token of every running request.
R1 keeps that record small. It stores 576 numbers per token in each of its 61 layers, in a compressed form. DeepSeek calls the format multi-head latent attention. It is why R1 stores less per token than its smaller distilled versions. At two bytes per number, that is about 69 KiB per token. A request of 32,768 tokens therefore needs about 2.3 GB of cache.
576 numbers × 61 layers × 2 bytes = 70,272 bytes per token (about 69 KiB)
70,272 bytes × 32,768 tokens = 2.3 GB per requestSo for the full model, the weights are the problem, not the cache.
Which DeepSeek R1 version fits which GPUs
DeepSeek also released six smaller "distilled" models: Qwen and Llama models trained on R1's answers. They are ordinary dense models, so every parameter works on every token. Their weights ship in BF16, two bytes per parameter.
The table compares weight sizes with the GPUs on our GPU machine types page. H100 has 80 GB, H200 141 GB and B200 192 GB. A VM can have 1, 2, 4 or 8 GPUs.
| Model | Weights on Hugging Face | Smallest setup that holds the weights with room for cache |
|---|---|---|
| DeepSeek R1, FP8 | 688.6 GB | 8× H200 (1,128 GB) |
| DeepSeek R1, NVIDIA's FP4 version | 423.6 GB | 4× B200 (768 GB) |
| R1 Distill Llama 70B | 141.1 GB | 2× H200, or 1× B200 |
| R1 Distill Qwen 32B | 65.5 GB | 2× H100, or 1× H200 |
| R1 Distill Qwen 14B | 29.5 GB | 1× H100 |
| R1 Distill Llama 8B | 16.1 GB | 1× L40S, an NVIDIA data-centre GPU with 48 GB |
Weight sizes are the files' totals, read on 23 October 2026. The FP4 version is NVIDIA's own conversion, which stores each parameter in about half a byte.
Eight H100s add up to 640 GB. That is 48.6 GB short of the FP8 weights, before any cache. You could shrink the model with quantization (storing parameters in fewer bits), but that is no longer the model DeepSeek tested.
Worked example: the 32B distilled model on one GPU or two
The distilled models keep a bigger cache per token than R1. They store full keys and values for 8 attention heads in each layer. An attention head is one of the parallel units inside a layer that compares tokens with each other. For the Qwen 32B version, with 64 layers and 128 numbers per head, the step looks like this:
2 (key and value) × 64 layers × 8 heads × 128 numbers × 2 bytes = 262,144 bytes per token (256 KiB)
262,144 bytes × 32,768 tokens = 8.6 GB per requestvLLM, the open-source serving engine, uses 92% of each GPU's memory by default. Whatever the weights leave of that holds the cache for all running requests.
| Setup | Usable memory (92%) | Left after 65.5 GB of weights | Requests of 32,768 tokens at once |
|---|---|---|---|
| 1× H100 | 73.6 GB | 8.1 GB | under 1 |
| 2× H100 | 147.2 GB | 81.7 GB | about 9 |
| 1× H200 | 129.7 GB | 64.2 GB | about 7 |
These are upper limits. vLLM also needs working memory for its own calculations, so the real numbers are lower.
One H100 loads the 32B model but cannot hold the cache for one 32K-token request (the cap in DeepSeek's command). That is why DeepSeek's own serving command, in the next section, spreads the model over two GPUs and caps requests at 32,768 tokens.
How to serve DeepSeek R1 with vLLM
For the 32B distilled model, DeepSeek's model card gives this command. The flag `--tensor-parallel-size 2` splits each layer across two GPUs. The `--enforce-eager` flag turns off a speed-up that needs extra GPU memory, so more memory is left for the cache.
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B --tensor-parallel-size 2 --max-model-len 32768 --enforce-eagerFor the full model, vLLM's guide shows eight H200s with the FP8 weights. We show R1-0528 because vLLM's guide uses it. It is DeepSeek's later update, with the same layout and the same 688.6 GB of weights. Expert parallelism places different experts on different GPUs.
vllm serve deepseek-ai/DeepSeek-R1-0528 \
--trust-remote-code \
--tensor-parallel-size 8 \
--enable-expert-parallelThe `--trust-remote-code` flag lets vLLM run the model code that ships with the weights on Hugging Face. The same guide runs NVIDIA's FP4 version on four B200s. Before the start, it sets `VLLM_USE_FLASHINFER_MOE_FP4=1`, which switches on FlashInfer's FP4 routines for the experts.
export VLLM_USE_FLASHINFER_MOE_FP4=1
vllm serve nvidia/DeepSeek-R1-FP4 \
--trust-remote-code \
--tensor-parallel-size 4 \
--enable-expert-parallelThe server speaks the OpenAI format, so your existing OpenAI client works against it. DeepSeek recommends a temperature of 0.6 for the R1 series. For the first R1 release, it also advises putting every instruction in the user message, not in a system prompt. The R1-0528 card says the update supports a system prompt.
On our GPU virtual machines, you get root access over SSH and run the vLLM commands above yourself. VMs are billed per second while they run.
What self-hosting costs compared with per-token DeepSeek models
A self-hosted model costs the same every hour, busy or idle. The full R1 holds eight GPUs for as long as it is loaded. Your bill follows one line of arithmetic, with the hourly rate from our compute page:
monthly GPU bill = GPUs × hours running × hourly rateA per-token API works the other way round. You pay for the tokens you send and receive, and quiet hours cost nothing. We do not serve DeepSeek R1 per token. We serve DeepSeek's V4 models through our serverless inference, EU-hosted.
| Model on our API | Input per 1M tokens | Cached input (a repeated prompt start, billed lower) | Output |
|---|---|---|---|
| DeepSeek V4.1 Flash | $0.50 | $0.13 | $1.50 |
| DeepSeek V4 Flash 0731 | $0.25 | $0.06 | $0.30 |
| DeepSeek V4 Pro 0813 | $2.00 | $0.50 | $4.00 |
Prices are from our model pages, read on 23 October 2026. Take one request with 2,000 input tokens and 1,000 output tokens on DeepSeek V4.1 Flash:
2,000 × $0.50 / 1,000,000 = $0.0010
1,000 × $1.50 / 1,000,000 = $0.0015
one request = $0.0025
10,000 requests a day = $25.00That example runs on DeepSeek V4.1 Flash, a model we serve, not on R1. To compare, take the monthly price of eight GPUs from your provider and set it against your monthly per-token bill. If the per-token bill is smaller, the API wins. If your traffic is steady all day, compare it with a dedicated endpoint instead. It runs a Hugging Face model on GPUs reserved for you, behind the same OpenAI-compatible API, priced per contract.
Licence and data handling for DeepSeek R1 in Europe
DeepSeek R1 and its weights are under the MIT licence, which allows commercial use and changes. Each distilled model also keeps its base model's licence, as DeepSeek's model card states. For the Qwen versions that is Apache 2.0. For the Llama 8B and 70B versions it is Meta's Llama 3.1 and Llama 3.3 licence.
Where you self-host, the data handling is yours to design. Lyceum is a sovereign European AI inference provider for open-source models: the company runs in Europe, and so do its GPUs. Our serverless models run in Paris and Finland. VM disks are wiped when you terminate the VM.
For our API, the facts are short. Our GPUs run in European data centres. We don't keep your prompts or outputs, and we never use them for training. The DPA (data processing agreement) is part of our terms. Our ISO 27001 audit is in progress, and the data centre operators hold ISO certifications at facility level. Our legal and security page has the documents.