Comment déployer deepseek-v3.1 localement via ollama : Le guide Eastest

DeepSeek-V3.1 est un modèle de langage MoE hybride « pensant/non-pensant » (671 B au total, environ 37 B activés par jeton) qui peut être exécuté localement si vous utilisez le fournisseur, la quantification et les outils appropriés. Ci-dessous, j'explique ce qu'est DeepSeek-V3.1, les prérequis matériels et logiciels, des tutoriels d'exécution locale étape par étape (exemples Ollama + llama.cpp) et comment procéder. déployer et utiliser le mode de réflexion (les <think>/</think> modèle de chat) avec des exemples de code que vous pouvez copier/coller.

Qu'est-ce que DeepSeek-V3.1 ?

DeepSeek-V3.1 est la version 3.1 de la famille MoE (Mixture-of-Experts) de DeepSeek. Conçu comme un modèle d'inférence hybride prenant en charge deux modèles/modes conversationnels : En pensant et Non-pensée — à partir du même point de contrôle en modifiant le modèle de chat. L'architecture du modèle s'inspire de la conception du MoE DeepSeek-V3 (671 milliards de paramètres au total ; environ 37 milliards de paramètres activés par jeton pour l'inférence) et apporte des améliorations post-formation pour l'utilisation des outils, les compétences des agents et la gestion des contextes longs.

Points saillants des fonctionnalités rapides

Hybride Pensée / Non-pensée modes (basculés par la tokenisation du modèle de chat).
Architecture MoE : grand nombre total de paramètres mais paramètres activés limités par jeton (permet l'efficacité).
Améliorations post-formation pour les appels d'outils et les flux de travail des agents (format d'appel d'outils et modèles d'agents documentés dans les ressources du modèle).

De quoi ai-je besoin pour exécuter DeepSeek-V3.1 localement ?

Exécuter le plein DeepSeek-V3.1 (points de contrôle bruts) est un outil lourd : le stockage des points de contrôle et d'entraînement et l'orchestration des inférences sont complexes. Il existe cependant des solutions pratiques :

Matériel

Inférence entièrement distribuée (recherche / cluster): plusieurs GPU haute mémoire (classe A100/H800) ou un cluster GPU avec service parallèle de modèles (typique pour les points de contrôle de 600 O+). À utiliser uniquement si vous exécutez des clusters de recherche en production.
Options locales pratiques: utiliser le paramètre activé Perspective (≈37 B activés) ou construction dynamique GGUF/1 bit quantifiée. Les quantifications communautaires (dynamique 1 bit/GGUF) réduisent considérablement les besoins en disque et RAM. Par exemple, des publications communautaires signalent la compression d'un point de contrôle de 720 Go à environ 170 Go GGUF pour une variante quantifiée. Cela rend l'inférence GPU locale sur un seul serveur réalisable pour les ordinateurs de bureau/serveurs disposant de ressources importantes.

En résumé : attendez-vous à un flux de travail de modèle volumineux (des dizaines à quelques centaines de Go de disque pour les artefacts quantifiés) ; pour la VRAM GPU, utilisez des variantes quantifiées et ciblez ≥ 24 à 48 Go de VRAM pour un débit raisonnable ; sinon, utilisez CPU+swap avec des compromis de performances.

Logiciels et outillages

Python 3.10+ (pour les outils de transformation/tokenisation et les scripts personnalisés).

transformers (pour les fonctions de tokenisation et d'assistance) — la carte modèle montre des exemples utilisant transformers.AutoTokenizer.

Un ou plusieurs runtimes d'inférence locaux :

Ollama (facile: ollama pull / ollama run Intégration ; certaines versions de DeepSeek sur Ollama nécessitent des versions préliminaires (consultez la note sur le modèle/Ollama). Ollama est devenu un exécuteur local standard pour les modèles communautaires.
lama.cpp / ggml piles ou llama-server pour les fichiers quantifiés GGUF — idéal pour l'exécution directe de GGUF.
génération de texte et inférence / Triton / Piles FlashAttention pour une inférence GPU plus performante (configurations avancées).

Disque : grand espace libre pour les fichiers modèles (dizaines → centaines de Go selon la quantification).

Artefacts du modèle (quel fichier obtenir)

Variantes officielles Safetensors / BF16 / FP8 / GGUF : Hugging Face héberge des artefacts de modèle V3.1 et de multiples quantifications. Si vous avez besoin d'un fichier GGUF/quantifié pour llama.cpp, recherchez une version de quantification communautaire (ou un script de conversion de safetensors → GGUF) — la carte modèle répertorie les variantes quantifiées.

Comment préparer le modèle pour l’inférence locale ?

Vous trouverez ci-dessous les étapes de préparation recommandées, classées de simple à avancé.

Étape 1 — Choisir un environnement d'exécution (recommandation)

Test débutant / rapide : Ollama — Configuration minimale : téléchargement, exécution du modèle, appel de l'API. Remarque : certaines versions de DeepSeek-V3.1 indiquent qu'Ollama v0.11.7 est requis pour certaines fonctionnalités.
Contrôle avancé / bas niveau : llama.cpp + Quantification GGUF (si une quantification GGUF est disponible). Cela vous permet un contrôle direct de l'inférence et une intégration avec llama-server.

Étape 2 — Télécharger le modèle

Si vous utilisez Ollama :

# install ollama (see https://ollama.com/docs)

# Pull the model (this downloads the model to your machine)
ollama pull deepseek-ai/DeepSeek-V3.1
# or a specific tag: ollama pull deepseek-ai/DeepSeek-V3.1:quant-q4_0

(Ollama run tirera automatiquement s'il n'est pas présent ; pull vous permet de contrôler le timing.)

Si vous utilisez Hugging Face + llama.cpp :

# Example: download via huggingface-cli or hf_transfer

pip install huggingface_hub
hf_hub_download(repo_id="deepseek-ai/DeepSeek-V3.1", filename="DeepSeek-V3.1.gguf")
# or use a community quant file (gguf) referenced on the Hugging Face model page

Hugging Face répertorie les artefacts, les modèles et les quantifications du modèle sur la carte du modèle.

Étape 3 — Convertir/quantifier (facultatif)

Si vous ne trouvez que des safetensors ou des artefacts BF16 mais que vous avez besoin de GGUF pour llama.cpp, utilisez les scripts de conversion dans llama.cpp (ou outils communautaires) pour convertir → quantifier. Il existe des outils communautaires pour la quantification dynamique 1 bit qui préservent la précision tout en réduisant la taille ; voir les publications communautaires qui indiquent une réduction jusqu'à environ 170 Go.

Comment exécuter DeepSeek-V3.1 localement ? (Tutoriels pratiques)

Je vais montrer Ollama (facile, recommandé) et lama.cpp (GGUF) exemples plus un court exemple Python utilisant les assistants de tokenisation de carte modèle.

A — Courir avec Ollama (démarrage rapide)

Installez Ollama (suivez les instructions officielles).
Tirez et exécutez le modèle :

# pull model to disk (optional; run will pull automatically)

ollama pull deepseek-ai/DeepSeek-V3.1

# start an interactive session (runs model and exposes local API)

ollama run deepseek-ai/DeepSeek-V3.1

Effectuez une requête HTTP au serveur Ollama local :

# curl usage example (local Ollama server usually listens on port 11434)

curl -sS -X POST 'http://localhost:11434/api/generate' \
  -H 'Content-Type: application/json' \
  -d '{
    "model":"deepseek-ai/DeepSeek-V3.1",
    "prompt":"Explain the difference between thinking and non-thinking mode in DeepSeek.",
    "max_tokens":256
  }'

Les modèles CLI et API d'Ollama sont conçus pour être simples : ollama run Si nécessaire, il extraira et lancera un serveur de modèles. Consultez la documentation et les pages de modèles d'Ollama pour des conseils sur la mémoire et les noms/étiquettes exacts des modèles.

B — Exécution d'un GGUF quantifié via llama.cpp

Se construisent llama.cpp avec CUDA (en option) ou CPU :

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
# for CUDA:

make clean && make LLAMA_CUBLAS=1
# or CPU only:

make

Placez le fichier modèle GGUF dans un chemin et exécutez :

./main -m /path/to/DeepSeek-V3.1.q4_K_M.gguf \
  -p "Explain how to enable thinking mode." \
  --temp 0.2 --n_predict 512

Pour une utilisation sur serveur, llama-server (projet communautaire) peut exposer un point de terminaison HTTP :

llama-server -m /path/to/DeepSeek-V3.1.q4_K_M.gguf
# then POST to the server like:

curl -X POST "http://localhost:8080/api/v1/generate" -d '{"prompt":"Hello","max_tokens":200}'

Utilisez les quantifications GGUF communautaires (q4/q8/1 bit dynamique) pour s'adapter aux budgets GPU/CPU ; llama.cpp le référentiel fournit des outils de conversion et des conseils.

C — Exemple Python utilisant le tokenizer + modèle de chat

La carte modèle Hugging Face fournit un tokenizer.apply_chat_template assistant et montre comment encoder une conversation avec thinking=TrueVoici un exemple Python minimal adapté de la carte modèle :

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.1")

messages = [
    {"role": "system", "content": "You are a helpful assistant"},
    {"role": "user", "content": "Who are you?"},
    {"role": "assistant", "content": "<think>Hmm</think>I am DeepSeek"},
    {"role": "user", "content": "1+1=?"}
]

# apply thinking chat template

s = tokenizer.apply_chat_template(messages, tokenize=False, thinking=True, add_generation_prompt=True)
print(s)  # the template includes the special <think> token placement

Vous pouvez ensuite alimenter l'invite tokenisée dans votre runtime d'inférence (Ollama/llama.cpp/TGI) en fonction de votre pile.

Comment fonctionne Thinking Mode et comment le déployer localement ?

DeepSeek-V3.1 utilise modèles de discussion qui contiennent un jeton de réflexion spécial (par exemple, <think> et </think>). La modèle détermine si le modèle est en mode Pensée ou Non-Pensée :

Non-pensée emplacements de modèles </think> dans le préfixe de l'assistant, qui demande au modèle de produire des réponses directes (le format d'appel d'outil est pris en charge en mode non réfléchi).
En pensant emplacements de modèles <think> dans le préfixe assistant qui permet au modèle de générer des signaux intermédiaires de type chaîne de pensée interne (le modèle est entraîné à utiliser cette séquence de jetons pour raisonner en interne et produire des réponses multi-étapes de meilleure qualité). La carte du modèle « Hugging Face » documente ces jetons précis et les tokenizer.apply_chat_template(..., thinking=True) API.

Basculement programmatique (exemples)

A — Avec le tokenizer (Python) :

# thinking=True or thinking=False changes how the prompt is formatted

prompt_thinking = tokenizer.apply_chat_template(messages, thinking=True, add_generation_prompt=True)
prompt_non_thinking = tokenizer.apply_chat_template(messages, thinking=False, add_generation_prompt=True)

Fil d'actualité prompt_thinking à votre runtime d'inférence pour obtenir le comportement de réflexion.

B — Avec l'invite brute (llama.cpp / manuel) :

insérer <think> avant que l'assistant ne se retourne lorsque vous l'invitez :

<｜begin_of_sentence｜>You are a helpful assistant<｜User｜>How to optimize this code?<｜Assistant｜><think>

(Ce cadrage de jeton exact se trouve dans la carte modèle — vous devez respecter l'espacement et les marqueurs spéciaux si vous utilisez le modèle brut.)

C — Avec Ollama (basculement de l'interface utilisateur) :
La démo web officielle de DeepSeek et les notes de version mentionnent un bouton « DeepThink » permettant de changer de mode dans l'interface utilisateur hébergée. Localement, Ollama ou votre application doit reproduire ce comportement en changeant le modèle de chat (c'est-à-dire en modifiant l'invite envoyée à l'environnement d'exécution entre les deux formulaires tokenisés). Si vous exécutez DeepSeek via Ollama, vous pouvez implémenter cela dans votre application en conservant deux modèles d'invite (réflexif et non-réfléchi) et en les basculant via l'API Ollama.

Comment déployer Thinking Mode en tant qu'agent (appels d'outils, agents de code) ?

Documents DeepSeek-V3.1 appel d'outil et agent Modèles dans les ressources du modèle. Le modèle s'attend à ce que les outils soient présentés dans un format JSON/instruction spécifique et prend en charge l'enchaînement de plusieurs appels d'outils en un seul tour si vous suivez les jetons wrapper décrits dans la fiche du modèle.

Exemple : wrapper d'appel d'outil simple (pseudo)

Le modèle spécifie un bloc descripteur d'outil et un tool_calls_begin / tool_call_begin format. Un exemple minimal (conceptuel) :

## Tools

You have access to the following tools:

### web_search

Description: Query the web
Parameters: {"q": "string"}

<｜begin_of_sentence｜>{system prompt}

## Tools

...tool descriptions...

<｜User｜>Find the population of Tokyo<｜Assistant｜></think>
<｜tool_calls_begin｜><｜tool_call_begin｜>web_search<｜tool_sep｜>{"q":"population of Tokyo 2025"}<｜tool_call_end｜><｜tool_calls_end｜>

La sortie de l'outil doit ensuite être renvoyée au modèle au tour suivant en suivant le format prescrit par le modèle (voir assets/search_tool_trajectory.html (sur la page du modèle pour le flux exact). L'implémentation des agents nécessite une orchestration programmatique : appel de l'outil → capture du résultat → réinjection du résultat dans le contexte du chat exactement comme le prescrit le modèle → appel à nouveau du modèle.

Conseils pratiques, dépannage et notes de sécurité (à quoi dois-je faire attention ?)

Les modèles de jetons sont stricts. Utilisez le modèle tokenizer.apply_chat_template ou reproduire exactement <think>/</think> Jetons comme indiqué. Un espacement incorrect ou des marqueurs manquants modifieront le comportement du modèle.
Le format de l'outil doit être un JSON valide. Le modèle analysera les arguments de l'outil au format JSON — un JSON non valide interrompra les appels d'outil.
Compromis de quantification. Les quantifications dynamiques/agressives 1 bit réduisent l'espace de stockage et la RAM, mais peuvent légèrement altérer la fidélité numérique. Testez sur vos charges de travail. Il existe des quantifications communautaires réduisant l'utilisation du disque de 80 % (exemple de rapport : 720 Go → ~170 Go), mais validez toujours avec vos invites.
Compatibilité Ollama. Certaines variantes de DeepSeek indiquent qu'Ollama v0.11.7 est requis pour les fonctionnalités de pré-version. Consultez la page du modèle Ollama et mettez-la à jour en conséquence.

Exemple de bout en bout : exécuter DeepSeek-V3.1 localement avec le mode Thinking (mini procédure pas à pas)

Installez Ollama et récupérez le modèle :

# install ollama per docs, then:

ollama pull deepseek-ai/DeepSeek-V3.1
ollama run deepseek-ai/DeepSeek-V3.1 &

Utilisez le tokenizer Python pour composer une invite de réflexion :

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V3.1")

msgs = [
  {"role":"system","content":"You are a helpful assistant."},
  {"role":"user","content":"Plan a multi-step strategy to prototype a mobile app in 2 weeks."}
]
prompt = tokenizer.apply_chat_template(msgs, thinking=True, add_generation_prompt=True)

import requests
resp = requests.post("http://localhost:11434/api/generate", json={
    "model": "deepseek-ai/DeepSeek-V3.1",
    "prompt": prompt,
    "max_tokens": 400
})
print(resp.json())

Si le modèle renvoie un appel d'outil au format toolcall, analysez le JSON et exécutez l'outil, puis injectez les résultats dans le message suivant conformément aux modèles de carte de modèle.

Comment choisir votre chemin de déploiement ?

Si vous voulez le chemin le plus rapide pour expérimenter : utilisé Ollama et les exemples de cartes du modèle Hugging Face. Ollama masque de nombreux détails d'infrastructure et fournit une API HTTP locale.
Si vous avez besoin d'un coût inférieur / d'une plus grande portabilité : utiliser une communauté GGUF quantifié artefact et courir avec llama.cpp or llama-serverLa quantification permet d'économiser du disque et de la mémoire, mais teste la précision de votre charge de travail.
Si vous créez des agents ou des outils : suivez les cartes modèles appel d'outil et agent modèles exactement ; orchestrer les sorties des outils dans le contexte du modèle.

Pour commencer

CometAPI est une plateforme d'API unifiée qui regroupe plus de 500 modèles d'IA provenant de fournisseurs leaders, tels que la série GPT d'OpenAI, Gemini de Google, Claude d'Anthropic, Midjourney, Suno, etc., au sein d'une interface unique et conviviale pour les développeurs. En offrant une authentification, un formatage des requêtes et une gestion des réponses cohérents, CometAPI simplifie considérablement l'intégration des fonctionnalités d'IA dans vos applications. Que vous développiez des chatbots, des générateurs d'images, des compositeurs de musique ou des pipelines d'analyse pilotés par les données, CometAPI vous permet d'itérer plus rapidement, de maîtriser les coûts et de rester indépendant des fournisseurs, tout en exploitant les dernières avancées de l'écosystème de l'IA.

Les développeurs peuvent accéder Recherche profonde V3.1 Grâce à CometAPI, les dernières versions des modèles répertoriées correspondent à la date de publication de l'article. Pour commencer, explorez les fonctionnalités du modèle dans la section cour de récréation et consultez le Guide de l'API Pour des instructions détaillées, veuillez vous connecter à CometAPI et obtenir la clé API avant d'y accéder. API Comet proposer un prix bien inférieur au prix officiel pour vous aider à vous intégrer.

Conclusion

DeepSeek-V3.1 propose une philosophie d'inférence hybride pratique (un point de contrôle + un comportement de pensée basé sur des modèles) qui simplifie l'expérimentation du raisonnement par chaîne de pensée et l'utilisation d'outils d'agent, à condition de respecter les modèles de chat et les exigences des outils. Utilisez d'abord la carte de modèle « Hugging Face » et les notes de version de DeepSeek, puis choisissez un environnement d'exécution local (Ollama pour plus de simplicité). llama.cpp pour le contrôle) et tester des builds quantifiés pour des déploiements locaux pratiques.