DeepSeek R1 14B VRAM Requirement by Quantization, plus Ollama Setup for Every Distill (2026)

To run DeepSeek R1 locally, install Ollama and pull a distilled model sized to your VRAM: ollama run deepseek-r1:8b (5.2GB) needs an 8GB card, deepseek-r1:14b (9.0GB) needs 12GB at a 4K context or 16GB at 16K, deepseek-r1:32b (20GB) needs 24GB, and the full deepseek-r1:671b is a 404GB download. The 32B distill is the best single-GPU option, scoring 72.6% on AIME 2024 per DeepSeek's model card; its bandwidth ceiling on an RTX 4090 is 1,008GB/s ÷ 20GB ≈ 50 tok/s, and real runs land below that. R1 is MIT-licensed, free for commercial use, and shows its reasoning live through visible <think> tokens. Setup takes about 10 minutes. Tags and sizes on this page were read from ollama.com on 2 November 2026.

DeepSeek R1 14B: VRAM requirement by quantization

deepseek-r1:14b (DeepSeek-R1-Distill-Qwen-14B) is a 9.0GB Q4_K_M download that needs about 11GB of VRAM at a 4K context and about 13GB at 16K — so a 12GB card at short context, a 16GB card for anything longer. The q8_0 tag is 16GB and needs a 24GB card; the fp16 tag is 30GB and fits no card below the 32GB RTX 5090. Nothing in this table fits an 8GB card. Ollama publishes exactly three 14b tags; the two in-between quants come from Hugging Face.

The KV cache is arithmetic from the model's config.json: 48 layers (num_hidden_layers), 8 KV heads (num_key_value_heads), head dim 128 (hidden_size 5120 ÷ num_attention_heads 40). Bytes per token = 2 (keys and values) × 48 × 8 × 128 × 2 bytes (f16) = 196,608, which is 0.8GB at 4,096 tokens, 3.2GB at 16,384, 6.4GB at 32,768 and 25.8GB at the full 131,072 the model supports — the full window is a 48GB proposition on its own. The VRAM columns are download size + KV cache + a 1GB allowance for llama.cpp's compute buffers; the exact buffer is printed at load time.

Speed for the 9.0GB tag is bounded by the card's memory bandwidth ÷ 9.0GB: about 50 tok/s on an RTX 5060 Ti 16GB (448GB/s), 75 on an RTX 5070 (672GB/s), 100 on a 5070 Ti (896GB/s), 104 on an RTX 3090 (936GB/s), 112 on an RTX 4090 (1,008GB/s) and 199 on an RTX 5090 (1,792GB/s) — ceilings from the vendor figures, not measurements, and real runs land below them.

Two levers move the VRAM numbers: --cache-type-k q8_0 --cache-type-v q8_0 in llama.cpp (or OLLAMA_KV_CACHE_TYPE=q8_0) halves the KV column, so Q5_K_M at 16K drops to about 13GB; and Ollama's num_ctx decides which column applies, so set it deliberately rather than inheriting a default. If you have an 8GB card, run the 8B distill from the quick-start above instead. For how the K-quant names trade size for quality, see quantization explained; for what else fits these cards, see the 12GB and 16GB picks and the Ollama RAM/VRAM table.

What is DeepSeek R1?

DeepSeek R1 is a 671 billion parameter reasoning model that revolutionized open-source AI when released on January 20, 2025. Built by Chinese AI lab DeepSeek for approximately $5.6 million in training costs, it matches or beats OpenAI's o1 and GPT-4 on complex reasoning tasks—and it's completely open source under the MIT license.

What makes R1 groundbreaking isn't just performance. It's the first open model to demonstrate transparent chain-of-thought reasoning through visible <think> tokens. Unlike closed models that hide their reasoning, R1 shows you exactly how it solves problems step by step. You can watch it explore solutions, catch its own mistakes, and course-correct in real-time.

The model uses a Mixture-of-Experts (MoE) architecture with 671B total parameters but only 37B active per token. This makes it computationally efficient while maintaining massive capability. DeepSeek achieved this through pure reinforcement learning—the model learned to reason without pre-programmed chains of thought.

Andrej Karpathy, founding member of OpenAI, commented: "DeepSeek making it look easy today with an open weights release of a frontier-grade LLM trained on a joke of a budget (2048 GPUs for 2 months, $6M)."

---

DeepSeek Model Family: Complete Version History

Understanding the DeepSeek ecosystem helps you choose the right model:

DeepSeek LLM 7B and 67B (November 29, 2023)

DeepSeek's first open models, and the ones the R1 family replaced. Per the model card, DeepSeek LLM was trained from scratch on 2 trillion tokens of English and Chinese and released as 7B and 67B Base and Chat models; the scaling work behind it is in the DeepSeek LLM paper. Dense models with a 4,096-token context, under the DeepSeek model license.

• On Ollama: deepseek-llm:7b (4.0GB) and deepseek-llm:67b (38GB)
• Today: superseded. For a DeepSeek model at the same 7-8B size, deepseek-r1:8b (5.2GB) reasons far better and has a much longer context; keep deepseek-llm:7b only for an old pipeline that was built around it

DeepSeek V3 (December 26, 2024)

The foundation model. General-purpose 671B MoE optimized for broad capabilities across coding, writing, and conversation.

• Parameters: 671B total, 37B active
• Context: 128K tokens
• Best for: General tasks, coding, writing

DeepSeek R1 (January 20, 2025)

The reasoning specialist. Same architecture as V3 but trained specifically for complex reasoning using reinforcement learning.

• Parameters: 671B total, 37B active
• Context: 128K-160K tokens
• Best for: Math, logic, multi-step problems, debugging

DeepSeek R1-0528 (May 28, 2025)

Upgrade to the 671B model. Per DeepSeek's model card: AIME 2025 accuracy up from 70% to 87.5%, longer reasoning (23K tokens per question on average, versus 12K), a reduced hallucination rate, function calling and system-prompt support.

• New distill: DeepSeek-R1-0528-Qwen3-8B — R1-0528's chain of thought distilled into Qwen3 8B Base; 86.0 on AIME 2024 versus 76.0 for stock Qwen3-8B
• On Ollama: deepseek-r1:8b and deepseek-r1:671b are the 0528 builds (tags 8b-0528-qwen3-q4_K_M, 671b-0528-q4_K_M); the 1.5B/7B/14B/32B/70B tags remain the January distills
• Best for: Production use, API integration

DeepSeek V3.1 (August 21, 2025)

Hybrid model combining V3's versatility with R1's reasoning. Can switch between thinking and non-thinking modes.

• Unique feature: Dynamic mode switching
• Best for: Users wanting both capabilities in one model

DeepSeek V3.2 (December 2025)

Latest general-purpose release with performance improvements across all benchmarks.

DeepSeek V4 (April 24, 2026)

Next-generation flagship, released as a preview in two sizes under the MIT license: V4-Pro (1.6T total / 49B active) and V4-Flash (284B total / 13B active). Both ship with a 1M-token context window and a focus on coding, agents, and tool use. V4-Pro scores ~80% on SWE-bench Verified. V4 introduces an Engram memory architecture and hybrid attention for efficient long context.

---

DeepSeek R1 Benchmark Performance

R1's benchmark scores explain why it disrupted the AI industry:

Mathematics Benchmarks

Coding Benchmarks

Knowledge Benchmarks

The R1 scores are particularly impressive on hard benchmarks—AIME (math olympiad), Codeforces (competitive programming), and GPQA Diamond (PhD-level science). Beating GPT-4o and Claude 3.5 together on these benchmarks by significant margins was unprecedented for an open model.

Distilled Model Performance

The distilled versions retain most reasoning capability:

The 32B distilled model achieves 72.6% on AIME—that's math olympiad performance from a model that runs on a single RTX 4090.

---

How DeepSeek R1's Thinking Mode Works

Understanding R1's reasoning mechanism helps you use it effectively.

Chain-of-Thought Architecture

When you send a prompt to R1, the model generates two distinct phases:

1. Thinking Phase (<think>...</think>)

   • Internal reasoning tokens visible in raw output
   • Problem breakdown and exploration
   • Self-correction and verification
   • Multiple solution paths evaluated

2. Response Phase

   • Final answer based on thinking
   • Clean, user-facing output
   • Conclusions from reasoning process

The Four-Stage Reasoning Taxonomy

Research into R1's behavior reveals four distinct stages:

1. Problem Definition: Initial understanding and constraint identification
2. Blooming Cycle: Exploration of multiple solution approaches
3. Reconstruction Cycles: Self-correction, rumination, "aha moments"
4. Final Decision: Commitment to answer after verification

"Aha Moments" - Emergent Self-Correction

One of R1's most remarkable behaviors is spontaneous error correction. During reasoning, the model will:

• Recognize when an approach is failing
• Explicitly state "Wait, this doesn't seem right..."
• Backtrack and try alternative methods
• Verify final answers against original constraints

This emerged purely from reinforcement learning—DeepSeek did not pre-program these behaviors.

Example Thinking Output

<think>
Let me break down this math problem...
First, I need to identify the variables: x represents...
Wait, I should check my assumption about...
Actually, that approach won't work because...
Let me try a different method using...
Now I can verify: if x = 5, then...
Yes, this satisfies all constraints.
</think>

The answer is x = 5, which I verified by substituting back into the original equation.

Controlling Thinking Mode

• Temperature 0.6 (recommended): Balanced reasoning
• Temperature 0.3-0.5: More focused, less exploration
• Temperature 0.7-0.8: More creative, more exploration
• Prompt engineering: "Think step by step" encourages extended reasoning
• V3.1 hybrid: Automatically decides when to think based on complexity

---

Complete Model Specifications

Full 671B Model

Distilled Model Specifications

Download sizes are Ollama's default (Q4_K_M) tags, read from the deepseek-r1 tags page; base models are from DeepSeek's model card.

---

Step-by-Step Local Setup with Ollama

Step 1: Install Ollama

macOS/Linux:

curl -fsSL https://ollama.com/install.sh | sh

Windows: Download the installer from ollama.com/download and run it.

Verify installation:

ollama --version
# Should show: ollama version 0.5.x or higher

Step 2: Choose and Pull Your Model

Select based on your VRAM:

# 4GB VRAM - Basic reasoning (1.1GB download)
ollama pull deepseek-r1:1.5b

# 8GB VRAM - Good balance, this is the 0528 Qwen3 distill (5.2GB)
ollama pull deepseek-r1:8b

# 12GB at 4K context / 16GB at 16K - Better reasoning (9.0GB)
ollama pull deepseek-r1:14b

# 24GB VRAM - Best local experience (20GB)
ollama pull deepseek-r1:32b

# 48GB+ VRAM - Near-full capability (43GB)
ollama pull deepseek-r1:70b

# 404GB download - Full R1-0528 (enterprise hardware)
ollama pull deepseek-r1:671b

Step 3: Run the Model

ollama run deepseek-r1:32b

Test with a reasoning problem:

A farmer has 17 sheep. All but 9 run away. How many sheep does the farmer have left?

Watch R1 reason through the problem—it will show its thinking process (internally) before answering correctly: 9 sheep.

Step 4: Advanced Configuration

Create a custom Modelfile for optimized settings:

cat > Modelfile << 'EOF'
FROM deepseek-r1:32b

# Optimal settings for reasoning
PARAMETER temperature 0.6
PARAMETER top_p 0.95
PARAMETER num_ctx 8192

# System prompt for reasoning tasks
SYSTEM """You are DeepSeek R1, an advanced reasoning assistant.
For complex problems:
1. Break down the problem systematically
2. Show your reasoning process clearly
3. Verify your answer before finalizing
4. If you notice an error, correct it explicitly
Think carefully and explain your logic step by step."""
EOF

# Create optimized model
ollama create deepseek-r1-reasoning -f Modelfile

# Run optimized version
ollama run deepseek-r1-reasoning

Step 5: Make Sure You Have the R1-0528 Builds

The library's deepseek-r1:8b and deepseek-r1:671b tags already point at the May 2025 R1-0528 builds (the library page says to run ollama pull deepseek-r1 if you downloaded before the upgrade). The explicit tags, and the Hugging Face route if you want a quant Ollama does not publish:

# The 0528 builds in the Ollama library (explicit tags)
ollama pull deepseek-r1:8b-0528-qwen3-q4_K_M     # 5.2GB; q8_0 is 8.9GB, fp16 16GB
ollama pull deepseek-r1:671b-0528-q4_K_M         # 404GB; q8_0 713GB, fp16 1.3TB

# Unsloth's dynamic quants of the full model, straight from Hugging Face
ollama pull hf.co/unsloth/DeepSeek-R1-0528-GGUF:UD-TQ1_0   # 162GB

---

VRAM Requirements: Complete Guide

Distilled Models by Quantization

Download sizes are the three quantizations Ollama publishes for every distill, read from the tags page. Ollama does not publish Q5_K_M or Q6_K for these models; the 14B section above has the Hugging Face sizes for those. "Minimum GPU" assumes the Q4_K_M file plus a short context.

Full 671B Model Quantization Options

Sizes for the Ollama tags are from the tags page; the dynamic quants are from Unsloth's R1-0528 GGUF card. "80GB GPUs to hold it" is the file size ÷ 80GB rounded up, before any KV cache. The last column is a bandwidth ceiling for a Mac Studio that holds the whole file in unified memory — Apple's figure for the chip ÷ file size — not a measurement; the M3 Ultra figure uses 800GB/s because Apple states "over 800GB/s".

The original January R1 dynamic quants (UD-IQ1_S 131GB, UD-IQ1_M 158GB, UD-IQ2_XXS 183GB, UD-Q2_K_XL 212GB on Unsloth's R1 card) are smaller than their 0528 counterparts; both repos list the Q4_K_M at 404–405GB. On a PC, none of these fits in VRAM: the file lives in system RAM with a few layers offloaded, and generation runs at system-RAM bandwidth, which is why the Mac Studio is the practical single-box route.

Consumer Hardware Configurations

Ceilings, not measurements: the card's memory bandwidth from NVIDIA's published figures (50-series compare table; the Ada whitepaper for the RTX 4090 and the GA102 whitepaper for the RTX 3090) divided by the Ollama download. Real decode speed lands below the ceiling — our measured 7B–8B runs on an M3 Pro reach 80–90% of theirs.

Apple Silicon Performance

Same arithmetic, with Apple's published memory bandwidth for each chip (newsroom and tech-spec pages linked in the sources) divided by the Ollama download. Ceilings only.

What we measured ourselves: R1 8B on an Apple M3 Pro

The tables above are configurations, not runs. This one is a run. deepseek-r1:8b (the Qwen3-based 8B distill, Q4_K_M, 5.23 GB) on our own 18GB M3 Pro, with the 7B/8B models people compare it against measured in the same session:

Measured on an Apple M3 Pro, 18 GB unified memory, Ollama 0.40.13, macOS 27.0.1 (Darwin 27.0.0, arm64), Metal, 2 November 2026. Median generation rate of 6 runs after a discarded warm-up, computed from Ollama's raw eval_count and eval_duration over its HTTP API (not scraped from the terminal); any run that produced fewer than 30 tokens is thrown out rather than averaged. The same prompt, 7 runs, for every model. Ceiling = 150 GB/s (Apple's figure for the M3 Pro) ÷ the file size Ollama downloaded. One machine is a data point, not a survey; download the script (MIT) if you want the same table for yours, and see how each row is measured.

Also measured: deepseek-r1:8b 46.2 tok/s on the NVIDIA L4 (24 GB), rented cloud VM, Ollama 0.40.13, 2026-11-03; deepseek-r1:14b 26.8 tok/s on the NVIDIA L4 (24 GB), rented cloud VM, Ollama 0.40.13, 2026-11-03; deepseek-r1:32b 12.3 tok/s on the NVIDIA L4 (24 GB), rented cloud VM, Ollama 0.40.13, 2026-11-03. Every row is in the open benchmark dataset.

R1 8B is the slowest row per token because it is the largest file, and it also writes the longest answers: its reasoning trace is counted in the tokens-per-second figure, so a reply takes two to four times longer in wall-clock time than llama3.1:8b at a nearly identical per-token rate. Budget for that when you pick a context length.

---

Integration Options

Open WebUI (ChatGPT-like Interface)

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main

Access at http://localhost:3000 and select deepseek-r1:32b from the model dropdown.

VS Code Integration (Continue Extension)

1. Install the Continue extension
2. Open Continue settings (Ctrl+Shift+P > "Continue: Open Config")
3. Add configuration:

{
  "models": [
    {
      "title": "DeepSeek R1 32B",
      "provider": "ollama",
      "model": "deepseek-r1:32b",
      "contextLength": 8192
    }
  ]
}

Python API Integration

import ollama

# Basic chat
response = ollama.chat(
    model='deepseek-r1:32b',
    messages=[{
        'role': 'user',
        'content': 'Solve step by step: What is the derivative of x^3 * sin(x)?'
    }]
)
print(response['message']['content'])

# Streaming for long reasoning
for chunk in ollama.chat(
    model='deepseek-r1:32b',
    messages=[{'role': 'user', 'content': 'Your complex question here'}],
    stream=True
):
    print(chunk['message']['content'], end='', flush=True)

OpenAI-Compatible API

Ollama exposes an OpenAI-compatible endpoint:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # any string works
)

response = client.chat.completions.create(
    model="deepseek-r1:32b",
    messages=[{"role": "user", "content": "Explain quantum entanglement"}],
    temperature=0.6
)
print(response.choices[0].message.content)

llama.cpp Direct (Advanced)

For maximum control with the full 671B model:

./llama.cpp/llama-cli \
  --model DeepSeek-R1-GGUF/DeepSeek-R1-UD-IQ1_S/DeepSeek-R1-UD-IQ1_S-00001-of-00003.gguf \
  --cache-type-k q4_0 \
  --threads 16 \
  --temp 0.6 \
  --ctx-size 8192 \
  --n-gpu-layers 7 \
  -no-cnv \
  --prompt "<|User|>Your prompt here<|Assistant|>"

---

Real-World Use Cases

1. Mathematical Problem Solving

R1 excels at competition math. Feed it IMO problems, calculus derivations, or statistical analysis. Use prompts like: "Please reason step by step, and put your final answer within \boxed{}"

2. Code Architecture and Debugging

Ask R1 to design system architectures or debug complex logic. Its reasoning shows the "why" behind decisions—invaluable for learning and code review.

3. Legal and Contract Analysis

R1 can parse complex documents, identify issues, and explain implications step-by-step. The visible reasoning creates an audit trail.

4. Scientific Research Assistance

Use for hypothesis evaluation, experimental design, and paper analysis. R1's 71.5% on GPQA Diamond (PhD-level science) demonstrates deep technical understanding.

5. Educational Tutoring

R1's visible reasoning makes it ideal for teaching. Students see the problem-solving process, not just answers. Perfect for math, physics, and programming education.

6. Complex Decision Analysis

Multi-criteria decisions benefit from R1's systematic reasoning. It naturally explores trade-offs and edge cases.

---

DeepSeek R1 vs Other Models

Reasoning Model Comparison

Local Model Comparison

Downloads are the default Ollama tags; the last column is the RTX 4090 bandwidth ceiling (1,008GB/s ÷ download), which only applies when the file actually fits the card's 24GB.

Verdict: For reasoning-heavy tasks, R1 32B is unmatched in the "runs on single 4090" category. Our wider ranking, with and without reasoning, is the best Ollama models guide; if you want R1 with its refusals removed, huihui_ai publishes abliterated builds of every distill — see the uncensored Ollama models page.

---

Troubleshooting Common Issues

Model Loads Slowly

# Pre-load into memory and keep warm
ollama run deepseek-r1:32b "warmup" --keepalive 1h

Out of Memory Errors

# The default 32b tag is already Q4_K_M (20GB); there is no smaller
# official 32B quant, so step down a size instead
ollama pull deepseek-r1:14b   # 9.0GB

# Reduce the context window (set before starting the server)
OLLAMA_CONTEXT_LENGTH=4096 ollama serve

Slow Generation Speed

# Verify GPU is being used
ollama ps

# Force GPU layers
OLLAMA_NUM_GPU=999 ollama run deepseek-r1:32b

# Check CUDA installation
nvidia-smi

Thinking Tokens Not Visible

Some interfaces hide <think> tags. Check settings for:

• "Show reasoning" or "Show thinking"
• "Raw output mode"
• Or use the CLI directly to see full output

Model Gives Truncated Responses

# Increase max tokens
ollama run deepseek-r1:32b --num-predict 4096

Function Calling and Structured Output (Pre-R1-0528)

R1-0528 added function calling and system-prompt support (per DeepSeek's model card). On Ollama the 8B and 671B tags are already the 0528 builds; if you pulled before the upgrade, refresh them:

ollama pull deepseek-r1:8b
ollama pull deepseek-r1:671b

---

Key Takeaways

1. DeepSeek R1 is the best open-source reasoning model, matching OpenAI o1 on complex math and coding benchmarks
2. The 32B distilled version is ideal for single-GPU setups (RTX 4090 or 64GB Mac)
3. Visible <think> tokens make R1 uniquely transparent—you can watch it reason
4. MIT license means completely free commercial use with no API costs
5. R1-0528 update added function calling and system prompts, cut hallucinations and lifted AIME 2025 from 70% to 87.5%; Ollama's 8B and 671B tags are already the 0528 builds
6. Full 671B needs a 512GB Mac Studio or a multi-GPU server — even the smallest dynamic quant of R1-0528 is 162GB, and nothing below that fits consumer VRAM
7. V4 shipped April 2026 (V4-Pro 1.6T / V4-Flash 284B, MIT, 1M context) with enhanced coding and agent capabilities

---

Next Steps

1. Set up RAG for document analysis with DeepSeek R1
2. Build AI agents using R1's reasoning capabilities
3. Compare with Llama 4 for your specific use case
4. Understand MoE architecture behind DeepSeek's efficiency
5. Check VRAM requirements for different model configurations, or the Ollama RAM/VRAM table for every common tag
6. Connect R1 to MCP servers through Ollama to give it files, GitHub and databases
7. See what else fits your card — the 16GB picks, and the 12GB picks if you are running the 14B at a short context

---

DeepSeek R1 represents a paradigm shift in open-source AI. For the first time, anyone can run a model that rivals the best closed-source systems for complex reasoning—completely free, completely private, completely yours. The visible reasoning process makes it uniquely suited for education, debugging, and trust-critical applications. Whether you're running the 8B distilled on an 8GB GPU or the full 671B on enterprise hardware, R1 delivers reasoning capabilities that were impossible to access locally just a year ago.