#Pourquoi configurer DeepSeek avec Ollama

Ollama gère à votre place le téléchargement des poids, la répartition GPU/CPU et l'API locale. Vous obtenez un serveur qui écoute sur http://localhost:11434 et une commande unique pour lancer n'importe quelle variante de DeepSeek. Le reste — température, taille de contexte, mémoire — se pilote via quelques paramètres qu'il vaut mieux comprendre que subir.

Une bonne configuration change tout : un DeepSeek R1 lancé avec la mauvaise température part en boucle ou tronque son raisonnement ; un DeepSeek Coder avec un contexte trop court oublie la moitié de votre fichier. Le but de ce guide est de fixer ces réglages une fois pour toutes.

#DeepSeek Coder vs Chat vs R1 : lequel installer

Trois familles cohabitent sous le nom DeepSeek dans la bibliothèque Ollama. Elles ne se configurent pas de la même façon parce qu'elles ne servent pas au même usage.

deepseek-coder: Spécialisé code : complétion, génération de fonctions, refactoring. Disponible en petites tailles (1.3B, 6.7B, 33B). Idéal branché sur un éditeur pour de l'autocomplétion locale.
deepseek-v3 / deepseek-llm (Chat): Modèle généraliste conversationnel. Réponses directes, sans chaîne de pensée exposée. Pour un assistant polyvalent en français comme en anglais.
deepseek-r1: Modèle de raisonnement : il déroule une chaîne de pensée (balises <think>) avant de répondre. Excellent en maths, logique et problèmes multi-étapes. Versions distillées 1.5B / 7B / 8B / 14B / 32B / 70B pour tenir en local.

R1 : ce sont des distillations

Les tailles 7B à 70B de deepseek-r1 sur Ollama sont des distillations basées sur Qwen et Llama, pas le modèle complet de 671B. C'est ce qui les rend exécutables sur une carte grand public — avec une part du talent de raisonnement du grand frère.

Règle simple : du code au fil de la frappe → Coder ; un assistant qui discute → Chat/V3 ; un problème qui demande de réfléchir → R1. Rien n'empêche d'installer les trois, Ollama les stocke côte à côte.

#Prérequis et VRAM par taille

Ollama doit être installé et son service actif. La quantification par défaut des modèles DeepSeek sur Ollama est Q4_K_M, le meilleur compromis qualité/mémoire pour la plupart des cartes. Voici la VRAM à prévoir en Q4, poids seuls — comptez 1 à 2 Go de plus pour le contexte.

1.5B – 3B (R1 distillé): ≈ 2 Go · tourne même sans GPU dédié, ou sur une RTX 3060 12 Go les doigts dans le nez.
7B – 8B: ≈ 5 Go · RTX 3060 12 Go, RTX 4070 12 Go. Le point d'équilibre pour un usage quotidien.
14B: ≈ 9 Go · RTX 4070 12 Go serré, RTX 4080 16 Go confortable.
32B / 33B (Coder): ≈ 19 Go · RTX 4090 24 Go, ou Mac à mémoire unifiée 24-48 Go.
70B: ≈ 40 Go · deux GPU 24 Go, ou un Mac M4 Pro 48 Go et plus.

→

Vérifier avant de télécharger

Lancez `ollama ps` après un premier essai : la colonne PROCESSOR indique 100% GPU si le modèle tient entièrement en VRAM, ou un partage GPU/CPU s'il déborde. Un partage = ralentissement net ; descendez alors d'une taille ou d'une quantification.

#Installer et lancer DeepSeek

01
Vérifier qu'Ollama tourne
Le service doit être démarré. `ollama --version` confirme l'installation ; le serveur écoute sur le port 11434.
02
Télécharger le modèle
Choisissez la variante et la taille avec `ollama pull`. Le tag après le : fixe la taille (ex. :7b, :14b, :32b). Sans tag, Ollama prend la taille par défaut.
03
Lancer une session
`ollama run` télécharge le modèle si besoin puis ouvre une invite interactive. Tapez /bye pour quitter.
04
Tester l'API
Le même modèle est aussitôt disponible sur l'API REST locale, prête à être branchée sur Open WebUI, un éditeur ou vos scripts.

Terminal — télécharger et lancer

# Modèle de raisonnement, distillation 7B
ollama pull deepseek-r1:7b

# Modèle de code, 6.7B
ollama pull deepseek-coder:6.7b

# Lancer une session interactive
ollama run deepseek-r1:7b

# Voir ce qui est chargé et où (GPU/CPU)
ollama ps

Terminal — appel API REST

curl http://localhost:11434/api/generate -d '{
  "model": "deepseek-r1:7b",
  "prompt": "Explique la récursivité en une phrase.",
  "stream": false
}'

#Régler température et fenêtre de contexte

Les deux paramètres qui pèsent le plus sur la qualité sont la température (créativité vs déterminisme) et num_ctx (taille de la fenêtre de contexte). Les valeurs par défaut d'Ollama ne sont pas toujours idéales, surtout pour R1.

temperature (R1): 0.5 à 0.7. DeepSeek recommande ~0.6 pour R1 : trop bas, le raisonnement se fige ; trop haut, il divague. Évitez 0 sur un modèle de raisonnement.
temperature (Coder): 0.1 à 0.3. Pour du code, on veut du déterministe et reproductible, pas de la créativité.
num_ctx: Taille du contexte en tokens. Par défaut souvent 4096. Montez à 8192 ou 16384 pour de longs fichiers ou de longues chaînes de raisonnement — au prix de plus de VRAM.
top_p: 0.95 environ. À laisser tel quel dans la plupart des cas ; ajustez la température d'abord.
repeat_penalty: 1.1 par défaut. Utile si R1 se répète en boucle dans sa chaîne de pensée.

Session interactive — régler à la volée

ollama run deepseek-r1:7b
>>> /set parameter temperature 0.6
>>> /set parameter num_ctx 8192
>>> Résous : un train part à 60 km/h...
>>> /bye

API — paramètres par requête

{
  "model": "deepseek-coder:6.7b",
  "prompt": "Écris une fonction Python de tri fusion.",
  "options": {
    "temperature": 0.2,
    "num_ctx": 8192,
    "top_p": 0.95
  },
  "stream": false
}

num_ctx coûte de la mémoire

Doubler la fenêtre de contexte augmente sensiblement la VRAM occupée par le cache KV. Sur une carte juste dimensionnée, passer de 4096 à 16384 peut faire basculer une partie du modèle sur le CPU. Montez le contexte seulement si vous en avez l'usage réel.

#Figer sa configuration avec un Modelfile

Régler les paramètres à chaque session est fastidieux. Un Modelfile crée une variante nommée qui embarque vos réglages et un system prompt. Vous obtenez un modèle prêt à l'emploi, invoqué comme n'importe quel autre.

Modelfile — deepseek-coder-fr

FROM deepseek-coder:6.7b

PARAMETER temperature 0.2
PARAMETER num_ctx 8192
PARAMETER top_p 0.95

SYSTEM """Tu es un assistant de programmation.
Réponds en français, commente le code, et privilégie la clarté."""

Terminal — créer et utiliser la variante

# Créer le modèle à partir du fichier
ollama create deepseek-coder-fr -f ./Modelfile

# L'utiliser comme n'importe quel modèle
ollama run deepseek-coder-fr

La même approche vaut pour R1 : un Modelfile avec temperature 0.6 et num_ctx 16384 vous donne un modèle de raisonnement calibré, sans avoir à y penser à chaque lancement.

#Optimiser la VRAM et la mémoire

Si un modèle déborde de la VRAM, Ollama place les couches excédentaires sur le CPU — et les tokens/seconde s'effondrent. Trois leviers pour rester full-GPU.

Descendre la quantification: Q4_K_M par défaut. Restez-y : c'est déjà le bon compromis. Ne montez en Q5_K_M ou Q8_0 que si la VRAM le permet et que vous cherchez un cran de qualité.
Choisir la bonne taille: Un 14B full-GPU bat un 32B qui déborde sur le CPU, en vitesse comme en confort d'usage. Visez la plus grosse taille qui tient entièrement en VRAM.
Maîtriser num_ctx: Le cache KV grossit avec le contexte. Un contexte raisonnable (8192) libère de la place pour les poids du modèle.
Décharger après usage: OLLAMA_KEEP_ALIVE règle combien de temps un modèle reste en mémoire après la dernière requête. Baissez-le pour libérer le GPU plus vite entre deux modèles.

Terminal — libérer le GPU rapidement

# Garder les modèles chargés 2 minutes seulement (défaut : 5 min)
export OLLAMA_KEEP_ALIVE=2m

# Décharger immédiatement un modèle précis
ollama stop deepseek-r1:7b

#Exécution en parallèle et concurrence

Ollama peut servir plusieurs requêtes simultanément et garder plusieurs modèles chargés à la fois. Utile pour un assistant partagé, ou pour faire tourner Coder et R1 en même temps. Deux variables d'environnement pilotent ce comportement.

OLLAMA_NUM_PARALLEL: Nombre de requêtes traitées en parallèle par un même modèle. Chaque requête consomme sa propre part de contexte, donc de la VRAM. Montez prudemment (2, 4) selon la carte.
OLLAMA_MAX_LOADED_MODELS: Nombre de modèles distincts gardés en mémoire simultanément. Passez à 2 pour garder Coder et R1 chauds en même temps, si la VRAM suit.

Terminal — démarrer avec concurrence

# Servir 4 requêtes en parallèle, 2 modèles chargés
export OLLAMA_NUM_PARALLEL=4
export OLLAMA_MAX_LOADED_MODELS=2

# Redémarrer le service pour prendre en compte les variables
ollama serve

Le parallélisme se paie en VRAM

Chaque requête parallèle et chaque modèle chargé occupe sa propre mémoire. Sur une carte juste dimensionnée, augmenter ces valeurs pousse vite vers le CPU. Mesurez avec `ollama ps` après avoir monté les curseurs, et redescendez si le PROCESSOR n'affiche plus 100% GPU.

#Dépannage courant

R1 tourne en boucle dans <think>: Température trop basse ou repeat_penalty absent. Remontez temperature à 0.6 et ajoutez repeat_penalty 1.1.
Génération très lente: Le modèle déborde sur le CPU. Vérifiez `ollama ps` : si PROCESSOR n'est pas 100% GPU, réduisez la taille, la quantification ou num_ctx.
Réponse tronquée: num_predict (nombre max de tokens générés) trop bas, ou contexte saturé. Augmentez num_ctx et laissez num_predict libre (-1).
Le code sort avec les balises de raisonnement: Vous utilisez R1 pour du code. Basculez sur deepseek-coder, qui ne produit pas de chaîne de pensée.

#Pour aller plus loin

DeepSeek configuré et calibré, voici les prolongements naturels : approfondir R1, affiner vos variantes et arbitrer la quantification selon votre carte.

Installer DeepSeek R1 avec Ollama: Le guide dédié au modèle de raisonnement, versions distillées et chaîne de pensée, pour aller plus loin que la config.
Personnaliser un modèle avec Ollama Modelfile: Système de templates, system prompts et paramètres — pour industrialiser les variantes vues ici.
Choisir sa quantification (Q4, Q5, Q8, FP16): Comprendre les compromis qualité/VRAM pour faire tenir le plus gros DeepSeek possible sur votre GPU.

Ce guide vous a aidé ?

Un retour, une erreur, une précision ? Faites-nous signe, ça améliore le guide pour tout le monde.

Suite logique

Installation · 8 min