AI Workflows

How to Run DeepSeek R1 with Ollama (June 2026)

How to Run DeepSeek R1 with Ollama (June 2026)
Last update:
June 19, 2026
11 mins read

Running the DeepSeek R1 reasoning model locally sounds simple until you check the hardware requirements. The full 671B model demands hundreds of GB of VRAM, far beyond any consumer GPU.

This guide covers everything, from what R1 is to how to run it with Ollama. You'll also learn to use a cloud GPU for less than the API costs, with no complex setup.

What Is DeepSeek R1?

DeepSeek R1 is an open-weight reasoning model from DeepSeek, a Chinese AI lab founded in 2023.

It was the first open-weight model to rival OpenAI o1 on math, coding, and science benchmarks. It ships under a permissive MIT license that allows commercial use and self-hosting.

What sets R1 apart from standard chat models is its chain-of-thought reasoning. Before answering, the model generates visible "thinking" steps wrapped in <think> tags. This lets it work through problems, catch errors, and course-correct before responding. The result is especially useful when reasoning quality matters more than speed.

DeepSeek R1 Model Details: Parameters, Context Window, and Release Date

DeepSeek R1 was released on January 20, 2025. The full model has 671B parameters on a Mixture of Experts (MoE) architecture. Only about 37B parameters are active during any single forward pass. This keeps inference compute manageable while tapping a massive pool of knowledge.

The model supports a 128K token context window, on par with GPT-4o. That makes it strong for long documents and extended multi-turn conversations. It has six distilled variants: 1.5B, 7B, 8B, 14B, 32B, and 70B.

Release Date January 20, 2025
Total Parameters 671B (MoE)
Active Parameters per Token ~37B
Context Window 128K tokens
Architecture Mixture of Experts (MoE) + Multi-head Latent Attention
License MIT (open weights, commercial use allowed)
Distilled Variants 1.5B, 7B, 8B, 14B, 32B, 70B

DeepSeek R1 Benchmarks: How Good Is It Really?

On release, DeepSeek R1 matched or exceeded OpenAI o1 across core reasoning benchmarks.

The May 2025 update, DeepSeek R1-0528, pushed these numbers further. This placed it second only to OpenAI's o3 on those benchmarks. The update also cut hallucinations by 45–50% and added JSON output and function calling.

Benchmark DeepSeek R1 DeepSeek R1-0528 OpenAI o1
AIME 2024 79.8% 91.4% 79.2%
AIME 2025 70.0% 87.5% N/A
MATH-500 97.3% 97.3% 96.4%
Codeforces Rating ~1530 ~1930 N/A

DeepSeek R1 vs V3: What's the Difference?

DeepSeek V3 and R1 share the same 671B MoE base architecture, but serve different purposes. V3 is a general-purpose chat model that answers directly, like GPT-4o. R1 is a reasoning model that uses reinforcement learning to think before answering, like OpenAI o1.

Think of V3 as a fast assistant for writing, translation, and general Q&A. R1 is built for multi-step math, code debugging, and logical analysis. It shines on any task where showing your work matters as much as the answer. The visible <think> chain isn't just decorative; it lets you audit the model's logic in research and debugging.

How DeepSeek R1 Was Trained for $6 Million

The widely cited "$6 million" figure actually referred to training DeepSeek V3, the base model R1 builds on. A peer-reviewed paper confirmed R1's own reasoning training cost about $294,000. That run used 512 NVIDIA H800 GPUs over a focused compute period.

For perspective, training GPT-4 was estimated at $50-$100M. The savings come from reinforcement learning without labeled data. This pipeline let the model build reasoning skills through self-play, not costly human annotation.

Critics note DeepSeek's total company investment is far larger, but the efficiency claim held up under peer review.

DeepSeek R1 vs ChatGPT: Is It Worth Switching?

For reasoning-heavy tasks, math, and code, DeepSeek R1 rivals or beats ChatGPT. But ChatGPT still leads in several areas:

  • Multimodal capabilities and voice mode
  • Integrated image generation
  • A polished, mature consumer ecosystem

For regulated teams, OpenAI also offers stronger data residency and compliance. On the other hand, DeepSeek's hosted API routes data through infrastructure in China.

The right answer depends on your use case. R1 wins for structured reasoning, cost-sensitive API workloads, and self-hosting with full data control. ChatGPT remains the stronger default for creative, multimodal, and conversational work.

Factor DeepSeek R1 ChatGPT (GPT-4o / o1)
Math & Reasoning 97.3% on MATH-500 ~83% on advanced math
Coding 96.3rd Codeforces percentile Competitive, varies by model
Multimodal (vision, audio) Text only Full multimodal support
API Cost (output tokens) $2.19 / 1M tokens $60 / 1M tokens (o1)
Open Weights / Self-hostable Yes (MIT license) No (proprietary)
Data Privacy (self-hosted) Full control Vendor-dependent
Consumer Experience Functional Polished, mature ecosystem

Running DeepSeek R1 with Ollama

Ollama is an open-source framework that bundles model weights, configs, and inference settings into one downloadable unit. This reduces local model deployment to a single command.

It handles GGUF loading, GPU detection, and context management. For DeepSeek R1, Ollama is the fastest path to a working local setup.

How Much VRAM Do You Need to Run DeepSeek R1?

VRAM needs depend on which variant you run and your quantization level.

Quantization compresses model weights into lower-precision formats, cutting memory use while lowering quality. Q4_K_M is the most recommended starting point. It roughly halves the memory footprint of FP16 with minor trade-offs.

Model Variant VRAM at Q4 Recommended GPU
R1 1.5B (Distill) 2.3 GB Any GPU with 4 GB+ VRAM
R1 7B (Distill) 4–5.5 GB NVIDIA RTX 4060 8 GB
R1 14B (Distill) 8–9 GB NVIDIA RTX 4070 12 GB
R1 32B (Distill) 18–20 GB NVIDIA RTX 4090 24 GB
R1 70B (Distill) 36–40 GB NVIDIA RTX A6000
R1 671B (Full MoE) 376 GB Multi-GPU cluster or cloud GPU (NVIDIA A100/H100)

The full 671B model is not a realistic target for consumer hardware. Running it at Q4 needs about 376 GB of VRAM. That means at least 8x NVIDIA A100 80GB GPUs.

For full reasoning depth without distillation trade-offs, a cloud GPU is the practical path.

Step-by-Step: Pull and Run the DeepSeek R1 Model in Ollama

Step 1: Install the Thunder Compute CLI

Download and install tnr for Windows, or macOS.

Run this command for Linux:

curl -fsSL https://raw.githubusercontent.com/Thunder-Compute/thunder-cli/main/scripts/install.sh | bash

Step 2: Login

tnr login

Step 3: Launch and connect to an Ollama instance

tnr create --template ollama

Note: The full 671B model needs an 8-GPU configuration.

Step 4: Connect to your instance

Establish a connection once the instance is created.

tnr connect 0

Start the Ollama UI. This will take around a minute. Once it's done loading, click the link provided by the terminal to open Ollama in a browser.

You'll be prompted to create an account.

start-ollama

Step 5: Load the desired model

  1. In the Ollama UI, click "Select a model".
  2. Add the URL of the model from the Ollama page
  3. Click "Pull [MODEL_URL]" in the dropdown.

Ollama Interface showing model selection dropdownYour download will start.

A few good variants ordered from lightest to heaviest include:

To go deeper into local LLM tooling options, see our guides on running LM Studio and Unsloth.

Why Most Local Machines Can't Handle Full DeepSeek R1

The distilled R1 variants (7B through 70B) are excellent models. But they were built by fine-tuning smaller architectures on R1's reasoning traces, not by running the full model.

There is a noticeable quality gap with the full 671B MoE. This shows most on the hardest reasoning tasks, where the broader parameter pool matters.

A high-end RTX 4090 carries 24 GB of VRAM, covering the 32B distill at Q4. But that falls far short of the full model's 376 GB requirement.

Thunder Compute Pricing vs DeepSeek R1 API Pricing

The DeepSeek R1 API costs $0.55/1M input tokens and $2.19/1M output tokens. That is far cheaper than OpenAI o1. But your data passes through DeepSeek's servers in China, a hard "no" for many regulated workloads.

Running R1 on Thunder Compute via Ollama removes per-token costs entirely. You pay for GPU time only while the instance runs, and stop the moment you pause it. Thunder Compute's A100 80 GB costs $0.78/hr, versus $5.07/hr on Google Cloud and $2.79/hr on Lambda.

Option Cost Model Data Privacy Model Quality
DeepSeek R1 API $0.55 input / $2.19 output per 1M tokens Data through DeepSeek servers (CN) Full 671B
Local Ollama (32B distill, RTX 4090) Hardware cost amortized (~$1,500–2,000 GPU) Fully local 32B distill (reduced vs full)
Thunder Compute + Ollama (A100) $0.78/hr, no per-token cost Fully self-hosted 70B distill
Google Cloud A100 $5.07/hr Fully self-hosted Full 671B or 70B distill

Do you run R1 more than a few hours a week, or handle data that can't leave your infrastructure? Then self-hosting on Thunder Compute is usually cheaper and more private than the DeepSeek API.

Ready to get started? Follow the Thunder Compute DeepSeek R1 guide to spin up an instance and run the full model with Ollama in minutes.

When does self-hosting on Thunder Compute make sense?

For most users, the API is the better default because managed providers are cheaper per token, faster, and require no infrastructure work.

Thunder Compute only makes sense for a few scenarios:

  • Data sovereignty: If your workload involves regulated data (healthcare, legal, finance) that cannot leave your infrastructure, a self-hosted deployment keeps inference in a controlled environment.
  • Very high sustained throughput: If you're running a production service generating tens of millions of tokens daily with consistently high GPU utilization, the fixed hourly rate can undercut per-token pricing.
  • Fine-tuning and custom weights: If you need to modify the model itself to fine-tune on proprietary data, merge adapters, or run a custom checkpoint.

FAQ

What Is DeepSeek R1?

DeepSeek R1 is an open-weight, 671B-parameter reasoning model from a Chinese AI lab that uses chain-of-thought to solve complex logic tasks. Released in January 2025 under an MIT license, it was the first open-weight model to match OpenAI's o1.

How Much VRAM Do You Need to Run DeepSeek R1?

You need between 4 GB to 376 GB of VRAM depending on the model variant and quantization size. The 7B distill requires ~4–5.5 GB (RTX 4060), 32B requires ~18–20 GB (RTX 4090), while the full 671B model demands ~376 GB across a multi-GPU setup.

How Do I Use DeepSeek R1?

You can use DeepSeek R1 via free web chat, the pay-per-token API, or locally using Ollama or LM Studio. For local deployment, run ollama run deepseek-r1:7b. Cloud providers like Thunder Compute offer fast blueprints to run the full 671B model without expensive personal hardware.

Can DeepSeek Generate Images?

No, DeepSeek R1 cannot generate images because it is a strictly text-only language model. It features no multimodal input or output support. As of June 2026, no multimodal variant exists, so users must rely on external tools like ComfyUI or DALL-E for image generation.

How Do I Fine-Tune DeepSeek R1?

Fine-tune DeepSeek R1 by using its distilled variants (7B, 14B, 32B) combined with memory-efficient pipelines like Unsloth. These variants support standard setups on a single cloud GPU, such as an A100. Fine-tuning the full 671B model is impractical without a massive, multi-GPU cluster.

We make GPUs cheaper

Low prices, developer-first features, simple UX. Start building today.


                                                           `..`                                          `                                  
                                                                                                                                            
                                                                                                                                            
               ``        `                                                                                                                  
                        .;.                                                                                                                 
                                                                                                                                            
      .                                                                                                                                     
                                                                                                                                            
                                                                                                                                            
                                                                                                                                            
                                                                                                                                            
                                                                                                                                           .
                                                         `....                            ``                                                
                                                                                                                                            
                                            .`                                                                                              
                                             `  `.                                                                                          
                                             `                                                                                              
                                   `.                                                                                                       
                                     `                                                                                                      
                                                                               ;`                     .                                     
                                                                                                                                            
                                                 ````                                  .```                                                 
                                                                                                                                            
                                                                                                                                            
                                                                       .                                                                    
                                                 `+`                  `.                                                                    
                                                    .`                                  ;`                                                  
                                         ``       `;                               `;;`.;;`    `                                            
                                         .`                                                                                                 
                                                                                               ` `                                          
                                    `     `                     `   ;       ;`                 `;`                                          
                                    .  .    `` `                                   ```                                                      
                                                                                                                                            
                                                                +*******.    ``     `+++++`         `.`                                     
                                                 `.......       +```````     `.                                                             
                                `                               *             ;                                                             
                                `                              `+            `*                                                             
                                  `              ````...`                     *                         `;                                  
                                                                              *                                                             
                                                                              .       ``   .`           .;                                  
                         .;```      `                   `                                    `;                 `.``.;                      
                       ;.           ;                                               .``.`      `        `             ...                   
                    `;;          `.`                       .   `    .        .           ;`         `.`                 `;.                 
                  .+`        `*```                         *   ;;  `*`  +;   *             +`                    .+        ;+               
                ;.         ;;`          ;``....+          .;   +;   *`  +;   *               ;...  `;`             `;;       `;`            
                        `;;`          `.                       *;   *`  +;   ;.                                      `;.`                   
                      `+;                                      *.   *`  +;                 `..+.                        ;+`                 
                    ;+.        .+`           `` `              `        ++            .```         .  `+;                 `+.               
                             ;+.                ......;.                                    ;.`         `+;                                 
                          `.+.               `.;;                                                         `;;`                              
                         ++`                                          `*                                     +*`                            
                      `++                                             .*`            +`                        ;+.                          
                     .;`                                .;            .*              .                         `;;                         
                                                        .             .*              .                                                     
                                                        .             .*              .                                                     
                                       ````````     `.  .`            `+              ;+`    ``````.                                        
                                     `+*.   ```     ;.   ;          ;  ;+             +*;    ````` ;*;                                      
                                   `**;             `   ;+         **   +;            +*;            +*+                                    
                                 `+*;                   `          ;*   +.             `              `+*;                                  
                               `;*;                                     `                               `+*;                                
                              ++;                  ``                                                     `+*;                              
                           `++;                    ..               `              +*                       `++;        `                   
                   `       `.                      ;`               ;              +*                         `.                            
                      `                            ;`               +              ;*                                                       
                     .+                            ;`               +              ;*`                                                      
                                                   .;;             `+`             .**`                                                     
                                                    `+*.           `*+`             .**;`                                                   
                                                      +*+           ;**+              ;**;                                                  
                            ``                         .**;           +*+.              +**.                                                
                                                        `+*+`          .+*;              `+*+.                                              
                               .;  ``.`                   ;**;           ;**;              ;**;`                                            
                             `.;;   `..`                   `**+           `***.              +**;                                           
                              `       `..                    **             ;**+              `+*+                                          
         ``                             ..`                  ++              `**+               **                                          
         ;;                              ...                 ..  ..            *+               ;+                 `                        
        `;.                               ...                ++` ;++           ++                    ..          ```                        
        ;;`                                `..`             `**`  +*`           .  .+;           ..  ;++        ```                         
       `.;                                  `.;.```````     .*+   +*`          ;+. .**.         `+;   +*.      ```