> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/deepseek-r1.md).

# DeepSeek-R1 Reasoning-Modell

{% hint style="success" %}
Alle Beispiele laufen auf GPU-Servern, die über die [CLORE.AI Marketplace](https://clore.ai/marketplace). RTX-4090-Instanzen beginnen bei etwa 0,50 $/Tag.
{% endhint %}

## Überblick

DeepSeek-R1 ist ein Reasoning-Modell mit 671B Parametern und offenen Gewichten, das im Januar 2025 von DeepSeek unter der **Apache 2.0** Lizenz veröffentlicht wurde. Es ist das erste offene Modell, das mit OpenAI o1 in Mathematik, Programmierung und wissenschaftlichen Benchmarks mithalten kann — und dabei seine gesamte Gedankenkette über explizite `<think>` Tags offenlegt.

Das vollständige Modell verwendet **Mixture-of-Experts (MoE)** mit 37B aktiven Parametern pro Token, wodurch die Inferenz trotz der großen Parameterzahl praktikabel bleibt. Für die meisten Anwender sind die **destillierten Varianten** (1,5B → 70B) praktischer: Sie übernehmen R1s Reasoning-Muster durch Knowledge Distillation in die Qwen-2.5- und Llama-3-Basisarchitekturen und laufen auf handelsüblichen GPUs.

## Hauptfunktionen

* **Explizite Gedankenkette** — jede Antwort beginnt mit einem `<think>` Block, in dem das Modell vor der endgültigen Antwort nachdenkt, zurückverfolgt und sich selbst korrigiert
* **Mit Reinforcement Learning trainiert** — die Reasoning-Fähigkeit entsteht aus RL-Belohnungssignalen und nicht aus manuell erstellten Gedankenkettendaten
* **Sechs destillierte Varianten** — 1,5B-, 7B-, 8B-, 14B-, 32B- und 70B-Parametermodelle, destilliert aus dem vollständigen 671B-Modell in Qwen- und Llama-Architekturen
* **Apache-2.0-Lizenz** — vollständig kommerziell nutzbar, keine Lizenzgebühren, keine Nutzungsbeschränkungen
* **Breite Framework-Unterstützung** — Ollama, vLLM, llama.cpp, SGLang, Transformers, TGI funktionieren alle sofort
* **AIME 2024 Pass\@1: 79,8 %** — gleichauf mit OpenAI o1 bei Wettbewerbs-Mathematik
* **Codeforces 2029 Elo** — übertrifft o1s 1891 bei Competitive Programming

## Modellvarianten

| Variante                        | Parameter        | Architektur  | FP16 VRAM | Q4 VRAM  | Q4-Disk  |
| ------------------------------- | ---------------- | ------------ | --------- | -------- | -------- |
| DeepSeek-R1 (vollständiges MoE) | 671B (37B aktiv) | DeepSeek MoE | \~1,3 TB  | \~350 GB | \~340 GB |
| R1-Distill-Llama-70B            | 70B              | Llama 3      | 140 GB    | 40 GB    | 42 GB    |
| R1-Distill-Qwen-32B             | 32B              | Qwen 2.5     | 64 GB     | 22 GB    | 20 GB    |
| R1-Distill-Qwen-14B             | 14B              | Qwen 2.5     | 28 GB     | 10 GB    | 9 GB     |
| R1-Distill-Llama-8B             | 8B               | Llama 3      | 16 GB     | 6 GB     | 5,5 GB   |
| R1-Distill-Qwen-7B              | 7B               | Qwen 2.5     | 14 GB     | 5 GB     | 4,5 GB   |
| R1-Distill-Qwen-1.5B            | 1,5B             | Qwen 2.5     | 3 GB      | 2 GB     | 1,2 GB   |

### Eine Variante auswählen

| Anwendungsfall                                 | Empfohlene Variante    | GPU auf Clore                                                                                                                 |
| ---------------------------------------------- | ---------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| Schnelle Experimente, Edge-Tests               | R1-Distill-Qwen-1.5B   | Jede GPU                                                                                                                      |
| Budget-Deployment, schnelle Inferenz           | R1-Distill-Qwen-7B     | RTX 3090 (\~0,30–1 $/Tag)                                                                                                     |
| Produktions-Sweet-Spot mit einer einzelnen GPU | R1-Distill-Qwen-14B Q4 | [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) (\~0,50–2 $/Tag)      |
| Bestes Preis-Leistungs-Verhältnis (empfohlen)  | R1-Distill-Qwen-32B Q4 | [RTX 4090 24 GB](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=deepseek-r1) oder A100 40 GB |
| Maximale destillierte Qualität                 | R1-Distill-Llama-70B   | 2× A100 80 GB                                                                                                                 |
| Forschung, vollständiges Reasoning             | DeepSeek-R1 671B       | 8× H100-Cluster                                                                                                               |

### HuggingFace-Repositories

| Variante          | Repository                                                                                                    |
| ----------------- | ------------------------------------------------------------------------------------------------------------- |
| Vollständiges R1  | [deepseek-ai/DeepSeek-R1](https://huggingface.co/deepseek-ai/DeepSeek-R1)                                     |
| Llama-70B-Distill | [deepseek-ai/DeepSeek-R1-Distill-Llama-70B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-70B) |
| Qwen-32B-Distill  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-32B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-32B)   |
| Qwen-14B-Distill  | [deepseek-ai/DeepSeek-R1-Distill-Qwen-14B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-14B)   |
| Llama-8B-Distill  | [deepseek-ai/DeepSeek-R1-Distill-Llama-8B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Llama-8B)   |
| Qwen-7B-Distill   | [deepseek-ai/DeepSeek-R1-Distill-Qwen-7B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-7B)     |
| Qwen-1.5B-Distill | [deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B](https://huggingface.co/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B) |

## Anforderungen

| Komponente | Minimum (7B Q4) | Empfohlen (32B Q4) |
| ---------- | --------------- | ------------------ |
| GPU-VRAM   | 6 GB            | 24 GB              |
| System-RAM | 16 GB           | 32 GB              |
| Festplatte | 10 GB           | 30 GB              |
| CUDA       | 12.1+           | 12.4+              |
| Docker     | 24.0+           | 25.0+              |

## Ollama-Kurzanleitung

Ollama übernimmt Quantisierung, Download und Serving automatisch — der schnellste Weg zu einem laufenden DeepSeek-R1.

### Installieren und ausführen

```bash
# Ollama installieren
curl -fsSL https://ollama.com/install.sh | sh

# Herunterladen und ausführen (wähle deine Variante):
ollama run deepseek-r1:1.5b    # Edge / Tests
ollama run deepseek-r1:7b      # Budget — passt auf jede 8-GB+-GPU
ollama run deepseek-r1:14b     # RTX-4090-Sweet-Spot
ollama run deepseek-r1:32b     # A100 / 2× RTX 4090
ollama run deepseek-r1:70b     # 2× A100 80 GB
```

### Beispiel einer interaktiven Sitzung

```
>>> Beweise, dass √2 irrational ist.

<think>
Ich verwende einen Beweis durch Widerspruch.
Nehmen wir an, √2 sei rational, also √2 = p/q, wobei p und q ganze Zahlen mit ggT(p,q) = 1 sind.
Dann gilt 2 = p²/q², woraus p² = 2q² folgt.
Das bedeutet, dass p² gerade ist, also muss p gerade sein. Schreibe p = 2k.
Einsetzen: (2k)² = 2q² → 4k² = 2q² → q² = 2k².
Also ist auch q² gerade, was bedeutet, dass q gerade ist.
Wenn aber sowohl p als auch q gerade sind, dann ist ggT(p,q) ≥ 2, was unserer Annahme widerspricht.
</think>

**Beweis, dass √2 irrational ist (durch Widerspruch):**

Nehmen wir an, √2 = p/q in vollständig gekürzter Form (ggT(p,q) = 1). Durch Quadrieren erhält man p² = 2q².
Da p² gerade ist, ist p gerade — schreibe p = 2k. Dann gilt 4k² = 2q², also q² = 2k²,
was bedeutet, dass auch q gerade ist. Dies widerspricht ggT(p,q) = 1. ∎
```

### Die OpenAI-kompatible API verwenden

```bash
# Ollama als Server starten (falls noch nicht läuft)
ollama serve &

# Abfrage via curl
curl -s http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-r1:32b",
    "messages": [{"role": "user", "content": "Faktorisieren Sie x^4 - 1 vollständig über den ganzen Zahlen."}],
    "temperature": 0.6
  }' | python3 -m json.tool
```

### Python-Client (via OpenAI SDK)

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="deepseek-r1:32b",
    messages=[
        {"role": "user", "content": "Schreibe eine Python-Funktion, um den längsten palindromischen Teilstring zu finden."}
    ],
    temperature=0.6,
    max_tokens=4096,
)
print(response.choices[0].message.content)
```

## vLLM-Produktionssetup

vLLM liefert den höchsten Durchsatz für das Serving mit mehreren Nutzern dank kontinuierlichem Batching, PagedAttention und Prefix-Caching.

### Eine GPU — 7B / 14B

```bash
pip install vllm

# 7B auf jeder 16-GB+-GPU
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-7B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384

# 14B auf RTX 4090 (24 GB)
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-14B \
    --host 0.0.0.0 --port 8000 \
    --max-model-len 16384 \
    --gpu-memory-utilization 0.92
```

### Mehrere GPUs — 32B (empfohlen)

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 2 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90 \
    --enable-prefix-caching
```

> **Tipp:** Der 32B Q4 GPTQ- oder AWQ-Checkpoint passt auf eine einzelne RTX 4090 (24 GB):
>
> ```bash
> vllm serve deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
>     --quantization awq --host 0.0.0.0 --port 8000 \
>     --max-model-len 16384
> ```

### Mehrere GPUs — 70B

```bash
vllm serve deepseek-ai/DeepSeek-R1-Distill-Llama-70B \
    --host 0.0.0.0 --port 8000 \
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.90
```

### Den vLLM-Endpunkt abfragen

```bash
curl -s http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    "messages": [{"role": "user", "content": "Löse: Finde alle Primzahlen p, sodass p^2 + 2 ebenfalls prim ist."}],
    "temperature": 0.6,
    "max_tokens": 4096
  }'
```

## Transformers / Python (mit `<think>` Tag-Parsing)

Verwende HuggingFace Transformers, wenn du eine fein granulare Kontrolle über die Generierung benötigst oder R1 in eine Python-Pipeline integrieren möchtest.

### Einfache Generierung

```python
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch, re

MODEL = "deepseek-ai/DeepSeek-R1-Distill-Qwen-7B"

tokenizer = AutoTokenizer.from_pretrained(MODEL, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    MODEL,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True,
)

prompt = "Was ist die Summe der ersten 100 positiven ganzen Zahlen?"
messages = [{"role": "user", "content": prompt}]
input_text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(input_text, return_tensors="pt").to(model.device)

with torch.no_grad():
    output = model.generate(
        **inputs,
        max_new_tokens=2048,
        temperature=0.6,
        do_sample=True,
    )

full_response = tokenizer.decode(output[0][inputs["input_ids"].shape[-1]:], skip_special_tokens=True)
print(full_response)
```

### Parsing `<think>` Tags

```python
def parse_r1_response(text: str) -> dict:
    """Eine DeepSeek-R1-Antwort in Denk- und Antwortteile aufteilen."""
    think_match = re.search(r"<think>(.*?)</think>", text, re.DOTALL)
    thinking = think_match.group(1).strip() if think_match else ""
    answer = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
    return {
        "thinking": thinking,
        "answer": answer,
        "thinking_tokens": len(thinking.split()),
    }

result = parse_r1_response(full_response)
print(f"Das Modell hat für {result['thinking_tokens']} Wörter nachgedacht")
print(f"Antwort: {result['answer']}")
```

### Streaming mit `<think>` Zustandsverfolgung

```python
from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="unused")

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B",
    messages=[{"role": "user", "content": "Leiten Sie die quadratische Formel aus ax² + bx + c = 0 her."}],
    stream=True,
    max_tokens=4096,
    temperature=0.6,
)

in_think = False
for chunk in stream:
    token = chunk.choices[0].delta.content or ""
    if "<think>" in token:
        in_think = True
        print("[Denkprozess] ", end="", flush=True)
        continue
    if "</think>" in token:
        in_think = False
        print("\n[Antwort] ", end="", flush=True)
        continue
    if not in_think:
        print(token, end="", flush=True)
print()
```

## Docker-Deployment auf Clore.ai

### Ollama-Docker (am einfachsten)

**Docker-Image:** `ollama/ollama` **Ports:** `22/tcp, 11434/http`

```bash
# Auf der Clore-Instanz
docker run -d --gpus all \
    -v ollama_data:/root/.ollama \
    -p 11434:11434 \
    --name deepseek-r1 \
    ollama/ollama

# Modell herunterladen und bereitstellen
docker exec deepseek-r1 ollama pull deepseek-r1:32b
```

### vLLM-Docker (Produktion)

**Docker-Image:** `vllm/vllm-openai:latest` **Ports:** `22/tcp, 8000/http`

```yaml
# docker-compose.yml
version: "3.8"
services:
  deepseek-r1:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN:-}
    command: >
      --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B
      --host 0.0.0.0 --port 8000
      --tensor-parallel-size 2
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --enable-prefix-caching
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 5
      start_period: 300s
volumes:
  hf_cache:
```

Auf Clore.ai bereitstellen:

1. Öffnen [clore.ai/marketplace](https://clore.ai/marketplace)
2. Filtern nach **2× GPU, insgesamt 48 GB+ VRAM** (z. B. 2× RTX 4090 oder A100 80 GB)
3. Stellen Sie das Docker-Image auf `vllm/vllm-openai:latest`
4. Port zuordnen **8000** als HTTP
5. Fügen Sie den Befehl aus der obigen Compose-Datei in den Startbefehl ein
6. Verbinden Sie sich über den HTTP-Endpunkt, sobald der Health-Check bestanden ist

## Tipps für Clore.ai-Deployments

### Die richtige GPU auswählen

| Budget        | GPU              | Tägliche Kosten | Beste Variante                       |
| ------------- | ---------------- | --------------- | ------------------------------------ |
| Minimal       | RTX 3090 (24 GB) | 0,30 – 1,00 $   | R1-Distill-Qwen-7B oder 14B Q4       |
| Standard      | RTX 4090 (24 GB) | 0,50 – 2,00 $   | R1-Distill-Qwen-14B FP16 oder 32B Q4 |
| Produktion    | A100 80 GB       | 3 – 8 $         | R1-Distill-Qwen-32B FP16             |
| Hohe Qualität | 2× A100 80 GB    | 6 – 16 $        | R1-Distill-Llama-70B FP16            |

### Leistungsoptimierung

* **Temperatur 0.6** ist der empfohlene Standard für Reasoning-Aufgaben — DeepSeeks eigene Papers verwenden diesen Wert
* **Setze `max_tokens` großzügig** — Reasoning-Modelle erzeugen lange `<think>` Blöcke; 4096+ für nichttriviale Probleme
* **Prefix-Caching aktivieren** (`--enable-prefix-caching` in vLLM) bei Verwendung eines gemeinsamen System-Prompts
* **Nebenläufigkeit begrenzen** (`--max-num-seqs 16`) für Reasoning-Workloads — jede Anfrage nutzt mehr Rechenleistung als ein normaler Chat
* **Q4-Quantisierung verwenden** um 32B mit minimalem Qualitätsverlust auf eine einzelne 24-GB-GPU zu bekommen (die Distillation komprimiert R1s Wissen bereits)

### Überlegungen zur Kontextlänge

Reasoning-Modelle verbrauchen mehr Kontext als Standard-Chat-Modelle wegen des `<think>` Blocks:

| Aufgabenkomplexität           | Typische Denklänge | Insgesamt benötigter Kontext |
| ----------------------------- | ------------------ | ---------------------------- |
| Einfache Arithmetik           | \~100 Tokens       | \~300 Tokens                 |
| Code-Generierung              | \~500–1000 Tokens  | \~2000 Tokens                |
| Wettbewerbs-Mathematik (AIME) | \~2000–4000 Tokens | \~5000 Tokens                |
| Mehrstufige Forschungsanalyse | \~4000–8000 Tokens | \~10000 Tokens               |

## Fehlerbehebung

### Speicher erschöpft (OOM)

```bash
# Kontextlänge reduzieren
--max-model-len 8192    # statt 32768

# Anzahl gleichzeitiger Sequenzen begrenzen
--max-num-seqs 8

# Quantisierung verwenden
--quantization awq      # oder gptq
```

### Modell erzeugt keinen `<think>` Block

Einige System-Prompts unterdrücken das Nachdenken. Vermeide Anweisungen wie „sei knapp“ oder „erkläre dein Denken nicht“. Verwende einen minimalen System-Prompt oder gar keinen:

```python
# Gut — bewahrt das Reasoning
messages = [{"role": "user", "content": "..."}]

# Schlecht — kann das Denken unterdrücken
messages = [
    {"role": "system", "content": "Sei extrem kurz. Keine Erklärungen."},
    {"role": "user", "content": "..."}
]
```

### Wiederholte oder `<think>` schleifenartige Ausgabe

Reduziere die Temperatur, um die Zufälligkeit in der Gedankenkette zu verringern:

```python
temperature = 0.0   # Deterministisch — am besten für Mathematik/Code
temperature = 0.3   # Leichte Variation — gut für Analyse
```

### Langsames erstes Token (hoher TTFT)

Das ist zu erwarten — das Modell generiert `<think>` Tokens vor der sichtbaren Antwort. Für Anwendungen mit geringer Latenz, bei denen kein Reasoning benötigt wird, verwende [DeepSeek-V3](/guides/guides_v2-de/sprachmodelle/deepseek-v3.md) stattdessen.

### Download stockt auf der Clore-Instanz

HuggingFace-Downloads können bei einigen Anbietern langsam sein. Cache das Modell vorab in einem persistenten Volume:

```bash
# Einmal in ein Volume herunterladen
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
    --local-dir /data/models/deepseek-r1-32b

# vLLM auf lokalen Pfad verweisen
vllm serve /data/models/deepseek-r1-32b --host 0.0.0.0 --port 8000
```

## Weiterlesen

* [DeepSeek-R1-Paper](https://arxiv.org/abs/2501.12948) — *Anreizsetzung für Reasoning-Fähigkeiten in LLMs via Reinforcement Learning*
* [DeepSeek-R1 GitHub](https://github.com/deepseek-ai/DeepSeek-R1) — Offizielles Repository mit Model Cards
* [DeepSeek-V3-Leitfaden](/guides/guides_v2-de/sprachmodelle/deepseek-v3.md) — Nicht-Reasoning-Allzweckmodell aus demselben Labor
* [vLLM-Leitfaden](/guides/guides_v2-de/sprachmodelle/vllm.md) — Umfassendes Produktions-Serving-Setup
* [Ollama-Leitfaden](/guides/guides_v2-de/sprachmodelle/ollama.md) — Einfache lokale Bereitstellung für jedes Modell
* [Open WebUI-Leitfaden](/guides/guides_v2-de/sprachmodelle/open-webui.md) — Chat-UI mit nativer `<think>` Tag-Darstellung
* [Qwen-2.5-Leitfaden](/guides/guides_v2-de/sprachmodelle/qwen25.md) — Die Basisarchitektur, die von den meisten R1-Distills verwendet wird


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/deepseek-r1.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.