> 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-fr/modeles-de-langage/deepseek-v4.md).

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

{% hint style="info" %}
**Statut (29 avril 2026) :** DeepSeek V4 a été lancé le **22 avril 2026** avec **des poids entièrement ouverts sous licence MIT**. Deux checkpoints sont disponibles : [deepseek-ai/DeepSeek-V4-Pro](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro) (1,6T au total / \~49B actifs, contexte 1M) et [deepseek-ai/DeepSeek-V4-Flash](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash) (284B au total / \~13B actifs). Le modèle Pro a déjà dépassé **174K téléchargements dès sa première semaine**, avec un support dès le jour 0 dans vLLM et SGLang.
{% endhint %}

DeepSeek V4 est le premier modèle open-weight de pointe de 2026 à être publié comme une **version à deux niveaux**. **V4-Pro** est le fleuron — un **Mixture-of-Experts à 1,6 trillion de paramètres** avec environ **49B de paramètres actifs par token**, une **fenêtre de contexte de 1M tokens**, et une conception d’attention hybride qui combine Compressed Sparse Attention avec une nouvelle tête Heavily Compressed Attention pour un préremplissage long contexte peu coûteux. **V4-Flash** est le frère pratique — **284B au total / 13B actifs**, la même architecture, tient sur un seul GPU de 80 Go lorsqu’il est quantifié, et fonctionne confortablement sur une machine 2×48 Go avec les builds Unsloth GGUF.

L’architecture est l’élément phare. L’attention hybride de DeepSeek réduit drastiquement la mémoire du cache KV à long contexte, et le routeur MoE a été réentraîné pour une sélection d’experts plus précise — des exécutions indépendantes précoces rapportent que Pro atteint des scores de codage au niveau de V3 à environ la moitié du calcul en paramètres actifs. Pour les utilisateurs de Clore.ai, c’est important car **V4-Flash est la première fois qu’un modèle de pointe à moins de 15B actifs est livré avec des poids complets**, rendant l’inférence open sérieuse accessible à un seul H100 ou à une machine multi-4090 peu coûteuse.

Pour la plupart des équipes, le déploiement Clore réaliste est **V4-Flash sur 1× A100 80 Go ou 2× RTX 4090** — c’est là que se trouve le meilleur rapport qualité-prix. V4-Pro est réservé aux infrastructures sérieuses : 8× H100, 4× H200, ou 8× B200, idéalement avec NVLink. Si vous utilisiez déjà [DeepSeek V3](/guides/guides_v2-fr/modeles-de-langage/deepseek-v3.md) ou [DeepSeek-R1](/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md), la migration est simple — même famille de modèles, même template de chat, remplacement direct dans vLLM.

### Spécifications clés

| Propriété                  | DeepSeek V4-Pro                                                                   | DeepSeek V4-Flash                                                                     |
| -------------------------- | --------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------- |
| Nombre total de paramètres | 1,6T (MoE)                                                                        | 284B (MoE)                                                                            |
| Paramètres actifs          | \~49B par token                                                                   | \~13B par token                                                                       |
| Fenêtre de contexte        | 1 000 000 tokens                                                                  | 256 000 tokens                                                                        |
| Attention                  | Compressed Sparse + Heavily Compressed Attention                                  | Compressed Sparse + HCA                                                               |
| Licence                    | MIT                                                                               | MIT                                                                                   |
| Date de publication        | 22 avril 2026                                                                     | 22 avril 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) |
| Outils principaux          | vLLM, SGLang (jour 0)                                                             | vLLM, SGLang, llama.cpp (Unsloth GGUF)                                                |

### Pourquoi DeepSeek V4 ?

* **De vrais poids open frontier** — licence MIT, aucune restriction d’usage, usage commercial complet
* **1M de contexte sur Pro, 256K sur Flash** — gère des bases de code entières, des livres ou des transcriptions d’une heure en un seul passage
* **Attention sparsa hybride** — le cache KV croît sous-linéairement à long contexte, le préremplissage est peu coûteux
* **Version à deux niveaux** — Flash est le premier MoE à 13B actifs suffisamment bon pour remplacer V3 dans la plupart des workflows
* **Support vLLM et SGLang dès le jour 0** — pas besoin d’attendre des correctifs communautaires, il suffit de `pip install -U` et c’est parti
* **Efficacité MoE** — vous payez le coût d’inférence de 13B/49B, pas de 284B/1,6T

***

## Exigences

{% hint style="warning" %}
**V4-Pro est un modèle de pointe.** Les poids BF16 complets font environ 3,2 To et nécessitent plusieurs nœuds H100/H200 ou 8× B200 NVLink. Il n’existe pas de chemin BF16 sur un seul serveur. Si vous n’avez pas d’infrastructure multi-nœuds, utilisez V4-Flash — il offre 80 % de la qualité pour 5 % du coût matériel.
{% endhint %}

| Composant | Min (V4-Flash, GGUF Q4) | Recommandé (V4-Flash FP8)      | V4-Pro complet (BF16)               |
| --------- | ----------------------- | ------------------------------ | ----------------------------------- |
| VRAM GPU  | 1× 80 Go ou 2× 48 Go    | 1× H100 80 Go ou 1× A100 80 Go | 8× H100 80 Go ou 4× H200 141 Go     |
| RAM       | 64 Go                   | 128 Go                         | 1 To+                               |
| Disque    | 200 Go NVMe             | 600 Go NVMe                    | 4 To NVMe                           |
| CUDA      | 12.4+                   | 12.6+                          | 12.6+                               |
| Réseau    | —                       | —                              | NVLink / 400 Gb IB pour multi-nœuds |

**Choix Clore.ai :** Pour 95 % des utilisateurs, **V4-Flash sur un seul A100 80 Go en FP8** est le point idéal — contexte complet 256K, aucune perte due à la quantification, environ 5–7 $/jour sur la marketplace. Optez pour [H100](https://clore.ai/rent-h100.html) ou [H200](https://clore.ai/rent-h200.html) des configurations tensor-parallel uniquement lorsque vous avez réellement besoin du contexte 1M de V4-Pro ou d’une marge de raisonnement supplémentaire.

***

## Option A — Ollama / GGUF (quantifié, V4-Flash uniquement)

Unsloth a publié des quantifications GGUF pour V4-Flash dans les 48 heures suivant la sortie. Q4\_K\_M est le meilleur compromis — tient sur 1× 80 Go ou 2× 48 Go et conserve une qualité proche de FP8.

```bash
# Récupérer le build Unsloth Q4_K_M
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

# Ou avec llama.cpp directement sur un GGUF téléchargé
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" %}
Les quants GGUF pour V4-**niveau Pro** existent mais ne sont pas pratiques — même Q2\_K fait environ 400 Go et les performances en déchargement sont inutilisables pour le chat. Restez sur Flash pour les déploiements quantifiés.
{% endhint %}

***

## Option B — vLLM (API de production, recommandé)

vLLM 0.7.x a ajouté le support dès le jour 0 pour les deux checkpoints V4. Les kernels d’attention hybride nécessitent `--trust-remote-code` et du matériel Hopper ou Blackwell pour une vitesse maximale.

**V4-Flash sur un seul H100 / A100 80 Go :**

```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 sur 8× H100 80 Go :** remplacez la commande par :

```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
# Tester l’API
curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [{"role": "user", "content": "Écris un serveur d’écho TCP asynchrone en Rust avec arrêt gracieux."}],
    "max_tokens": 2048,
    "temperature": 0.6
  }'
```

{% hint style="info" %}
Commencez avec `--max-model-len 131072` même si vous voulez au final le contexte complet de 1M — les contextes longs augmentent fortement le temps de préremplissage et la mémoire KV. N’augmentez la valeur qu’une fois la base stable.
{% endhint %}

***

## Option C — SGLang (alternative, souvent plus rapide sur Hopper)

RadixAttention et le cache de préfixe de SGLang s’accordent bien avec l’attention hybride de V4 — pour les charges agentiques avec des prompts partagés, attendez-vous à un tok/s nettement meilleur que vLLM.

```bash
docker pull lmsysorg/sglang:latest

# V4-Flash sur 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 sur 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
```

Le `--enable-torch-compile` ajoute généralement encore 10 à 20 % de débit sur Hopper après le réchauffement initial.

***

## Recommandations GPU Clore.ai

| Configuration                                               | Modèle                                     | VRAM        | Débit attendu                          | Coût Clore.ai     |
| ----------------------------------------------------------- | ------------------------------------------ | ----------- | -------------------------------------- | ----------------- |
| 2× [RTX 4090](https://clore.ai/rent-4090.html) (Q4 GGUF)    | V4-Flash                                   | 48 Go       | Usage loisir, flux unique              | \~2–3 $/jour      |
| 1× [A100 80 Go](https://clore.ai/rent-a100-80gb.html) (FP8) | V4-Flash                                   | 80 Go       | Production solide à locataire unique   | \~5–7 $/jour      |
| 1× RTX 5090 32 Go (Q4 GGUF, déchargement partiel)           | V4-Flash                                   | 32 Go + RAM | Contraint, dev uniquement              | \~3,94 $/h au pic |
| 4× [H100 80 Go](https://clore.ai/rent-h100.html)            | V4-Flash FP8 (surdimensionné) ou V4-Pro Q4 | 320 Go      | Flash multi-locataire, Pro flux unique | \~24–32 $/jour    |
| 8× [H100 80 Go](https://clore.ai/rent-h100.html)            | V4-Pro BF16                                | 640 Go      | Inférence de pointe en production      | \~48–64 $/jour    |
| 4× [H200 141 Go](https://clore.ai/rent-h200.html)           | V4-Pro BF16 + ctx 1M                       | 564 Go      | Contexte complet 1M, débit maximal     | \~32–48 $/jour    |

{% hint style="success" %}
**Meilleur rapport qualité-prix sur Clore.ai :** 1× A100 80 Go exécutant V4-Flash FP8. Vous obtenez un contexte de 256K, un coût d’inférence actif d’environ 13B, aucune perte liée à la quantification, et la facture est à peu près le prix d’un abonnement API Claude Sonnet — avec des poids qui restent sur votre machine.
{% endhint %}

***

## Cas d’usage

* **Raisonnement sur base de code entière** — le contexte 1M de V4-Pro tient dans un monorepo typique de 500K LOC ainsi que ses tests dans un seul prompt
* **RAG long format** — déposez des livres entiers, des dossiers judiciaires ou des rapports annuels dans le contexte, en sautant le pipeline de découpage
* **Codage agentique** — V4-Flash égalise V3 sur SWE-Bench pour une fraction du coût d’inférence ; associez-le à SWE-agent ou OpenHands
* **Synthèse multi-documents** — les workflows de recherche qui nécessitaient auparavant Gemini 2.5 Pro tournent désormais sur votre propre matériel
* **Remplacement self-hosted de Cursor / Copilot** — V4-Flash sur un seul A100 suffit pour une équipe de 5 développeurs
* **Base de fine-tuning** — la licence MIT + l’architecture MoE propre en font un excellent point de départ pour des fine-tunes de domaine

***

## Benchmarks

{% hint style="warning" %}
**Déclaré par le fournisseur — à vérifier indépendamment.** Les chiffres ci-dessous proviennent de l’annonce de DeepSeek du 22 avril 2026 et de la fiche modèle. Des reproductions indépendantes sont encore publiées ; considérez-les comme indicatives, pas comme parole d’évangile.
{% 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 contexte (1M needle-in-haystack) | \~98%  | n/a      | n/a         | n/a     |

Pour une comparaison open-weight de type pommes à pommes, voir le [guide GLM-5.1](/guides/guides_v2-fr/modeles-de-langage/glm-5-1.md) — V4-Pro et GLM-5.1 se disputent la victoire selon le benchmark.

***

## Dépannage

| Problème                                           | Solution                                                                                                                                                                                                        |
| -------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `OutOfMemoryError` chargement de V4-Pro sur 8×H100 | Le BF16 nécessite environ 3,2 To — on ne peut pas faire tenir Pro sur un seul nœud 8×H100. Utilisez 4× H200 141 Go ou un déploiement multi-nœuds.                                                               |
| `backend d’attention non pris en charge`           | V4 nécessite vLLM ≥ 0.7.0 ou SGLang ≥ 0.4.4. Exécutez `pip install -U vllm` (ou récupérez `:latest` image Docker).                                                                                              |
| Téléchargement HuggingFace lent                    | Utilisez `huggingface-cli download deepseek-ai/DeepSeek-V4-Flash --local-dir ./weights --resume-download`. Pro fait environ 3,2 To ; Flash fait environ 570 Go.                                                 |
| `--trust-remote-code` refusé                       | Les modules d’attention hybride sont fournis comme code personnalisé dans le dépôt — `--trust-remote-code` est requis pour les deux moteurs jusqu’à ce que les kernels arrivent dans Transformers en amont.     |
| Les sorties GGUF Q4 sont du charabia               | Assurez-vous d’utiliser le build Unsloth (`unsloth/DeepSeek-V4-Flash-GGUF`), pas une quantification communautaire précoce. Le routeur MoE nécessite une gestion spéciale que les premières quants géraient mal. |
| OOM de contexte 1M sur V4-Pro                      | Descendez à `--max-model-len 262144` et ajoutez `--enable-prefix-caching`. Un vrai service 1M nécessite H200 ou B200.                                                                                           |
| Préremplissage lent à long contexte                | C’est normal — même avec l’attention hybride, un préremplissage de 500K+ prend des minutes, pas des secondes. Utilisez `--enable-chunked-prefill` et le cache de préfixe pour amortir.                          |

***

## Étapes suivantes

* **Prédécesseur :** [DeepSeek V3](/guides/guides_v2-fr/modeles-de-langage/deepseek-v3.md) — le modèle que V4-Flash remplace effectivement
* **Frère de raisonnement :** [DeepSeek-R1](/guides/guides_v2-fr/modeles-de-langage/deepseek-r1.md) — optimisé pour la chaîne de pensée, toujours utile pour les workflows très orientés maths
* **Alternative open-weight :** [GLM-5.1](/guides/guides_v2-fr/modeles-de-langage/glm-5-1.md) — 744B MoE, sommet de SWE-Bench Pro, rapport qualité-prix comparable
* **Alternative multimodale :** [Qwen3.5-Omni](/guides/guides_v2-fr/modeles-de-langage/qwen35-omni.md) — si vous avez besoin de vision/audio dans le même modèle
* **Louez le matériel :** [place de marché Clore.ai](https://clore.ai/marketplace) — H100/H200/A100/RTX 4090 à partir de 0,50 $/jour

### Liens

* [DeepSeek-V4-Pro sur HuggingFace](https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro)
* [DeepSeek-V4-Flash sur HuggingFace](https://huggingface.co/deepseek-ai/DeepSeek-V4-Flash)
* [Quantifications GGUF V4-Flash d’Unsloth](https://huggingface.co/unsloth/DeepSeek-V4-Flash-GGUF)
* [GitHub de DeepSeek](https://github.com/deepseek-ai)
* [Documentation vLLM](https://docs.vllm.ai)
* [Dépôt SGLang](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-fr/modeles-de-langage/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.
