How to Run DeepSeek Locally (and When Not To)

"Run DeepSeek locally" means two very different things. The distilled models — DeepSeek's six official R1 distills from 1.5B to 70B parameters — genuinely run on a laptop or a single gaming GPU through Ollama. The full DeepSeek-R1 is a 671B-parameter Mixture-of-Experts model; even at 4-bit quantization its weights are 404 GB, which is server-class hardware, not a desktop. This guide draws that line precisely: a "what you actually need" VRAM/RAM table sourced from real download sizes, the quantization trade-off, and the honest cost math on when a hosted API beats buying a GPU at all.

Can you run DeepSeek locally?

Yes — the distilled models run on a laptop or a single GPU; the full model does not. This is the whole trick to setting up DeepSeek locally: there is no single "DeepSeek" you download. There is a family.

• The full DeepSeek-R1 is a Mixture-of-Experts model with 671B total parameters and 37B activated per token, built on DeepSeek-V3-Base, with a 128K context window and an MIT license. At 4-bit its weights are 404 GB — server hardware.
• The six official distills (1.5B to 70B) are smaller dense models fine-tuned on R1 reasoning data. These are what actually fit on consumer hardware.

So "can you run DeepSeek locally?" is really "which DeepSeek, on what hardware?" The rest of this guide answers exactly that, with numbers from the official Ollama library and Hugging Face model cards.

Which DeepSeek: distill vs the full model

The distills are not the 671B model — they are much smaller models that borrowed its reasoning style. DeepSeek released six official distilled models, each fine-tuned on reasoning traces from DeepSeek-R1 onto an existing open base:

Two things follow from this. First, these are dense models — every parameter is active per token — not the sparse MoE of the full R1, so a "7B distill" behaves like a 7B model, not a slice of a 671B one. Second, they inherit their base licenses: the Qwen-based distills follow Qwen's Apache 2.0, the Llama-based ones follow the respective Meta Llama license — only the full DeepSeek-R1 (and the newer V3-line weights) is MIT. If you are comparing DeepSeek's open reasoning against other open weights, see DeepSeek-R1 vs GPT-OSS.

What you actually need to run DeepSeek locally

Match the model size to your VRAM — or your unified/system RAM — before you download 404 GB by accident. The table below is synthesized from Ollama's published download sizes (the weights alone, at the default Q4_K_M quantization), with a practical headroom margin added for the KV cache, context, and runtime overhead. Treat the hardware column as the minimum comfortable target, not a floor.

Sizes from the Ollama deepseek-r1 tags (verified July 2026). "Practical memory" adds ~20-40% headroom over the raw weights for context and KV cache; it is our derived estimate, not a vendor spec. Apple Silicon uses unified memory, so its usable ceiling is roughly total RAM minus what the OS needs.

The jump that surprises people is the last row: the full 671B model is ~9× larger on disk than the 70B distill (and ~45× the 14B). There is no consumer GPU that holds it — this is the line between "local" and "a small cluster."

Install and run DeepSeek with Ollama

One command pulls a distill; a tag picks the size. Ollama is the simplest path for the distilled models. After installing Ollama, the bare command pulls the default 8B distill (a 5.2 GB download):

# Default: the 8B distill (5.2 GB, Q4_K_M)
ollama run deepseek-r1

# Pick a size explicitly
ollama run deepseek-r1:1.5b    # 1.1 GB — laptop / CPU-only
ollama run deepseek-r1:7b      # 4.7 GB — ~8 GB VRAM
ollama run deepseek-r1:14b     # 9.0 GB — ~12 GB VRAM
ollama run deepseek-r1:32b     # 20 GB  — ~24 GB VRAM (RTX 3090/4090)
ollama run deepseek-r1:70b     # 43 GB  — ~48 GB VRAM

The unsuffixed tags default to Q4_K_M quantization. The distill tags advertise a 128K context window; the full 671b tag advertises 160K. If you want the newer DeepSeek-V3 line, deepseek-v3.1 is in the Ollama library (671b, a 404 GB download, 160K context) — but note that DeepSeek-V3.2 / V3.2-Exp is not yet in the Ollama library as of the July 2026 check, so there is no one-command local path to it there.

Quantization: the memory-vs-quality lever

Lower precision shrinks the weights roughly proportionally — that is how a 671B model goes from 1.3 TB to 404 GB. Quantization stores each weight in fewer bits. On Ollama the full DeepSeek-R1 is offered at three precisions, and the footprint scales directly with the bit-width:

The trade-off is accuracy for memory: fewer bits per weight means a smaller model that fits in less VRAM/RAM, at some cost to fidelity. Q4_K_M is the common default balance — it is what the unsuffixed Ollama tags ship, and it is why the "404 GB" figure is the one you see quoted for local 671B. The same R1-0528 update variants (671b-0528-q4_K_M and so on) are offered at matching sizes. If you only remember one number: 4-bit is roughly a third of the full-precision footprint.

Running the full 671B model locally

It is possible, but it is a server build, not a desktop one. The full DeepSeek-R1 is a 671B-total / 37B-active MoE. Even though only 37B parameters activate per token (which helps throughput), the whole 671B must be resident in memory. From the 404 GB Q4_K_M weights, realistic paths are:

• Multi-GPU server VRAM — on the order of 8× H100-80GB to hold the weights plus context in fast memory. This is the config that runs at genuinely usable speed.
• High-RAM workstation — roughly 512 GB of system RAM for CPU or offloaded inference. It runs, but token throughput on CPU is far lower than on GPUs; expect it to be usable for experimentation, not production serving.

The newer DeepSeek-V3.2-Exp keeps the same 671B-class MoE (its canonical config file is config_671B_v3.2.json; the Hugging Face card header shows "685B params", which reflects the summed tensor count including its new sparse-attention indexer — sources conflict on which label to cite) and adds DeepSeek Sparse Attention for long-context efficiency, with a ~160K context window. It is an experimental release and, as noted, not yet a one-command Ollama pull. None of that changes the hardware reality: this is a large model regardless of the attention trick.

Self-host vs API: the honest cost

For the full-quality 671B model, a hosted API is almost always cheaper than the hardware to run it — and the gap is not close. Be honest with yourself about which column you are really in:

The math is blunt: a single H100 costs more than most teams spend on inference APIs in years, and the full model needs several of them plus the power, cooling, and ops to keep them fed. Unless you have near-constant utilization or a hard privacy requirement, buying GPUs to run the 671B model occasionally is the expensive option. For a laptop-sized distill on a GPU you already own, local is genuinely free at the margin — that is the sweet spot for self-hosting. For the full model, price a few providers first; our cheapest LLM API guide walks the per-token comparison.

When to reach for the gateway instead

If you want full-quality DeepSeek without owning a cluster, call it over an OpenAI-compatible endpoint. DataLLM Lab exposes 300+ chat models — including large open weights — behind one API key on a familiar base URL, so "running DeepSeek" becomes a single HTTP call with no 404 GB download:

from openai import OpenAI

client = OpenAI(
    base_url="https://www.datallmlab.com/v1",
    api_key="YOUR_DATALLMLAB_KEY",
)

resp = client.chat.completions.create(
    model="deepseek/deepseek-r1",
    messages=[{"role": "user", "content": "Explain MoE routing in one paragraph."}],
)
print(resp.choices[0].message.content)

Because the endpoint is OpenAI-compatible, the same base URL also serves other open-weight reasoning models — see GPT-OSS 120B (whose local footprint we break down in the GPT-OSS 120B requirements guide) and the best open-source LLMs of 2026. If you are choosing an open model to build on rather than to host, that comparison is the place to start.

FAQ