Cover: the label Model library and the title Deploy DeepSeek R1 on European GPU cloud: VRAM, costs and compliance, beside a terminal prompt wired to a purple-topped machine.

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 request

So 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.

ModelWeights on Hugging FaceSmallest setup that holds the weights with room for cache
DeepSeek R1, FP8688.6 GB8× H200 (1,128 GB)
DeepSeek R1, NVIDIA's FP4 version423.6 GB4× B200 (768 GB)
R1 Distill Llama 70B141.1 GB2× H200, or 1× B200
R1 Distill Qwen 32B65.5 GB2× H100, or 1× H200
R1 Distill Qwen 14B29.5 GB1× H100
R1 Distill Llama 8B16.1 GB1× 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.

Horizontal bars of total GPU memory: eight H100s 640 GB, four B200s 768 GB, eight H200s 1,128 GB. A solid line marks the FP8 weights of DeepSeek R1 at 688.6 GB, a dashed line NVIDIA's FP4 version at 423.6 GB. Eight H100s end below the FP8 line, so they cannot load the full model. Weight sizes from Hugging Face, read 23 October 2026.
The FP8 weights of DeepSeek R1 take 688.6 GB, more than the 640 GB of eight H100s; eight H200s hold them with room left for the cache (Hugging Face file sizes, read 23 October 2026).

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 request

vLLM, 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.

SetupUsable memory (92%)Left after 65.5 GB of weightsRequests of 32,768 tokens at once
1× H10073.6 GB8.1 GBunder 1
2× H100147.2 GB81.7 GBabout 9
1× H200129.7 GB64.2 GBabout 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.

Stacked bars of the memory vLLM uses by default (92%) on three setups for the DeepSeek R1 Distill Qwen 32B model. The 65.5 GB of weights take the same space on each. What is left holds the cache: 8.1 GB on one H100, 81.7 GB on two H100s and 64.2 GB on one H200. One request of 32,768 tokens needs 8.6 GB, so one H100 cannot hold even one, two H100s about 9 and one H200 about 7. Calculated example, upper limits before vLLM's own working memory.
In our calculated example, one H100 leaves 8.1 GB for the cache of the 32B distilled model, less than the 8.6 GB one 32K-token request needs.

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-eager

For 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-parallel

The `--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-parallel

The 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 rate

A 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 APIInput per 1M tokensCached 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.00

That 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.

Sources

  1. huggingface.co
  2. arxiv.org
  3. huggingface.co
  4. huggingface.co
  5. docs.vllm.ai
  6. docs.vllm.ai