The Complete DeepSeek Guide: R1, V3.2 & V4 Explained (2026)

DeepSeek is the model family that changed what people expected from open AI. When DeepSeek R1 arrived in January 2025, it did something no open model had done convincingly before: it reasoned — working through hard math, logic, and code step by step, out loud — at a level that rivalled the best closed models, and it did so under a fully permissive MIT license that let anyone run, study, and build on it. The industry has not been the same since.

This is the complete guide to DeepSeek. We will trace the family from V3 through R1 to the giant V4 models, explain how reasoning models actually work and when to use them, and — most importantly — show you which DeepSeek models you can realistically run on your own hardware (the answer is mostly the R1 distills, and they are excellent). We will cover running it locally in Ollama and LM Studio, the honest local-vs-API trade-off for the huge models, and how DeepSeek stacks up against Qwen and the cloud giants. Beginner-friendly, but detailed enough to be your DeepSeek reference.

Table of contents

• What DeepSeek is and why it matters
• The "DeepSeek moment" that shook AI
• The DeepSeek family tree
• How reasoning models actually work
• DeepSeek R1 and its distills: what you'll actually run
• Which DeepSeek fits your GPU?
• The giants: V3, V3.2 and V4
• MoE: how DeepSeek runs 671B efficiently
• Reasoning vs non-reasoning: when to use DeepSeek
• Benchmarks: DeepSeek vs the field
• The MIT license advantage
• Privacy: local weights vs the hosted app
• Running DeepSeek locally
• Prompting DeepSeek well
• What DeepSeek is genuinely great at
• DeepSeek for coding
• Local vs API: the honest trade-off
• DeepSeek vs Qwen vs the field
• Fine-tuning with DeepSeek
• Capstone: a private reasoning workstation
• Troubleshooting
• Frequently asked questions

What DeepSeek is and why it matters {#what-is-deepseek}

DeepSeek is a Chinese AI lab that develops open-weight large language models, and its defining contribution is open reasoning. Most language models answer immediately, pattern-matching their way to a response. Reasoning models instead generate an internal chain of thought — a stretch of step-by-step working — before committing to an answer, which dramatically improves accuracy on problems that require actual thinking: multi-step math, logical deduction, complex coding, and careful analysis.

DeepSeek R1's release in early 2025 was a landmark for three reasons. First, it demonstrated that a fully open model could match the closed reasoning models of the day on hard benchmarks. Second, it was trained at a reported fraction of the cost people assumed such a model required, which upended industry expectations about how much compute frontier AI needs — the so-called "DeepSeek moment." Third, and most usefully for you, DeepSeek released distilled versions — smaller models (8B, 14B, 32B) that inherit much of R1's reasoning ability and fit on consumer hardware. That combination of capability, openness, and accessibility is why DeepSeek is a fixture of the local-AI world.

The MIT license matters as much as the models. It is one of the most permissive licenses in existence: use commercially, modify, redistribute, no attribution required. Where some open models carry usage conditions, DeepSeek's MIT terms mean you truly own what you run — a point explored in open LLM licenses for business. Combined with local execution, that makes DeepSeek a serious option for private, on-premise AI where both capability and data control are non-negotiable.

The "DeepSeek moment" that shook AI {#deepseek-moment}

It is worth understanding why DeepSeek R1 was such a big deal, because it explains the family's outsized reputation and why it matters for local AI specifically.

Before R1, the prevailing wisdom held two things: that frontier reasoning was the exclusive domain of a few well-funded closed labs, and that training such models required almost unimaginable compute budgets. DeepSeek R1 challenged both. It delivered reasoning competitive with the leading closed models of the time, it was released with open weights anyone could download and inspect, and it was reportedly trained for a fraction of the cost the industry assumed necessary. The market reaction was dramatic — the release rippled through tech stocks and dominated headlines for weeks, as people absorbed that the moat around frontier AI was narrower than believed.

For the local-AI community, the lasting significance was not the stock moves but the democratization. R1 proved that state-of-the-art reasoning could be open, and — through its distills — that a meaningful slice of that capability could run on a gaming GPU. Overnight, hobbyists could run a model that reasoned through olympiad math problems on hardware they already owned. That shifted expectations permanently: reasoning stopped being something you rented from a cloud and became something you could own. Every reasoning model since, open or closed, competes in a world DeepSeek helped create — and the practical beneficiary is anyone who wants private, capable AI at home. It is a core thread in the state of local AI in 2026.

The DeepSeek family tree {#family-tree}

DeepSeek ships two intertwined lines: V-series general models and R-series reasoning models, plus distills that bring reasoning to small sizes.

Reading the tree: the V-series (V3, V3.2, V4) are large, general MoE models — hugely capable but server-class. The R-series (R1) is the reasoning line, and its distills are what brought DeepSeek to consumer hardware. There is a persistent rumor of a "DeepSeek R2," but as of mid-2026 it remains unreleased; the current reasoning model you actually run locally is R1 and its distills. The always-current list is on the Model Library.

How reasoning models actually work {#reasoning}

To use DeepSeek well, you need to understand what makes a reasoning model different — because it changes how it feels and when you should reach for it.

When you ask DeepSeek R1 a hard question, it first produces a visible chain of thought — you will literally see it working through the problem, considering approaches, checking itself, sometimes backtracking — before it delivers a final answer. This "thinking" is not decoration; it is where the accuracy comes from. Just as you would solve a tricky problem on scratch paper rather than answering instantly, the model uses those intermediate tokens to reason its way to a correct result.

The trade-off is speed and tokens. A reasoning model is slower to finish because it generates all that thinking first, and it uses more of your context. That is a great deal for a hard math proof or a subtle bug, and a poor deal for "rewrite this sentence." The skill is matching the tool to the task — covered in the when-to-use section. Notably, Qwen's thinking mode offers the same capability as a toggle; DeepSeek R1 is reasoning-first by design.

To make it concrete, imagine asking "A bat and a ball cost $1.10 together; the bat costs $1.00 more than the ball; how much is the ball?" A standard model often blurts "$0.10" — the intuitive but wrong answer. A reasoning model works it out: if the ball is x, the bat is x + 1.00, so 2x + 1.00 = 1.10, meaning x = $0.05. It catches the trap precisely because it does the algebra step by step instead of pattern-matching to the obvious-looking number. Multiply that across genuinely hard problems — where the intuitive answer is wrong in subtle ways — and you see why reasoning models are worth the extra time when correctness matters.

DeepSeek R1 and its distills: what you'll actually run {#r1-distills}

Here is the practical heart of DeepSeek for local use. The full R1 is a 671B MoE model that needs a server; almost nobody runs it at home. What you do run are the distills — smaller models trained to imitate R1's reasoning, built on Qwen and Llama backbones.

Distillation is a teacher-student process: the giant R1 "teacher" generates reasoning traces, and a smaller "student" model learns to reproduce them. The result is a compact model that reasons far better than its size would suggest. The R1 distills come in these sizes:

• DeepSeek R1 Distill 8B (Llama-based) — reasoning on a small card. Fits in ~6 GB, runs on an 8 GB GPU. Remarkable logic for its size.
• DeepSeek R1 Distill 14B (Qwen-based) — the 12 GB sweet spot. At ~9 GB it delivers better logical performance than most non-reasoning 70B models, on a mainstream card like an RTX 3060 or 4070.
• DeepSeek R1 Distill 32B (Qwen-based) — the powerhouse. At ~20 GB it fits a 24 GB card (RTX 4090/3090 or a 5090) and beats many 70B models at math and code. This is the best local reasoning model most enthusiasts can run.

The distills carry the MIT license and R1's step-by-step style. For hard problems on consumer hardware, they are genuinely the state of the art — a 14B or 32B distill will often solve a tricky logic or math question that a much larger non-reasoning model gets wrong. Our comparison DeepSeek R1 vs GPT-4o puts this in context.

A note on the base models. The distills are built on two different backbones, which occasionally matters. The 8B distill is Llama-based; the 14B and 32B are Qwen-based. In practice both reason well, but the Qwen-based 14B and 32B tend to be the strongest for math and code, inheriting Qwen's already-excellent technical ability plus R1's reasoning on top. This is also why you will see the distills described with names like "R1 Distill Qwen 32B" — the first part names the teacher (R1's reasoning), the second the student (the Qwen base). For running purposes you do not need to worry about it: deepseek-r1:14b and deepseek-r1:32b in Ollama give you the strong Qwen-based distills automatically. It is simply useful to know that a DeepSeek distill is, under the hood, a familiar base model that has been taught to reason like R1 — which is why they behave predictably and enjoy broad tooling support.

Which DeepSeek fits your GPU? {#which-fits}

The practical question: which DeepSeek can you run? Here is the map, at Q4_K_M.

Confirm any size against your exact card with the VRAM Calculator or the Hardware Analyzer. For the vast majority of people, the 14B and 32B distills are the answer — the best open reasoning you can run privately, on hardware you own.

The giants: V3, V3.2 and V4 {#giants}

DeepSeek's flagship models are extraordinary, and almost entirely impractical to self-host. It is worth knowing what they are so you understand the ceiling.

• DeepSeek V3 / V3.2 — 671B/685B-parameter MoE general models. Frontier-class, but they need multi-GPU server clusters (~400 GB+ of memory). These power DeepSeek's hosted chat and API.
• DeepSeek V4 (April 2026) — the current flagship, MIT-licensed with a 1-million-token context. It comes in two sizes: V4-Flash (284B total / 13B active) and V4-Pro (1.6T total / 49B active). Even the "small" Flash needs roughly 140–160 GB at Q4 — realistically a multi-GPU workstation or a datacenter card — and local software support is still experimental as of mid-2026. V4-Pro, at 1.6 trillion parameters, is a datacenter-only model estimated at ~400 GB even heavily quantized.

The honest framing: the giants are API or reference models, not local ones. V4-Pro topped open-weight leaderboards on release (our writeup DeepSeek V4-Pro: rank-1 open-weight model covers it), but for almost everyone the practical way to use them is DeepSeek's hosted API or chat — while running an R1 distill locally for private work. If you occasionally need that frontier power, renting a suitable GPU by the hour for the job beats owning the hardware. This split — small distills local, giants via API — is the defining practical fact about the DeepSeek family.

The 1-million-token context on V4 deserves a mention, because it hints at where things are heading. A million tokens is roughly 750,000 words — several long books at once. Paired with reasoning, that enables analysis over enormous corpora: reason across an entire codebase, a full case file, or a shelf of research papers in a single pass. Today that capability lives in the server-class V4 models, so you reach it through the API rather than locally. But the trajectory is clear — capabilities that debut in the giants tend to filter down to smaller, runnable models over time, just as R1's reasoning filtered down into the distills you run today. Long-context reasoning is likely to become locally practical in future generations; for now, the context windows guide explains how to make the most of the (still generous) context on the distills you can run.

MoE: how DeepSeek runs 671B efficiently {#moe}

DeepSeek's large models are Mixture-of-Experts (MoE), and understanding this explains both their power and their memory appetite.

A dense model uses all its parameters for every token. An MoE model splits into many "expert" sub-networks and routes each token to only a few of them. DeepSeek V3/R1's 671B is MoE: it stores 671B parameters but activates only a fraction per token, so it computes far more cheaply than a 671B dense model would — that efficiency is part of how DeepSeek trained it affordably. V4-Pro pushes this further: 1.6 trillion total parameters but only 49B active per token.

The catch is memory. Even though only a slice runs per token, all the experts must be loaded, so an MoE's VRAM need tracks its total size, not its active size. That is exactly why the 671B model needs ~400 GB despite activating far less — you must hold every expert in memory in case the router picks it. This is the same principle that makes Qwen's 35B-A3B fast but still demanding of ~21 GB. The deeper mechanics are in MoE Models Explained. The takeaway for DeepSeek: MoE is why the giants are so capable and why they will not fit on your desk — and why the dense distills, which have no such total-size overhang, are what you run locally.

This is also why MoE and distillation are complementary strategies. The giant MoE (R1) is where the reasoning capability is created — its scale and expert routing let it learn to reason at a high level. Distillation then compresses that capability into a compact dense model that has no expert overhead, so it fits and runs efficiently on consumer hardware. In other words, DeepSeek uses MoE to build the smartest possible teacher, then distillation to hand a slice of that intelligence to a student small enough for your GPU. Understanding that pipeline demystifies the whole family: the big MoE models you cannot run are the source, and the small dense distills you can run are the gift. It is one of the most elegant capability-transfer stories in open AI, and it is why "you can't run the 671B" is not the disappointment it sounds like — you run its distilled reasoning instead, and for most problems that is plenty.

Reasoning vs non-reasoning: when to use DeepSeek {#when-to-use}

DeepSeek R1 is not the right tool for every task — using a reasoning model for simple work wastes time and tokens. Here is when to reach for it, and when to reach for a fast general model like Qwen instead.

A practical setup many people adopt: keep both a DeepSeek distill and a fast general model installed, and switch per task. In Open WebUI or LM Studio, that is a dropdown change. Use qwen3:14b for the bulk of your day, and hand the genuinely hard problems to deepseek-r1:14b or :32b. You get fast, pleasant everyday interaction and deep reasoning on demand, all local. This mirrors how the cloud world splits "fast" and "reasoning" models — except you own both and pay for neither per token.

A simple heuristic for the decision: would you reach for a pen and paper to solve it? If yes — a calculation, a logic puzzle, a design problem, a careful analysis — use DeepSeek. If you would just answer off the top of your head — a quick reply, a rewrite, a summary, a factual lookup — use the fast model. That instinct maps almost perfectly onto when the reasoning tokens are worth their cost. Over-using a reasoning model is the most common mistake newcomers make: they run everything through DeepSeek, find it "slow," and conclude reasoning models are impractical, when the real issue is using a scalpel for every job. Matched to the right tasks, it feels less slow and more thorough — and the thoroughness is exactly what you wanted.

Benchmarks: DeepSeek vs the field {#benchmarks}

DeepSeek's calling card is reasoning benchmarks — math (AIME, MATH), science (GPQA), and code (LiveCodeBench, HumanEval) — where the step-by-step approach shines. The headline results are consistent: the R1 distills punch far above their weight on exactly these tasks.

Two caveats keep this honest. First, benchmarks are narrow — DeepSeek's edge is specifically on reasoning tasks; for general chat, creative writing, or breadth of knowledge, a good general model may feel better. Second, always test on your own work rather than trusting headline numbers, a point we make in who is winning the local LLM race. For live, hardware-specific throughput figures, the benchmarks page measures tokens/sec per GPU, and the Compare tool puts two models' scores side by side. The reliable summary: for hard, verifiable problems, a DeepSeek distill is the best thing you can run locally at its size.

The MIT license advantage {#license}

DeepSeek's MIT license is among the most permissive in AI, and it is a genuine differentiator:

• Commercial use, no fees, no attribution — ship it in products freely.
• Full modification and redistribution rights — fine-tune, distill, adapt, and release the result.
• No usage restrictions or acceptable-use carve-outs beyond the law.
• No deprecation risk — the weights are yours permanently.

For a business, this removes legal friction that some other open models introduce with community licenses or usage caps. Combined with local execution, DeepSeek offers powerful reasoning with total data control and clean commercial terms — a rare trio. It is a natural fit for private AI in regulated settings, and the license details are covered in open LLM licenses for business. When capability, openness, and licensing all line up, you get to own the reasoning capability rather than rent it — the argument developed across why companies choose local AI and why they fine-tune open models instead of using an API.

Privacy: local weights vs the hosted app {#privacy}

Because DeepSeek is a Chinese lab, a common and fair question is: "is it safe to use, privacy-wise?" The answer hinges on a distinction that matters for every model, not just DeepSeek — the difference between running open weights locally and using a hosted service.

Running the open weights locally (in Ollama or LM Studio) means the model is just a file of numbers on your disk. Inference happens entirely on your hardware, with no network calls — the model cannot send your data anywhere, because it is not connected to anything. You can verify this by pulling your network cable and watching it work. This is exactly why privacy-focused users choose local models: a DeepSeek distill running offline is as private as a calculator. It does not matter who trained it; the weights cannot phone home. Using DeepSeek's hosted app or API is different — that sends your prompts to their servers, like any cloud service (OpenAI, Google, etc.), subject to their jurisdiction and policies. If your data is sensitive, that is the thing to avoid, and the solution is simple: run the weights locally instead.

So the practical guidance is unambiguous: for private work, run a DeepSeek distill locally and enjoy MIT-licensed reasoning with zero data exposure. Reserve the hosted API for non-sensitive tasks that genuinely need the giant models. This local-weights-are-private principle is foundational to the whole site — see why local LLMs are cheaper and more secure and private AI for business. It is the reason "which country made the model" is far less important than "am I running it locally."

Running DeepSeek locally {#running}

DeepSeek runs in every local tool. The two easy paths:

With Ollama (see the Complete Ollama Bible):

ollama run deepseek-r1:8b     # reasoning on an 8 GB card
ollama run deepseek-r1:14b    # the 12 GB sweet spot
ollama run deepseek-r1:32b    # best local reasoning, 24 GB

With LM Studio (see the Complete LM Studio Bible): open Discover, search "deepseek-r1", and download the largest distill that shows a green "fits" badge at Q4_K_M.

Running tips specific to DeepSeek's reasoning nature:

• Expect to see it think. The reasoning appears before the answer. Most UIs (including Open WebUI) can collapse it; embrace it for hard problems, where the reasoning is the value.
• Give it room. Reasoning uses tokens, so set a generous context (num_ctx) and a high enough output limit that it can finish thinking and answer without being cut off.
• Be patient on hard questions. A reasoning model finishing in 20 seconds of thinking that gets the right answer beats a fast model that confidently gets it wrong.
• Quantization: Q4_K_M is the default; step up if you have VRAM to spare. See Quantization Explained.
• Don't use it for everything. For quick chat, switch to a fast general model — see the when-to-use section.

Prompting DeepSeek well {#prompting}

Reasoning models reward a different prompting style than standard chat models. A few habits get much better results from DeepSeek:

• Let it think — don't fight the process. Do not instruct it to "answer immediately" or "skip the reasoning" on a hard problem; the thinking is where the accuracy lives. Give it the space and time to work.
• State the problem clearly and completely. Reasoning models excel when the problem is well-specified. Include all constraints, examples, and the exact question. Ambiguity wastes its reasoning on guessing what you meant.
• Ask it to verify. For math and logic, adding "check your answer" or "verify each step" nudges it to catch its own mistakes — something reasoning models do well.
• Don't over-constrain the format mid-reasoning. Let it reason freely, then ask for the final answer in a specific format. Forcing rigid formatting too early can short-circuit the thinking.
• Use lower temperatures for correctness. For math, logic, and code, a temperature around 0.2–0.4 keeps it focused; higher temperatures suit open-ended exploration.
• Break giant problems into parts. For very complex tasks, decomposing into sub-problems it can reason through one at a time often beats one enormous prompt.

The meta-point: treat DeepSeek like a careful analyst you have given a hard problem and some quiet time, not like a search box. Prompt it that way and it rewards you. General prompting technique transfers too — see System Prompts & Personas 101 — but the "let it think" instinct is what is specific to reasoning models.

What DeepSeek is genuinely great at {#use-cases}

DeepSeek's reasoning focus makes it the best local tool for a specific, valuable set of tasks:

• Mathematics and quantitative work. Multi-step problems, proofs, derivations, and word problems — where step-by-step reasoning is exactly what is needed. A superb private math tutor.
• Hard debugging and algorithm design. When a bug requires tracing logic through several layers, or you need to design a non-trivial algorithm, DeepSeek's reasoning finds what a fast model skims past. See Coding & Debugging Workflow.
• Logical analysis and planning. Breaking down complex decisions, evaluating trade-offs, planning multi-step processes, and reasoning about cause and effect.
• Careful document analysis. Combined with RAG, it reasons over your documents rather than just retrieving from them — useful for contracts, research, and technical material where the implications matter, not just the text.
• Learning and tutoring. Because it shows its work, DeepSeek is excellent for learning — you can see how it reached an answer, not just the answer. A powerful study partner (Using LLMs for Learning).
• Research assistance. Working through hypotheses, checking reasoning, and stress-testing arguments.

What it is not the best pick for: fast casual chat, creative fiction, quick drafting, or simple lookups — a general model like Qwen is faster and more fluent there. The winning move is to keep both and route by task, as the when-to-use section describes. Used for what it is great at, a DeepSeek distill is like having a patient, rigorous analyst on call, entirely offline — a genuinely new capability to have running on your own desk, and one of the standout local LLM use cases for 2026.

DeepSeek for coding {#coding}

Reasoning and coding overlap heavily — debugging, algorithm design, and understanding complex code all benefit from step-by-step thinking — so DeepSeek distills are excellent local coding assistants for hard programming tasks. Where a fast coder model is great for autocomplete and boilerplate, a DeepSeek distill shines when you hand it a subtle bug, a tricky algorithm, or a "why doesn't this work?" that needs actual reasoning.

To use it, run a distill via a local API server and point Continue (VS Code) or Aider at it — your code never leaves your machine. A common pattern: use a fast coder model like qwen3-coder for everyday completion, and switch to deepseek-r1:14b/32b for the hard debugging sessions. The full setup is in Local Coding Assistant Setup and Coding & Debugging Workflow. For serious local coding with reasoning, a 24 GB card running the 32B distill is a genuinely capable, entirely private pair.

Local vs API: the honest trade-off {#local-vs-api}

DeepSeek forces a clear decision that other families blur, because its best models are unrunnable locally. Here is the honest framework.

Run locally (a distill) when: privacy matters (confidential data, code, documents), you want zero per-query cost, you need offline capability, or a 14B/32B distill is capable enough for your task — which, for most reasoning work, it is. This is the default for anyone with a decent GPU, and the reason DeepSeek is on this site at all. Use the API (or hosted chat) when: you specifically need the frontier capability of the full R1, V3.2, or V4 that no consumer hardware can run, and the task is not so sensitive that it cannot leave your machine. The API gives you the giants without a server, priced per token.

The pragmatic hybrid many adopt: a distill locally for private, everyday reasoning, and the API for the rare task that genuinely needs the 671B/V4 tier. In a tool like Open WebUI you can put both in one dropdown and choose per task. The Cost Calculator and cloud vs local comparison help you find the break-even; the key insight is that the distills are good enough that most people rarely reach for the API at all.

DeepSeek vs Qwen vs the field {#comparison}

Where DeepSeek sits among the families you actually choose between.

The honest positioning: DeepSeek is the specialist you keep for hard problems; Qwen is the generalist you use all day. They complement each other perfectly, and since both are free and permissively licensed, most serious local-AI users keep both — a Qwen for breadth and speed, a DeepSeek distill for depth. Add a Gemma for the smallest multimodal devices and you have the whole toolbox. See the Complete Qwen Guide for the generalist side, and DeepSeek R1 vs GPT-4o for how the reasoning compares to the cloud.

One nuance worth naming: the lines are blurring. Qwen's toggleable thinking mode means a single Qwen can act as both generalist and reasoner, which tempts some people to run only Qwen. That is a reasonable choice — but DeepSeek's reasoning-first design still tends to edge ahead on the very hardest math and logic, where its whole training was oriented toward step-by-step correctness. So the split is not "one is better," it is "different tools for different jobs." If you have the disk space (models are just files), keeping a dedicated DeepSeek distill for your toughest problems costs you nothing and gives you the best local reasoning available for those moments when correctness truly matters. Think of it as keeping a specialist on retainer: rarely needed, invaluable when it is. The whole comparison landscape is mapped in who is winning the local LLM race in 2026.

Fine-tuning with DeepSeek {#fine-tuning}

Because the distills are open, MIT-licensed, and built on popular Qwen/Llama backbones, they are strong bases for fine-tuning — especially if you want a model that reasons in your domain. The usual approach is LoRA/QLoRA, which adapts a distill cheaply on a single consumer GPU. You could, for example, fine-tune the 14B distill on your own worked-solution data to make it reason in a specialized way for your field.

The workflow: pick a distill that fits your GPU, prepare a dataset (see the Datasets explorer and Which Dataset Should I Use?), run a LoRA fine-tune, and convert the result to GGUF to run in Ollama. The beginner path is Fine-Tune Your First LLM in 1 Hour; deeper methods are in Fine-Tuning with Datasets. Note that the R1 distills were themselves produced by distillation — a reminder that these techniques are how a giant model's capability gets compressed into something you can run and further shape yourself.

Capstone: a private reasoning workstation {#capstone}

Let us assemble a setup that plays to DeepSeek's strengths — a private analytical workstation that reasons through hard problems and your documents, entirely offline.

1. Pick your models. Install two: a DeepSeek distill for reasoning and a fast generalist for everyday work. On a 24 GB card, deepseek-r1:32b plus qwen3:14b; on 12 GB, deepseek-r1:14b plus qwen3:8b. Pull them in Ollama.

ollama pull deepseek-r1:32b   # the reasoning specialist
ollama pull qwen3:14b         # the fast generalist
ollama pull nomic-embed-text  # embeddings for document reasoning

2. Front it with Open WebUI. Install Open WebUI so both models sit in one dropdown — switch to DeepSeek for hard problems, Qwen for quick ones. Set the embedding model for RAG. 3. Build a knowledge base. Upload the documents you need to reason over — research papers, technical specs, contracts. Because DeepSeek reasons rather than just retrieves, it can answer questions that require connecting facts across documents, not just finding a passage. 4. Tune the reasoning assistant. Create a custom model on deepseek-r1:32b with a system prompt like: "You are a rigorous analyst. Reason step by step, verify your logic, cite the documents, and flag any assumptions. If a question requires information not provided, say so." Temperature 0.3, generous context. 5. Use it well. Hand it the genuinely hard questions — the math, the tricky analysis, the subtle bug, the "does this argument hold up?" — and let it think. For everything else, flip to the fast Qwen. You now have a private research-and-reasoning desk that rivals expensive cloud tools, with nothing leaving your machine.

That is the DeepSeek endgame for local AI: frontier-adjacent reasoning, private and free, on hardware you own — paired with a fast generalist so you get depth and speed. Scale it onto a home server for the household, or a 5090 workstation for maximum speed, and it becomes a genuinely powerful private AI lab.

Troubleshooting {#troubleshooting}

Frequently asked questions {#faq}

Can I run DeepSeek locally?

Yes — the R1 distills (8B, 14B, 32B) run on consumer GPUs and are the best open reasoning models you can run at home. The full R1 (671B) and the V4 giants need servers; use the API for those. See which fits your GPU.

What's the difference between DeepSeek R1 and V3/V4?

R1 is the reasoning model (thinks step-by-step); V3, V3.2, and V4 are large general models. R1's distills are what most people run locally; the V-series flagships are server/API tier. Details in the family tree.

Which DeepSeek should I use?

For a 12 GB card, deepseek-r1:14b; for 24 GB, deepseek-r1:32b. These give the best local reasoning. Pair one with a fast general model like Qwen for everyday tasks. Confirm fit with the Hardware Analyzer.

Is DeepSeek free and open source?

Yes — DeepSeek models are MIT licensed, one of the most permissive terms available, allowing free commercial use, modification, and redistribution with no attribution. See the license section.

Why does DeepSeek "think" before answering?

Because it is a reasoning model — generating a chain of thought before the answer dramatically improves accuracy on hard math, logic, and code. It is slower but far more reliable on difficult problems. See how reasoning works.

Is DeepSeek better than GPT or Claude?

On hard reasoning benchmarks, DeepSeek is competitive with the closed reasoning models, and the distills bring much of that home to run privately. The very largest closed models still lead at the frontier, but a local distill is often good enough — and private and free. See DeepSeek R1 vs GPT-4o.

Does running DeepSeek locally send data to China?

No. When you run a DeepSeek model locally in Ollama or LM Studio, inference happens entirely on your machine with no network calls — the weights are just files. That is the whole point of local models, and a key reason privacy-sensitive users choose them. (Using DeepSeek's hosted API or app is different — that sends data to their servers, like any cloud service.)

Is DeepSeek good for coding?

Yes, especially for hard, reasoning-heavy coding — debugging and algorithm design. Pair a distill with Continue or Aider via a local API server. For everyday autocomplete, a fast coder model like qwen3-coder complements it.

What is DeepSeek R2? Is it out?

As of mid-2026, R2 remains unreleased and unconfirmed — a persistent rumor rather than a product. The current reasoning model to run locally is R1 and its distills. When a genuine successor ships, it will appear on the Model Library; set up new-model alerts if you want to know.

Why is my DeepSeek model so slow?

Two common causes. First, it is a reasoning model, so it generates thinking tokens before answering — that is normal and expected on hard questions. Second, if it is genuinely crawling (a few tokens per second), the model likely spilled to system RAM; use a smaller distill or one that fits fully in VRAM. See the troubleshooting table.

Can I turn off the "thinking" to get faster answers?

For simple tasks, the better move is to switch to a fast general model rather than fight the reasoning model. If you want to keep DeepSeek but hide the reasoning, most UIs collapse the block so you only see the final answer — the model still thinks, it is just tidier on screen.

How much VRAM do I need for DeepSeek?

About 6 GB for the 8B distill, ~9 GB for the 14B, and ~20 GB for the 32B, all at Q4_K_M, plus a little for context. The full 671B and V4 models need hundreds of gigabytes and are not local. The VRAM Calculator gives exact figures.

Is DeepSeek's reasoning better than Qwen's thinking mode?

Both are strong and use the same underlying idea. DeepSeek R1 is reasoning-first and slightly more specialized for it; Qwen lets you toggle thinking on and off in one model, which is more flexible for mixed workloads. Many people run both. Compare in the Complete Qwen Guide.

Verdict and where to go next

DeepSeek is the open reasoning specialist, and its distilled R1 models are, without much competition, the best step-by-step reasoning you can run on your own hardware — a 14B on a 12 GB card or a 32B on 24 GB will out-think much larger models on hard math, logic, and code, all under a clean MIT license and entirely privately. The giant flagship models (671B, V4) are extraordinary but belong to the API tier; the genius of the distills is that they bring most of that reasoning within reach of a normal GPU. Keep a DeepSeek distill alongside a fast generalist like Qwen, and you have both depth and speed covered, for free.

To put it to work:

• Run it: the Complete Ollama Bible and Complete LM Studio Bible.
• Give it an interface: the Complete Open WebUI Guide.
• Pair it with a generalist: the Complete Qwen Guide.
• Get the hardware: the Complete RTX 5090 Guide and Best GPU Buyer's Guide.

---

See every DeepSeek variant and its specs → DeepSeek on the Model Library Check which DeepSeek your machine can run → Hardware Analyzer Compare local DeepSeek to the API on cost → Cost Calculator