Comment exécuter DeepSeek V4 en local

TR

La façon la plus pratique d’exécuter DeepSeek V4 en local consiste à utiliser les poids officiels open source avec une pile de service haute performance comme vLLM, puis à exposer le modèle via un endpoint local compatible OpenAI. La documentation publique actuelle de DeepSeek décrit deux modèles dans la famille V4 : DeepSeek-V4-Pro avec 1,6T de paramètres totaux / 49B actifs, et DeepSeek-V4-Flash avec 284B au total / 13B actifs, tous deux dotés d’un contexte de 1M de tokens et de trois modes de raisonnement. Les exemples de déploiement local actuels de vLLM ciblent 8× B200/B300 pour Pro et 4× B200/B300 pour Flash. Si vous ne disposez pas de ce type de matériel, une solution hébergée comme CometAPI est plus pratique.

DeepSeek AI a créé la surprise le 24 avril 2026 avec la diffusion en avant-première de DeepSeek-V4, présentant deux puissants modèles Mixture-of-Experts (MoE) : DeepSeek-V4-Pro (1,6T de paramètres totaux, 49B actifs) et DeepSeek-V4-Flash (284B au total, 13B actifs). Les deux prennent en charge nativement une fenêtre de contexte d’1 million de tokens — un changement de paradigme pour l’analyse de longs documents, les workflows agents, le codage sur d’immenses bases de code et la génération augmentée par récupération (RAG) à grande échelle.

Entraîné sur plus de 32 000 milliards de tokens avec des innovations architecturales telles que l’attention compressée hybride Compressed Sparse Attention (CSA) + Heavily Compressed Attention (HCA), les hyper‑connexions contraintes par variété (mHC) et une gestion mémoire efficace, V4 atteint jusqu’à 73% de réduction des FLOPs d’inférence et 90% de réduction de l’empreinte du cache KV pour des contextes 1M par rapport à V3.2. Les performances rivalisent avec les meilleurs modèles propriétaires tout en restant à poids ouverts (licence MIT) et extrêmement rentables via API.

Exécuter ces modèles en local offre une confidentialité inégalée, zéro coût API récurrent (hors matériel), des capacités hors ligne et une personnalisation totale. Cependant, leur échelle pose des défis : les poids complets de V4‑Pro dépassent 800GB de téléchargement, et l’inférence exige un matériel conséquent ou une quantification agressive.

DeepSeek V4 peut‑il vraiment tourner en local ?

Oui, mais « en local » signifie ici quelque chose de très différent que de faire tourner un modèle 7B sur un ordinateur portable. Les documents de DeepSeek et la note de support vLLM pointent vers de grands systèmes multi‑GPU : V4‑Pro est un modèle à 1,6T de paramètres avec 49B de paramètres actifs, tandis que V4‑Flash compte 284B au total / 13B actifs. Les exemples de déploiement officiels de vLLM sont rédigés pour 8× B200/B300 sur Pro et 4× B200/B300 sur Flash. C’est le signal le plus clair que DeepSeek V4 relève d’un déploiement local de classe entreprise, et non d’une expérimentation de bureau.

Cette échelle a une raison d’être. DeepSeek indique que V4 prend en charge un contexte de 1M de tokens, et le rapport technique affirme que V4‑Pro n’utilise que 27% des FLOPs d’inférence par token et 10% du cache KV par rapport à DeepSeek‑V3.2 à 1M de contexte. vLLM explique en outre qu’avec un cache KV bf16, DeepSeek V4 utilise 9,62 GiB de cache KV par séquence à 1M de contexte, soit environ 8,7× plus petit que les 83,9 GiB estimés pour une pile comparable de type DeepSeek‑V3.2. En d’autres termes, V4 est nettement plus efficace que les générations précédentes, mais un million de tokens reste un problème de systèmes colossal.

Tableau comparatif d’architecture : DeepSeek V4 vs V3 et concurrents

Le design MoE de V4 n’active qu’une fraction des paramètres par token, maintenant le calcul proche d’un modèle dense 13B–49B tout en bénéficiant des connaissances d’un réseau bien plus vaste.

Quel modèle Deepseek V4 choisir ?

Pour la plupart des déploiements locaux, DeepSeek‑V4‑Flash est le meilleur point de départ. V4‑Flash délivre un raisonnement proche de Pro sur des tâches agents plus simples, tout en restant plus rapide et plus économique.

Utilisez DeepSeek‑V4‑Pro lorsque vous privilégiez la capacité absolue à l’efficacité. Pro est le modèle le plus robuste pour le raisonnement difficile, le code et les tâches agentiques. Les tableaux de benchmarks l’illustrent : sur la comparaison officielle, V4‑Pro‑Base atteint 90.1 en MMLU, 76.8 en HumanEval et 51.5 en LongBench‑V2, tandis que V4‑Flash‑Base obtient respectivement 88.7, 69.5 et 44.7. Les deux sont solides ; Pro pousse simplement plus haut lorsque vous avez besoin du meilleur résultat possible.

Une lecture simple du tableau suffit pour la planification produit. Flash n’est pas un modèle bridé : c’est un assistant long‑contexte sérieux à coût réduit. Pro est le modèle à tester en premier lorsque le problème est difficile, étatique ou proche d’un flux de connaissances en production.

Pile locale recommandée

1) vLLM pour un service de niveau production

L’option officielle la plus solide aujourd’hui est vLLM. L’équipe vLLM indique prendre désormais en charge la famille DeepSeek V4 et fournit des commandes de lancement monoposte concrètes pour les deux modèles. Leur article présente V4 comme une famille de modèles long‑contexte conçue pour des tâches jusqu’à un million de tokens et décrit le travail d’implémentation nécessaire pour le cache KV hybride, la fusion de noyaux et le service désagrégé.

Pour V4‑Pro, l’exemple vLLM cible 8× B200 ou 8× B300. Pour V4‑Flash, l’exemple cible 4× B200 ou 4× B300. Les commandes utilisent également --kv-cache-dtype fp8, --block-size 256, --enable-expert-parallel, ainsi que des indicateurs de parsing spécifiques à DeepSeek, tels que --tokenizer-mode deepseek_v4, --tool-call-parser deepseek_v4 et --reasoning-parser deepseek_v4. Cette combinaison constitue un indice clair sur la manière dont DeepSeek s’attend à ce que l’auto‑hébergement sérieux soit réalisé.

# DeepSeek-V4-Flash on a supported multi-GPU hostdocker run --gpus all \  --ipc=host -p 8000:8000 \  -v ~/.cache/huggingface:/root/.cache/huggingface \  vllm/vllm-openai:deepseekv4-cu130 deepseek-ai/DeepSeek-V4-Flash \  --trust-remote-code \  --kv-cache-dtype fp8 \  --block-size 256 \  --enable-expert-parallel \  --data-parallel-size 4 \  --compilation-config '{"cudagraph_mode":"FULL_AND_PIECEWISE", "custom_ops":["all"]}' \  --attention_config.use_fp4_indexer_cache=True \  --tokenizer-mode deepseek_v4 \  --tool-call-parser deepseek_v4 \  --enable-auto-tool-choice \  --reasoning-parser deepseek_v4

Pour passer à V4‑Pro, conservez le même schéma et changez le modèle en deepseek-ai/DeepSeek-V4-Pro, avec la taille de parallélisme de données ajustée selon l’exemple Pro dans l’article vLLM. C’est la façon la plus simple de commencer les tests en local sans réinventer la pile de service.

2) Outils d’inférence du dépôt DeepSeek

Deepseek V4 ne fournit pas de template de chat au format Jinja. À la place, il propose un dossier encoding dédié avec des scripts Python et des cas de test pour convertir des messages de style OpenAI en chaînes d’entrée du modèle et pour parser la sortie. La même page indique de consulter le dossier inference pour les détails de déploiement local, y compris la conversion des poids et des démos de chat interactives. C’est utile si vous souhaitez construire un front‑end personnalisé ou contrôler finement le formatage des prompts.

3) CometAPI comme plan de secours pratique

Si vous ne disposez pas de matériel de classe B200/B300, une voie hébergée est un choix raisonnable. CometAPI indique offrir une clé API pour tout, l’accès à 500+ modèles d’IA, et une tarification 20–40% moins chère que les tarifs des fournisseurs officiels. Il publie également des pages dédiées à DeepSeek V4, y compris DeepSeek‑V4‑Pro et DeepSeek‑V4‑Flash, avec des exemples d’intégration compatibles OpenAI.

Pas à pas : comment exécuter DeepSeek V4 en local

1. Prérequis

• OS : Linux recommandé (Ubuntu 22.04/24.04) pour la meilleure prise en charge CUDA/ROCm. Windows via WSL2 ou natif. macOS avec Metal (limité pour les plus grands modèles).
• Pilotes : NVIDIA CUDA 12.4+ (ou plus récent). AMD ROCm pour cartes Radeon.
• Python 3.11+, Git, et suffisamment d’espace disque.
• Compte Hugging Face pour les modèles à accès restreint (le cas échéant) : huggingface-cli login.

2. Le plus simple : Ollama ou LM Studio (pour débutants)

Ollama offre l’expérience CLI et WebUI la plus simple. Fin avril 2026, le support V4 complet peut nécessiter des Modelfiles personnalisés ou des tags communautaires, mais des versions quantifiées de V4‑Flash émergent rapidement.

Installer Ollama (Linux/macOS) :

curl -fsSL https://ollama.com/install.sh | sh
ollama --version

Exécuter un modèle compatible (commencez petit ou vérifiez les tags V4) :

ollama pull deepseek-v4-flash:q4_0   # Example quantized tag; check ollama.com/library or community
ollama run deepseek-v4-flash:q4_0

Pour du personnalisé : créer un Modelfile (texte) :

FROM ./DeepSeek-V4-Flash-GGUF-Q4.gguf
TEMPLATE """{{ .Prompt }}"""
PARAMETER num_ctx 32768  # Start conservative; increase as hardware allows up to 1M with sufficient RAM/VRAM

Puis ollama create my-v4-flash -f Modelfile.

LM Studio : alternative GUI. Téléchargez depuis lmstudio.ai, recherchez/parcourez HF pour des quantifications GGUF de DeepSeek‑V4 (style TheBloke ou officielles), chargez et discutez. Excellent pour expérimenter avec des curseurs de contexte et du déport GPU.

Open WebUI : se superposer à Ollama pour une interface type ChatGPT (Bash) :

docker run -d -p 8080:8080 --add-host=host.docker.internal:host-gateway -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main

Accédez à http://localhost:8080.

3. Avancé : Hugging Face + vLLM ou SGLang (hautes performances)

Pour un maximum de vitesse et le support du contexte 1M, utilisez vLLM (excellent support MoE et PagedAttention) :

Étape 1 : Préparer l’environnement

Commencez par installer la pile vLLM actuelle et assurez‑vous que votre CUDA, vos pilotes et votre topologie GPU correspondent au modèle que vous souhaitez exécuter. recommending temperature = 1.0 and top_p = 1.0 for local deployment, and for Think Max it recommends a context window of at least 384K tokens. That is a useful starting point whether you are building a chat app, a coding assistant, or an agent workflow.

Installation :

Bash
pip install -U "vllm>=0.9.0"  # Check latest for V4 compatibility

Télécharger le modèle (utilisez la CLI pour les gros fichiers) :

Bash
pip install -U "huggingface_hub[cli]"
huggingface-cli download deepseek-ai/DeepSeek-V4-Flash --local-dir ./DeepSeek-V4-Flash

Servir avec vLLM (exemple pour Flash sur 2 GPU) :

Étape 2 : Lancer le serveur de modèle

Une fois le conteneur en place, exposez le modèle comme un endpoint local compatible OpenAI. Cela facilite la réutilisation de votre code applicatif existant et le changement d’arrière‑plan sans modifier votre architecture.

Servir avec vLLM (exemple pour Flash sur 2 GPU) :

Python
from vllm import LLM, SamplingParams

llm = LLM(
    model="deepseek-ai/DeepSeek-V4-Flash",
    tensor_parallel_size=2,      # Adjust to your GPU count
    max_model_len=1048576,       # 1M context (hardware permitting)
    dtype="auto",                # or "fp8" / "bfloat16"
    quantization="gptq" if using quantized weights else None,
    gpu_memory_utilization=0.9
)

sampling_params = SamplingParams(temperature=0.7, top_p=0.95, max_tokens=4096)

outputs = llm.generate(["Explain the architecture of DeepSeek V4 in detail."], sampling_params)
for output in outputs:
    print(output.outputs[0].text)

Pour le mode serveur (API compatible OpenAI) :

Bash
vllm serve deepseek-ai/DeepSeek-V4-Flash \
  --tensor-parallel-size 2 \
  --max-model-len 1048576 \
  --port 8000

Puis interrogez via le client OpenAI en définissant base_url="http://localhost:8000/v1".

SGLang comme alternative pour potentiellement de meilleures performances long‑contexte :

Bash
pip install "sglang[all]>=0.4.0"
python -m sglang.launch_server --model-path deepseek-ai/DeepSeek-V4-Flash --port 30000

Étape 3 : Interroger l’endpoint local depuis Python

from openai import OpenAI
# Adjust the base URL if your vLLM server is bound differently.

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

response = client.chat.completions.create(
model="deepseek-ai/DeepSeek-V4-Flash",
messages=[
{"role": "system", "content": "You are a precise, technical assistant."},
{"role": "user", "content": "Explain the difference between V4-Pro and V4-Flash."},
],
temperature=1.0,
top_p=1.0,
)

print(response.choices[0].message.content)

Attentes de performance et conseils d’optimisation

• Tokens/sec : Sur RTX 4090 avec Q4 Flash : 15–40+ t/s à 8K–32K de contexte (varie selon l’implémentation). Chute à 128K+ à cause de l’attention/cache KV, mais les optimisations de V4 aident. Le multi‑GPU scale bien via le parallélisme tensoriel/pipeline.
• Optimisations :
• Utiliser FlashAttention‑3 ou PagedAttention de vLLM.
• Décodage spéculatif pour un gain de 1,5–2×.
• Techniques d’élagage ou de compression de contexte.
• Surveiller avec nvidia-smi ; utiliser gpu_memory_utilization.
• Pour CPU : llama.cpp avec --n-gpu-layers -1 (tout déporter si possible) ou CPU pur avec beaucoup de RAM.

Évaluez votre configuration avec des outils comme llama-bench ou de simples scripts de timing. Le débit réel dépend de la longueur du prompt, de la longueur de génération et du matériel.

Défis et limites d’un déploiement V4 local

• Intensité en ressources : Même Flash requiert un matériel décent pour des vitesses confortables à long contexte.
• Compromis de quantification : Des bits plus bas peuvent réduire la qualité de raisonnement, surtout sur des tâches complexes — validez avec des benchmarks comme SWE‑Bench, MMLU, ou vos évaluations métier.
• Maturité logicielle : En tant que nouvelle préversion (avril 2026), le support pleinement optimisé dans tous les backends est en cours de déploiement. Consultez les issues GitHub de vLLM, llama.cpp et HF.
• Téléchargement/stockage : Des modèles de l’ordre du téraoctet nécessitent un internet et un stockage rapides.
• Énergie & chaleur : Les configurations haut de gamme consomment beaucoup d’électricité.

Pour beaucoup d’utilisateurs, des approches hybrides fonctionnent le mieux : exécuter les petites tâches en local, déporter au cloud le raisonnement 1M‑contexte lorsque nécessaire.

Quand le local ne suffit pas : intégration transparente avec CometAPI

Pour de nombreuses équipes, la meilleure décision est de ne pas forcer un déploiement local. Si le local excelle en confidentialité et contrôle, passer à l’échelle production, gérer les pics de charge, ou accéder à la performance non quantifiée sans investissement matériel massif favorise souvent une API fiable.

CometAPI fournit une passerelle unifiée, compatible OpenAI, vers les modèles DeepSeek — y compris la dernière série Deeppseek V4 — ainsi que des dizaines d’autres LLMs (Claude, GPT, Llama, Qwen, Grok, etc.).

Là où l’API dépasse le déploiement local

Les modèles Deepseek V4 actuels sont disponibles via des endpoints de style OpenAI et Anthropic, avec des base URLs stables tandis que le nom du modèle change. La documentation précise aussi que les noms de modèles deepseek-chat et deepseek-reasoner seront finalement dépréciés et mappés au comportement V4‑Flash pendant la transition.

C’est important car le déploiement local a un coût opérationnel. Si la charge n’est pas sensible à la résidence des données ou si votre équipe souhaite un time‑to‑value plus rapide, la voie API est généralement le choix rationnel. V4‑Flash à 0.14 $ par 1M de tokens en entrée en cache miss, 0.0028 $ par 1M en entrée en cache hit, et 0.28 $ par 1M de tokens en sortie. La même page indique que V4‑Pro est actuellement remisé de 75% jusqu’au 31 mai 2026, à 0.435 $ par 1M de tokens en entrée en cache miss et 0.87 $ par 1M de tokens en sortie.

La meilleure alternative à Deepseek : où CometAPI s’insère

CometAPI est utile quand l’objectif n’est pas seulement d’appeler DeepSeek V4 une fois, mais de construire une pile capable de changer de modèle rapidement. CometAPI affirme fournir une clé API pour 500+ modèles, une API compatible OpenAI, des analytics d’usage, et une tarification inférieure à celle des fournisseurs officiels. Il se positionne aussi comme un moyen d’éviter l’enfermement propriétaire et de gérer les dépenses entre plusieurs prestataires.

Cela fait de CometAPI une recommandation solide pour les équipes qui évaluent V4‑Pro face à V4‑Flash, ou comparent DeepSeek à d’autres modèles de pointe dans la même application. Plutôt que de recâbler une nouvelle intégration à chaque changement de modèle, l’application peut conserver un client de style OpenAI stable et ne changer que la valeur model et la base URL. Le guide V4 de CometAPI montre exactement ce schéma.

Démarrage rapide avec CometAPI pour DeepSeek V4 :

• Utilisez le SDK OpenAI :
• Inscrivez‑vous/connectez‑vous sur CometAPI.com.
• Générez une clé API dans la console.

Voici la version hébergée du même pattern d’intégration :

from openai import OpenAIclient = OpenAI(    base_url="https://api.cometapi.com",    api_key="YOUR_COMETAPI_KEY",)response = client.chat.completions.create(    model="deepseek-v4-pro",    messages=[        {"role": "system", "content": "You are a senior coding assistant."},        {"role": "user", "content": "Review this architecture for bottlenecks."}    ],    stream=False,    extra_body={        "thinking": {"type": "enabled"},        "reasoning_effort": "high"    })print(response.choices[0].message.content)

La valeur de cette approche est opérationnelle, pas rhétorique. Elle supprime le travail d’infrastructure, garde le code client portable et donne à l’équipe un point central pour tester coût, latence et qualité sur plusieurs modèles. CometAPI indique aussi suivre les dépenses, la latence et le volume d’appels, ce qui est utile une fois le prototype basculé en production.

Quand choisir le local, l’API ou CometAPI

La voie locale se justifie lorsque le contrôle compte plus que la commodité. La voie API se justifie lorsque la vitesse et la simplicité comptent plus que la propriété. CometAPI est la couche intermédiaire lorsque l’équipe veut la portabilité et le contrôle des coûts sans reconstruire l’intégration à chaque changement de modèle.

FAQ

DeepSeek V4 peut‑il tourner sur un laptop ?

Pas dans le sens pratique sous‑entendu par les tutoriels d’inférence locale. Les documents officiels pointent vers un déploiement multi‑GPU et multi‑nœuds, et la taille des modèles dépasse de loin les budgets mémoire des machines grand public. Un laptop convient pour l’accès API, mais pas pour un auto‑hébergement significatif de V4‑Pro ou même pour un V4‑Flash confortable.

Quel est le meilleur : V4‑Pro ou V4‑Flash ?

V4‑Pro est le plus robuste pour le raisonnement, le code et la recherche. V4‑Flash est le meilleur défaut pour la vitesse, le débit et le coût réduit. La version officielle et le tableau de benchmarks conduisent à la même conclusion.

CometAPI est‑il requis pour le déploiement local ?

Non. C’est une couche de production optionnelle. L’API de DeepSeek fonctionne directement, et l’auto‑hébergement local est possible via la voie d’inférence officielle. CometAPI devient attrayant lorsque vous voulez un chemin de code unique sur de nombreux fournisseurs, un suivi des coûts, et un basculement plus facile entre familles de modèles.

Conclusion

DeepSeek V4 n’est pas une sortie de modèle comme les autres. C’est un système long‑contexte, orienté agents, avec des poids ouverts, un accès API officiel, et une division claire entre un modèle de raisonnement haut de gamme et un modèle à débit plus économique. La dernière actualité officielle change l’arbre de décision : le déploiement local est possible, mais seulement pour des équipes avec une infrastructure GPU sérieuse ; l’accès API est disponible immédiatement ; et CometAPI est une recommandation sensée lorsque la portabilité et la discipline de coûts importent plus que la possession de la pile d’inférence.

Si la charge est complexe et que le matériel existe, commencez par V4‑Pro. Si la charge est axée sur le volume, commencez par V4‑Flash. Si l’objectif est d’expédier rapidement et de garder des options de modèle ouvertes, utilisez la couche API et gardez votre code portable. C’est la stratégie de production la plus défendable à l’heure actuelle.

Prochaines étapes concrètes :

1. Évaluez votre matériel et commencez par V4‑Flash quantifié via Ollama ou LM Studio.
2. Expérimentez avec les exemples de code ci‑dessus et benchmarkez sur vos charges.
3. Explorez les quantifications GGUF et les optimisations communautaires au fil de leur maturation post‑release.
4. Pour la production ou les travaux lourds, intégrez CometAPI pour un accès fiable et économique à V4‑Pro/Flash complet sans gestion de matériel.