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 classe de modèles open-weight — 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 arriver : une installation, une commande, et un modèle tourne en local. Cette page vous mène de zéro à un modèle en marche, vous montre comment l'appeler depuis le code et expose les compromis, pour que vous n'attendiez pas 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 par rapport aux modèles de pointe dans le 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 le code via l'API d'Ollama compatible OpenAI
  • 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 l'embranchement 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 les dépenses en tokens sont 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 mauvaises surprises dans les conditions d'utilisation.

Les compromis honnêtes :

  • Écart de capacité. Un modèle que vous pouvez exécuter sur un portable (1B–14B paramètres) n'est pas dans la même catégorie qu'un modèle de pointe dans le cloud pour le raisonnement difficile, le long contexte ou les tâches agentiques. Pour beaucoup de tâches courantes, l'écart est faible ; pour les plus difficiles, il est grand.
  • Matériel. Les modèles plus gros et plus capables demandent plus de RAM/VRAM que n'en a une machine typique. Vous choisissez souvent le plus gros modèle que votre matériel peut exécuter, pas le meilleur 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 cloud — voir Choisir un modèle), utiliser le local pour le travail privé/hors ligne/économique à grande échelle, et recourir à une API de pointe quand la tâche exige vraiment 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'installateur sur 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 sous Linux (macOS/Windows utilisent plutôt l'installateur téléchargé) :

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

Télécharger et exécuter un petit modèle (bon premier choix)

ollama run gemma4:e2b

Cette unique commande télécharge gemma4:e2b — le modèle par lequel commence le guide de démarrage rapide d'Ollama, une variante Gemma 4 de taille edge d'environ 2,3B paramètres effectifs et de quelques Go sur disque — et lance un chat interactif. Pour télécharger sans discuter tout de suite, 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 le 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 sur http://localhost:11434, sur le port par défaut 11434. Elle possède ses propres points d'accès natifs (/api/generate, /api/chat) et une couche compatible OpenAI sur /v1 — ainsi, la plupart du code écrit pour le SDK OpenAI fonctionne avec votre modèle local en changeant deux lignes.

HTTP brut avec curl (point d'accès natif) :

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

Depuis Python avec 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 ignore sa 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="gemma4:e2b",
    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 elle 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 / function calling, qui fonctionnent en local comme dans le cloud (à condition que le modèle soit réellement bon pour cela). La couche /v1 d'Ollama couvre /v1/chat/completions, /v1/completions, /v1/responses, /v1/models (et /v1/models/{model}) ainsi que /v1/embeddings.

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

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

La quantification est l'astuce clé qui rend cela réalisable sur des machines ordinaires. Les poids du modèle sont à l'origine stockés en haute précision (p. ex. 16 bits), mais ils peuvent être compressés à ~4 bits pour un faible coût en qualité, 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 en quelques Go. Une règle empirique approximative (à vérifier sur la page du modèle concerné) :

  • Modèles ~1B–3B : tournent confortablement sur la plupart des portables récents (quelques Go de RAM).
  • Modèles ~7B–8B : le juste milieu entre capable et exécutable ; prévoyez plusieurs Go de RAM libre.
  • Modèles ~13B–14B : demandent une machine plutôt bien équipée.
  • Modèles ~70B+ : demandent une station de travail/un serveur avec beaucoup de RAM ou un GPU puissant — pas le terrain d'un portable typique.

Une recette pratique : commencez par un petit modèle (gemma4:e2b), validez le flux de bout en bout, puis montez en taille jusqu'au plus gros modèle qui tourne encore confortablement sur votre matériel — pas le plus gros 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 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 — lancer un serveur local compatible OpenAI pour que votre code puisse lui parler. C'est la porte d'entrée la plus facile pour les non-développeurs ou ceux qui préfèrent le pointer-cliquer au terminal ; Ollama l'emporte plutôt 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 open-weight, donc les concepts de cette page se transposent directement.

Testez-vous

0/4
  1. Quel est le plus grand compromis honnête de l'exécution d'un modèle en local par rapport à un modèle de pointe dans le cloud ?
  2. Quelle commande télécharge un modèle (si nécessaire) ET commence à discuter avec ?
  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 quelques Go de RAM seulement ?
Key takeaways
  • Local = confidentialité + hors ligne + pas de coût par token + contrôle ; le compromis est un réel écart de capacité et des limites matérielles.
  • Deux commandes suffisent : installer Ollama, puis ollama run gemma4:e2b.
  • CLI de base : pull (télécharger), run (discuter), list, ps, stop, rm — c'est l'essentiel.
  • L'appeler depuis le code via le point d'accès 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, puis montez à ce qui tourne confortablement.
  • Vous préférez une interface graphique ? LM Studio fait le même travail en pointer-cliquer et expose aussi un serveur local compatible OpenAI.

Sources et pour aller plus loin​

Suite​