How to Run DeepSeek R1 Locally with Ollama (2026 Guide)

What DeepSeek R1 Is and How It Differs from Standard LLMs

DeepSeek R1 is a reasoning model, not a standard autoregressive language model. The difference is the inference process: R1 generates a step-by-step thinking chain (wrapped in `` tags) before producing its final answer. This reasoning process is visible in Ollama's output and is the source of R1's performance improvement on complex tasks.

DeepSeek trained R1 using reinforcement learning from its own generated reasoning traces, without relying on supervised fine-tuning on human-labelled reasoning data. The full R1 model has 671 billion parameters with a Mixture-of-Experts (MoE) architecture, but DeepSeek also released distilled versions based on Llama 3 and Qwen 2.5 backbones. These are the versions most practical to run locally.

DeepSeek R1 variants available on Ollama (as of March 2026):

The distilled models (1.5B through 70B) are trained to replicate R1's reasoning behaviour in smaller dense architectures. They retain most of R1's reasoning improvement over standard Llama and Qwen models while running on consumer hardware.

Install Ollama

Ollama is the runtime that manages DeepSeek R1 model files and handles inference. Install it on your local machine or VPS.

Linux and macOS

# One-command installer
curl -fsSL https://ollama.com/install.sh | sh

Verify installation:

ollama --version
# Expected: ollama version 0.6.x

On Linux, the installer creates a systemd service. Check it is active:

systemctl status ollama
# Expected: active (running)

Windows (WSL2)

Install Ubuntu via WSL2, then run the Linux installer inside the WSL2 terminal. Ollama on Windows also has a native installer available at ollama.com/download — download the `.exe` file, run it, and verify in PowerShell:

ollama --version

Docker (for VPS deployments)

# Pull and run Ollama in a container with model persistence
docker run -d \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

Choose Your Model Size and Pull It

Choose the largest model your RAM supports. Larger models produce significantly better reasoning output on complex tasks.

Quick decision guide:

• 8 GB RAM: use `deepseek-r1:7b` or `deepseek-r1:8b`
• 16 GB RAM: use `deepseek-r1:14b`
• 32 GB RAM: use `deepseek-r1:32b`
• 48 GB RAM: use `deepseek-r1:70b`

Check your available RAM before pulling:

# Linux
free -h

# macOS
vm_stat | grep "Pages free"

# Example output (Linux, 32 GB machine):
# total        used        free
# Mem:          31Gi        4.2Gi       27Gi

Pull the model (example: 14B variant):

ollama pull deepseek-r1:14b

# Expected output:
# pulling manifest
# pulling 6e9f90f02bb3...  100% ████████ 9.0 GB / 9.0 GB
# pulling 11ce4ee3e170...  100% ████████ 1.8 KB / 1.8 KB
# success

Download times vary by connection speed. The 14B model (9 GB) takes approximately 8 minutes on a 150 Mbps connection.

After the pull completes, confirm the model is available:

ollama list

# Expected output:
# NAME                    ID              SIZE    MODIFIED
# deepseek-r1:14b         ea35dfe18182    9.0 GB  2 minutes ago

Run Your First Inference

Interactive CLI Session

Start an interactive session directly in the terminal:

ollama run deepseek-r1:14b

After the model loads (10-20 seconds on first run), type a prompt:

>>> Solve this step by step: A train travels 120 km at 60 km/h, then 80 km at 40 km/h. What is the average speed for the entire journey?

DeepSeek R1 generates a visible reasoning block before the final answer:

<think>
To find average speed, I need total distance divided by total time.

Total distance = 120 km + 80 km = 200 km

Time for first leg = 120 km / 60 km/h = 2 hours
Time for second leg = 80 km / 40 km/h = 2 hours
Total time = 4 hours

Average speed = 200 km / 4 hours = 50 km/h
</think>

The average speed for the entire journey is 50 km/h.

Here is the calculation:
- Leg 1: 120 km at 60 km/h = 2 hours
- Leg 2: 80 km at 40 km/h = 2 hours
- Total: 200 km in 4 hours = 50 km/h

The `` block shows R1's internal reasoning. The content after the closing `` tag is the final answer.

Exit the interactive session:

>>> /bye

Single-Shot Inference (Non-Interactive)

ollama run deepseek-r1:14b "What is the time complexity of merge sort and why?"

Check Inference Speed

After running a prompt, Ollama prints performance stats:

eval count:    312 token(s)
eval duration: 22.4s
eval rate:     13.9 tokens/s

On CPU-only inference with the 14B model: expect 8-15 tokens/second on a 4-core VPS. With an NVIDIA GPU: 40-120 tokens/second depending on VRAM.

Use the Ollama REST API

Ollama exposes a REST API at `http://localhost:11434` and an OpenAI-compatible endpoint at `http://localhost:11434/v1`. Both work for DeepSeek R1.

Native Ollama API

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:14b",
    "prompt": "Explain how quicksort works in three sentences.",
    "stream": false
  }'

The response JSON includes the reasoning trace in the `response` field, along with token counts and timing:

{
  "model": "deepseek-r1:14b",
  "response": "<think>
Quicksort works by...
</think>

Quicksort is a divide-and-conquer algorithm...",
  "done": true,
  "eval_count": 198,
  "eval_duration": 14200000000
}

OpenAI-Compatible API

Applications built for the OpenAI API work with Ollama's compatible endpoint:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ollama" \
  -d '{
    "model": "deepseek-r1:14b",
    "messages": [
      {"role": "user", "content": "Write a Python function to find all prime numbers up to n using the Sieve of Eratosthenes."}
    ]
  }'

Stripping the Think Block from API Responses

If your application only needs the final answer (not the reasoning trace), filter the response with a simple Python snippet:

import re

def strip_think(response: str) -> str:
    """Remove DeepSeek R1 <think>...</think> block from response."""
    return re.sub(r'<think>.*?</think>', '', response, flags=re.DOTALL).strip()

# Example usage
raw = "<think>\nLet me work through this...\n</think>\n\nThe answer is 42."
clean = strip_think(raw)
print(clean)
# Output: The answer is 42.

Connect Open-WebUI for a Chat Interface

Open-WebUI gives DeepSeek R1 a ChatGPT-style browser interface, including support for rendering the `` reasoning blocks in a collapsible format.

Quick Start with Docker

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

Open `http://localhost:3000` in your browser. Select `deepseek-r1:14b` from the model dropdown. Open-WebUI renders the `` content in a collapsible "Thinking..." accordion, keeping the interface clean while preserving access to the full reasoning trace.

For a detailed Open-WebUI setup guide, see How to Set Up Open-WebUI with Ollama.

Enable GPU Acceleration

GPU inference reduces response time from 10-15 tokens/second (CPU) to 40-120 tokens/second (GPU), depending on the model size and GPU VRAM.

NVIDIA GPU (CUDA)

Ollama detects NVIDIA GPUs automatically on Linux when the NVIDIA CUDA Toolkit is installed. Verify GPU detection:

ollama run deepseek-r1:14b "Hello"

# Check GPU usage in a second terminal:
nvidia-smi

# Expected: Python or ollama process using GPU memory

If Ollama is not using the GPU, install the CUDA toolkit:

# Ubuntu 22.04
sudo apt install nvidia-cuda-toolkit

Partial GPU Offloading (Mixed CPU + GPU)

If the model does not fully fit in VRAM, Ollama offloads as many layers as possible to the GPU and runs the rest on CPU. This is automatic. For the 14B model (9 GB) on a GPU with 8 GB VRAM, Ollama offloads approximately 28 of 40 layers to the GPU, resulting in 25-35 tokens/second instead of the full-GPU 60+ tokens/second.

Check how many layers are GPU-offloaded by reviewing the Ollama server log:

journalctl -u ollama -f | grep "offload"

# Example output:
# llama_new_context_with_model: n_ctx      = 16384
# llm_load_tensors: offloading 28 repeating layers to GPU
# llm_load_tensors: offloaded 28/41 layers to GPU

Apple Silicon (Metal)

On Apple Silicon Macs, Ollama uses the Metal GPU framework automatically. No configuration is required — install Ollama and pull the model as normal. The M2 Pro with 16 GB unified memory runs deepseek-r1:14b at approximately 20-30 tokens/second.

Ollama Configuration for DeepSeek R1

Ollama's behaviour is controlled via environment variables set before starting the service.

Set Variables on Linux (systemd)

sudo systemctl edit ollama

Add to the override file:

[Service]
Environment="OLLAMA_HOST=0.0.0.0:11434"
Environment="OLLAMA_KEEP_ALIVE=10m"
Environment="OLLAMA_FLASH_ATTENTION=1"

Restart the service:

sudo systemctl restart ollama

Troubleshooting

Frequently Asked Questions