DeepSeek V4 Hardware Requirements: Flash vs Pro
Want to go deeper than this article?
Free account unlocks the first chapter of all 25 courses — RAG, agents, MCP, voice AI, MLOps, real GitHub repos.
Got the hardware sorted? Now build on it. You know what to buy — the courses show you what to actually run, fine-tune, and ship on it. First chapter free, no card.
The practical verdict by memory tier: a 128 GB unified-memory machine (Strix Halo, Mac Studio) is the floor for DeepSeek V4-Flash and holds the 82.5 to 97 GB builds; a 192 GB or 256 GB machine holds Flash at its native 155 GB precision with room for context; V4-Pro at 850 GB and up is a server model that no single consumer box holds; and DeepSeek-V4.1-Flash (first released 10 September 2026, refreshed as V4.1-Flash-1017 on 17 October) is a 256 GB-and-up model even at 1- to 2-bit, which llama.cpp has supported since 25 October 2026. The "13B activated" figure in every headline is a throughput number, not a memory number: routing picks 6 of 256 experts per token, but all 256 must be resident before the first token appears.
Updated 2 November 2026: re-checked Ollama's tags (the official deepseek-v4-flash entry was retired on 27 August 2026 and no longer lists any tags), added the V4.1-Flash-1017 builds and llama.cpp's V4.1 support, and moved the parameter-count source to DeepSeek's own model card. Previous full re-check: 19 September 2026, against Hugging Face, Ollama's tag list and the llama.cpp issue tracker.
This page is a spec lookup, not a setup walkthrough. Every size below was read from the Hugging Face repository file listings and safetensors headers on 23 August 2026, re-checked on 19 September 2026, and is reproducible: open the repo, sum the shards. Where a number is derived rather than published, the arithmetic is shown. There are no throughput figures anywhere on this page, because we do not own a 4×GB300 node and will not pretend otherwise.
If you want the install steps instead, they live on our DeepSeek V4 local setup page. If you are still choosing the machine, the hardware guide covers the memory tiers this page keeps referring to.
How Much Memory Does DeepSeek V4 Actually Need?
Start with the two official checkpoints. Both are MIT-licensed, both declare a 1,048,576-token position limit in config.json, and both ship weights that are already quantised — which is the single fact that makes DeepSeek V4 behave differently from every other model you have sized.
| DeepSeek-V4-Flash-0731 | DeepSeek-V4-Pro-0813 | |
|---|---|---|
| Repo | deepseek-ai/DeepSeek-V4-Flash-0731 | deepseek-ai/DeepSeek-V4-Pro-0813 |
| Published | 31 July 2026 | 13 August 2026 |
| Total parameters | 284B (304B counting the DSpark module) | 1.6T (1.65T counting DSpark) |
| Activated per token | 13B | 49B |
| Layers | 43 | 61 |
| Hidden size | 4,096 | 7,168 |
| Routed experts | 256, top-6 | 384, top-6 |
| Shared experts | 1 | 1 |
| MoE intermediate size | 2,048 | 3,072 |
Context (max_position_embeddings) | 1,048,576 | 1,048,576 |
| Shards in repo | 48 | 66 |
| Weights on disk, official repo | 166.9 GB (155.4 GiB) | 892.7 GB (831.4 GiB) |
| Smallest published build | 82.5 GB (unsloth UD-IQ1_S) | 849.7 GB (unsloth UD-Q4_K_XL) |
| DeepSeek's own serving example | single 4×GB300 node | single 4×GB300 node |
| Licence | MIT | MIT |
Architecture rows come from each repo's config.json. The 284B/13B and 1.6T/49B splits are stated in DeepSeek's own DeepSeek-V4 model card ("DeepSeek-V4-Pro with 1.6T parameters (49B activated) and DeepSeek-V4-Flash with 284B parameters (13B activated)", read 2 November 2026), and Ollama's deepseek-v4-pro page repeats the Pro split ("1.6T total parameters and 49B activated"). The disk figures are the sum of the model-*.safetensors shards reported by the Hugging Face API for each repo.
Note the gap between the two Pro columns and the two Flash columns. Flash is roughly one fifth the weight of Pro on disk and needs about one quarter the compute per token. That ratio, not the benchmark table, is the reason almost everyone asking this question ends up on Flash.
Reading articles is good. Building is better.
Free account = the first chapter of all 25 courses, with a per-chapter AI tutor. No card.
Why Doesn't 13B Active Mean 13GB of VRAM?
Because activated parameters govern how much arithmetic happens per token, and total parameters govern how much memory has to be filled before any arithmetic happens at all. These are two different budgets and the marketing number is always the smaller one.
Here is the routing, straight out of Flash's config.json: n_routed_experts: 256, num_experts_per_tok: 6, n_shared_experts: 1. Every token is scored against all 256 routers, six experts win, the shared expert always runs. So 7 of 257 experts do work — about 2.7% of the expert weights.
The catch is that the winning six change on every token, and nothing predicts which six. Keep only the popular experts in VRAM and the other 250 still have to be somewhere the GPU can reach within a token's budget. That is why the memory requirement tracks the 284B number and the speed characteristic tracks the 13B number.
You can verify the 13B yourself from the tensor shapes in the checkpoint. Per layer, reading the safetensors header of model-00002-of-00048.safetensors:
attention wkv [512,4096] + wq_a [1024,4096] + wq_b [32768,1024]
+ wo_a [8192,4096] + wo_b [4096,8192] = 106,954,752
router ffn.gate [256,4096] = 1,048,576
shared expert w1 + w3 + w2, each [2048,4096]-shaped = 25,165,824
6 routed experts 6 x 25,165,824 = 150,994,944
-----------
per layer ~ 284,950,000
x 43 layers = 12.25B
+ embedding + lm_head (2 x 129,280 x 4,096) = 1.06B
-------
13.3B active
Which matches the published 13B. The same arithmetic on Pro's config (61 layers, hidden 7,168, expert intermediate 3,072, top-6 of 384) lands on 49.1B, matching its published 49B. Both figures are honest, and neither one is your VRAM budget.
If this is the first MoE you have sized, our guide to VRAM requirements by model size covers the dense case, and what quantisation actually costs covers the trade you are about to make.
Is DeepSeek V4 Flash 284B or 304B?
Both, and the difference is the speculative-decoding module. This trips up everyone comparing sources, because Hugging Face's model header says 304B while DeepSeek's model card says 284B, and the numbers are 20B apart.
The repo has 48 shards. Shard 1 is the embedding, shard 45 is the output head, shards 2–44 are the 43 transformer layers, and shards 46, 47 and 48 are three more full MoE layers — the DSpark draft module the model card describes as "a speculative decoding module attached." Three extra layers of 256 experts is 19.3B parameters. 304.18B minus 19.3B is roughly 284B.
So:
- 284B = the model that answers you. This is what llama.cpp reports; issue #26399 logs a loaded Flash checkpoint as "145.63 GiB, 284.33 B params, arch deepseek4."
- 304B = the same model plus the DSpark draft head, which is what Hugging Face's parameter counter totals. Ollama's
deepseek-v4-flashpage, before the entry was retired on 27 August 2026, split the difference by describing the model as 284B in prose and listing "Size 304B parameters" in the sidebar. - The draft head is also distributed on its own. In the unsloth GGUF repo it is a separate 10.9 GB
dspark-file, so you can skip it and save that memory if you are not using speculative decoding.
The same structure appears in Pro: 66 shards = embedding + 61 layers + output head + 3 DSpark layers, which is why its two published totals are 1.6T and 1.65T.
The part almost nobody mentions: the weights ship pre-quantised
Flash's config.json contains "expert_dtype": "fp4". That is not a suggestion for you — it describes the file. Reading the safetensors header directly, a routed expert's first matrix is stored as layers.0.ffn.experts.0.w1.weight, dtype I8, shape [2048, 2048], paired with layers.0.ffn.experts.0.w1.scale, dtype F8_E8M0, shape [2048, 128]. The shared expert's equivalent tensor is F8_E4M3 at [2048, 4096] — full width.
Half the width, one scale per 32 values: the routed experts are 4-bit values packed two to a byte with block scales. That is MXFP4. Attention and the shared expert are FP8.
This has one consequence that dominates the rest of this page:
- Flash's routed experts are 296.35B parameters at 4 bits = 148.2 GB, which is 95.5% of the 155.1 GB UD-Q4_K_XL GGUF.
- Pro's routed experts are 1.623T parameters at 4 bits = 811.7 GB, which is 95.5% of the 849.7 GB UD-Q4_K_XL GGUF.
In other words, a "Q4" build of DeepSeek V4 is not a compression of anything — it is a repack at native precision. Everything smaller is genuinely lossy in a way that a Q4 of a BF16-released model is not, and everything larger is padding the 5% that was never 4-bit to begin with. Which is exactly why unsloth's Pro Q8_K_XL (873.4 GB) is only 2.8% bigger than its Q4_K_XL (849.7 GB): there is almost nothing left to upcast.
Which DeepSeek V4 Flash Build Fits Your Machine?
Every published Flash build, sorted by size. "Effective bpw" is file bytes × 8 ÷ 284.33B parameters — arithmetic, not a quality score. Sizes are the sum of the file's shards as reported by the Hugging Face API, in GB (10⁹ bytes) and GiB (2³⁰ bytes) because llama.cpp reports the latter and your OS reports the former.
| Build | Repo | GB | GiB | Effective bpw |
|---|---|---|---|---|
| UD-IQ1_S | unsloth | 82.5 | 76.9 | 2.32 |
| UD-IQ1_M | unsloth | 86.9 | 80.9 | 2.45 |
| UD-IQ2_XXS | unsloth | 90.9 | 84.6 | 2.56 |
| UD-IQ2_M | unsloth | 90.9 | 84.7 | 2.56 |
| ROCmFPx Strix Lean 2.58bpw | otheru | 91.5 | 85.3 | 2.58 |
| OptiQ-2bit (MLX) | mlx-community | 92.5 | 86.1 | 2.60 |
| 2.4bit-mixed (MLX) | mlx-community | 92.8 | 86.5 | 2.61 |
| 2bit-DQ (MLX) | mlx-community | 96.5 | 89.9 | 2.72 |
| UD-Q2_K_XL | unsloth | 96.8 | 90.2 | 2.72 |
| Q2_K_S | ggml-org | 98.6 | 91.8 | 2.77 |
| UD-IQ3_XXS | unsloth | 104.2 | 97.1 | 2.93 |
| UD-IQ3_S | unsloth | 116.1 | 108.1 | 3.27 |
| Q2_K | ggml-org | 117.3 | 109.3 | 3.30 |
| UD-Q3_K_M | unsloth | 128.1 | 119.3 | 3.60 |
| UD-Q3_K_XL | unsloth | 128.2 | 119.4 | 3.61 |
| UD-IQ4_XS / UD-IQ4_NL | unsloth | 136.7 | 127.3 | 3.85 |
| 4bit (MLX) | mlx-community | 151.5 | 141.1 | 4.26 |
| MXFP4 | ggml-org | 155.0 | 144.3 | 4.36 |
| UD-Q4_K_XL (native precision) | unsloth | 155.1 | 144.4 | 4.36 |
| MXFP4 | bartowski / lmstudio-community | 156.4 | 145.6 | 4.40 |
| UD-Q8_K_XL | unsloth | 161.9 | 150.8 | 4.55 |
| Official safetensors | deepseek-ai | 166.9 | 155.4 | 4.70 |
| NVFP4 | nvidia | 168.3 | 156.7 | 4.73 |
| DSpark draft head (optional, separate) | unsloth / ggml-org | 10.9 | 10.1 | — |
Three things worth reading off that table:
- The floor is about 82 GB, not 32 GB. There is no 4-bit-class build under 80 GB and there is unlikely to ever be one, because 296B expert parameters at 2 bits is still 74 GB before anything else.
- Everything at or above 155 GB is the same information. UD-Q4_K_XL, the two MXFP4 repacks and the official safetensors differ by under 8%, and that difference is FP8 attention layers being stored slightly differently, not model quality.
- The 2.5-ish bpw cluster is where the interesting engineering is. Four separate groups independently landed between 91.5 and 98.6 GB, which is not a coincidence: that is the largest build that fits a 128 GB machine with room for context.
Run this on your own machine and stop paying every month
Pay once and keep it. No renewal, no per-token bill, and nothing you feed it ever leaves your hardware.
What Does DeepSeek V4 Pro Need?
Short version: a rack. Longer version, every published DeepSeek-V4-Pro-0813 build:
| Build | Repo | GB | GiB | Routed experts as share of file |
|---|---|---|---|---|
| UD-Q4_K_XL | unsloth | 849.7 | 791.3 | 95.5% |
| UD-Q8_K_XL | unsloth | 873.4 | 813.5 | 92.9% |
| Official safetensors | deepseek-ai | 892.7 | 831.4 | 90.9% |
| NVFP4 | nvidia | 913.1 | 850.4 | 88.9% |
That is the whole list as of 23 August 2026, and it was still the whole list when re-checked on 19 September 2026. Nobody has published a sub-4-bit 0813 build, and the reason is the one from the previous section: 1.623T expert parameters at 4 bits is 811.7 GB, so the file cannot go meaningfully below 850 GB without re-quantising weights that were already 4-bit. Even pushing Pro into the 2.5 bpw band that makes Flash interesting would land near 500 GB — which is the entire memory of a maxed-out 512 GB Mac Studio, with nothing left for the OS or a context window.
The earlier Pro preview checkpoint does have community GGUFs down to 574 GB, but it is a different model with a different parameter count, so do not read those sizes across to 0813.
Pro's practical answer for almost everyone reading this: use it through an API, and run Flash locally. Note that Flash-0731 was released specifically as the model that "outperforms DeepSeek-V4-Pro (Preview) on benchmarks listed below despite its far smaller activated parameter count" — the gap between the two you can actually host is narrower than the parameter counts suggest.
Can an RTX 5090 Run DeepSeek V4 Flash?
Not on its own. A 5090 has 32 GB of VRAM. The smallest published Flash build is 82.5 GB. That is a 50 GB shortfall against the smallest file that exists, so every 5090 configuration is an offload configuration, not a resident one.
What a 5090 changes is how well the offload goes, and that depends entirely on the system RAM behind it:
| Configuration | VRAM | System RAM | Combined | UD-IQ1_S (82.5 GB) | UD-Q2_K_XL (96.8 GB) | UD-Q4_K_XL (155.1 GB) |
|---|---|---|---|---|---|---|
| RTX 5090 + 64 GB DDR5 | 32 GB | 64 GB | 96 GB | Offloads | No | No |
| RTX 5090 + 128 GB DDR5 | 32 GB | 128 GB | 160 GB | Offloads | Offloads | No headroom |
| RTX 5090 + 256 GB DDR5 | 32 GB | 256 GB | 288 GB | Offloads | Offloads | Offloads |
| 2× RTX 3090 + 128 GB | 48 GB | 128 GB | 176 GB | Offloads | Offloads | Offloads |
| 4× RTX 3090 + 256 GB | 96 GB | 256 GB | 352 GB | Runs | Offloads | Offloads |
| RTX PRO 6000 Blackwell + 128 GB | 96 GB | 128 GB | 224 GB | Runs | Offloads | Offloads |
| Ryzen AI Max+ 395 (Strix Halo), 128 GB unified | shared | 128 GB | 128 GB | Runs | Runs | No |
| Mac Studio 256 GB unified (M3 Ultra or M5 Ultra) | unified | — | 256 GB | Runs | Runs | Runs |
| Mac Studio M5 Ultra 512 GB | unified | — | 512 GB | Runs | Runs | Runs |
| 6× AMD MI50 32 GB + 503 GB | 192 GB | 503 GB | 695 GB | Runs | Runs | Runs |
| 8× H100 80 GB | 640 GB | — | 640 GB | Runs | Runs | Runs |
Definitions, because "runs" is doing a lot of work in that table:
- Runs — the whole build fits in the fastest memory pool (discrete VRAM, or unified memory on Apple Silicon and Strix Halo) with room left for KV cache and compute buffers.
- Offloads — it fits in VRAM plus system RAM together, so the runtime keeps the overflow experts in host RAM and moves them across PCIe on demand. It works. Whether it works fast enough for you is a question this page deliberately does not answer with a number we did not measure.
- No headroom — the file alone is within a few GB of total system memory, before the OS, the KV cache and the compute buffers. Treat it as no.
- No — exceeds VRAM plus RAM, so pages come off the SSD.
Two of those rows are not hypothetical. The 6× MI50 machine is the rig in llama.cpp issue #26399, running the 145.63 GiB MXFP4 build "fully GPU-resident across all 6 cards, no CPU expert offload." The dual-Strix-Halo case is issue #26768, two 128 GB Strix Halo boxes joined over RPC to hold the 161.9 GB UD-Q8_K_XL.
If you are choosing a card rather than choosing a model, the honest read is that no consumer GPU is the deciding component here — total system memory is. Our RTX 5090 vs 4090 comparison and the dual-3090 versus single-5090 build math both apply, but for a 284B MoE the DDR5 budget matters more than either. How much system RAM local AI needs is the more relevant page. If your card is a 16 GB part, this model is not on the menu at all; the best models for an RTX 5080 list is where that budget actually goes.
What about the KV cache at 1M context?
Budget for it separately, and treat the following as a ceiling rather than a measurement. The checkpoint's wkv projection emits 512 values per token per layer. DeepSeek's own vLLM example runs --kv-cache-dtype fp8, one byte per value. So the upper bound is:
Flash: 43 layers x 512 values x 1 byte = 22,016 bytes/token
128K tokens -> ~2.8 GB 1M tokens -> ~23 GB
Pro: 61 layers x 512 values x 1 byte = 31,232 bytes/token
128K tokens -> ~4.0 GB 1M tokens -> ~33 GB
That is a genuine ceiling, not a figure to plan against: config.json sets sliding_window: 128 and a compress_ratios list that alternates 4 and 128 across layers, so most layers store considerably less than the uncompressed bound. The real number is lower and we are not going to invent a compression factor to make it precise.
What Breaks After It Loads?
Sizing is necessary but it is not sufficient, and DeepSeek V4 is about seven weeks old in the llama.cpp tree. These are the reports that affect a purchase, with their status as of 19 September 2026, linked so you can check whether they have moved since:
| Report | Backend | Status (19 Sep 2026) | Why it affects your hardware choice |
|---|---|---|---|
| #27021 — TOP_K "invalid configuration argument" when ncols > 1024 | ROCm | Closed 2 Sep 2026 | Was blocking DeepSeek V4 context above 128K on AMD; fixed, so update your build |
| #26399 — GGML_OP_TOP_K falls back to CPU on HIP/ROCm above ~3–4K context | ROCm | Open | Reporter measures a 6.4× token-generation loss on a fully resident 6× MI50 rig |
| #27155 — VRAM leak with Flash + DSpark, draft KV cache grows ~10 MB per prefill+generate cycle | any | Open | Turns a sized-correctly box into an OOM after enough turns |
#26654 — fails to start on CUDA with the default -np -1 | CUDA | Open | A startup failure, not a memory failure — set -np explicitly |
| #26768 — dual Strix Halo RPC crash at n_decoded ≈ 4038 | ROCm / RPC | Closed 8 Aug 2026 | The two-box RPC trick works, but check your build |
| #26537 — aarch64 repack aborts on first token with 3D MoE expert tensors | CPU (arm64) | Closed 4 Aug 2026 | Workaround in the title: --no-repack |
The pattern is that CUDA and Metal support landed first and AMD is still catching up on this architecture specifically. The 128K context blocker on ROCm is now fixed, but the TOP_K CPU fallback (#26399) is not. If you are buying for DeepSeek V4 and were leaning AMD, read that issue before you order — the AMD versus NVIDIA versus Intel comparison covers the general case, but this model's specific gaps are current.
What About DeepSeek V4.1-Flash?
DeepSeek-V4.1-Flash, published on 10 September 2026, is a larger and heavier model than V4-Flash, not a smaller one. llama.cpp has run it since 25 October 2026; Ollama still offers it as a cloud model only. The spec table was read from the deepseek-ai/DeepSeek-V4.1-Flash repo on 19 September 2026; the 1017 release, its GGUF sizes and the llama.cpp status were added on 2 November 2026.
| DeepSeek-V4.1-Flash | |
|---|---|
| Published | 10 September 2026 |
| Backbone parameters | 552B (model card); 763.2B counted across every tensor in the safetensors headers, which includes the vision encoder, the DSpark draft layers and the n-gram "engram" tables |
| Activated per token | 8B during prefill, 16B during decode |
| Architecture | Causal Encoder-Decoder: 40 text layers as a 20-layer causal encoder followed by a 20-layer decoder, plus a 32-layer vision encoder |
| Routed experts | 384, top-6, 1 shared, MoE intermediate size 2,304, hidden size 5,120 |
| Expert dtype in the released weights | fp4 ("expert_dtype": "fp4" in config.json, same as V4) |
Context (max_position_embeddings) | 1,048,576 |
| Native image input | Yes |
| Shards in repo | 48 |
| Weights on disk, official repo | 510.3 GB (475.1 GiB) |
| Licence | MIT |
Because the routed experts are already 4-bit, the same rule from the V4 section applies: a "4-bit" repack cannot be much smaller than the official file, and it is not.
| Build | Repo | GB | Runs in |
|---|---|---|---|
| MLX 2-bit | mlx-community | 238.8 | MLX (Apple Silicon) |
| Q2 GGUF | antirez | 365.7 | DwarfStar (Metal), not llama.cpp; the author's card lists 151.8 GB of that as language-model weights |
| Q4 GGUF | antirez | 518.6 | DwarfStar (Metal), not llama.cpp; 294.2 GB of that as language-model weights |
| Official safetensors | deepseek-ai | 510.3 | vLLM, SGLang |
| MLX 4-bit | mlx-community | 540.6 | MLX (Apple Silicon) |
The 1017 refresh. DeepSeek published an updated checkpoint, deepseek-ai/DeepSeek-V4.1-Flash-1017, on 17 October 2026: 48 shards, 510.3 GB, the same size as the September release. It is also the version DeepSeek's own API serves today; the DeepSeek pricing page (read 2 November 2026) lists the deepseek-flash model as DeepSeek-V4.1-Flash-1017 and says requests to the legacy deepseek-v4-flash name are now served by it. unsloth's DeepSeek-V4.1-Flash-1017-GGUF repo, which targets llama.cpp, lists these builds (shard sums from the Hugging Face API, 2 November 2026):
| Build (unsloth, 1017) | GB |
|---|---|
| UD-IQ1_S | 233.0 |
| UD-IQ1_M | 250.4 |
| UD-IQ2_XXS | 300.5 |
| UD-Q2_K_XL | 334.8 |
| UD-IQ3_XXS | 394.7 |
| UD-IQ3_S | 423.6 |
| UD-Q3_K_XL | 485.1 |
| UD-Q4_K_XL | 500.7 |
| UD-Q8_K_XL | 508.4 |
| mmproj (vision projector, optional) | 1.0 |
| DSpark draft head Q8_0 (optional) | 8.0 |
What that means in memory tiers:
- 128 GB machines are out. The smallest published V4.1-Flash builds are unsloth's 1017 UD-IQ1_S at 233.0 GB and the MLX 2-bit at 238.8 GB. Nothing published fits a Strix Halo box or a 128 GB Mac, and nothing under 200 GB is likely, because 552B of mostly 4-bit experts at 2 bits is still well over 130 GB before the vision encoder and the engram tables.
- 256 GB Mac Studio: the MLX 2-bit build (about 17 GB left for macOS and context) or the 233.0 GB UD-IQ1_S in llama.cpp (about 23 GB left). The 4-bit MLX build at 540.6 GB does not fit even the 512 GB Mac Studio M5 Ultra configuration Apple announced on 25 August 2026, and the official 510.3 GB safetensors would leave a 512 GB machine with no room for the KV cache.
- llama.cpp: supported since 25 October 2026. The first converter, pull request #28696, was closed without being merged; support landed in #31086 ("model: DSV4.1 flash"), merged on 25 October 2026. Two open reports are worth reading before you buy for it: #31480 (gibberish output on Vulkan with flash attention on, correct with
-fa off) and #31385 (problems with the unsloth 1017 GGUFs on CUDA). The antirez GGUF files in the first table target a different Metal runtime and are not the llama.cpp builds. - Ollama: cloud only.
deepseek-v4.1-flashhas two tags as of 2 November 2026,:cloudand:1017-cloud, and both run on Ollama's servers.
If you bought a 128 GB machine for DeepSeek, V4-Flash-0731 is still the model for it. V4.1 is a 256 GB-and-up story: the llama.cpp runtime now exists, but no published build is smaller than about 233 GB. This page will be updated if one appears.
Does Ollama Run DeepSeek V4 Locally?
Not the official model, no. This surprises people, so it is worth being blunt about it. Every official DeepSeek V4 entry in Ollama's library has been cloud-only, and as of 2 November 2026:
deepseek-v4-flashwas retired on 27 August 2026. Its page now reads "No models have been pushed", and the:cloudand:0731-cloudtags it carried in September return 404 from Ollama's registry.deepseek-v4-prohas two tags,:cloudand:0813-cloud, both cloud-only.deepseek-v4.1-flashhas two tags,:cloudand:1017-cloud, both cloud-only.
So ollama run deepseek-v4-pro:cloud or ollama run deepseek-v4.1-flash:cloud sends your prompt to Ollama's servers. That is remote inference, and it needs an Ollama account.
Community uploads do download the weights to your machine, and their sizes match the GGUF table above — frob/deepseek-v4-flash-0731 lists 284b-a13b-ud-iq1_s at 83 GB, 284b-a13b-ud-q2_k_xl at 97 GB, 284b-a13b-ud-q3_k_xl at 128 GB, 284b-a13b-ud-q4_k_xl at 155 GB, 284b-a13b-mxfp4 at 156 GB and 284b-a13b-ud-q8_k_xl at 162 GB (tags read from ollama.com on 2 November 2026). Those are the unsloth and bartowski builds repackaged by a community account rather than by Ollama or DeepSeek, so nothing on this page changes, and llama.cpp remains the better-documented local route.
The practical rule: if the tag ends in -cloud, your hardware is irrelevant and so is this page. If it does not, size it from the table. For everything else in the catalogue, our Ollama model RAM and VRAM table is the general reference.
What This Page Does Not Tell You
- No tokens per second, anywhere. We do not own a GB300 node, a 512 GB Mac Studio or a 6× MI50 rack, and a throughput number for a 284B MoE is worthless without the exact build, backend, context depth and offload split it was taken at. Where a speed figure appears above it is quoted from a linked GitHub issue and attributed to the reporter.
- No quality ranking of the small quants. UD-IQ1_S at 2.32 bpw and UD-Q2_K_XL at 2.72 bpw are 14 GB apart and we have not evaluated either. The bpw column is division, not judgement.
- Sizes drift. When this was written unsloth had published thirteen Flash builds plus two standalone DSpark draft heads, and exactly two Pro-0813 builds. On 19 September 2026 those counts were unchanged. More will appear. Re-check the repo listings before you plan a purchase around a number here.
- Strix Halo's GPU share is configurable. The 128 GB row assumes you have given the GPU a large enough share in BIOS; the default split will not hold a 96 GB model.
- We have not verified the DSpark draft head is optional in every runtime. It ships as a separate GGUF in the unsloth and ggml-org repos, which strongly implies it is, but vLLM and SGLang load it from the same checkpoint as the target model.
FAQ
What are the minimum hardware requirements for DeepSeek V4 Flash?
Roughly 96 GB of total system memory, and that is for the smallest build in existence (unsloth UD-IQ1_S, 82.5 GB) with enough headroom left for the OS and a modest context. For a native-precision build at 155.1 GB, plan on 192 GB. There is no configuration built around a single consumer GPU that holds this model in VRAM — a 5090's 32 GB is 50 GB short of the smallest file that exists.
How much VRAM does DeepSeek V4 Pro need?
More than any single machine you can buy. The smallest published DeepSeek-V4-Pro-0813 build is unsloth's UD-Q4_K_XL at 849.7 GB, the official safetensors are 892.7 GB, and NVIDIA's NVFP4 conversion is 913.1 GB. DeepSeek's own model card serves it on a 4×GB300 node. It cannot be shrunk much further either, because its routed experts are already 4-bit and account for 95.5% of that Q4 file.
DeepSeek V4 Flash is 13B active — can I run it on a 24GB GPU?
No. Activated parameters set how much compute each token costs, not how much memory the model occupies. All 256 routed experts have to be reachable because the six that get picked change every token and nothing predicts which. The memory requirement follows the 284B total, which is 82.5 GB at the very smallest published precision.
Is DeepSeek V4 Flash 284B or 304B parameters?
284B is the model; 304B includes the DSpark speculative-decoding module bolted on top. The repo's last three of 48 shards are three extra MoE layers worth about 19.3B parameters, which is exactly the gap. llama.cpp reports the checkpoint it loads as 284.33B. Both numbers are correct depending on what you are counting.
Why is a Q8 build barely bigger than a Q4 build?
Because the released weights are already 4-bit. Flash's config.json declares "expert_dtype": "fp4", and the routed-expert tensors are stored as packed 4-bit values with one E8M0 block scale per 32 weights. Those experts are 95.5% of a Q4_K_XL file, so a "Q8" build can only upcast the remaining 5% — which is why unsloth's Pro Q8_K_XL (873.4 GB) is 2.8% larger than its Q4_K_XL (849.7 GB) rather than double.
Does the 1M context change the memory requirement?
Yes, on top of every weight figure on this page. As a ceiling, Flash's compressed KV is 43 layers × 512 values × 1 byte per token at the FP8 cache dtype DeepSeek's own example uses, which is about 23 GB at a full million tokens. The real number is lower because compress_ratios compresses most layers further. Separately, llama.cpp issue #27021, which had ROCm failing above 128K context on this architecture, was closed as fixed on 2 September 2026, so on AMD the practical ceiling now depends on how recent your build is.
Can I run DeepSeek V4 on a Mac?
Flash, yes, if you bought enough memory. MLX conversions exist at 92.5 GB (OptiQ-2bit), 96.5 GB (2bit-DQ) and 151.5 GB (4bit), so a 256 GB Mac Studio holds the 4-bit build comfortably and a 128 GB machine holds the 2-bit ones. Pro at 849.7 GB does not fit any Mac, including the 512 GB Mac Studio M5 Ultra configuration Apple announced in August 2026. V4.1-Flash is a different story: its smallest published builds are unsloth's 233.0 GB UD-IQ1_S GGUF and the 238.8 GB MLX 2-bit, so it needs a 256 GB Mac at minimum.
Can I run DeepSeek V4.1-Flash on a 128 GB machine?
No. As of 2 November 2026 the smallest published DeepSeek-V4.1-Flash builds are unsloth's 1017 UD-IQ1_S GGUF at 233.0 GB and mlx-community's 2-bit MLX conversion at 238.8 GB, and the official weights are 510.3 GB. llama.cpp has supported the model since 25 October 2026 (PR #31086), and Ollama offers it as a cloud tag only. On a 128 GB box, V4-Flash-0731 remains the model to run.
Sources
- deepseek-ai/DeepSeek-V4-Flash-0731 — model card,
config.json,inference/README.mdand the 48-shard file listing (created 31 July 2026) - deepseek-ai/DeepSeek-V4-Pro-0813 — model card,
config.jsonand the 66-shard file listing (created 13 August 2026) - deepseek-ai/DeepSeek-V4-Pro model card — the 284B/13B and 1.6T/49B splits and the 1M context figure (read 2 November 2026)
- ollama.com/library/deepseek-v4-flash (retired 27 August 2026), deepseek-v4-pro and deepseek-v4.1-flash — the cloud-only tag lists (read 2 November 2026)
- unsloth/DeepSeek-V4-Flash-0731-GGUF and unsloth/DeepSeek-V4-Pro-0813-GGUF — GGUF build sizes
- ggml-org, bartowski, mlx-community and nvidia — the remaining Flash builds
- llama.cpp issues #26399, #26537, #26654, #26768, #27021 and #27155, pull requests #28696 (first V4.1 converter, closed unmerged) and #31086 (V4.1-Flash support, merged 25 October 2026), and issues #31385 and #31480
- deepseek-ai/DeepSeek-V4.1-Flash — model card,
config.jsonand the 48-shard file listing (created 10 September 2026); mlx-community 2-bit and 4-bit, and antirez/deepseek-v4.1-flash-gguf — V4.1 build sizes; deepseek-ai/DeepSeek-V4.1-Flash-1017 and unsloth/DeepSeek-V4.1-Flash-1017-GGUF — the 1017 release and its GGUF sizes (read 2 November 2026) - DeepSeek API models and pricing — which checkpoint the API serves (read 2 November 2026)
Repo sizes were read from the Hugging Face model API on 23 August 2026 (V4), 19 September 2026 (V4.1, plus a re-check of every V4 listing) and 2 November 2026 (V4.1-Flash-1017), and tensor dtypes and shapes from the safetensors headers of model-00002-of-00048.safetensors (Flash) and model-00002-of-00066.safetensors (Pro).
Got the hardware sorted? Now build on it.
You know what to buy — the courses show you what to actually run, fine-tune, and ship on it. First chapter free, no card.
Decide before you spend a thousand pounds
The AI Hardware course sizes your build properly — VRAM ladder, real bottlenecks, budget builds — and Pick the Right Model tells you what to run on it.
Liked this? 25 full AI courses are waiting.
From fundamentals to RAG, agents, MCP servers, voice AI, and production deployment with real GitHub repos. First chapter free, every course.
Build Real AI on Your Machine
RAG, agents, NLP, vision, and MLOps - chapters across 25 courses that take you from reading about AI to building AI.
Want the structured version?
Hands-on courses on local AI, from $8.99 a month. The first chapter of each is free.
Keep going
- PILLARLocal AI Hardware Requirements (2026): Complete Guide
- Best Mac for Local AI: Every Apple Silicon Chip Ranked M1–M6
- Ollama System Requirements: Minimum RAM, GPU, Disk Size
- Run an LLM on Your Phone: Offline AI on Android & iPhone
- Wan 2.2 VRAM Requirements by GPU: 8GB to 24GB Guide
- Qwen 2.5 Coder 1.5B: Download, VRAM & Benchmarks
- Running LLMs on CPU Only: What Actually Works Without a GPU
- Best GPU for AI Video Generation: By VRAM Tier (2026)
- blog/best-local-ai-server
- DGX Spark vs Strix Halo vs Mac Studio for LLMs
Comments (0)
No comments yet. Be the first to share your thoughts!
