How to Run DeepSeek Locally

Yes, you can run DeepSeek locally — and the model family is unusually flexible for self-hosting, because DeepSeek ships both a massive 671-billion-parameter Mixture-of-Experts flagship and a full lineup of distilled dense models that run on far more modest hardware.

DeepSeek is a Chinese AI lab that releases its models under the MIT license, one of the most permissive open-source licenses available. That gives businesses clear, unrestricted rights to self-host, modify, and deploy the model commercially — no usage caps, no revenue thresholds, no special clauses.

This guide walks through choosing the right DeepSeek size for your hardware, the quantization options that shrink the footprint further, which serving tool fits your setup (Ollama, LM Studio, vLLM, or SGLang), and a practical step-by-step path to a working local deployment.

Whether you want to prototype on a laptop with a 7B distilled model or deploy the full DeepSeek-V3 on a GPU cluster, the same family covers both ends of the spectrum — and that range is the key advantage over models that only ship at one size.

Can You Run DeepSeek Locally?

Yes — DeepSeek is one of the most flexible open-weight families to self-host, because the same lab ships models spanning from 1.5B parameters up to a 671B MoE flagship. You are not locked into one hardware tier.

The distilled dense models (1.5B, 7B, 8B, 14B, 32B, 70B) run on progressively larger hardware, starting from a laptop CPU for the smallest sizes up to a workstation GPU for the 70B. The full DeepSeek-V3 and DeepSeek-R1 at 671B need a multi-GPU server, similar to other frontier open models.

The practical question is not whether you can run DeepSeek but which size fits your hardware and your task. Start with the smallest model that could plausibly handle your workload and move up only if it falls short.

• Distilled 1.5B–8B — run on a laptop or a single consumer GPU.
• Distilled 14B–70B — a good fit for one or two workstation-class GPUs.
• Full 671B MoE (DeepSeek-V3, R1) — needs a multi-GPU server.

Picking the Right DeepSeek Size for Your Hardware

Match the DeepSeek size to the hardware you actually have, then size up only if your task needs more capability. Running the full 671B model on insufficient hardware just means failed loads or painfully slow inference — a smaller distilled model that fits comfortably in memory almost always performs better in practice.

GPU memory (VRAM) is the binding constraint: it decides which DeepSeek model fits at a given quantization level. The distilled models are standard dense architectures, so the memory math is straightforward — parameter count times bytes per weight, plus overhead for context. The full 671B MoE is more nuanced because only about 37B parameters activate per token, but you still need enough total memory to hold all 671B weights.

For teams evaluating multiple sizes, start with a compact distilled model locally, then test the larger variants against your real prompts — either self-hosted on bigger hardware or through the DeepSeek API — before committing to server-class infrastructure.

Quantization: Running DeepSeek on Less Hardware

Quantization lets a given DeepSeek model run on less hardware by storing its weights at lower numeric precision, which shrinks memory use at some cost to output quality. This is the main lever for fitting a larger DeepSeek size onto a smaller GPU than its full-precision weights would need.

Community-quantized builds (commonly GGUF or AWQ format) appear on Hugging Face quickly after each DeepSeek release, often from well-known contributors. For the distilled models, GGUF quantization is especially popular because it allows CPU-only inference via llama.cpp, which means even the 14B can run on a machine with no GPU at all — just slower.

Treat quantization level as a dial, not a free win. Test your own prompts at each level and keep the lowest precision that still clears your quality bar. The distilled models are already optimized for efficiency, so aggressive quantization on those can degrade quality faster than you might expect.

• Lower precision (e.g. 4-bit) shrinks memory use so a bigger DeepSeek size fits smaller hardware.
• GGUF and AWQ are the common community quantization formats for DeepSeek.
• GGUF enables CPU-only inference on the distilled models via llama.cpp.
• Aggressive quantization can hurt quality on hard tasks — test before committing.

Ollama, LM Studio, vLLM, and SGLang: Which Tool?

For the distilled DeepSeek models on a single machine, Ollama and LM Studio are the simplest way to get started — both have DeepSeek models in their libraries, so you can pull and run with one command and no manual weight conversion.

For the full 671B DeepSeek-V3 or R1 across multiple GPUs, high-throughput engines like vLLM and SGLang are the right fit, because they handle multi-GPU memory management and concurrent requests, which Ollama is not designed for at that scale.

A common pattern: prototype and develop against a distilled DeepSeek model in Ollama or LM Studio locally, then move the same OpenAI-compatible client code to a vLLM- or SGLang-served endpoint once you scale to the full 671B or need to serve multiple users at once.

• Single machine, quick start — Ollama or LM Studio, using their built-in DeepSeek model listings.
• Local power users — llama.cpp directly, for fine-grained control over GGUF quantization and hardware offload.
• Production / multi-GPU — vLLM or SGLang, serving an OpenAI-compatible API.

A Practical Setup Outline

Getting DeepSeek running locally follows a short, repeatable path regardless of which size you pick. The distilled models make this especially fast because you can go from zero to a working local endpoint in minutes.

Start with the smallest DeepSeek size that could plausibly do your task, and only move up if it falls short on your real prompts — this keeps hardware cost and setup time proportional to actual need.

Keep a small evaluation set of your own real prompts from day one, so you can tell quickly whether a given size, quantization level, or serving config is good enough — or whether you need the next tier up.

• Step 1 — Pick the smallest DeepSeek size that could plausibly handle your task (start with 7B or 8B distilled if unsure).
• Step 2 — Pull it via Ollama or LM Studio, or download the weights from DeepSeek's Hugging Face.
• Step 3 — Choose a quantization level (if any) that fits your GPU memory.
• Step 4 — Serve it: Ollama or LM Studio for single-machine use, vLLM or SGLang for multi-GPU production.
• Step 5 — Point your app at the local OpenAI-compatible endpoint so the client code stays unchanged if you later swap models or sizes.
• Step 6 — Test against your own prompts, and size up only if the smaller model genuinely falls short.

Licensing and When to Self-Host vs Use the API

DeepSeek releases its models under the MIT license, which is one of the most permissive open-source licenses available. There are no commercial restrictions, no monthly-active-user caps, no special clauses — you can self-host, modify, and deploy commercially with no legal overhead beyond standard open-source attribution.

Self-host DeepSeek when you need data residency, a compliance rule requires in-house hosting, or your usage volume is high enough that hardware cost beats ongoing API fees. The MIT license makes this as legally frictionless as self-hosting gets.

Use the DeepSeek API when you want to start fast with no hardware and your data is not sensitive enough to require in-house control. For most teams still evaluating the model, the API is the better default — especially since the API gives you access to the full 671B model without the server hardware.

• MIT license — no commercial restrictions, no usage caps, no special clauses.
• Self-host — data residency, compliance, or high-volume cost savings.
• Hosted API — fastest start, no hardware, full 671B model access without a server.
• Note: the DeepSeek API is hosted in China — factor data sovereignty into your decision.

What you need to run DeepSeek yourself

How much hardware you need depends entirely on the model’s size. A small model runs on a laptop; a frontier model needs a server or the cloud. Here is the map by size class — pick the row that matches the model you have in mind.

Whichever size you land on, a one-click runner like Ollama or LM Studio gets small and mid models going in minutes; for a hosted endpoint, point Cursor at the model through OpenRouter. For specific hardware picks, see Best mini PCs for local AI and Local AI hardware calculator.

NVIDIA GeForce RTX 4090

Phi / Gemma / small Qwen-class

View on Amazon →

Apple Mac Studio (M4 Max, 128GB)

Llama-70B / Mixtral-class

View on Amazon →