Garder un modèle Ollama chargé en mémoire
Après 5 minutes d’inactivité, Ollama décharge le modèle et la requête suivante attend son rechargement. Définissez OLLAMA_KEEP_ALIVE avec systemd et préchargez-le après redémarrage.
Pourquoi Ollama décharge-t-il le modèle après quelques minutes ?
Ollama conserve un modèle chargé en mémoire pendant cinq minutes après la dernière requête, puis libère cette mémoire. La requête suivante doit donc recharger les poids dans la RAM ou la VRAM, ce qui provoque un délai avant l’arrivée du premier token. C’est pourquoi une interface de chat ou un agent de programmation semble rapide, reste inactif pendant un moment, puis paraît de nouveau lent au message suivant. Rien n’est défaillant. Le délai d’inactivité a expiré.
Le délai s’appelle keep_alive. Il est défini par modèle et redémarre chaque fois qu’une requête se termine. Un modèle qui répond à une requête n’est jamais déchargé, car le serveur n’expire que les modèles qui n’ont aucune requête active. En octobre 2026, la valeur par défaut est de cinq minutes et elle s’applique à tous les modèles chargés par ce serveur.
Il existe deux endroits où définir le délai d’inactivité : le champ keep_alive de chaque requête ou OLLAMA_KEEP_ALIVE comme valeur par défaut du serveur. Un drop-in systemd permet de conserver la valeur par défaut du serveur après un redémarrage. Ce guide suppose qu’Ollama fonctionne déjà comme service. Si ce n’est pas le cas, commencez par installer Ollama sur un VPS, puis revenez ici.
Quels modèles sont actuellement chargés, et quand expirent-ils ?
ollama psNAME ID SIZE PROCESSOR CONTEXT UNTIL
qwen3:8b 500a1f067a9f 6.6 GB 100% GPU 4096 4 minutes from nowUne sortie vide signifie qu’aucun modèle n’est chargé. La prochaine requête doit donc d’abord charger le modèle. PROCESSOR indique où les poids ont été chargés. 100% GPU et 100% CPU correspondent aux cas simples. Une valeur fractionnée comme 25%/75% CPU/GPU signifie qu’une partie seulement du modèle se trouve dans la VRAM. Le reste s’exécute sur le processeur, ce qui ralentit la génération. Cela signifie généralement que le modèle ne tenait pas entièrement en mémoire. Toutefois, un paramètre num_gpu qui limite le nombre de couches envoyées au GPU produit le même type de répartition.
UNTIL indique le compte à rebours. Il affiche une durée relative comme 4 minutes from now. Il affiche Forever lorsque le modèle a été chargé avec une valeur keep_alive négative. Il affiche Stopping... après l’expiration, y compris lorsque des requêtes actives retardent le déchargement.
L’ensemble des colonnes a changé entre les releases. Consultez donc l’en-tête au lieu de compter les champs dans un script. Ollama v0.40.5, vérifié le 2026-10-30, affiche également une colonne RUNNER entre CONTEXT et UNTIL. Elle indique le runner qui sert le modèle. Votre en-tête peut donc comporter une colonne de plus que dans l’exemple ci-dessus. Pour toute automatisation, interrogez l’API :
curl -s http://localhost:11434/api/psChaque entrée contient expires_at, un timestamp absolu comme 2026-08-09T14:38:31.83753Z, ainsi que size_vram, la partie de ce modèle présente dans la mémoire du GPU. Une valeur size_vram égale à 0 signifie que le modèle s’exécute sur le CPU.
Le coût réel du rechargement
Ne le devinez pas. Ollama indique le temps de chargement dans chaque réponse, dans load_duration, en nanosecondes.
sudo apt install -y jq
ollama stop qwen3:8b
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "prompt": "hi", "stream": false}' | jq '{load_duration, total_duration}'Attendez que ollama ps ne liste plus le modèle après ollama stop avant d’exécuter les deux appels API. Le premier appel charge le modèle, donc sa valeur load_duration est élevée. Divisez-la par 1000000000 pour la lire en secondes. Le second appel s’exécute alors que le modèle est déjà en mémoire et indique une valeur beaucoup plus faible. L’écart entre ces deux valeurs correspond au coût subi par chaque utilisateur une fois le délai expiré. C’est la raison d’être de la modification de keep_alive. Après le déchargement, le page cache du kernel contient souvent encore le fichier du modèle. Sur une machine disposant de suffisamment de RAM, un rechargement peut donc être plus rapide que le premier chargement après un boot. Lorsque ce cache a été récupéré, les poids sont lus depuis le disque. Si vous avez déplacé le répertoire des modèles vers un second volume, la vitesse de ce volume détermine alors le temps minimal de chaque chargement à froid. Pour mesurer la vitesse de génération avant et après cette pause, consultez la méthode de mesure des tokens par seconde sur votre propre machine.
Conserver un modèle Ollama chargé en mémoire sur une requête
Envoyez keep_alive avec la requête. Ce paramètre s’applique à ce modèle dès que la requête est terminée.
curl -s http://localhost:11434/api/chat -d '{
"model": "qwen3:8b",
"messages": [{"role": "user", "content": "hello"}],
"keep_alive": "30m"
}'Quatre formes de valeur sont acceptées :
- une chaîne indiquant une durée :
"30m","24h","90s" - un nombre simple, interprété comme un nombre de secondes :
3600 - une valeur négative,
-1ou"-1m", qui désactive complètement le délai d’inactivité 0, qui décharge le modèle dès qu’il n’a plus de requêtes actives
Une valeur indiquée dans la requête remplace la valeur par défaut du serveur, dans les deux sens. Ce point est important : si un client envoie sa propre valeur keep_alive, elle est prioritaire sur toute configuration définie sur le serveur.
Vous pouvez également charger un modèle sans générer de contenu. Envoyez uniquement le nom du modèle. Le serveur le charge et renvoie une réponse vide avec "done": true.
curl -s http://localhost:11434/api/generate -d '{"model": "qwen3:8b", "keep_alive": "30m"}'C’est la commande à exécuter après un redémarrage ou après le téléchargement d’un nouveau modèle. La première requête réelle d’un utilisateur n’attend ainsi pas le chargement. La CLI permet de faire la même chose avec une option :
ollama run --keepalive 30m qwen3:8b "hello"Conservez le modèle chargé par défaut avec OLLAMA_KEEP_ALIVE
Le serveur lit OLLAMA_KEEP_ALIVE au démarrage et l’utilise pour chaque modèle qui ne possède pas sa propre valeur. La variable accepte les mêmes formats que le champ de la requête. 30m, 3600 et -1 fonctionnent donc tous.
Le point important est de définir la variable dans l’environnement du bon processus. Exécuter export OLLAMA_KEEP_ALIVE=30m dans votre session SSH ne change rien, car l’installation packagée exécute le serveur comme un service systemd, avec son propre utilisateur et son propre environnement. Votre shell de connexion et ce service ne partagent pas leur environnement. C’est la cause la plus fréquente lorsque le paramètre semble ignoré.
Assurer la persistance après un redémarrage avec un drop-in systemd
sudo systemctl edit ollama.serviceL'éditeur s'ouvre avec deux marqueurs de commentaire. Saisissez votre configuration entre ces deux lignes : systemd ignore tout ce qui est écrit après le second marqueur.
[Service]
Environment="OLLAMA_KEEP_ALIVE=30m"L'enregistrement crée le fichier /etc/systemd/system/ollama.service.d/override.conf. Il s'agit d'un drop-in plutôt que d'une modification directe de l'unité fournie par le paquet, ainsi une mise à jour du paquet Ollama qui remplace ollama.service ne supprimera pas votre configuration. Si les drop-ins et les fichiers d'unité sont nouveaux pour vous, le guide des services et timers systemd détaille leur fonctionnement.
sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=EnvironmentLa dernière commande affiche l'environnement réel dans lequel le service s'exécutera. Si OLLAMA_KEEP_ALIVE=30m est absent de cette ligne, le drop-in n'a pas été pris en compte ; la cause est presque toujours l'oubli de l'en-tête [Service] ou des lignes saisies sous le marqueur. Le redémarrage vide tous les modèles chargés en mémoire, la requête suivante sera donc un chargement à froid. Réchauffez le service avec l'appel de préchargement ci-dessus. Le drop-in conserve le paramètre après un redémarrage, mais pas le modèle : le service démarre ollama serve sans rien en mémoire, exécutez donc la commande de préchargement après chaque démarrage du système.
Le coût du maintien d'un modèle en mémoire vive
La colonne SIZE dans ollama ps représente la mémoire occupée pendant toute la fenêtre d'inactivité, et non uniquement lors d'une requête. Un modèle 8B quantifié en 4-bit occupe environ 5 à 6 Go. Un modèle 27B change la donne, et le calcul de la mémoire nécessaire pour l'exécuter sur un VPS sans GPU mérite d'être effectué avant de décider de le maintenir en mémoire. Réglez keep_alive sur -1 pour désactiver l'expiration en cas d'inactivité ; les requêtes ultérieures pour le même modèle peuvent réinitialiser son délai d'expiration ou forcer un rechargement si les options d'exécution changent. Sur un petit VPS, c'est un arbitrage direct au détriment de votre base de données, de votre application web et de vos tâches de build.
Surveillez les chiffres réels plutôt que de vous fier à une estimation. Exécutez ceci pendant qu'un modèle est chargé, puis à nouveau après ollama stop :
free -hLa colonne available indique la mémoire que le noyau pourrait encore allouer à un nouveau processus. Sur une machine équipée d'un GPU NVIDIA, nvidia-smi montre la même chose pour la VRAM. Si la machine sature, le noyau tue un processus pour récupérer de l'espace :
sudo dmesg -T | grep -i "out of memory"Une ligne mentionnant ollama signifie que le serveur de modèle a été la victime. Une ligne mentionnant votre base de données signifie que le modèle a gagné et qu'un service important a été sacrifié. Ces deux résultats découlent de la même décision : une fenêtre de keep-alive trop longue sur une machine sans marge de manœuvre.
Deux coûts sont faciles à oublier. Une longueur de contexte plus importante réserve un cache KV plus grand (key value cache, l'état d'attention par jeton que le modèle conserve pendant la génération), et ce cache fait partie de la taille résidente. Sa taille dépend de num_ctx, donc augmenter la fenêtre de contexte augmente la mémoire qu'un modèle résident occupe pendant toute la période d'inactivité, et pas seulement pendant qu'il répond. Une valeur de OLLAMA_NUM_PARALLEL supérieure à 1 réserve ce cache une fois par slot parallèle lorsque le modèle prend en charge ce parallélisme. Ollama v0.40.16 force le parallélisme à 1 pour les modèles sans capacité de complétion, y compris les modèles d'embedding ; son ordonnanceur ne distingue plus mllama ou qwen3next. Si vous prévoyez de servir plusieurs utilisateurs avec un seul modèle, dimensionnez la mémoire en fonction des slots, et non uniquement en fonction des poids.
Une valeur par défaut raisonnable : un modèle sur une machine disposant de marge peut utiliser -1. Une machine partagée devrait utiliser une fenêtre couvrant les intervalles entre vos requêtes, comme 30m, afin que la mémoire soit libérée lorsque vous cessez de travailler.
Décharger immédiatement un modèle
ollama stop qwen3:8bLa commande ne renvoie rien après la demande d’expiration. Le déchargement attend la fin des requêtes actives. La commande peut donc se terminer avant que la mémoire soit libérée. Elle ne renvoie également rien pour un modèle que vous avez téléchargé, mais qui n’est pas chargé actuellement. La commande ne vérifie jamais quels modèles résident en mémoire. Elle envoie la demande de déchargement, et le serveur répond que l’opération a réussi, qu’un modèle soit présent en mémoire ou non. L’erreur couldn't find model "qwen3:8b" to stop apparaît uniquement lorsqu’aucun modèle portant ce nom n’est installé sur ce serveur. Cela indique généralement une faute de frappe dans le nom ou le tag. Ainsi, un ollama stop silencieux ne prouve pas que de la mémoire a été libérée. ollama ps le confirme. La forme API est une requête sans prompt, avec keep_alive défini sur 0 :
curl -s http://localhost:11434/api/chat -d '{"model": "qwen3:8b", "messages": [], "keep_alive": 0}'La réponse contient "done_reason": "unload". Utilisez cette méthode au lieu de redémarrer le service. systemctl restart ollama libère également la mémoire, mais décharge tous les autres modèles chargés et interrompt toute requête en cours.
Exécuter plusieurs modèles sur un même serveur
OLLAMA_MAX_LOADED_MODELS limite le nombre de modèles conservés simultanément en mémoire. En octobre 2026, la valeur par défaut est de trois modèles par GPU, ou de trois modèles sur une machine équipée uniquement d’un CPU. Cette limite compte les modèles, mais la mémoire reste la contrainte réelle. Un deuxième modèle volumineux peut donc être refusé bien avant d’atteindre trois modèles.
Lorsqu’un nouveau modèle est demandé et que la mémoire disponible ne suffit pas, ou que la limite est atteinte, le scheduler décharge l’un des modèles présents pour libérer de la place. Il préfère un modèle qui ne traite aucune requête active. Il peut aussi évincer un modèle dont le délai n’a pas expiré, y compris un modèle chargé avec -1, mais il essaie d’abord les modèles dont la fenêtre est la plus courte. Ainsi, une valeur négative pour keep_alive signifie qu’aucun délai d’inactivité n’est appliqué. Le modèle n’est pas conservé en mémoire pour empêcher le chargement d’un autre modèle demandé.
Ces décisions apparaissent dans le journal du service. Le cas où la limite est atteinte n’est journalisé qu’au niveau debug. Ajoutez une deuxième ligne Environment="OLLAMA_DEBUG=1" au même drop-in, redémarrez le service, puis surveillez le journal :
sudo journalctl -u ollama -fLisez la raison indiquée à côté de la requête qui a déclenché le déchargement. max runners achieved, unloading one to make room signifie que la limite OLLAMA_MAX_LOADED_MODELS a été atteinte. Cela peut se produire même si les deux modèles pourraient tenir en mémoire. Augmentez donc cette limite si free -h indique qu’il reste suffisamment de mémoire. Une ligne indiquant que le nouveau modèle devrait dépasser la mémoire disponible, suivie d’une éviction, signifie que le contrôle de compatibilité du scheduler a refusé de charger les deux modèles ensemble en fonction de la mémoire disponible. Dans ce cas, utilisez moins de modèles sur cette machine, ou définissez une fenêtre longue pour le modèle qui doit répondre rapidement et 0 pour celui que vous utilisez rarement.
Des recommandations valables au-delà de la prochaine version
Ollama publie fréquemment de nouvelles versions et ses valeurs par défaut évoluent. Vérifiez donc la version installée plutôt que de mémoriser des numéros :
ollama --version
ollama serve --helpollama serve --help répertorie les variables d’environnement effectivement lues par cette version, notamment OLLAMA_KEEP_ALIVE. Deux règles sont restées valables au fil des versions et peuvent servir de base. Une valeur définie dans la requête prend le dessus sur la valeur par défaut du serveur. Et ollama ps indique ce qui est réellement chargé, quel que soit le contenu attendu par un fichier de configuration.
Si un éditeur ou un agent pilote votre serveur, vérifiez ce que ce client envoie avant d’incriminer le serveur. Connecter un agent de développement à votre propre serveur Ollama explique où se trouvent ces paramètres de requête.
FAQ
Pourquoi Ollama décharge-t-il mon modèle après 5 minutes ?
Cinq minutes correspondent à la valeur par défaut de keep_alive, le délai d’inactivité qu’Ollama démarre lorsqu’une requête se termine. À son expiration, le serveur libère les poids du modèle. La requête suivante doit donc les charger à nouveau, ce qui explique la pause que vous constatez. Augmentez cette valeur pour une seule requête en envoyant "keep_alive": "30m" dans le corps JSON, ou pour l’ensemble du serveur avec la variable d’environnement OLLAMA_KEEP_ALIVE.
Comment conserver définitivement un modèle Ollama chargé en mémoire ?
Utilisez une valeur négative : "keep_alive": -1 pour la requête, ou OLLAMA_KEEP_ALIVE=-1 pour le serveur. ollama ps affiche alors Forever dans la colonne UNTIL. Cela supprime uniquement le délai d’inactivité. Si un autre modèle est demandé et que la mémoire disponible est insuffisante, le scheduler peut tout de même décharger celui-ci pour faire de la place. Les requêtes ultérieures pour le même modèle peuvent également remplacer son délai d’expiration ou déclencher un rechargement lorsque les options du runner changent. Un redémarrage du service ou du serveur le supprime aussi de la mémoire. Rechargez donc le modèle ensuite.
Pourquoi OLLAMA_KEEP_ALIVE est-il ignoré ?
Vérifiez où vous avez défini cette variable. Exécutez systemctl show ollama --property=Environment. Si la variable n’apparaît pas dans la sortie, le serveur ne l’a jamais reçue, car une variable exportée dans votre shell n’est pas transmise à un service systemd. Définissez-la avec sudo systemctl edit ollama.service, puis exécutez sudo systemctl daemon-reload et sudo systemctl restart ollama. L’autre cause possible est un client qui envoie sa propre valeur keep_alive dans la requête. Celle-ci remplace la valeur par défaut du serveur.
Comment libérer la mémoire sans redémarrer Ollama ?
ollama stop qwen3:8b demande l’expiration de ce modèle uniquement. Le serveur et tous les autres modèles chargés continuent de fonctionner. Les requêtes actives doivent se terminer avant son déchargement. Avec l’API, envoyez une requête sans prompt et avec "keep_alive": 0. La réponse contient alors "done_reason": "unload". Vérifiez avec ollama ps. Le modèle ne devrait plus être listé une fois le déchargement terminé.