Ollama : le guide complet pour LLM en local [2026]

Ollama est un outil gratuit et open source qui permet de faire tourner des LLM ouverts (grands modèles de langage) sur votre propre ordinateur. Il s'installe sous Windows, macOS et Linux, et une seule ligne, ollama run nom-du-modèle, suffit pour télécharger un modèle puis discuter avec lui. Pendant qu'il tourne, un serveur d'API écoute sur localhost:11434 : vos propres applications et des outils comme Claude Code peuvent donc l'appeler aussi. En plus des modèles qui tournent sur votre machine, il fait désormais tourner, avec les mêmes commandes, des modèles cloud dont le nom se termine par :cloud.

Ce guide se concentre sur l'utilisation d'Ollama lui-même, vérifiée sur le texte original du dépôt GitHub officiel (code source compris), de la documentation officielle et de la page des tarifs (au 12 novembre 2026). Pour les LLM locaux en général, voyez comment démarrer avec un LLM local ; pour choisir un modèle, notre comparatif des meilleurs modèles de LLM locaux ; pour calculer la VRAM nécessaire, l'article sur la configuration matérielle ; et pour brancher un modèle sur votre éditeur, l'article Ollama + Cline.

1. Qu'est-ce qu'Ollama ? Deux façons de faire tourner les modèles : en local et dans le cloud

Ollama est un outil gratuit et open source pour faire tourner facilement des modèles ouverts (Gemma, Qwen, gpt-oss et d'autres) sur votre propre PC. Il gère en arrière-plan la partie fastidieuse (télécharger les modèles, gérer les formats de quantification, configurer l'usage du GPU) : il ne vous reste qu'à « nommer un modèle et le lancer ». L'inférence repose sur llama.cpp, et sur les Mac à puce Apple certains modèles existent aussi en versions qui tournent sur MLX d'Apple.

Il existe deux façons de faire tourner un modèle, et votre choix change complètement le PC nécessaire et ce que vous payez.

Un outil proche est LM Studio. En gros : Ollama = centré sur les commandes et l'API, pour les développeurs, l'automatisation et le branchement d'agents ; LM Studio = centré sur une interface graphique, pour qui veut passer de la recherche d'un modèle à la discussion sans quitter la fenêtre. Les deux sont gratuits. Les différences entre local et cloud en elles-mêmes (coût, performances, confidentialité) sont traitées dans notre comparatif LLM local contre LLM cloud.

2. Installer Ollama (Windows / macOS / Linux / Docker)

La page de téléchargement officielle et le README sur GitHub proposent deux voies pour chaque système : une ligne à coller dans le terminal ou un installateur manuel. Les deux donnent le même résultat.

Windows

Si vous préférez éviter les commandes, récupérez OllamaSetup.exe sur la page de téléchargement et lancez-le. D'après la page Windows officielle, il s'installe par défaut dans votre dossier utilisateur, et les modèles peuvent occuper en plus de quelques dizaines à quelques centaines de Go. Si le lecteur C: manque de place, changez l'emplacement d'installation avec OllamaSetup.exe /DIR="d:\some\location" et celui des modèles avec la variable d'environnement OLLAMA_MODELS (section 9). Après l'installation, Ollama tourne en arrière-plan et la commande ollama fonctionne aussi bien dans cmd que dans PowerShell.

macOS

Pour une installation manuelle, ouvrez Ollama.dmg et faites glisser l'app dans le dossier Applications. Au premier lancement, si la commande ollama n'est pas dans le PATH, l'app demande l'autorisation de créer un lien dans /usr/local/bin (page macOS officielle).

Linux

L'installation manuelle sans le script et le paquet supplémentaire pour les GPU AMD sont décrits sur la page Linux officielle. Linux n'a pas d'app comme Windows et macOS : on l'utilise par les commandes et l'API.

Docker

L'image officielle ollama/ollama est sur Docker Hub. Voici un démarrage minimal sur CPU seul. Pour les GPU NVIDIA, installez le NVIDIA Container Toolkit et ajoutez --gpus=all ; pour les GPU AMD, utilisez l'image ollama/ollama:rocm (page Docker officielle). Docker Desktop sur macOS ne peut pas utiliser le GPU (FAQ officielle) : sur Mac, installer l'app directement est plus rapide.

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama
docker exec -it ollama ollama run gemma4:e2b

3. Est-ce que ça ira vite sur votre GPU ? (GPU pris en charge en un coup d'œil)

Si Ollama ne peut pas utiliser votre GPU, il se rabat sur le CPU : aucune erreur ne s'affiche, mais tout devient plusieurs fois plus lent. Avant d'installer, vérifiez que votre GPU figure sur la page officielle Hardware support. Voici l'essentiel.

Pour savoir si un modèle est vraiment chargé sur le GPU, lancez ollama ps pendant qu'il est en mémoire. Si la colonne PROCESSOR indique 100% GPU, il est entièrement sur le GPU ; un partage comme 48%/52% CPU/GPU signifie qu'il déborde de la VRAM (FAQ officielle). Ce qu'il faut réduire en cas de partage figure dans le tableau de la section 9. Les estimations de VRAM par GPU sont dans notre article sur la configuration matérielle.

4. Liste des commandes Ollama

Ce tableau reprend les commandes de la référence CLI officielle et celles définies dans le code source (cmd/cmd.go). Au quotidien, vous utiliserez surtout les six premières.

ollama run a quelques options pratiques. Avec --verbose, il affiche après chaque réponse le temps écoulé et le nombre de tokens par seconde (eval rate) : vous comparez ainsi la vitesse en chiffres quand vous changez de modèle ou de tag. --think=false empêche les modèles qui affichent leur raisonnement de le faire, --format json renvoie la réponse en JSON, et --keepalive 30m change la durée pendant laquelle le modèle reste en mémoire. Avec les modèles qui lisent les images, il suffit d'inclure le chemin du fichier dans la requête, par exemple ollama run gemma4 "Que montre cette image ? ./photo.png".

Pendant une discussion (après l'invite >>>), des commandes spéciales commençant par / sont disponibles. /bye quitte, /? les liste toutes, /clear efface le contexte de la conversation et /set parameter num_ctx 8192 change la longueur de contexte à la volée. Pour saisir plusieurs lignes d'un coup, encadrez-les de """.

5. Récupérer des modèles et lire les tags

Un modèle se désigne par nom + tag. Sans tag, c'est latest qui est utilisé, mais la taille vers laquelle pointe latest varie d'un modèle à l'autre. Installer sans vérifier peut vous faire télécharger une version bien plus grosse que prévu. En prenant pour exemple la liste officielle des tags de gemma4, le tableau montre comment les lire (affichage du 12 novembre 2026).

Les tailles sont données en fourchettes parce qu'un tag contient plusieurs formats et que celui qui convient à votre machine est choisi. Pour le latest de gemma4, le bas de la fourchette (6,6 Go) correspond à e4b-it-q4_K_M et le haut (9,5 Go) à e4b-mlx. Dans le doute, choisissez un tag sans suffixe (comme gemma4:e4b) : Ollama prend le format adapté à votre machine. Les formats de quantification eux-mêmes (comment lire le Q4_K_M de GGUF, etc.) sont traités dans notre article sur les formats de quantification.

Les valeurs de VRAM sont indicatives : la taille du modèle plus une marge pour la conversation (le contexte). Le guide de démarrage officiel recommande lui aussi « 8 Go de VRAM (ou de mémoire unifiée sur Mac) » pour gemma4:e2b (environ 7,2 Go dans le format installé par défaut). Une fois installé, ollama show gemma4 affiche le nombre de paramètres, la quantification et la longueur de contexte.

6. Avec une interface graphique (l'app Ollama, Open WebUI et d'autres)

Si vous préférez éviter le terminal, commencez par ouvrir l'app d'Ollama lui-même. Les versions Windows et macOS comprennent une fenêtre où choisir un modèle et discuter (billet officiel « Ollama's new app »). Linux n'a pas d'app : utilisez l'une des autres interfaces ci-dessous.

7. Modèles cloud et tarifs

Quand votre GPU ne peut pas faire tourner un gros modèle, vous pouvez utiliser, avec la même démarche, des modèles cloud qui tournent sur les serveurs d'Ollama. Connectez-vous à ollama.com avec ollama signin, puis indiquez un nom se terminant par :cloud, comme ollama run gemma4:cloud. Aucun téléchargement n'est nécessaire (page Cloud officielle). Voici les offres (page des tarifs, au 12 novembre 2026).

L'usage est compté au prix de chaque modèle par million de tokens. La version cloud de gemma4 coûte par exemple $0,14 en entrée et $0,40 en sortie. Avec 1 million de tokens en entrée et 200 000 en sortie, on arrive à 0,14 + 0,40 × 0,2 = environ $0,22. Dans cette proportion, les $60 mensuels de Pro couvrent environ 270 passages de ce type (60 ÷ 0,22). L'usage inclus n'est pas reporté sur le mois suivant. Les modèles qui tournent sur votre machine sont illimités et gratuits dans toutes les offres.

8. Utiliser l'API (compatible OpenAI et Anthropic)

La vraie force d'Ollama, c'est son API locale. Par défaut, le serveur écoute sur 127.0.0.1:11434 ; envoyez-y des requêtes, et vos applications, scripts et outils peuvent utiliser un LLM local. Il existe trois formats de requête.

/api/chat (envoyer l'historique de la conversation)

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

La réponse se trouve dans message.content. Sans "stream": false, la réponse arrive petit à petit sous forme de lignes JSON (le streaming est le comportement par défaut). Pour une réponse unique, vous pouvez aussi envoyer un "prompt" à /api/generate. L'exemple ci-dessus est écrit pour les shells de macOS et Linux ; PowerShell sous Windows traite les guillemets différemment, utilisez donc cette forme tirée de la page Windows officielle (seul le nom du modèle a changé).

(Invoke-WebRequest -method POST -Body '{"model":"gemma4", "prompt":"Why is the sky blue?", "stream": false}' -uri http://localhost:11434/api/generate ).Content | ConvertFrom-json

Compatible OpenAI (/v1)

Avec la bibliothèque officielle d'OpenAI, il suffit de pointer base_url vers Ollama. D'après la documentation officielle, sur un serveur local la clé d'API est « obligatoire mais ignorée » : n'importe quelle chaîne fait l'affaire.

from openai import OpenAI

client = OpenAI(
    base_url='http://localhost:11434/v1/',
    api_key='ollama',  # required but ignored
)

chat_completion = client.chat.completions.create(
    messages=[{'role': 'user', 'content': 'Say this is a test'}],
    model='gemma4',
)
print(chat_completion.choices[0].message.content)

Compatible Anthropic (brancher Claude Code)

La page officielle sur la compatibilité Anthropic demande de définir ces deux variables d'environnement pour les outils conçus autour de l'API d'Anthropic. Même sans les définir vous-même, ollama launch claude lance Claude Code déjà branché.

export ANTHROPIC_AUTH_TOKEN=ollama  # required but ignored
export ANTHROPIC_BASE_URL=http://localhost:11434

Les deux couches de compatibilité ne couvrent qu'une partie des API d'origine. Le format Responses, par exemple, est sans état : il faut renvoyer l'historique de la conversation à chaque fois. Avec un modèle local et un agent de code, c'est la longueur de contexte de la section suivante qui compte.

9. Personnalisation (Modelfile, variables d'environnement, réglage de la mémoire)

Modelfile : créer votre propre modèle

Un Modelfile est un fichier de configuration très proche d'un Dockerfile. Vous partez d'un modèle de base (FROM, obligatoire), ajoutez des paramètres (PARAMETER) et un prompt système (SYSTEM), et vous obtenez « votre propre modèle », qui se comporte toujours de la même façon. Un exemple minimal :

FROM gemma4
PARAMETER temperature 0.7
PARAMETER num_ctx 16384
SYSTEM """Tu es un assistant concis. Commence par l'essentiel et réponds en français."""

Enregistrez-le dans un fichier nommé Modelfile et lancez ce qui suit dans le même dossier. Mettre num_ctx dans le Modelfile allonge la longueur de contexte pour ce modèle seulement, sans changer la valeur par défaut de tout le serveur.

ollama create my-assistant -f Modelfile
ollama run my-assistant

ollama show --modelfile gemma4 affiche le Modelfile d'un modèle existant. Le copier et le modifier est le moyen le plus rapide de commencer.

Principales variables d'environnement

Le comportement du serveur se règle par des variables d'environnement. ollama serve --help affiche la liste complète. Voici les plus courantes, avec les valeurs par défaut écrites dans le code source (envconfig/config.go) et la FAQ officielle.

La façon de les définir dépend du système (FAQ officielle). Sous Windows, quittez Ollama depuis la barre des tâches, ajoutez une variable utilisateur dans les réglages des variables d'environnement, puis relancez Ollama depuis le menu Démarrer. Sous macOS, définissez-la avec par exemple launchctl setenv OLLAMA_HOST "0.0.0.0:11434" et redémarrez l'app. Sous Linux (avec systemd), procédez ainsi :

systemctl edit ollama.service
# sous [Service], ajouter une ligne par variable
# Environment="OLLAMA_HOST=0.0.0.0:11434"
systemctl daemon-reload
systemctl restart ollama

Réglages en cas de mémoire limitée ou de long contexte

Avec moins de 24 Gio de VRAM, la longueur de contexte par défaut n'est que de 4k (environ 4 000 tokens). La page officielle Context length recommande au moins 64 000 tokens pour la recherche web, les agents et les outils de code. Quand c'est trop court, le modèle oublie ce qui précède sans afficher d'erreur ; ce tableau donne donc le réglage pour chaque objectif, afin de remonter depuis le symptôme.

Après un changement, vérifiez avec ollama ps que la colonne CONTEXT affiche la longueur voulue et que PROCESSOR indique toujours 100% GPU. La conversion de la longueur de contexte en mémoire est détaillée dans notre article sur la configuration matérielle, et les symptômes d'un agent à court de contexte dans l'article Ollama + Cline.

10. Dépannage

Les blocages les plus fréquents et les solutions données par la FAQ officielle et la page Troubleshooting.

Conclusion

Ollama fait tourner des modèles ouverts sur votre machine ou dans le cloud avec la même démarche. Quatre points à retenir :

• Vérifier le GPU avant d'installer : NVIDIA demande une Compute Capability de 5.0 ou plus, AMD la liste ROCm v7 ou Vulkan, les Mac une puce Apple série M. Une fois lancé, confirmez 100% GPU dans ollama ps.
• Lire le tag avant de choisir : ce que contient latest varie selon le modèle. Regardez le nombre qui indique la taille (e2b, 12b, 31b) et, dans le doute, prenez un tag sans suffixe.
• Fixer soi-même la longueur de contexte : sous 24 Gio de VRAM, la valeur par défaut est 4k. Au moins 64k sont recommandés pour les agents ; regagnez de la mémoire en quantifiant le cache K/V.
• Brancher les outils par l'API et launch : les API compatibles OpenAI et Anthropic et ollama launch permettent de l'utiliser depuis vos applications et Claude Code. Les modèles lourds, avec :cloud.

Commencez par ouvrir l'app ou taper ollama run gemma4:e2b. Le meilleur moyen d'apprendre est de le faire tourner tout en explorant les différences avec le cloud et la façon de choisir un modèle. Pour aller plus loin et brancher un modèle sur votre éditeur afin qu'il écrive du code, coder avec un LLM local explique la configuration de Cline et de Continue.

FAQ