# DeepSeek V4 (1,6T MoE, multimodal)

{% hint style="info" %}
**Status (29. April 2026):** DeepSeek V4 erschien am **22. April 2026** mit **vollständig offenen Gewichten unter MIT-Lizenz**. Zwei Checkpoints sind live: [deepseek-ai/DeepSeek-V4-Pro](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro) (1,6T gesamt / \~49B aktiv, 1M Kontext) und [deepseek-ai/DeepSeek-V4-Flash](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash) (284B gesamt / \~13B aktiv). Das Pro-Modell hat in seiner ersten Woche bereits **174K Downloads überschritten**, mit Day-0-Support in vLLM und SGLang.
{% endhint %}

DeepSeek V4 ist das erste Open-Weight-Frontier-Modell von 2026, das als **zweistufige Veröffentlichung**. **V4-Pro** ist das Flaggschiff — ein **Mixture-of-Experts mit 1,6 Billionen Parametern** mit ungefähr **49B aktiven Parametern pro Token**, einem **Kontextfenster von 1M Token**, und einem hybriden Attention-Design, das Compressed Sparse Attention mit einem neuen Heavily Compressed Attention-Head für günstiges Long-Context-Prefill kombiniert. **V4-Flash** ist der praktische Bruder — **284B gesamt / 13B aktiv**, dieselbe Architektur, passt quantisiert auf eine einzelne 80-GB-GPU und läuft komfortabel auf einer 2×48-GB-Box mit Unsloth-GGUF-Builds.

Die Architektur ist die Hauptattraktion. DeepSeeks hybride Attention reduziert den KV-Cache-Speicher bei langem Kontext drastisch, und der MoE-Router wurde für eine präzisere Expertenauswahl neu trainiert — frühe unabhängige Läufe berichten, dass Pro bei etwa halbem Rechenaufwand der aktiven Parameter V3-Niveau bei Coding-Scores erreicht. Für Nutzer von Clore.ai ist das wichtig, weil **V4-Flash das erste Mal ist, dass ein Frontier-Modell mit unter 15B aktiven Parametern mit vollständigen Gewichten ausgeliefert wurde**, wodurch ernsthafte Open Inference mit einer einzelnen H100 oder einer günstigen Multi-4090-Box in Reichweite rückt.

Für die meisten Teams ist das realistische Clore-Deployment **V4-Flash auf 1× A100 80GB oder 2× RTX 4090** — dort liegt das Preis-Leistungs-Verhältnis. V4-Pro ist für ernsthafte Infrastruktur reserviert: 8× H100, 4× H200 oder 8× B200, idealerweise mit NVLink. Wenn du bisher [DeepSeek V3](/guides/guides_v2-de/sprachmodelle/deepseek-v3.md) oder [DeepSeek-R1](/guides/guides_v2-de/sprachmodelle/deepseek-r1.md)betrieben hast, ist der Migrationspfad unkompliziert — dieselbe Modellfamilie, dieselbe Chat-Vorlage, Drop-in-Ersatz in vLLM.

### Wichtige Spezifikationen

| Eigenschaft                   | DeepSeek V4-Pro                                                                   | DeepSeek V4-Flash                                                                     |
| ----------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| Gesamtparameter               | 1,6T (MoE)                                                                        | 284B (MoE)                                                                            |
| Aktive Parameter              | \~49B pro Token                                                                   | \~13B pro Token                                                                       |
| Kontextfenster                | 1.000.000 Token                                                                   | 256.000 Token                                                                         |
| Attention                     | Compressed Sparse + Heavily Compressed Attention                                  | Compressed Sparse + HCA                                                               |
| Lizenz                        | MIT                                                                               | MIT                                                                                   |
| Veröffentlichungsdatum        | 22. April 2026                                                                    | 22. April 2026                                                                        |
| HuggingFace                   | [deepseek-ai/DeepSeek-V4-Pro](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro) | [deepseek-ai/DeepSeek-V4-Flash](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash) |
| Primäre Tooling-Unterstützung | vLLM, SGLang (Day-0)                                                              | vLLM, SGLang, llama.cpp (Unsloth GGUF)                                                |

### Warum DeepSeek V4?

* **Wirklich offene Frontier-Gewichte** — MIT-Lizenz, keine Nutzungsbeschränkungen, vollständige kommerzielle Nutzung
* **1M Kontext bei Pro, 256K bei Flash** — verarbeitet ganze Codebasen, Bücher oder stundenlange Transkripte in einem Durchlauf
* **Hybride Sparse Attention** — der KV-Cache skaliert bei langem Kontext sublinear, Prefill ist günstig
* **Zweistufige Veröffentlichung** — Flash ist das erste MoE mit 13B aktiven Parametern, das gut genug ist, um V3 für die meisten Workflows zu ersetzen
* **Day-0-Support für vLLM und SGLang** — kein Warten auf Community-Patches, einfach `pip install -U` und los
* **MoE-Effizienz** — du zahlst die Inferenzkosten von 13B/49B, nicht von 284B/1,6T

***

## Anforderungen

{% hint style="warning" %}
**V4-Pro ist ein Frontier-Modell.** Die vollständigen BF16-Gewichte sind etwa 3,2 TB groß und erfordern Multi-Node-H100/H200 oder 8× B200 NVLink. Es gibt keinen Single-Server-BF16-Pfad. Wenn du keine Multi-Node-Infrastruktur hast, nutze V4-Flash — es bietet 80 % der Qualität bei 5 % der Hardwarekosten.
{% endhint %}

| Komponente | Min. (V4-Flash, GGUF Q4) | Empfohlen (V4-Flash FP8)       | Vollständig V4-Pro (BF16)        |
| ---------- | ------------------------ | ------------------------------ | -------------------------------- |
| GPU-VRAM   | 1× 80GB oder 2× 48GB     | 1× H100 80GB oder 1× A100 80GB | 8× H100 80GB oder 4× H200 141GB  |
| RAM        | 64GB                     | 128GB                          | 1TB+                             |
| Speicher   | 200GB NVMe               | 600GB NVMe                     | 4TB NVMe                         |
| CUDA       | 12.4+                    | 12.6+                          | 12.6+                            |
| Netzwerk   | —                        | —                              | NVLink / 400Gb IB für Multi-Node |

**Clore.ai-Empfehlung:** Für 95 % der Nutzer ist **V4-Flash auf einer einzelnen A100 80GB mit FP8** der Sweet Spot — voller 256K-Kontext, kein Quantisierungsverlust, ca. 5–7 $/Tag auf dem Marktplatz. Greif zu [H100](https://clore.ai/rent-h100.html) oder [H200](https://clore.ai/rent-h200.html) Tensor-Parallel-Setups nur dann, wenn du wirklich den 1M-Kontext von V4-Pro oder den zusätzlichen Reasoning-Spielraum brauchst.

***

## Option A — Ollama / GGUF (quantisiert, nur V4-Flash)

Unsloth veröffentlichte GGUF-Quants für V4-Flash innerhalb von 48 Stunden nach dem Release. Q4\_K\_M ist der Sweet Spot — passt auf 1× 80GB oder 2× 48GB und hält die Qualität nahe an FP8.

```bash
# Den Unsloth-Q4_K_M-Build ziehen
docker exec ollama ollama pull hf.co/unsloth/DeepSeek-V4-Flash-GGUF:Q4_K_M
docker exec ollama ollama run hf.co/unsloth/DeepSeek-V4-Flash-GGUF:Q4_K_M

# Oder direkt mit llama.cpp auf einem heruntergeladenen GGUF
docker run --gpus all -it --rm -p 8080:8080 \
  -v $(pwd)/models:/models \
  ghcr.io/ggerganov/llama.cpp:server-cuda \
  -m /models/DeepSeek-V4-Flash-Q4_K_M.gguf \
  --n-gpu-layers 99 --ctx-size 65536 \
  --port 8080 --host 0.0.0.0
```

{% hint style="info" %}
GGUF-Quants für V4-**Pro** existieren, sind aber nicht praktikabel — selbst Q2\_K ist etwa 400GB groß und die Offload-Performance ist für Chat unbrauchbar. Bleib bei Flash für quantisierte Deployments.
{% endhint %}

***

## Option B — vLLM (Produktions-API, empfohlen)

vLLM 0.7.x fügte Day-0-Support für beide V4-Checkpoints hinzu. Die hybriden Attention-Kernels benötigen `--trust-remote-code` und Hopper- oder Blackwell-Hardware für volle Geschwindigkeit.

**V4-Flash auf einer einzelnen H100 / A100 80GB:**

```yaml
version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model deepseek-ai/DeepSeek-V4-Flash
      --tensor-parallel-size 1
      --max-model-len 131072
      --dtype bfloat16
      --gpu-memory-utilization 0.92
      --enable-chunked-prefill
      --served-model-name deepseek-v4-flash
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]
    shm_size: "16gb"

volumes:
  hf_cache:
```

**V4-Pro auf 8× H100 80GB:** ersetze den Befehl durch:

```yaml
    command: >
      --model deepseek-ai/DeepSeek-V4-Pro
      --tensor-parallel-size 8
      --max-model-len 262144
      --dtype bfloat16
      --gpu-memory-utilization 0.90
      --enable-chunked-prefill
      --enable-prefix-caching
      --served-model-name deepseek-v4-pro
      --trust-remote-code
```

```bash
# Die API testen
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [{"role": "user", "content": "Schreibe einen asynchronen Rust-TCP-Echo-Server mit sauberem Shutdown."}],
    "max_tokens": 2048,
    "temperature": 0.6
  }'
```

{% hint style="info" %}
Beginne mit `--max-model-len 131072` auch wenn du letztlich den vollen 1M-ctx willst — lange Kontexte erhöhen die Prefill-Zeit und den KV-Speicher dramatisch. Erhöhe ihn erst, wenn die Basis stabil ist.
{% endhint %}

***

## Option C — SGLang (Alternative, oft schneller auf Hopper)

SGLangs RadixAttention und Prefix-Caching passen gut zu V4s hybrider Attention — bei agentischen Workloads mit geteilten Prompts ist ein deutlich besserer tok/s-Wert als bei vLLM zu erwarten.

```bash
docker pull lmsysorg/sglang:latest

# V4-Flash auf 1× H100/A100
python3 -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Flash \
  --tp-size 1 \
  --context-length 131072 \
  --mem-fraction-static 0.90 \
  --enable-torch-compile \
  --served-model-name deepseek-v4-flash \
  --trust-remote-code

# V4-Pro auf 8× H100
python3 -m sglang.launch_server \
  --model-path deepseek-ai/DeepSeek-V4-Pro \
  --tp-size 8 \
  --context-length 262144 \
  --mem-fraction-static 0.88 \
  --enable-torch-compile \
  --served-model-name deepseek-v4-pro \
  --trust-remote-code
```

SGLangs `--enable-torch-compile` fügt nach dem anfänglichen Warmup auf Hopper typischerweise weitere 10–20 % Durchsatz hinzu.

***

## Clore.ai-GPU-Empfehlungen

| Setup                                                      | Modell                                 | VRAM       | Erwarteter Durchsatz                          | Clore.ai-Kosten      |
| ---------------------------------------------------------- | -------------------------------------- | ---------- | --------------------------------------------- | -------------------- |
| 2× [RTX 4090](https://clore.ai/rent-4090.html) (Q4 GGUF)   | V4-Flash                               | 48GB       | Hobby-Nutzung, Einzel-Stream                  | \~2–3 $/Tag          |
| 1× [A100 80GB](https://clore.ai/rent-a100-80gb.html) (FP8) | V4-Flash                               | 80GB       | Solide Produktionsumgebung mit Single-Tenant  | \~5–7 $/Tag          |
| 1× RTX 5090 32GB (Q4 GGUF, partielles Offload)             | V4-Flash                               | 32GB + RAM | Eingeschränkt, nur für Entwicklung            | \~3,94 $/Std. Spitze |
| 4× [H100 80GB](https://clore.ai/rent-h100.html)            | V4-Flash FP8 (Overkill) oder V4-Pro Q4 | 320GB      | Flash für Multi-Tenant, Pro für Einzel-Stream | \~24–32 $/Tag        |
| 8× [H100 80GB](https://clore.ai/rent-h100.html)            | V4-Pro BF16                            | 640GB      | Produktionstaugliche Frontier-Inferenz        | \~48–64 $/Tag        |
| 4× [H200 141GB](https://clore.ai/rent-h200.html)           | V4-Pro BF16 + 1M ctx                   | 564GB      | Voller 1M-Kontext, maximale Durchsatzrate     | \~32–48 $/Tag        |

{% hint style="success" %}
**Bestes Preis-Leistungs-Verhältnis auf Clore.ai:** 1× A100 80GB, auf der V4-Flash FP8 läuft. Du bekommst 256K Kontext, \~13B aktive Inferenzkosten, keinen Quantisierungsverlust, und die Rechnung entspricht ungefähr dem Preis eines Claude-Sonnet-API-Abos — mit Gewichten, die auf deiner Maschine bleiben.
{% endhint %}

***

## Anwendungsfälle

* **Reasoning über die gesamte Codebasis** — V4-Pro mit 1M Kontext passt in ein typisches Monorepo mit 500K LOC plus dessen Tests in einen einzigen Prompt
* **RAG in Langform** — ganze Bücher, Gerichtsakten oder Jahresberichte in den Kontext laden, die Chunking-Pipeline überspringen
* **Agentisches Coden** — V4-Flash erreicht bei SWE-Bench V3 mit einem Bruchteil der Inferenzkosten; kombiniere es mit SWE-agent oder OpenHands
* **Synthese aus mehreren Dokumenten** — Forschungs-Workflows, die bisher Gemini 2.5 Pro benötigten, laufen jetzt auf deiner eigenen Hardware
* **Self-hosted Cursor-/Copilot-Ersatz** — V4-Flash auf einer einzelnen A100 reicht für ein Team von 5 Entwicklern aus
* **Basis für Fine-Tuning** — MIT-Lizenz + saubere MoE-Architektur machen es zu einem starken Ausgangspunkt für domänenspezifische Fine-Tunes

***

## Benchmarks

{% hint style="warning" %}
**Vom Anbieter behauptet — unabhängig verifizieren.** Die folgenden Zahlen stammen aus DeepSeeks Ankündigung vom 22. April 2026 und der Model Card. Unabhängige Reproduktionen werden noch veröffentlicht; als Richtwert verstehen, nicht als Evangelium.
{% endhint %}

| Benchmark                            | V4-Pro | V4-Flash | DeepSeek V3 | GLM-5.1 |
| ------------------------------------ | ------ | -------- | ----------- | ------- |
| MMLU-Pro                             | \~84%  | \~78%    | \~76%       | \~80%   |
| SWE-Bench Verified                   | \~82%  | \~74%    | \~70%       | \~79%   |
| HumanEval                            | \~96%  | \~92%    | \~91%       | \~94%   |
| MATH-500                             | \~94%  | \~88%    | \~85%       | \~90%   |
| LiveCodeBench                        | \~76%  | \~68%    | \~62%       | \~72%   |
| Long-Context (1M Nadel-im-Heuhaufen) | \~98%  | k. A.    | k. A.       | k. A.   |

Für einen fairen Open-Weight-Vergleich siehe den [GLM-5.1-Leitfaden](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) — V4-Pro und GLM-5.1 liefern je nach Benchmark unterschiedliche Ergebnisse.

***

## Fehlerbehebung

| Problem                                    | Lösung                                                                                                                                                                                                                 |
| ------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` V4-Pro auf 8×H100 laden | BF16 benötigt etwa 3,2 TB — Pro passt nicht auf einen einzelnen 8×H100-Node. Nutze 4× H200 141GB oder Multi-Node.                                                                                                      |
| `nicht unterstütztes Attention-Backend`    | V4 benötigt vLLM ≥ 0.7.0 oder SGLang ≥ 0.4.4. Führe aus `pip install -U vllm` (oder ziehe `:latest` Docker-Image).                                                                                                     |
| Langsamer HuggingFace-Download             | Verwende `huggingface-cli download deepseek-ai/DeepSeek-V4-Flash --local-dir ./weights --resume-download`. Pro ist etwa 3,2 TB groß; Flash etwa 570 GB.                                                                |
| `--trust-remote-code` abgelehnt            | Die hybriden Attention-Module werden im Repo als benutzerdefinierter Code ausgeliefert — `--trust-remote-code` ist für beide Engines erforderlich, bis die Kernel in den upstream Transformers angekommen sind.        |
| GGUF Q4 gibt Kauderwelsch aus              | Stelle sicher, dass du den Unsloth-Build verwendest (`unsloth/DeepSeek-V4-Flash-GGUF`), nicht einen frühen Community-Quant. Der MoE-Router braucht eine spezielle Behandlung, die frühe Quants falsch umgesetzt haben. |
| 1M-Kontext OOM auf V4-Pro                  | Gehe runter auf `--max-model-len 262144` und füge `--enable-prefix-caching`hinzu. Echtes 1M-Serving benötigt H200 oder B200.                                                                                           |
| Langsames Prefill bei langem Kontext       | Das ist erwartbar — selbst mit hybrider Attention dauert ein Prefill von 500K+ Minuten, nicht Sekunden. Nutze `--enable-chunked-prefill` und Prefix-Caching, um die Kosten zu amortisieren.                            |

***

## Nächste Schritte

* **Vorgänger:** [DeepSeek V3](/guides/guides_v2-de/sprachmodelle/deepseek-v3.md) — das Modell, das V4-Flash effektiv ersetzt
* **Reasoning-Bruder:** [DeepSeek-R1](/guides/guides_v2-de/sprachmodelle/deepseek-r1.md) — auf Chain-of-Thought abgestimmt, weiterhin nützlich für mathematisch schwere Workflows
* **Open-Weight-Alternative:** [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) — 744B MoE, Spitze bei SWE-Bench Pro, vergleichbares Preis-Leistungs-Verhältnis
* **Multimodale Alternative:** [Qwen3.5-Omni](/guides/guides_v2-de/sprachmodelle/qwen35-omni.md) — wenn du Vision/Audio im selben Modell brauchst
* **Hardware mieten:** [Clore.ai-Marktplatz](https://clore.ai/marketplace) — H100/H200/A100/RTX 4090 ab 0,50 $/Tag

### Links

* [DeepSeek-V4-Pro auf HuggingFace](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro)
* [DeepSeek-V4-Flash auf HuggingFace](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash)
* [Unsloth V4-Flash GGUF-Quants](https://huggingface.co/unsloth/DeepSeek-V4-Flash-GGUF)
* [DeepSeek GitHub](https://github.com/deepseek-ai)
* [vLLM-Dokumentation](https://docs.vllm.ai)
* [SGLang-Repo](https://github.com/sgl-project/sglang)


---

# 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-v4.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.
