DeepSeek 101: from the app to running it on your own computer

In the last week of January 2025, a free chatbot from a little-known Chinese company became the most downloaded app in America, and the world’s most valuable chip-maker lost close to $600 billion of stock-market value in a single day. The company was DeepSeek, and it had just released a reasoning model as good as OpenAI’s best — and given it away.

DeepSeek is worth understanding for two reasons. As a tool, it is capable, very cheap and, uniquely among the top labs, it publishes its models so anyone can run them. And as a story, it changed how the whole industry thinks about what building frontier AI costs. This guide covers both: the history, how to use it step by step, the clever engineering behind it, how to run it on your own computer, and the privacy questions you should weigh.

What is DeepSeek?

DeepSeek is a Chinese AI company, based in Hangzhou, and the name of its family of AI models and chat app. You can use it like ChatGPT — ask questions, write, code, analyse — and it is best known for reasoning: it can think a problem through step by step, and it shows you that thinking.

Two things make it different from ChatGPT, Claude or Gemini. First, open weights: DeepSeek publishes its models for anyone to download, run and modify, so you can use DeepSeek without using DeepSeek’s servers at all. Second, price: its engineering is so efficient that its API costs a small fraction of most Western rivals.

From hedge fund to headline

DeepSeek grew out of High-Flyer, a quantitative hedge fund co-founded by engineer Liang Wenfeng that used AI for trading and had bought thousands of Nvidia GPUs before US export controls tightened. In 2023 Liang spun out DeepSeek as a research lab with a stated goal of general AI, funded by the fund rather than outside investors — and with a culture of publishing its methods openly.

The January 2025 shock

Why did one model move markets? Until then, the assumption was that frontier AI required tens of billions of dollars and the most advanced chips — a game only a few American giants could play. DeepSeek, working under export restrictions that limited it to less powerful Nvidia chips, reported that the final training run of V3 used about 2.8 million GPU-hours, roughly $5.6 million at rental prices, and then released R1, which matched OpenAI’s o1 on many maths and coding tests.

The reaction was partly overdone — the headline cost left out a great deal, and the big labs soon released stronger models. But the lesson stuck: clever engineering can substitute for a lot of raw computing power, and open models can stay close behind closed ones.

Four ways to use DeepSeek

Because the models are open, “using DeepSeek” can mean four quite different things — and the difference matters most for where your data goes.

Getting started with the app

1. Open DeepSeek at chat.deepseek.com, or install the app published by DeepSeek on iPhone or Android. Watch out for copycat apps with similar names and logos.
2. Create an account and read the privacy notice — we come back to this in section 13.
3. Choose how it answers. DeepThink turns on reasoning for maths, logic, code and planning; leave it off for quick everyday questions. Search lets it look things up on the web.
4. Read the thinking. DeepSeek shows its reasoning in a collapsible box above the answer. It’s a great way to learn — and to spot where it went wrong.

Prompting a reasoning model

Reasoning models like DeepSeek’s like slightly different handling from ordinary chatbots. DeepSeek’s own R1 research paper found some habits that help:

• Describe the problem, not the method. With DeepThink on, you don’t need “think step by step” — it already does. Spend your words on the goal, the facts and the constraints.
• Ask directly, without long example lists. The R1 paper reported that few-shot examples tended to make it perform worse; a clear zero-shot request worked best.
• Say the output format you want: “final answer in a box”, “a table”, “JSON only”.
• Turn thinking off for simple jobs — rewriting, translating, short summaries. It is faster and the result is often just as good.

Everything else from the six prompt ingredients still applies: give context, say who it’s for, and iterate with follow-ups.

How it’s built so cheaply

DeepSeek’s models are Transformers, like every modern chatbot (our first article explains the basics). What makes them efficient is a stack of engineering ideas, published in DeepSeek’s technical reports. Two matter most.

1. DeepSeekMoE: many small experts

In a mixture-of-experts model, each layer holds many expert sub-networks and a router picks a few for each token, so most of the model sits idle on any given step. DeepSeek’s version splits experts into many small, fine-grained ones for sharper specialisation, and adds shared experts that every token uses, so common knowledge isn’t duplicated across experts.

2. Multi-head latent attention (MLA)

As a model reads a long conversation, it keeps a memory of every earlier token — the KV cache — and on long contexts that cache, not the model, fills up GPU memory. MLA squeezes each token’s keys and values into one small compressed vector and expands them only when needed.

How R1 learned to reason

R1’s most influential idea was an experiment. DeepSeek took its base model and trained it with reinforcement learning only: no human-written examples of good reasoning at all. The model answered maths and coding problems and was rewarded simply when the final answer was correct and in the right format. The result, R1-Zero, taught itself to reason at length — spending more tokens on harder problems, checking its work, even pausing to say, in effect, “wait, let me re-examine that”, which the paper called an “aha moment”.

R1-Zero’s reasoning was powerful but messy: it mixed languages and was hard to read. The released R1 used a four-stage recipe to keep the reasoning and fix the readability:

Distillation then transferred R1’s skill to much smaller models: DeepSeek generated hundreds of thousands of R1 reasoning examples and fine-tuned small open models from the Qwen and Llama families on them. That is why you can run a “DeepSeek-R1” with 8 billion parameters on a laptop — it’s a smaller model that learned from the big one.

GRPO, the maths

The reinforcement-learning algorithm behind R1 is GRPO — Group Relative Policy Optimization, introduced in DeepSeek’s earlier DeepSeekMath paper. Classic methods such as PPO train a second “critic” network, as big as the model itself, to estimate how good each answer is. GRPO drops the critic. For each question it samples a group of answers, scores them all, and judges each answer against the group:

Answers with a positive advantage are made more likely, those with a negative advantage less likely, with a clipping term and a penalty for drifting too far from a reference model to keep training stable. Try it:

Open weights, explained

A model’s weights are the billions of numbers learned in training — the model itself. DeepSeek publishes its weights on Hugging Face, including the V4 family. R1 was released under the permissive MIT licence, meaning anyone could use, modify and sell products built on it.

Open weights mean other companies can host DeepSeek models on their own servers in other countries — and you can run the smaller ones yourself. The trade-off: the full-size models are enormous, so running them needs data-centre hardware.

Run it on your own computer

The easiest way to run DeepSeek locally is Ollama, a free app for Mac, Windows and Linux. Install it from ollama.com, open a terminal and run one command. The first run downloads the model; after that, it works completely offline.

ollama run deepseek-r1          # the default size
ollama run deepseek-r1:8b       # pick a size: 1.5b, 7b, 8b, 14b, 32b, 70b…

$ ollama run deepseek-r1:8b
pulling manifest… downloading 5.2 GB ████████████ 100%
>>> Is 2027 a prime number?
<think>
Check divisors up to √2027 ≈ 45. Not even. Digit sum 11 → not divisible by 3.
Not 5. 7×289=2023, 7×290=2030 → no. 11: 2−0+2−7=−3 → no. 13×156=2028 → no…
…43×47=2021, 43×48=2064 → no. No divisor found.
</think>

Yes — 2027 is prime. It isn’t divisible by any prime up to 43,
and √2027 is about 45, so no larger factor is possible.
(runs offline — nothing leaves this computer)

Which size can your machine handle? Rough guidance for the usual compressed (4-bit) versions:

The DeepSeek API

DeepSeek’s API uses the same request format as OpenAI’s (and it also accepts Anthropic’s format), so existing code and tools work by changing two settings. Create an account at platform.deepseek.com, add a small balance, create a key and set it as DEEPSEEK_API_KEY. The current models are deepseek-flash (DeepSeek-V4.1-Flash, recommended, and it understands images) and deepseek-v4-pro, both with a 1-million-token context window.

import os
from openai import OpenAI   # DeepSeek's API speaks the OpenAI format

client = OpenAI(
    api_key=os.environ["DEEPSEEK_API_KEY"],
    base_url="https://api.deepseek.com",
)

response = client.chat.completions.create(
    model="deepseek-flash",
    messages=[
        {"role": "system", "content": "You are a patient physics tutor for Class 11 students."},
        {"role": "user", "content": "Why does a ball thrown straight up take as long to come down as to go up?"},
    ],
    reasoning_effort="high",
    extra_body={"thinking": {"type": "enabled"}},
)

message = response.choices[0].message
print("THINKING:\n", message.reasoning_content)   # the model's working
print("ANSWER:\n", message.content)               # the final reply

Because it is the OpenAI format, the same code can talk to DeepSeek’s servers, to a DeepSeek model on your own laptop, or to another host — only two lines change:

from openai import OpenAI

# Same SDK, pointed at Ollama running on your own machine
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="deepseek-r1:8b",
    messages=[{"role": "user", "content": "Summarise this contract clause in plain Hindi: ..."}],
)
print(response.choices[0].message.content)   # nothing left your computer

Cost and features

API prices are per million tokens and very low: at the time of writing, deepseek-flash costs about $0.15–$0.30 per million input tokens and $0.60–$1.20 per million output tokens, with off-peak hours half price. Repeated prompt prefixes are cached automatically and billed at a small fraction of the normal rate. The API also supports JSON output, tool calling and a thinking reasoning_effort setting.

Privacy and trust

This is the section to read carefully. DeepSeek’s privacy policy says the data it collects from its app and API is stored on servers in the People’s Republic of China, where companies can be required to cooperate with authorities. In early 2025, Italy’s data-protection regulator blocked the app, and several governments — including Australia, Taiwan and South Korea — restricted it on official devices; India’s finance ministry advised staff not to use AI tools such as DeepSeek on office computers.

The hosted app also follows Chinese content rules: on topics that are politically sensitive in China, it may decline to answer or give a one-sided account. The open weights carry some of that tuning too, though independent hosts can and do adjust it.

• Never share passwords, bank or card numbers, Aadhaar or passport numbers, or anyone else’s personal details.
• For confidential work, use a local model or a host whose data terms your organisation has approved.
• Check facts as with any AI — reasoning models can still reason their way to a wrong answer confidently.

Your 30-day path

From your first chat to running models and reading the research.

Quick quiz

Tap a question to check your answer.

That is DeepSeek: a capable, cheap and open family of models, a genuinely important piece of AI history, and a tool that asks you to think about where your data goes. Use it with your eyes open — and try running it yourself at least once. 🐋

DeepSeek is a product of Hangzhou DeepSeek Artificial Intelligence; Ollama and LM Studio are independent projects. This article is independent and not affiliated with or endorsed by any of them. Model names, prices, API code and release dates follow DeepSeek’s API documentation and changelog; Ollama sizes follow the Ollama library; architecture and training details follow DeepSeek’s V2, V3, DeepSeekMath and R1 papers — all as of 24 September 2026. Figure values are simplified where noted; screens are illustrations. Spotted something out of date? Tell us.