Ollama : corriger « context deadline exceeded »
L’erreur Ollama `context deadline exceeded` vient d’un délai Go expiré. Identifiez si le timeout est défini par le client, le chargement du modèle ou nginx.
Ce que signifie réellement « context deadline exceeded »
L’erreur Ollama context deadline exceeded signale un délai d’attente dépassé. Une partie du code Go a défini une échéance pour une opération. L’opération ne s’est pas terminée dans le délai prévu et l’échéance a expiré. Le plus souvent, il s’agit d’une requête qui attend la réponse d’un modèle. Rien n’a planté et aucun fichier n’est corrompu. Le traitement était encore en cours lorsque le délai a expiré.
Cette formulation vient du package standard context de Go. C’est déjà un indice utile. Un client Python basé sur httpx lève plutôt httpx.ReadTimeout. Un navigateur affiche une erreur réseau générique. Si vous lisez exactement ces mots, un programme Go a cessé d’attendre : l’outil en ligne de commande Ollama, le serveur Ollama lui-même ou une application Go qui appelle l’API (interface de programmation d’application).
L’échéance ne concerne pas toujours la réponse du modèle. Les mêmes mots peuvent apparaître pendant les téléchargements : ollama pull, ou le téléchargement que ollama run lance lorsque le modèle n’est pas encore présent sur le disque. Le ticket Ollama #17484, signalé avec la version 0.32.5, montre ollama run d’un modèle Hugging Face afficher ses lignes pulling, puis Error: context deadline exceeded, tandis que le journal du serveur indique qu’une récupération de blob depuis hf.co échoue avec la même erreur. Si votre sortie s’arrête juste après les lignes pulling, l’échéance concerne le téléchargement. Relancez donc le pull et vérifiez le chemin réseau vers le registre avant de modifier un paramètre ci-dessous.
Lorsque le modèle est déjà présent sur le disque, cinq couches interviennent. Trois d’entre elles définissent leur propre échéance : votre client, le délai de chargement du modèle côté serveur et un reverse proxy. Les deux autres, keep_alive et num_ctx, ne définissent aucune échéance, mais déterminent la quantité de travail qui doit tenir dans une seule échéance. Elles échouent à des étapes différentes et nécessitent chacune une correction différente. Il faut donc déterminer laquelle est à l’origine de l’erreur.
- Votre client HTTP, qui a accordé à la requête un délai fixe.
- Le délai de chargement du modèle du serveur Ollama, qui expire lorsqu’un modèle volumineux est lu depuis le disque pour la première fois.
keep_alive, qui décharge le modèle entre les requêtes. L’appel suivant doit donc de nouveau payer le coût du chargement.- Un
num_ctxsuffisamment volumineux pour que le traitement du prompt dure plusieurs minutes sur une machine utilisant uniquement le CPU. - Un reverse proxy tel que nginx ou Traefik, qui coupe la connexion avant qu’Ollama ait répondu.
Suivez cette liste dans l’ordre. Chaque étape ci-dessous élimine une couche de l’analyse et vous évite de procéder par suppositions.
Reproduire l’appel API pour écarter le proxy
Exécutez la requête directement sur le serveur, auprès d’Ollama, sans proxy intermédiaire.
time curl -s http://127.0.0.1:11434/api/generate -d '{
"model": "llama3.1:8b",
"prompt": "Why is the sky blue?",
"stream": false
}' | head -c 400curl ne définit aucune limite de temps globale. Il définit uniquement un délai d’expiration de connexion. Cette commande attend donc aussi longtemps qu’Ollama en a besoin. Cela permet de réduire le problème de moitié. Si un corps JSON est renvoyé, Ollama a répondu et le délai vient d’un composant situé en amont. Si cet appel reste bloqué pendant plusieurs minutes, le délai se produit dans Ollama et votre proxy n’est pas en cause.
Envoyez maintenant la même requête via votre URL publique et mesurez sa durée.
curl -s -o /dev/null -w '%{http_code} %{time_total}\n' \
-X POST https://llm.example.com/api/generate \
-d '{"model": "llama3.1:8b", "prompt": "hi", "stream": false}'Un statut 504 affiché après un nombre de secondes anormalement rond, comme 60.0 ou 30.0, indique un délai d’expiration du proxy. Les proxys utilisent des valeurs par défaut arrondies. Un modèle ne termine pas exactement après 60.000 secondes deux fois de suite. Si l’appel direct est refusé immédiatement au lieu de rester lent, le problème concerne l’écoute sur le port et non le délai d’expiration. l’adresse sur laquelle Ollama écoute sur le port 11434 traite ce cas.
Surveillez le journal du serveur pendant l’exécution de la requête
Ouvrez une deuxième session et suivez le journal du service, puis envoyez à nouveau la requête.
journalctl -u ollama --no-pager --follow --pager-endLors d’un démarrage à froid normal, le journal indique que le modèle est chargé, puis qu’un runner démarre et que la requête est traitée. Un échec du chargement se présente plutôt ainsi dans les versions actuelles, après vérification avec le code source de la version 0.40.11 en octobre 2026. Cette chaîne identifie le délai d’expiration du chargement imposé par le serveur :
timed out waiting for llama-server to start - <last error from the runner>Les anciennes versions, comme 0.12.0, utilisent la formulation timed out waiting for llama runner to start - progress 0.00 -. Dans les deux cas, le processus du modèle n’a pas fini de démarrer dans le délai imparti par le serveur. Dans l’ancienne formulation, l’indicateur de progression montre jusqu’où le chargement est arrivé. La valeur 0.00 signifie que le runner n’a rien signalé avant l’expiration du délai. Cela signifie généralement que le fichier est encore en cours de lecture ou que la machine utilise le swap. Les versions actuelles suppriment cet indicateur et ajoutent la dernière erreur du runner. Ce champ est vide lorsqu’aucune erreur n’a été signalée. Si le journal indique plutôt que la connexion client a été fermée avant la fin du chargement par llama-server, c’est l’appelant, votre client ou un proxy placé devant le serveur, qui a abandonné le premier. Le chargement a alors été interrompu. Pour obtenir plus de détails pendant le chargement, redémarrez le service avec OLLAMA_DEBUG=1 défini, puis recommencez.
Mesurez si le délai vient du chargement ou de la génération
Ollama affiche ses propres durées. Vous n’avez donc pas à deviner l’origine du délai.
ollama run --verbose llama3.1:8b "Why is the sky blue?"Après la réponse, il affiche total duration, load duration, prompt eval count, prompt eval rate, eval count et eval rate. Exécutez la commande deux fois. Lors de la deuxième exécution, load duration doit devenir presque nul, car le modèle est déjà résident en mémoire. Si ce n’est pas le cas, le modèle est déchargé entre les deux exécutions. C’est le cas keep_alive décrit plus bas.
Les mêmes valeurs sont renvoyées par l’API dans le dernier objet JSON, sous la forme load_duration, prompt_eval_duration et eval_duration. La documentation indique que toutes les durées sont exprimées en nanosecondes. Divisez-les donc par 10^9 pour obtenir des secondes.
curl -s http://127.0.0.1:11434/api/generate -d '{
"model": "llama3.1:8b",
"prompt": "Why is the sky blue?",
"stream": false
}' | python3 -c 'import json,sys; d=json.load(sys.stdin); print({k: round(v/1e9, 2) for k, v in d.items() if k.endswith("_duration")})'Examinez la valeur la plus élevée. Si load_duration domine, le problème vient du chargement du modèle. Passez aux deux sections suivantes. Si prompt_eval_duration domine, le traitement du prompt est le principal coût. Passez à la section num_ctx. Si eval_duration domine, le modèle génère simplement lentement sur ce matériel. Aucun paramètre de timeout ne changera cela. Réduisez la longueur de la sortie avec num_predict ou utilisez un modèle plus petit.
Augmentez OLLAMA_LOAD_TIMEOUT après avoir vérifié votre version
La variable serveur qui contrôle ce comportement est OLLAMA_LOAD_TIMEOUT. Dans le code source de la version 0.40.11, vérifié en octobre 2026, elle définit la durée pendant laquelle le chargement d’un modèle peut rester bloqué avant l’abandon. Sa valeur par défaut est de 5 minutes. Chaque signe de progression du chargement redémarre ce délai. Cette variable n’existe pas du tout dans les versions plus anciennes, comme 0.3.0. Consultez donc la valeur par défaut de votre version, et non celle d’un article, y compris celui-ci. Affichez d’abord la version.
ollama --versionOuvrez ensuite le code source correspondant exactement à ce tag, https://github.com/ollama/ollama/blob/<your version>/envconfig/config.go, puis recherchez OLLAMA_LOAD_TIMEOUT. La valeur indiquée dans ce fichier est la valeur par défaut intégrée à la compilation de votre binaire. Définissez votre propre valeur au moyen d’un systemd drop-in.
sudo systemctl edit ollama.serviceAjoutez les variables dans une section [Service]. C’est la méthode indiquée par la documentation officielle d’Ollama pour Linux :
[Service]
Environment="OLLAMA_LOAD_TIMEOUT=15m"
Environment="OLLAMA_KEEP_ALIVE=-1"sudo systemctl daemon-reload
sudo systemctl restart ollama
systemctl show ollama --property=EnvironmentLa dernière commande affiche l’environnement effectivement reçu par le service. Un résultat vide signifie que le drop-in a été enregistré en dehors des marqueurs de l’éditeur ou sous un nom de section incorrect. Les paramètres définis ne sont donc pas appliqués. Comprenez bien ce que cela change : un délai de chargement plus long empêche le serveur d’abandonner trop tôt, mais n’accélère rien. Si le modèle ne tient pas en mémoire, la machine utilisera le swap, le chargement deviendra très lent et une valeur plus élevée ne fera que repousser l’échec.
Pourquoi la première requête après une pause est lente
Ollama décharge un modèle inactif pour libérer de la mémoire. Le paramètre keep_alive détermine le délai. La documentation d’Ollama indique une valeur par défaut de 5 minutes, vérifiée en octobre 2026. Ainsi, une application de chat utilisée une fois par heure recharge le modèle à chaque message, et chaque message subit l’intégralité du démarrage à froid. La requête qui expire est la première après une période d’inactivité. C’est exactement le schéma que les utilisateurs décrivent comme aléatoire.
Vérifiez ce qui est actuellement chargé en mémoire :
ollama ps
curl -s http://127.0.0.1:11434/api/psUne liste vide ou une expiration prévue dans quelques minutes le confirme. keep_alive accepte une chaîne de durée telle que "10m" ou "24h", un simple nombre de secondes, 0 pour décharger immédiatement le modèle, ainsi qu’un nombre négatif pour le conserver indéfiniment en mémoire. Définissez ce paramètre pour chaque requête ou configurez OLLAMA_KEEP_ALIVE sur le service pour l’appliquer à toutes les requêtes. La valeur de la requête est prioritaire : la documentation d’Ollama précise que le paramètre d’API keep_alive remplace le paramètre OLLAMA_KEEP_ALIVE. Un client qui envoie sa propre valeur keep_alive décharge donc toujours le modèle selon son propre délai.
curl -s http://127.0.0.1:11434/api/generate -d '{
"model": "llama3.1:8b",
"keep_alive": -1
}'Une requête contenant un modèle mais aucun prompt charge le modèle, puis se termine. C’est la méthode documentée pour préchauffer un serveur après un redémarrage. Elle doit être intégrée à une petite unité systemd afin que personne n’attende le premier démarrage à froid après un reboot. Le coût est réel : un modèle maintenu en mémoire conserve cette mémoire indéfiniment. Sur un petit serveur, vous pouvez donc maintenir un modèle en mémoire, pas quatre. Conserver un modèle en mémoire entre les requêtes détaille le calcul de la mémoire et l’unité de préchauffage.
Pourquoi un num_ctx élevé expire avant le premier token
Avant de générer quoi que ce soit, un modèle doit lire l’intégralité de votre prompt. Cette étape s’appelle le prefill, et c’est ce que mesure prompt eval. num_ctx définit la longueur du contexte, avec deux effets simultanés. Il limite le nombre de tokens que le modèle peut prendre en compte et dimensionne le KV cache (key value cache) que le serveur alloue au démarrage. Dans les deux cas, la charge de travail augmente.
Sur un serveur uniquement équipé d’un CPU, le prefill est lent et sa durée augmente linéairement avec le nombre de tokens du prompt. Un long document collé dans un chat peut rester plusieurs minutes en prefill sans que le client n’affiche quoi que ce soit, car le streaming n’a pas encore commencé. Le délai d’attente du client expire et celui-ci signale context deadline exceeded, alors que le serveur a travaillé pendant tout ce temps. Vérifiez-le avec les valeurs de la section précédente. Envoyez le long prompt et consultez prompt_eval_count et prompt_eval_duration, qui correspondent, dans Ollama, au temps consacré à l’évaluation des tokens du prompt non mis en cache. Plusieurs minutes à cet endroit, avec un eval_duration faible, indiquent un prefill. Seuls les tokens non mis en cache étant comptabilisés, une nouvelle exécution du même prompt sur un modèle qui est toujours chargé peut afficher une valeur beaucoup plus faible. Comparez donc les premières exécutions. Pour mesurer le coût d’un cache plus volumineux, exécutez le prompt avec "options": {"num_ctx": 2048}, puis avec 32768, et consultez également load_duration, car le temps consacré au chargement du modèle y est indiqué, et non dans prompt_eval_duration.
La valeur par défaut du serveur provient de OLLAMA_CONTEXT_LENGTH. Une valeur num_ctx par requête dans l’objet options la remplace. L’erreur courante consiste à l’augmenter jusqu’à la valeur maximale annoncée par le modèle simplement parce que cette valeur existe. L’allocation du KV cache peut en effet faire sortir le modèle de la RAM et transformer une configuration fonctionnelle en configuration utilisant le swapping. La section Choisir num_ctx en fonction de votre mémoire réelle détaille le dimensionnement.
Pourquoi nginx renvoie 504 Gateway Time-out
nginx documente proxy_read_timeout avec une valeur par défaut de 60s, et son error log décrit clairement l’échec :
upstream timed out (110: Connection timed out) while reading response header from upstreamLe point important se trouve dans la documentation nginx : le timeout « s’applique uniquement entre deux opérations de lecture successives, et non à la transmission de l’ensemble de la réponse ». Une réponse en streaming réinitialise le délai à chaque chunk. Les chats en streaming peuvent donc durer. Une requête avec "stream": false n’envoie rien avant que la réponse soit terminée. Toute la génération doit donc s’achever dans cette seule fenêtre. C’est pourquoi le même modèle fonctionne dans la fenêtre de chat, mais expire depuis un script.
location / {
proxy_pass http://127.0.0.1:11434;
proxy_http_version 1.1;
proxy_set_header Host $host;
proxy_read_timeout 600s;
proxy_send_timeout 600s;
proxy_buffering off;
}sudo nginx -t && sudo systemctl reload nginxproxy_buffering off est important pour le streaming. Lorsque le buffering est activé, nginx peut accumuler la réponse et la transmettre à la fin. Les tokens cessent alors d’apparaître un par un, et un flux fonctionnel commence à ressembler à un blocage.
Traefik place le même réglage dans le ServersTransport utilisé par le router.
http:
serversTransports:
ollama:
forwardingTimeouts:
dialTimeout: "30s"
responseHeaderTimeout: "0s"
idleConnTimeout: "60s"responseHeaderTimeout couvre l’attente des response headers après l’écriture de la requête, et la valeur 0 désactive le timeout. Le service doit référencer le transport par son nom avec serversTransport: ollama. Sinon, vous avez modifié un bloc qui n’est utilisé nulle part.
Une quantification plus légère se charge plus rapidement, car il y a moins de données à lire
La quantification correspond à la précision avec laquelle les poids sont stockés. Une précision inférieure produit un fichier plus petit. Le chargement d’un modèle consiste principalement à lire ce fichier depuis le disque et à le placer en mémoire.
Les données de ce graphique
[
{
"label": "q4_K_M",
"download_size_gb": 4.9
},
{
"label": "q8_0",
"download_size_gb": 8.5
},
{
"label": "fp16",
"download_size_gb": 16
}
]Ces tailles sont celles publiées sur la page du modèle. Elles ne proviennent pas de mesures effectuées sur un serveur de test. La version 8B par défaut fait 4.9 Go. La version en pleine précision du même modèle fait 16 Go. Elle contient plus de trois fois plus d’octets à lire et nécessite plus de trois fois plus de mémoire. Sur un serveur loué avec un stockage partagé, cette différence suffit à faire la distinction entre un chargement qui aboutit et un chargement qui dépasse le délai d’attente. Déterminer quel modèle tient dans votre RAM est la vérification à effectuer avant de télécharger un fichier volumineux.
Modifications à effectuer sur un serveur loué
Appliquez ces modifications dans l’ordre indiqué par les mesures, une par une. Relancez la commande de mesure après chacune d’elles.
- Fixez le modèle avec
OLLAMA_KEEP_ALIVE=-1et préchargez-le au démarrage. Les requêtes utilisateur n’auront ainsi plus à payer le coût du chargement. Vérifiez ensuite qu’aucun client n’envoie sa propre valeurkeep_alive, car une valeur fournie dans la requête remplace le paramètre du serveur. - Réduisez
num_ctxà la valeur réellement nécessaire pour vos prompts. Le prefill est ainsi plus court et la mémoire occupée par le cache KV est libérée. - Utilisez une quantification plus compacte. Le chargement lit ainsi moins d’octets et le modèle laisse davantage de mémoire au cache.
- Augmentez
proxy_read_timeoutdans nginx ouresponseHeaderTimeoutdans Traefik. Désactivez également la mise en buffer pour que les tokens générés en streaming parviennent au client. - Augmentez le timeout dans votre propre client. Un programme Go ou Python limité à 30 secondes échouera avec tout modèle dont le temps de réflexion dépasse cette durée.
Une autre cause peut se cacher derrière tous ces problèmes. Ollama traite un nombre limité de requêtes simultanément et met les autres en file d’attente. Un deuxième appelant peut donc rester dans la file jusqu’à l’expiration de son propre délai, même si aucun modèle n’est lent. Le journal du serveur indique alors que la requête a été traitée tardivement, et non qu’elle a échoué. Ce qui se passe lorsque plusieurs personnes partagent un serveur Ollama présente les paramètres de parallélisme. L’installation de base sur un VPS décrit la configuration du service supposée par ces remplacements.
FAQ
Que signifie « context deadline exceeded » dans Ollama ?
Cela signifie qu’une échéance a expiré avant la fin de l’opération concernée. Il s’agit le plus souvent d’une requête qui attend un modèle, mais cette erreur apparaît aussi pendant le téléchargement des modèles, dans ollama pull ou lors du pull lancé par ollama run. Cette expression vient du package Go context. Elle a donc été affichée par un programme Go : l’outil en ligne de commande Ollama, le serveur Ollama ou une application Go qui appelle l’API. Il s’agit d’un timeout. Rien n’est donc cassé ni corrompu. Si la sortie s’est arrêtée juste après les lignes pulling, considérez qu’il s’agit d’un problème de téléchargement. Dans le cas contraire, cherchez quelle couche a défini l’échéance. Le client, le chargement du modèle et le reverse proxy définissent chacun leur propre délai, tandis que keep_alive et num_ctx déterminent la quantité de travail qui doit tenir dans ces délais.
Dois-je augmenter le timeout de mon client ou celui d’Ollama ?
Commencez par mesurer. Envoyez la requête avec curl directement au serveur, vers http://127.0.0.1:11434, car curl n’impose aucune limite de temps globale. Si cet appel renvoie un corps JSON, Ollama répond. L’échéance appartient donc à votre client ou à votre proxy. Augmentez-la à cet endroit. Si cet appel reste également bloqué, le délai se situe dans Ollama. Les champs load_duration et prompt_eval_duration de la réponse indiquent alors si le modèle est en cours de chargement ou s’il lit votre prompt.
Pourquoi la première requête expire-t-elle alors que la suivante fonctionne ?
Ollama décharge un modèle inactif pour libérer de la mémoire, selon une durée définie par keep_alive. La valeur par défaut documentée est de 5 minutes, vérifiée en octobre 2026. La première requête après une période d’inactivité recharge le modèle depuis le disque et subit tout le démarrage à froid. Une requête envoyée juste après trouve le modèle déjà chargé et répond rapidement. Exécutez ollama ps pour voir les modèles chargés et leur heure d’expiration. Définissez OLLAMA_KEEP_ALIVE=-1 pour conserver le modèle en mémoire, en sachant que la mémoire restera occupée. Un client qui envoie son propre keep_alive remplace ce réglage. Vérifiez donc aussi la configuration de vos clients.
Pourquoi cela échoue-t-il uniquement lorsque je passe par nginx ?
nginx documente proxy_read_timeout avec une valeur par défaut de 60s. Ce timeout s’applique entre deux lectures successives et non à l’ensemble de la réponse. Une réponse en streaming réinitialise ce délai à chaque chunk, tandis qu’une requête envoyée avec "stream": false doit se terminer dans une seule fenêtre. C’est pourquoi l’interface de chat fonctionne alors qu’un script échoue. Recherchez upstream timed out (110: Connection timed out) while reading response header from upstream dans le journal d’erreurs de nginx, puis augmentez proxy_read_timeout et définissez proxy_buffering off.
Augmenter OLLAMA_LOAD_TIMEOUT accélère-t-il le chargement ?
Non. Ce réglage modifie uniquement la durée pendant laquelle le serveur laisse un chargement bloqué avant d’abandonner et de journaliser timed out waiting for llama-server to start, ou timed out waiting for llama runner to start dans les builds plus anciennes. Si le modèle ne tient pas en mémoire, la machine utilise le swap. Le chargement devient très lent, et un timeout plus long ne fait que retarder l’échec sans le corriger. Vérifiez la valeur par défaut de votre build en exécutant ollama --version et en lisant envconfig/config.go sur ce tag. Considérez ensuite qu’un chargement qui nécessite plusieurs minutes indique qu’il faut télécharger une quantisation plus petite.