Déployer DeepSeek-R1 en local avec Ollama

Brancher une API dans le nuage est pratique, mais il y a des situations où l’on veut tout garder en local : des documents internes confidentiels qu’on ne veut envoyer à personne, une connexion qui flanche, ou simplement l’envie de ne plus payer au jeton. Dans ce guide, vous allez faire tourner un modèle DeepSeek-R1 directement sur votre machine grâce à Ollama, puis l’interroger depuis le terminal et depuis Python. À la fin, vous aurez un assistant de documentation qui répond à vos questions sans jamais sortir de votre ordinateur.

🎯 Ce que vous allez apprendre

• Installer Ollama et comprendre ce qu’il fait réellement.
• Télécharger et lancer un modèle DeepSeek-R1 en une commande.
• Choisir la taille de modèle adaptée à votre matériel.
• Interroger le modèle via son API REST locale, en ligne de commande et en Python.
• Fixer le rôle de l’assistant avec un fichier de configuration dédié.
• Séparer la chaîne de raisonnement de la réponse finale.

🛠️ Ce que vous allez construire

Un assistant de documentation hors-ligne : un petit script doc_locale.py qui prend une question, y ajoute un extrait de votre documentation interne en contexte, et renvoie une réponse générée entièrement en local. Aucune clé, aucun crédit, aucune donnée qui quitte la machine — exactement ce qu’il faut quand la confidentialité prime.

Prérequis

• Un ordinateur sous Linux, macOS ou Windows avec au moins 8 Go de mémoire vive libre pour la version conseillée.
• Quelques gigaoctets d’espace disque (un modèle pèse de 1 à plus de 40 Go selon la taille).
• Être à l’aise avec le terminal. Test express : si vous savez lancer une commande et lire sa sortie, vous êtes prêt.
• ⏱️ Temps estimé : environ 30 minutes, hors temps de téléchargement.

Étape 1 — Installer Ollama

Ollama est un petit serveur local qui télécharge des modèles, les charge en mémoire et les expose derrière une API. Pensez-le comme un « moteur d’exécution » pour modèles de langage : vous lui demandez un modèle par son nom, il s’occupe du reste. L’installation tient en une ligne sous Linux ou macOS.

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

Sous Windows, téléchargez plutôt l’installateur depuis le site officiel et lancez-le. Une fois installé, vérifiez que le service répond :

ollama --version

Si la commande affiche un numéro de version, le serveur Ollama tourne en arrière-plan et écoute par défaut sur le port 11434. C’est ce service qui rendra le modèle accessible aux étapes suivantes.

Étape 2 — Lancer DeepSeek-R1 en une commande

La force d’Ollama, c’est qu’une seule commande télécharge le modèle s’il est absent, le charge, et ouvre une session de discussion. DeepSeek-R1 est un modèle spécialisé dans le raisonnement : il réfléchit visiblement avant de répondre, ce qui le rend excellent pour les questions techniques.

ollama run deepseek-r1

Sans précision de taille, Ollama télécharge la version par défaut, soit deepseek-r1:8b (environ 5,2 Go, une distillation issue de la révision R1-0528 du modèle). Le premier lancement prend le temps du téléchargement ; les suivants sont instantanés. Quand l’invite >>> apparaît, posez une question. Vous verrez le modèle dérouler son raisonnement entre des balises, puis livrer sa réponse. Tapez /bye pour quitter.

✅ Point d’étape — Le modèle répond dans le terminal et tout se passe hors ligne. Pour le confirmer : coupez votre connexion réseau et reposez une question — la réponse arrive quand même, car le modèle est déjà sur votre disque.

Étape 3 — Choisir la bonne taille

DeepSeek-R1 existe en plusieurs tailles distillées, du minuscule 1,5 milliard de paramètres au gigantesque modèle complet. Plus le modèle est gros, plus il est pertinent — mais plus il exige de mémoire. Le tableau ci-dessous donne des repères pour viser juste sans saturer votre machine.

Pour télécharger une taille précise sans la lancer immédiatement, utilisez pull :

ollama pull deepseek-r1:14b

Les versions de 1,5 à 32 milliards de paramètres sont des distillations bâties sur la famille Qwen, tandis que la version 70 milliards repose sur Llama 3.3 ; la version 8b par défaut s’appuie sur la révision R1-0528. Une distillation est un modèle plus petit entraîné à imiter le raisonnement du grand modèle d’origine : elle conserve une bonne part de la qualité pour une fraction des ressources. Si votre machine peine, descendez d’un cran ; si les réponses manquent de finesse, montez.

Étape 4 — Interroger l’API REST locale

Ollama n’est pas qu’une invite interactive : il expose une API HTTP sur localhost:11434, ce qui permet de l’appeler depuis n’importe quel programme. L’endpoint natif /api/chat attend une liste de messages, comme les grandes API du marché.

curl http://localhost:11434/api/chat -d '{
  "model": "deepseek-r1:8b",
  "messages": [{"role": "user", "content": "Explique ce qu'\''est un proxy inverse."}],
  "stream": false
}'

La réponse est un objet JSON contenant le message de l’assistant. Le champ stream mis à false renvoie la réponse complète d’un coup ; à true, Ollama renvoie une suite de fragments. Cet endpoint suffit pour bricoler, mais il existe encore plus pratique pour réutiliser du code existant.

Étape 5 — Réutiliser le SDK OpenAI en pointant vers le local

Comme l’API de DeepSeek dans le nuage, Ollama propose une couche compatible OpenAI sur /v1. Conséquence appréciable : le même code Python que pour l’API distante fonctionne en local, à un détail près — l’URL de base pointe vers votre machine, et la clé est factice puisqu’aucune authentification n’est requise.

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",   # valeur ignoree, mais requise par le SDK
)

r = client.chat.completions.create(
    model="deepseek-r1:8b",
    messages=[{"role": "user", "content": "Qu'est-ce qu'un certificat TLS ?"}],
)
print(r.choices[0].message.content)

Ce point est précieux : vous pouvez développer et tester gratuitement en local, puis basculer vers l’API dans le nuage pour la production en changeant seulement base_url et le nom du modèle. Le reste du code ne bouge pas.

Étape 6 — Fixer le rôle avec un Modelfile

Pour notre assistant de documentation, on veut un comportement constant : répondre en français, s’appuyer sur le contexte fourni, et admettre quand l’information manque. Plutôt que de répéter cette consigne à chaque appel, Ollama permet de la graver dans une variante du modèle via un Modelfile, un fichier de configuration déclaratif.

# fichier nomme : Modelfile
FROM deepseek-r1:8b
PARAMETER temperature 0.3
SYSTEM "Tu es un assistant de documentation technique interne. Reponds en francais, uniquement a partir du contexte fourni. Si le contexte ne contient pas la reponse, dis-le clairement."

On construit ensuite le modèle personnalisé à partir de ce fichier :

ollama create doc-interne -f Modelfile
ollama run doc-interne

Le paramètre temperature abaissé à 0,3 rend les réponses plus déterministes et factuelles, ce qui convient à de la documentation : on ne cherche pas de créativité, on cherche de la fidélité. Désormais, doc-interne embarque sa consigne ; vous l’appelez comme n’importe quel autre modèle, sans répéter le rôle.

Étape 7 — Assembler l’assistant et isoler le raisonnement

Les modèles R1 encadrent leur réflexion entre des balises <think> et </think>, suivies de la réponse finale. Pour un assistant propre, on veut afficher la réponse sans le brouillon. On injecte aussi un extrait de documentation en contexte, ce qui transforme le modèle en assistant ancré sur vos contenus.

import re
from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

def doc_locale(question, contexte):
    invite = "Contexte:\n" + contexte + "\n\nQuestion: " + question
    r = client.chat.completions.create(
        model="doc-interne",
        messages=[{"role": "user", "content": invite}],
    )
    texte = r.choices[0].message.content
    # retirer le bloc de raisonnement pour ne garder que la reponse
    reponse = re.sub(r"<think>.*?</think>", "", texte, flags=re.DOTALL).strip()
    return reponse

doc = "Le VPN d'entreprise utilise le protocole WireGuard. Les cles sont renouvelees tous les 90 jours."
print(doc_locale("Quel protocole VPN utilisons-nous ?", doc))

L’expression régulière supprime tout ce qui se trouve entre les balises de raisonnement, y compris sur plusieurs lignes grâce à re.DOTALL. En lançant ce script hors ligne, vous obtenez une réponse fondée uniquement sur le contexte fourni — ici, que le protocole est WireGuard. C’est le principe d’un assistant ancré : il ne récite pas ses connaissances générales, il lit vos documents.

✅ Point d’étape — Votre assistant répond à partir d’un contexte et masque son raisonnement. Pour vérifier : posez une question dont la réponse n’est pas dans le contexte ; il doit répondre qu’il ne sait pas, plutôt que d’inventer.

Étape 8 — Surveiller les ressources et ajuster la qualité

Faire tourner un modèle en local, c’est arbitrer en permanence entre qualité, vitesse et mémoire. Deux leviers vous donnent la main sur cet arbitrage : la surveillance de ce qui est chargé, et le choix du niveau de quantification. Commençons par voir ce qu’Ollama fait réellement de votre matériel.

ollama ps

Cette commande liste les modèles actuellement chargés en mémoire, leur taille occupée, et surtout la répartition entre processeur et carte graphique. Si vous disposez d’un GPU compatible, Ollama y décharge automatiquement une partie des calculs : vous verrez une mention du type 100% GPU ou un partage CPU/GPU. Un modèle traité à 100 % sur le processeur répondra plusieurs fois plus lentement qu’avec un GPU — un facteur décisif quand vous dimensionnez votre poste.

Le second levier est la quantification. Un modèle « brut » stocke ses poids en haute précision, ce qui pèse lourd. Les versions quantifiées compressent ces poids : q4_K_M, la quantification par défaut de DeepSeek-R1 sur Ollama, divise la taille par rapport à la pleine précision tout en gardant l’essentiel de la qualité. Pour un peu plus de fidélité au prix de davantage de mémoire, on peut demander une quantification moins agressive.

ollama pull deepseek-r1:8b-0528-qwen3-q8_0

La variante q8_0 occupe davantage d’espace mais rend des réponses légèrement plus précises ; à l’inverse, sur une machine très contrainte, une quantification plus basse libère de la mémoire au prix d’une qualité moindre. Pour libérer la mémoire sans éteindre le service, déchargez un modèle après usage :

ollama stop deepseek-r1:8b

Enfin, un mot sur la latence du premier appel : Ollama garde un modèle chargé quelques minutes après la dernière requête, puis le décharge pour rendre la mémoire. La première question après une pause paie donc le temps de rechargement ; les suivantes sont rapides. Sur un serveur partagé, vous pouvez allonger ce délai de maintien en mémoire via la variable d’environnement OLLAMA_KEEP_ALIVE, ce qui évite des rechargements répétés au prix d’une mémoire mobilisée en continu.

✅ Point d’étape — Vous savez maintenant lire la répartition processeur/carte graphique et choisir un niveau de quantification. Pour vérifier : lancez ollama ps juste après une question ; le modèle doit apparaître chargé, puis disparaître de la liste après quelques minutes d’inactivité.

🐞 Pièges fréquents

Tirer parti du mode hors-ligne

Le déploiement local brille précisément quand le réseau fait défaut ou coûte cher. Une fois le modèle téléchargé, plus aucun octet ne transite : vous pouvez travailler dans un train, sur un site isolé ou derrière un pare-feu strict. Pour un poste modeste, la version 8b offre le meilleur compromis ; gardez la 1,5b sous le coude comme solution de secours sur une machine vraiment limitée. Et comme tout reste local, vous pouvez soumettre au modèle des documents internes que vous n’enverriez jamais vers un service tiers — un argument décisif pour la confidentialité.

✅ Récapitulatif

Vous avez installé Ollama, lancé DeepSeek-R1 en une commande, appris à dimensionner le modèle selon votre matériel, et vous l’interrogez aussi bien au clavier que depuis Python via la couche compatible OpenAI. Vous avez gravé un rôle dans un Modelfile et construit un assistant de documentation qui masque son raisonnement et s’appuie sur vos contenus. Le tout fonctionne sans clé, sans crédit et sans connexion.

🧾 Aide-mémoire

💪 À vous de jouer

Modifiez doc_locale() pour qu’il charge le contexte depuis un fichier texte au lieu d’une chaîne codée en dur, puis testez-le avec un vrai document. Bonus : faites-lui ingérer plusieurs fichiers et concaténer leur contenu avant la question.

from pathlib import Path

def charger_docs(dossier):
    morceaux = []
    for f in Path(dossier).glob("*.txt"):
        morceaux.append(f.read_text(encoding="utf-8"))
    return "\n\n".join(morceaux)

contexte = charger_docs("./documentation")
print(doc_locale("Quelle est la politique de mot de passe ?", contexte))

Dans la même série

• Premiers pas avec l’API DeepSeek en Python — la version dans le nuage, avec streaming et gestion du coût.
• Servir un modèle DeepSeek en production avec vLLM — passer du poste local à un serveur d’inférence performant.

Pour approfondir

• 🔝 Revenir au guide principal : DeepSeek : modèles, API et déploiement local
• Page officielle du modèle : ollama.com/library/deepseek-r1

FAQ

Ollama est-il gratuit ?
Oui, Ollama est un logiciel libre et les modèles DeepSeek-R1 distillés sont publiés sous licences ouvertes. Vous ne payez que l’électricité et le matériel.

Quelle taille choisir avec 8 Go de mémoire ?
La version deepseek-r1:8b est le bon point de départ. Si la machine peine, descendez à 1.5b.

Mes données sont-elles envoyées quelque part ?
Non. Une fois le modèle téléchargé, toutes les requêtes restent sur votre machine. C’est l’intérêt majeur du déploiement local.

Puis-je utiliser le même code qu’avec l’API distante ?
Oui, grâce à l’endpoint compatible OpenAI sur localhost:11434/v1. Seules l’URL de base et la valeur du modèle changent.