How to Run DeepSeek Locally (2026)

By LocalLLMGear Editorial · Editorial Team · Updated 2026-06-29

We test hardware hands-on and may use AI tools in research — every guide is human-reviewed. Editorial policy.

We may earn a commission from links in this article, at no extra cost to you. Disclosure.

DeepSeek is one of the most talked-about open model families, and the good news is you don’t need a data center to use it. With the right tool and a size that matches your GPU, you can have DeepSeek running on your own machine in a few minutes — private, offline, no API bill. Here’s the practical path.

The 30-second answer: Install Ollama, then run ollama run deepseek-r1:8b. That’s a distilled 8B variant that fits a typical 8 GB GPU or a 16 GB+ Apple Silicon Mac. Want bigger? Pick a larger tag that fits your VRAM — or rent a GPU for the flagship sizes.

What “DeepSeek” actually means

DeepSeek isn’t a single model — it’s an open-weight family. As of 2026 it spans large flagship models (general chat and reasoning-focused “R1”-style variants) plus a set of distilled, smaller versions built on top of common base models like Qwen and Llama. The distilled ones are the practical heroes for local use: they squeeze much of the behavior into 1.5B, 7B, 8B, 14B and 32B sizes that ordinary GPUs can actually hold.

Sizes and exact variant names shift over time, so as of 2026, check the latest variants and sizes in the Ollama library or LM Studio’s model search before you commit a download. The workflow below stays the same regardless of which specific tag is current.

Pick a size for your VRAM

The one rule that decides everything: the quantized model has to fit in your VRAM, with a little headroom for the context window. Go over it and the tool spills layers into system RAM — it still runs, just much slower. Rough, approximate guidance (4-bit quantized):

• 1.5B (~1.5 GB): tiny and fast, runs almost anywhere, even CPU-only. Good for testing.
• 7B / 8B (~5–6 GB): the sweet spot — fits an 8 GB GPU or a 16 GB Mac, genuinely useful.
• 14B (~9–10 GB): stronger reasoning; wants a 12 GB+ card.
• 32B (~20 GB): high quality, needs a 24 GB card like a 4090/5090-class GPU.
• Flagship (tens of GB+): multi-GPU rigs or big unified-memory Macs only — or rent.

Not sure what your card can hold? Our best GPU for local LLMs guide maps VRAM tiers to real models, and the hardware hub covers budget picks, dual-GPU builds and Apple Silicon. These are approximate figures — actual footprint varies with quantization and context length, so leave margin.

Run it with Ollama (fastest)

Ollama is the quickest route. Install it from ollama.com (macOS/Windows installer, or Linux: curl -fsSL https://ollama.com/install.sh | sh), then one command downloads the model and drops you into a chat:

ollama run deepseek-r1:8b

Swap the tag for whatever fits your hardware — deepseek-r1:1.5b for a tiny machine, deepseek-r1:14b or :32b if you’ve got the VRAM. To download without chatting (for scripting), use pull:

ollama pull deepseek-r1:8b
ollama list      # see what you have, with sizes
ollama ps        # see what's loaded in memory right now

Once Ollama is running it also serves a local API at http://localhost:11434, so your own apps and editors can talk to DeepSeek without sending a byte to the cloud. The full reference is in our Ollama guide.

Run it with LM Studio (graphical)

Prefer clicking to typing? LM Studio is a free desktop app with a built-in model browser and a ChatGPT-style chat window. The flow:

1. Install LM Studio and open the Search/Discover tab.
2. Search “DeepSeek” and pick a distilled variant whose size fits your VRAM (the app shows download sizes and often flags whether a model will fit your machine).
3. Download it, switch to the Chat tab, load the model, and start typing.

LM Studio also exposes a local OpenAI-compatible server so other tools can use the model — handy if you want a GUI for chatting but an API for your code. Both tools read the same underlying open weights, so you can use whichever feels better; see LM Studio vs Ollama if you’re deciding.

Hardware needs (the honest version)

For the distilled 7B/8B models, almost any modern setup works: an 8 GB GPU, or an Apple Silicon Mac with 16 GB+ of unified memory. That’s the configuration most readers should aim for — it’s cheap, fast enough, and covers the majority of real use.

Stepping up to 32B wants a single 24 GB card. The flagship DeepSeek models are a different league: tens of gigabytes of weights that realistically need multi-GPU rigs or very large unified-memory machines. If that’s where you want to go but your hardware isn’t there yet, renting is the sane move.

When the model is too big: rent a GPU

If the variant you want won’t fit locally, you don’t have to buy a new rig to try it. Spin up a cloud GPU by the hour, run the same ollama run command on it, and shut it down when you’re done — often cheaper than a single new graphics card for occasional heavy use.

Whether renting or buying makes sense for you depends on how many hours a month you’ll actually run it — we did the math in Cloud vs Buy a GPU for AI.

Troubleshooting

• Runs slowly / pegs the CPU: the model didn’t fit in VRAM and offloaded to system RAM. Drop to a smaller variant or a heavier quant, and close other GPU apps. Check with ollama ps.
• Out of memory mid-generation: lower the context window, feed it less at once, or step down a size.
• connection refused on port 11434: the Ollama server isn’t running — launch the app (macOS/Windows) or sudo systemctl start ollama (Linux).
• Model name not found: variant tags change over time. Run a fresh search in the Ollama library or LM Studio to get the current name — as of 2026, check the latest variants.
• Reasoning model is “thinking” forever: R1-style models emit a chain-of-thought before the answer; that’s expected. If it’s too verbose for your use, pick a non-reasoning chat variant instead.

Where to go next

Running DeepSeek is really just the general local-LLM workflow pointed at one model family. To go deeper, start with the full Ollama guide, make sure your GPU is up to the job, or browse the hardware hub for the right card or rig.

And if you want to genuinely understand prompting, RAG and fine-tuning on top of local models — not just run them — a structured course shortcuts months of trial and error: