Aller au contenu principal

Exécuter des modèles d'IA en local avec Ollama

Intermédiaire

Les modèles de pointe vivent dans le cloud, mais toute une catégorie de modèles à poids ouverts — Llama, Mistral, Qwen, DeepSeek, Gemma — peut être téléchargée et exécutée sur votre propre ordinateur portable ou serveur. Ollama est le moyen le plus simple d'y parvenir : une installation, une commande, et un modèle tourne en local. Cette page vous fait passer de zéro à un modèle en fonctionnement, appelé depuis du code, tout en connaissant les compromis pour ne pas attendre d'un modèle local de 7B qu'il se comporte comme un modèle de pointe.

What you'll learn
  • Savoir POURQUOI exécuter un modèle en local — et les compromis honnêtes face aux modèles de pointe du cloud
  • Installer Ollama et exécuter votre premier modèle en deux commandes
  • Utiliser la CLI de base : pull, run, list, ps, rm, stop
  • Appeler votre modèle local depuis du code via l'API compatible OpenAI d'Ollama
  • Comprendre les besoins en RAM, les tailles de modèles et la quantification — pour choisir un modèle que votre machine peut réellement exécuter
  • Savoir quand LM Studio (une interface graphique) est le meilleur point de départ

Pourquoi exécuter un modèle en local (et quand ne pas le faire)​

Exécuter un modèle sur votre propre matériel vous apporte quatre choses :

  • Confidentialité — vos prompts et vos données ne quittent jamais votre machine. C'est la raison pour laquelle les équipes de domaines réglementés ou sensibles se tournent vers les modèles locaux. (Voir la bifurcation confidentialité/auto-hébergement dans Choisir un modèle.)
  • Hors ligne — pas d'internet, pas d'API, pas de dépendance aux pannes. Le modèle est un fichier sur votre disque.
  • Coût — pas de facture au token. Une fois téléchargé, l'exécuter est « gratuit » (vous payez en électricité et en matériel, pas en dépenses d'API). Si la dépense en tokens est votre contrainte à grande échelle, le local peut l'emporter.
  • Contrôle — figer une version exacte, personnaliser le comportement et intégrer sans limites de débit ni surprises de conditions d'utilisation.

Les compromis honnêtes :

  • Écart de capacité. Un modèle que vous pouvez exécuter sur un ordinateur portable (1B–14B paramètres) n'est pas dans la même catégorie qu'un modèle de pointe du cloud sur le raisonnement difficile, le contexte long ou les tâches agentiques. Pour beaucoup de tâches quotidiennes l'écart est faible ; pour les plus difficiles, il est grand.
  • Matériel. Les modèles plus gros et plus performants ont besoin de plus de RAM/VRAM que n'en possède une machine typique. Vous choisissez souvent le plus grand modèle que votre matériel peut exécuter, et non le meilleur modèle qui existe.
  • Vous l'exploitez. Pas de mise à l'échelle gérée, pas de mises à niveau automatiques — c'est le prix du contrôle.

Un schéma courant et durable : prototyper et choisir avec une petite évaluation (même méthode que pour les modèles du cloud — voir Choisir un modèle), utiliser le local pour le travail privé/hors ligne/peu coûteux à grande échelle, et se tourner vers une API de pointe quand la tâche a réellement besoin de la capacité supplémentaire.

Installer Ollama et exécuter votre premier modèle​

Guided walkthrough1 of 4
  1. macOS et Windows : téléchargez l'installeur depuis ollama.com/download et lancez-le. Linux : utilisez le script d'installation officiel (ci-dessous). Cela installe la commande ollama et un service local en arrière-plan.

Installation Linux (macOS/Windows utilisent plutôt l'installeur téléchargé) :

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

Récupérer et exécuter un petit modèle (bon premier choix)

ollama run llama3.2

Cette seule commande télécharge à la fois llama3.2 (un petit modèle de classe 1B/3B qui tourne sur du matériel modeste) et démarre un chat interactif. Pour télécharger sans encore discuter, utilisez plutôt ollama pull.

La CLI de base​

Une poignée de commandes couvre presque tout. Lancez ollama --help pour la liste complète.

# Download a model without starting a chat
ollama pull qwen3

# Start an interactive chat (downloads first if needed)
ollama run qwen3

# One-shot: pass the prompt inline, get the answer, exit
ollama run qwen3 "Summarize the CAP theorem in two sentences."

# List models you've downloaded
ollama list

# Show models currently loaded in memory
ollama ps

# Stop a running/loaded model (frees memory)
ollama stop qwen3

# Delete a downloaded model to reclaim disk
ollama rm qwen3

Dans une session interactive ollama run, tapez /bye pour quitter et /? pour voir les commandes de session. Le service en arrière-plan qui sert réellement les modèles est démarré par ollama serve (l'application de bureau le démarre automatiquement pour vous).

L'appeler depuis du code (API compatible OpenAI)​

C'est la partie qui rend les modèles locaux vraiment utiles dans les applications. Le service Ollama en arrière-plan expose une API HTTP locale à l'adresse http://localhost:11434, sur le port par défaut 11434. Il a ses propres endpoints natifs (/api/generate, /api/chat) et une couche compatible OpenAI à /v1 — de sorte que la plupart du code écrit pour le SDK OpenAI fonctionne avec votre modèle local en changeant deux lignes.

HTTP brut avec curl (endpoint natif) :

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    { "role": "user", "content": "Why is the sky blue?" }
  ],
  "stream": false
}'

Depuis Python en utilisant le SDK OpenAI officiel — il suffit de pointer base_url vers Ollama et de passer n'importe quelle api_key non vide (Ollama exige le champ mais en ignore la valeur) :

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # required by the SDK, ignored by Ollama
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain gradient descent in two sentences."},
    ],
)

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

Comme c'est compatible OpenAI, les mêmes schémas que vous utiliseriez avec une API hébergée s'appliquent — y compris le streaming et l'utilisation d'outils / appel de fonctions, qui fonctionnent en local de la même manière que dans le cloud (à condition que le modèle soit réellement bon à cela). La couche /v1 d'Ollama couvre /v1/chat/completions, /v1/completions, /v1/models et /v1/embeddings, entre autres.

Matériel, tailles de modèles et quantification​

Le nombre que vous verrez attaché à un modèle — 1B, 7B, 8B, 70B — est son nombre de paramètres (en milliards). Plus de paramètres signifie généralement plus performant et plus gourmand en mémoire. La limite pratique de ce que vous pouvez exécuter est la RAM (et sur un GPU, la VRAM).

La quantification est l'astuce clé qui rend cela faisable sur des machines ordinaires. Les poids du modèle sont initialement stockés en haute précision (par exemple 16 bits), mais ils peuvent être compressés à ~4 bits avec un coût de qualité faible, souvent à peine perceptible. Ollama livre la plupart des modèles quantifiés par défaut — c'est pourquoi un modèle de plusieurs milliards de paramètres peut tenir dans quelques Go. Une règle empirique approximative (à vérifier sur la page du modèle spécifique) :

  • Les modèles ~1B–3B : tournent confortablement sur la plupart des ordinateurs portables modernes (quelques Go de RAM).
  • Les modèles ~7B–8B : le juste milieu entre performant et exécutable ; prévoyez plusieurs Go de RAM libre.
  • Les modèles ~13B–14B : nécessitent une machine assez bien équipée.
  • Les modèles ~70B+ : nécessitent une station de travail/serveur avec beaucoup de RAM ou un GPU puissant — pas le territoire habituel d'un ordinateur portable.

Une recette pratique : commencez avec un petit modèle (llama3.2), confirmez le flux de travail de bout en bout, puis montez en taille jusqu'au plus grand modèle qui tourne encore sans accroc sur votre matériel — pas le plus grand qui existe.

Vocabulaire des modèles locaux
Appuyez sur Entrée ou Espace pour retourner la carte. Utilisez les flèches gauche et droite pour naviguer entre les cartes.Terme affiché.
1 / 6

LM Studio : une alternative en interface graphique​

Si la ligne de commande n'est pas votre truc, LM Studio est une application de bureau (macOS, Windows, Linux) qui fait le même travail via une interface graphique : parcourir et télécharger des modèles ouverts, discuter avec eux dans une interface intégrée, et — comme Ollama — exécuter un serveur local compatible OpenAI pour que votre code puisse lui parler. C'est la voie d'accès la plus facile pour les non-développeurs ou quiconque préfère le clic au terminal ; Ollama tend à l'emporter quand vous voulez une CLI scriptable et un service léger en arrière-plan. Les deux exécutent les mêmes types de modèles à poids ouverts, donc les concepts de cette page se transposent directement.

Vérifiez vos connaissances

0/4
  1. Quel est le seul et plus grand compromis honnête de l'exécution d'un modèle en local par rapport à un modèle de pointe du cloud ?
  2. Quelle commande télécharge à la fois un modèle (si nécessaire) ET démarre une conversation avec lui ?
  3. Pour appeler votre modèle local depuis du code utilisant le SDK OpenAI, que définissez-vous ?
  4. Pourquoi un modèle de plusieurs milliards de paramètres peut-il tenir dans seulement quelques Go de RAM ?
Key takeaways
  • Local = confidentialité + hors ligne + pas de coût au token + contrôle ; le compromis est un réel écart de capacité et des limites matérielles.
  • Deux commandes vous lancent : installer Ollama, puis ollama run llama3.2.
  • CLI de base : pull (télécharger), run (discuter), list, ps, stop, rm — c'est l'essentiel.
  • Appelez-le depuis du code via l'endpoint compatible OpenAI : base_url http://localhost:11434/v1, n'importe quelle api_key non vide.
  • Le nombre de paramètres + la quantification décident si votre machine peut exécuter un modèle — commencez petit, montez en taille jusqu'à ce qui tourne sans accroc.
  • Vous préférez une interface graphique ? LM Studio fait le même travail au clic et expose aussi un serveur local compatible OpenAI.

Sources et lectures complémentaires​

Suite​