How to Install and Run DeepSeek R1 Locally (2026 Guide)

DeepSeek R1 changed the local-AI conversation by delivering frontier-grade reasoning — the step-by-step "thinking" that powers hard problem-solving — in models small enough to run on hardware you already own. You do not need an API key, a subscription, or an internet connection. You need a few commands and the right model size for your GPU. This guide is built to be the one you bookmark: a clean path from an empty terminal to a working DeepSeek R1 chat interface, with the hardware guidance and real interface examples a technical reader actually needs. If you are weighing local models for a business use case, ITECS covers the strategy side through AI consulting — but this article is about getting it running yourself.

A single modern GPU is enough to run DeepSeek R1's reasoning models entirely on your own hardware.

A Quick Note on What "DeepSeek R1" Means Locally

Technical accuracy matters here because it drives your hardware decision. The true DeepSeek R1 is a 671-billion-parameter Mixture-of-Experts (MoE) model that requires roughly 320–400 GB of memory — a multi-GPU server workload, not a desktop one. What almost everyone runs locally are the distilled models: DeepSeek fine-tuned Qwen and Llama base models on R1's reasoning traces, producing 1.5B, 7B, 8B, 14B, 32B, and 70B variants that inherit R1's characteristic chain-of-thought style at a fraction of the size. In Ollama these are all tagged deepseek-r1, and for practical purposes they are "running R1 locally" — just know the distills are their own models, not the full 671B.

Hardware Requirements and Recommendations

The single most important choice is matching model size to your VRAM. The table below uses the standard Q4_K_M quantization — a 4-bit format that roughly halves memory use versus full precision with only minor quality loss, and the right default for nearly everyone. If you have VRAM to spare, Q5_K_M or Q8 tags trade memory for a small quality bump.

Your GPU's VRAM is the deciding factor — it sets the ceiling on which model size runs entirely in memory.

If this is destined for a shared internal service rather than one workstation, the VRAM math points toward dedicated GPU infrastructure — the kind of workload that fits naturally on private cloud hosting rather than a machine under someone's desk.

Step 1: Install Ollama

Ollama is the runtime that does the heavy lifting — it bundles model weights, handles GGUF loading, detects your GPU, and manages the context window. Install it first, per your operating system:

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

# macOS (Homebrew) — or download the .dmg from ollama.com
brew install ollama

# Windows — download and run the installer from ollama.com

Confirm it is working by checking the version. On Linux and Windows the background service starts automatically; on macOS, launch the Ollama app once so the service is running.

ollama --version
# ollama version is 0.x.x

Step 2: Download a DeepSeek R1 Model

Pull the size you chose from the table. If you are unsure, start with 7b to validate your setup end-to-end, then scale up once it works — a small download is a cheap way to confirm your GPU is being used before committing to a 20 GB pull.

# The recommended balanced default
ollama pull deepseek-r1:14b

# Or start small to validate, then scale
ollama pull deepseek-r1:7b

# Confirm what you have downloaded
ollama list

One nuance worth knowing: the distills come from two base families. The 7B, 14B, and 32B tags are distilled from Qwen, while the 8B and 70B tags are distilled from Llama. In practice they behave very similarly for reasoning tasks, so choose by the size that fits your VRAM rather than the base family — but if you already have tooling or fine-tuning tied to one lineage, it is a reason to prefer its matching tag. Ollama pulls the correct quantized GGUF automatically, so you rarely need to specify a quantization tag unless you deliberately want a higher-precision build.

Step 3: Run It in the Terminal

Before adding a web interface, confirm the model itself works. The run command drops you into an interactive prompt:

ollama run deepseek-r1:14b

>>> Give me three tips for writing faster SQL queries.
<think>
The user wants practical SQL performance advice. I should
focus on the highest-impact, generally-applicable wins...
</think>

1. Index the columns you filter and join on...
2. Select only the columns you need, never SELECT *...
3. Filter early with WHERE before aggregating...

Notice the <think> block — that is R1's reasoning trace, visible in the raw output before the final answer. It is the model "showing its work," and it is exactly what makes R1 strong at multi-step problems. Type /bye to exit. If responses stream quickly and your GPU fans spin up, you are running on the GPU and ready for a real interface.

Step 4: Add Open WebUI for a ChatGPT-Style Experience

The terminal proves it works, but a web interface makes it usable day to day — conversation history, model switching, file uploads, and a clean rendering of that reasoning trace. Open WebUI is the standard choice and runs in a single Docker container. It auto-detects Ollama on the same machine.

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

Open your browser to http://localhost:3000, create a local admin account (it stays on your machine), and select deepseek-r1:14b from the model dropdown. You now have a private, offline ChatGPT-style workspace. Here is what a first exchange looks like — note how Open WebUI renders R1's reasoning in a collapsible "Thinking" panel above the answer, keeping the interface clean while preserving the full trace:

Simulated Open WebUI interface: R1's reasoning appears in a collapsible "Thinking" block above the final answer.

Step 5: Read the Interface Like a Pro

The reasoning trace is R1's signature, and Open WebUI surfaces it cleanly. Expanding the "Thinking" block is the fastest way to debug a wrong answer — you can see exactly where the model's logic went sideways, which a plain answer never reveals. Here is a coding example showing the same pattern, where the visible reasoning is arguably more valuable than the code itself:

Simulated Open WebUI interface: the 32B distill on a coding prompt, reasoning trace expanded.

Step 6: Tuning and Troubleshooting

A few adjustments separate a working setup from a great one:

• Context window: Longer contexts consume more VRAM. If you hit out-of-memory errors, lower the context length (num_ctx) or drop to a smaller model — the KV cache grows with context and can silently push you over your VRAM budget.
• Quantization: If quality feels off and you have spare VRAM, pull a higher-precision tag (Q5_K_M, Q8_0). If you are memory-constrained, the standard Q4_K_M is the sweet spot.
• Slow responses: Sub-15 tokens/second usually means the model is running on CPU. Confirm your GPU drivers (CUDA for NVIDIA, ROCm for AMD) are installed and that the model fully fits in VRAM.
• Remote access: To reach Open WebUI from another device, point it at the host with -e OLLAMA_BASE_URL, and put it behind a reverse proxy with authentication — never expose it raw to the internet.

Why Local Is the Point: Privacy and Control

The reason to run DeepSeek R1 yourself rather than call a hosted API comes down to one word: data. When the model runs on your hardware, every prompt, document, and response stays on that machine. Nothing is logged by a third party, nothing trains someone else's model, and the whole system works with the network cable unplugged. For businesses handling regulated or confidential information — legal, healthcare, financial, or proprietary R&D — that is often the difference between "we can use AI here" and "we cannot."

That said, a workstation experiment and a production internal service are different animals. Turning a local model into something a whole team relies on — with proper GPU capacity, access controls, monitoring, and data governance — is exactly the bridge ITECS builds as a Managed Integration Provider, operationalizing local and private AI for organizations that want the privacy of on-prem with the reliability of managed infrastructure.

Sources

• SitePoint — "Running DeepSeek R1 Locally: Your Complete Setup Guide (2026)"
• Local AI Master — "Run DeepSeek R1 Locally with Ollama (2026): Setup + VRAM Guide"
• Thunder Compute — "How to Run DeepSeek R1 with Ollama (August 2026)"
• Open WebUI — Official Quick Start Documentation
• Open WebUI — GitHub Repository