How to Run DeepSeek-R1 Locally

For a personal computer, choose an exact DeepSeek-R1 distilled model rather than assuming the flagship download fits. Start with a small supported download, confirm a short task works, and increase size only when it improves your actual work. R1-style reasoning can be useful for mathematics and code, but it can take longer to reach a final answer and can still produce incorrect reasoning or conclusions.

Use this path if you want to compare a reasoning model on tasks with answers you can check. For quick rewriting or ordinary chat, also compare a supported instruction model; a longer reasoning trace is not automatically a better result.

Know which model you are downloading

The original full DeepSeek-R1 is a mixture-of-experts model with 671B total parameters and 37B active per token. The active count describes computation, not the complete weight-storage requirement. Idealized four-bit storage alone is about 335.5 billion bytes before format overhead and higher-precision tensors. This is a specialist high-memory workload, far beyond an ordinary laptop or 24GB graphics card.

The original distilled releases are smaller dense models:

These are starting points for an exact-file calculation, not minimum-memory guarantees. GPU buffers, conversation memory, desktop use, and app settings can change the result. Two 24GB cards also do not behave like one 48GB card unless the selected runtime supports the intended split.

There is an important version distinction: Ollama's current deepseek-r1:8b package uses DeepSeek-R1-0528-Qwen3-8B, rather than the original Llama-based 8B distill. If you need the original release, select its explicitly named checkpoint and compatible package. Parameter count alone does not establish model identity.

Plan the full memory requirement

Use the memory calculator with the actual compression, file size, context, and hardware. Begin at about 4096 tokens for a setup check. Reasoning output takes part of the output budget and working context; a long response can become impractical even when the weights fit.

For a smaller GPU, start with a smaller distilled download that leaves room for the conversation and buffers. On a Mac, leave room for macOS and other apps in the same unified-memory pool. On CPU-only hardware, a short small-model comparison can work, but a long reasoning response may take too much time to be useful.

Do not allocate all available memory to weights or set the largest advertised context immediately. Check context length and model compression if a download name or setting is unclear.

Set up Ollama

Use the Ollama installation guide for your operating system and start the installed app or intended service. Confirm ollama --version works. Choose one model for the first run:

ollama run deepseek-r1:1.5b

For a supported machine with more memory, investigate deepseek-r1:8b or deepseek-r1:14b after the smaller setup works. ollama run downloads the named package if needed, so the first run requires a connection and disk space.

At the interactive chat prompt, set a modest context:

/set parameter num_ctx 4096

Ask a checkable question such as “Which prime numbers are strictly between 20 and 40? Give the final list.” The expected final list is 23, 29, 31, 37. Check the conclusion yourself; a convincing reasoning trace does not replace that check.

While the model is loaded, run ollama ps in another terminal. It shows CPU/GPU placement and context. A CPU/GPU split can result from memory limits or backend selection; it is not by itself proof of a broken installation. If speed is unacceptable, shorten the response, reduce context, or compare a smaller model that can use the intended accelerator.

Exit with /bye, confirm the model appears in ollama list, and run it again. Reopening a downloaded model and receiving a correct short answer is the useful setup result.

Set up LM Studio

Install the app for a supported machine, then search Discover for the exact distilled checkpoint. Read the model card, publisher, and complete file name. A GGUF conversion and the original checkpoint have different packaging; check both the conversion's details and its source model.

1. Choose a supported four-bit GGUF download as the first comparison. On Apple Silicon, a supported MLX package is another option, but do not treat it as the same file.
2. Complete the download and load one model with modest context.
3. Use GPU offload only within the available memory. Raising it can cause an allocation failure if the GPU has no room left.
4. Ask the same prime-number question and check the final list.
5. Quit and reopen the app, load the same model, and repeat a short task.

The optional CLI can estimate memory before loading: use lms ls to obtain the model key, then lms load "MODEL_KEY" --context-length 4096 --estimate-only. Replace MODEL_KEY with your own listed key. This estimates the load requirement; it does not measure generation speed or answer quality.

Reasoning settings and output

DeepSeek's original R1 usage recommendations suggest temperature 0.5–0.7, with 0.6 as its example, and putting instructions in the user prompt rather than adding a system prompt. Its reported sampling evaluations use top-p 0.95. These are model-specific starting settings; do not treat them as a guarantee or blindly apply them to every later derivative.

An interface can display a reasoning section before the final response. Depending on the model and template, raw output may contain <think> tags. Current Ollama APIs also separate reasoning and answer fields: chat returns message.thinking and message.content, while generate returns thinking and response. A program consuming those APIs should read the documented fields rather than assume all reasoning is embedded inside one tagged text string.

Ollama's available thinking controls depend on the model. Check /api/show or the model's documented behavior before assuming thinking can be disabled. Hiding a reasoning panel changes presentation; it does not necessarily stop generating those tokens or reduce the work.

What to compare and when to stop

Try a small coding function with explicit input/output checks, an arithmetic problem with an independently known answer, or a source passage with conditions that must remain intact. Keep the same question when comparing model sizes or compression options. Record correctness and whether the response arrives at a pace you can use.

A reasoning model can make mistakes, loop, mix languages, or ignore an output format. Its apparent self-correction is still generated text, and it does not establish a mathematical proof or a verified legal conclusion. Current facts and authorities require current sources supplied to the model or checked separately.

If output repeats or never reaches the conclusion, check the intended template, publisher's sampling guidance, and output limit. If the runner crashes, use memory checks or LM Studio loading checks. If it loads but invents answers, use answer-quality checks. Increasing every limit is not a useful repair for a task the model cannot answer.

License and privacy

DeepSeek publishes its R1 code and weights under MIT, while also identifying the base-model ancestry of its distills. The original Qwen distills derive from Apache 2.0 Qwen models; the original Llama 8B and 70B distills derive from models under their respective Llama licenses. Read the exact release's license and base-model terms before redistribution or commercial integration. “DeepSeek-R1” on a download button is not enough to resolve those terms.

Local inference can keep the prompt on your computer, but a connected cloud provider, remote tool, document embedding service, or exposed API changes the workflow. Prepare the intended setup and follow the offline restart check before assuming it can run without a connection.

Sources

• DeepSeek-R1 original releases, usage recommendations, and licensing
• DeepSeek-R1-0528-Qwen3-8B exact model card
• Ollama DeepSeek-R1 packages and 70B Q4_K_M file
• Ollama reasoning fields and controls and context
• LM Studio requirements and load estimates