Ollama, faire tourner des LLM en local

As-tu déjà eu envie de discuter avec une IA sans pouvoir envoyer tes données dans le cloud ? Ou voulu expérimenter avec différents modèles sans payer pour des tokens ? Ou peut-être simplement voulu garder le contrôle total sur ce qu'il advient de tes données ?

Ollama résout ces problèmes de la façon la plus simple possible. Une seule commande, et tu as un modèle de langage puissant qui tourne en local sur ton ordinateur : pas de cloud, pas d'abonnement, pas de limite de tokens.

Qu'est-ce qu'Ollama ?

Ollama est un framework gratuit et open source pour télécharger, exécuter et gérer de grands modèles de langage (LLM) sur ton ordinateur. Il fonctionne comme Docker pour les modèles d'IA : tu tapes une commande, et Ollama s'occupe du reste : il télécharge le modèle, configure la quantification, gère la mémoire et démarre un serveur API local.

Sous le capot, Ollama s'appuie sur la bibliothèque llama.cpp, qui fournit une couche d'abstraction masquant les détails bas niveau et rendant le travail avec des modèles locaux aussi simple que ollama run llama3.2.

Le projet compte plus de 178 000 étoiles sur GitHub et une licence MIT, et la version actuelle porte le numéro 0.32.6, datée du 4 août 2026. Les versions correctives sortent ici environ chaque semaine, si bien que le troisième chiffre du numéro de version change plus vite qu'on ne peut l'écrire. Le programme lui-même est écrit en Go.

Quelle quantité de matériel cela demande vraiment

C'est la question qui décide si les modèles locaux ont un sens pour toi, et la plupart des articles l'esquivent ou y répondent de façon vague.

La règle de calcul est d'environ un demi-gigaoctet de mémoire par milliard de paramètres en quantification quatre bits. Un modèle de 7 milliards de paramètres (7B) demande environ 4 Go, un modèle 13B environ 8 Go, un modèle 70B environ 40 Go. Ajoute un peu de marge pour la fenêtre de contexte, qui grandit avec la longueur de la conversation.

La distinction clé, c'est l'endroit où cette mémoire se trouve. Sur une machine avec une carte graphique dédiée, le modèle se charge dans la mémoire vidéo et tourne vite. Sans carte dédiée, il atterrit dans la mémoire système et tourne sur le processeur, ce qui est plusieurs fois plus lent mais reste utilisable pour des réponses courtes.

Les puces Apple Silicon occupent une position intermédiaire qui s'avère payante ici, car la mémoire est partagée entre le processeur et la puce graphique : un ordinateur portable avec 32 Go gère des modèles qui demanderaient une carte graphique coûteuse sur un ordinateur de bureau.

Le conseil pratique : commence par un modèle autour de 8B. Il tient presque partout, répond assez vite pour que ce soit utile, et te permet de savoir si toute l'approche convient à ton travail avant de dépenser de l'argent en matériel.

La quantification, ou ce que tu perds en échange

Le terme revient dans chaque description de modèle et mérite d'être compris, car il détermine directement ce que tu peux faire tourner.

En pleine précision, un modèle occupe environ 2 Go par milliard de paramètres. La quantification réduit la précision des poids, et la quantification quatre bits ramène cela à environ un quart. C'est pour ça qu'un modèle qui demanderait 28 Go tient dans 8 et tourne sur du matériel ordinaire.

La qualité baisse, mais pas de façon linéaire. Entre la pleine précision et huit bits, la différence est à peine perceptible. Entre huit et quatre bits, elle devient visible sur les tâches difficiles et négligeable sur les tâches simples. En dessous de quatre bits, ça se voit clairement : le modèle commence à faire des erreurs basiques et à perdre le fil des instructions longues.

La règle à laquelle la plupart des gens arrivent par l'expérience : un modèle plus gros quantifié plus agressivement bat généralement un modèle plus petit en plus haute précision, tant que tu restes à quatre bits ou au-dessus.

Pourquoi Ollama ?

Confidentialité des données

C'est la raison principale pour laquelle on se tourne vers Ollama. Tes données ne quittent jamais ton ordinateur. Aucun prompt, aucune réponse, aucun fichier n'est envoyé vers un cloud quelconque. Pour les entreprises qui travaillent avec des données sensibles, du code source ou de la documentation interne, ça change tout.

Coûts d'exploitation nuls

Une fois le modèle téléchargé, tu ne paies ni pour les tokens, ni pour les appels API, ni pour un abonnement. Le modèle tourne sur ton matériel, et le seul coût, c'est l'électricité. Si tu utilises l'IA intensivement au travail, les économies peuvent être considérables.

Simplicité

Ollama fait une seule chose, et il la fait bien. Pas de configuration compliquée, pas de tableaux de bord, pas d'assistants d'installation. L'installation tient en une commande, lancer un modèle tient en une commande, et l'intégration avec des applications se résume à un réglage d'URL.

Travail hors ligne

Une fois téléchargé, un modèle fonctionne sans internet. C'est parfait en avion, dans les endroits sans WiFi, ou dans des environnements à accès réseau restreint.

Comparaison avec les alternatives

Installation

macOS

brew install ollama

Ou télécharge l'installeur natif depuis ollama.com.

Linux

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

Windows

Télécharge l'installeur depuis ollama.com ou utilise WSL2 :

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

Docker

docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Avec le support GPU (NVIDIA) :

docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama

Premiers pas

Lancer un modèle

Après l'installation, une seule commande suffit :

ollama run llama3.2

Ollama télécharge automatiquement le modèle (s'il n'a pas déjà été téléchargé) et démarre une session de chat interactive. Tu peux directement commencer à écrire et à recevoir des réponses.

Commandes de base

ollama run llama3.2         # Lance un modèle et démarre le chat
ollama pull gemma3           # Télécharge un modèle sans le lancer
ollama list                  # Affiche les modèles installés
ollama ps                    # Affiche les modèles en cours d'exécution
ollama rm llama3.2           # Supprime un modèle
ollama show llama3.2         # Affiche les détails du modèle
ollama serve                 # Démarre le serveur API (sans interface)

Travailler avec un modèle

En mode interactif, tu peux simplement discuter avec le modèle :

>>> Explique ce qu'est TypeScript en 3 phrases

TypeScript est un sur-ensemble de JavaScript qui ajoute le typage statique au langage.
Il permet de détecter les erreurs à la compilation, avant que le code n'atteigne le navigateur
ou l'environnement Node.js. Il est développé par Microsoft et est devenu la référence
dans les grands projets frontend et backend.

Mode multimodal

Les modèles avec support de la vision (par exemple Llama 3.2 Vision) permettent d'analyser des images :

ollama run llama3.2-vision
>>> What's in this image? /path/to/screenshot.png

Bibliothèque de modèles

Ollama propose plus de 230 modèles dans sa bibliothèque sur ollama.com/library. Voici les plus importants :

Modèles généralistes

Modèles de code

Modèles de vision

Modèles d'embeddings

Comment choisir un modèle ?

• 8 Go de RAM : Llama 3.2 3B, Gemma 3 1B, Phi-3 3.8B
• 16 Go de RAM : Llama 3.1 8B, Gemma 3 4B, Mistral 7B
• 32 Go de RAM : Gemma 3 12B-27B, DeepSeek-R1 14B
• 64 Go de RAM et plus : Llama 3.1 70B, DeepSeek-R1 32B+

Règle générale : commence par un modèle plus petit (3B-8B) et monte en taille selon tes besoins et le matériel disponible.

Les tableaux ci-dessus listent des modèles éprouvés et largement documentés, pas tout ce qui sort de nouveau. La bibliothèque suit les sorties, donc elle porte aussi les générations suivantes des mêmes familles, parmi lesquelles llama4, gemma4 et qwen3. Vérifie la page de la bibliothèque avant de choisir, car les noms et les tailles disponibles changent tous les quelques mois.

API REST

Ollama lance un serveur API local sur le port 11434, compatible avec le format OpenAI. Cela signifie que de nombreux outils et bibliothèques existants peuvent s'y intégrer sans changement de code.

Générer des réponses

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Explique ce qu'est React",
  "stream": false
}'

API de chat

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "system", "content": "Tu es un assistant de programmation utile."},
    {"role": "user", "content": "Comment créer un hook en React ?"}
  ],
  "stream": false
}'

Générer des embeddings

curl http://localhost:11434/api/embed -d '{
  "model": "nomic-embed-text",
  "input": "Ollama est un framework pour les LLM locaux"
}'

Point de terminaison compatible OpenAI

Ollama propose un point de terminaison compatible avec l'API OpenAI :

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Bonjour !"}
  ]
}'

Cela signifie qu'il suffit de changer le base_url dans le code existant :

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Qu'est-ce que TypeScript ?"}]
)
print(response.choices[0].message.content)

Mode JSON

Forcer les réponses au format JSON :

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Liste 3 frameworks JavaScript sous forme de tableau JSON",
  "format": "json",
  "stream": false
}'

Bibliothèques clientes

Python

pip install ollama

import ollama

response = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Qu'est-ce que Rust ?"}]
)
print(response["message"]["content"])

En streaming :

import ollama

stream = ollama.chat(
    model="llama3.2",
    messages=[{"role": "user", "content": "Écris un poème sur la programmation"}],
    stream=True
)
for chunk in stream:
    print(chunk["message"]["content"], end="", flush=True)

JavaScript/TypeScript

npm install ollama

import { Ollama } from "ollama"

const ollama = new Ollama({ host: "http://localhost:11434" })

const response = await ollama.chat({
  model: "llama3.2",
  messages: [{ role: "user", content: "Qu'est-ce que Next.js ?" }],
})
console.log(response.message.content)

Modelfile, créer ses propres modèles

Un Modelfile est un fichier de configuration (similaire à un Dockerfile) qui permet de créer des variantes personnalisées de modèles. Tu peux changer le prompt système, les paramètres de génération, et même combiner un modèle de base avec tes propres poids.

Modelfile de base

FROM llama3.2

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

SYSTEM """
Tu es un développeur expérimenté en TypeScript et React.
Tu réponds de façon concise et tu fournis des exemples de code pratiques.
Tu utilises toujours les derniers patterns et les meilleures pratiques.
"""

Créer et lancer

ollama create typescript-helper -f Modelfile
ollama run typescript-helper

Modelfile avancé

FROM llama3.2

PARAMETER temperature 0.2
PARAMETER top_p 0.85
PARAMETER repeat_penalty 1.1
PARAMETER num_ctx 8192

TEMPLATE """
{{ if .System }}<|start_header_id|>system<|end_header_id|>
{{ .System }}<|eot_id|>{{ end }}{{ if .Prompt }}<|start_header_id|>user<|end_header_id|>
{{ .Prompt }}<|eot_id|>{{ end }}<|start_header_id|>assistant<|end_header_id|>
{{ .Response }}<|eot_id|>
"""

SYSTEM """
Tu es un assistant de revue de code. Analyse le code à la recherche de bugs, de problèmes
de sécurité et de problèmes de performance. Propose toujours des améliorations concrètes avec des exemples de code.
"""

Importer des modèles GGUF

Si tu as un modèle au format GGUF (par exemple depuis Hugging Face), tu peux l'importer :

FROM ./my-model-q4_K_M.gguf

PARAMETER temperature 0.8
SYSTEM "Tu es un assistant utile."

ollama create my-custom-model -f Modelfile

Accélération GPU

Ollama détecte et utilise automatiquement les GPU disponibles :

NVIDIA (CUDA)

Prérequis : capacité de calcul 5.0 ou plus et pilote en version 550 ou plus récent. Les cartes avec une capacité de calcul comprise entre 5.0 et 6.2 ont besoin du pilote 570 ou plus récent.

ollama run llama3.2

Ollama utilise automatiquement CUDA si disponible. Pour plusieurs GPU :

CUDA_VISIBLE_DEVICES=0,1 ollama serve

Apple Silicon (Metal)

Sur les Mac avec puces M1/M2/M3/M4, Ollama utilise automatiquement Metal. Apple Silicon est particulièrement bien pris en charge : la mémoire unifiée permet même aux modèles plus gros de tourner sans accroc.

AMD (ROCm)

Cartes AMD prises en charge avec ROCm. Le flash attention est activé automatiquement.

Performance GPU

Vitesse de génération approximative (tokens/s) pour Llama 3.1 8B :

Docker et déploiement en production

Docker Compose de base

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

volumes:
  ollama-data:

Avec Open WebUI

Une combinaison populaire : Ollama comme backend + Open WebUI comme interface graphique :

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama-data:/root/.ollama
    restart: unless-stopped

  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://ollama:11434
    volumes:
      - open-webui-data:/app/backend/data
    depends_on:
      - ollama
    restart: unless-stopped

volumes:
  ollama-data:
  open-webui-data:

Précharger les modèles dans Docker

FROM ollama/ollama

RUN ollama serve & sleep 5 && ollama pull llama3.2 && ollama pull nomic-embed-text

Configuration

Variables d'environnement

Partager sur le réseau local

Par défaut, Ollama écoute uniquement sur localhost. Pour le partager sur le réseau :

OLLAMA_HOST=0.0.0.0:11434 ollama serve

Changer le répertoire des modèles

Les modèles peuvent occuper beaucoup d'espace. Pour les déplacer sur un autre disque :

OLLAMA_MODELS=/mnt/ssd/ollama/models ollama serve

Intégrations

L'écosystème Ollama compte plus de 50 intégrations :

Interfaces graphiques

• Open WebUI : l'interface web la plus populaire, elle ressemble à ChatGPT
• LibreChat : chat multi-fournisseurs avec prise en charge de plusieurs modèles
• Chatbox : application de bureau multiplateforme
• Enchanted : application macOS native
• Lobe Chat : interface moderne avec des plugins

Frameworks IA

• LangChain : construction de pipelines RAG, d'agents, de chaînes
• LlamaIndex : indexation de documents et recherche sémantique
• CrewAI : orchestration d'équipes d'agents IA
• AutoGen : conversations multi-agents, le projet est passé en mode maintenance et s'est scindé en plusieurs successeurs

Outils pour développeurs

• Continue : assistant de code dans VS Code et JetBrains
• Aider : pair programming IA dans le terminal
• Cody : assistant de code IA de Sourcegraph
• GitHub Copilot (backend self-hosted) : via l'API compatible OpenAI

RAG et recherche

• RAGFlow : moteur RAG qui lit la mise en page des documents : tableaux, colonnes et scans
• AnythingLLM : IA tout-en-un avec RAG
• PrivateGPT : questions-réponses privées sur des documents

Cas d'usage pratiques

Assistant de codage

ollama create code-assistant -f - <<EOF
FROM codellama:13b
PARAMETER temperature 0.3
SYSTEM "Tu es un ingénieur logiciel senior. Écris du code propre et bien testé. Inclue toujours la gestion des erreurs."
EOF

ollama run code-assistant
>>> Écris une fonction TypeScript qui récupère des données avec une logique de nouvelle tentative

Analyse de code source

cat src/components/App.tsx | ollama run llama3.2 "Passe en revue ce composant React à la recherche de problèmes potentiels"

Génération de documentation

cat src/utils/helpers.ts | ollama run llama3.2 "Génère une documentation JSDoc pour ces fonctions"

Traductions locales

ollama run llama3.2 "Traduis en français : The quick brown fox jumps over the lazy dog"

RAG avec tes propres documents

Combiner Ollama avec LlamaIndex pour effectuer une recherche dans tes propres documents :

from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

llm = Ollama(model="llama3.2", request_timeout=120)
embed = OllamaEmbedding(model_name="nomic-embed-text")

documents = SimpleDirectoryReader("./docs").load_data()
index = VectorStoreIndex.from_documents(documents, embed_model=embed)
query_engine = index.as_query_engine(llm=llm)

response = query_engine.query("Comment configurer l'authentification ?")
print(response)

Configuration matérielle requise

Minimale

• RAM : 8 Go (modèles 1B-3B)
• Disque : 5-10 Go par modèle
• CPU : n'importe quel processeur x86_64 ou ARM64 moderne
• GPU : optionnel (accélère nettement les choses)

Recommandée

• RAM : 16-32 Go (modèles 7B-13B)
• Disque : SSD avec au moins 50 Go d'espace libre
• GPU : NVIDIA RTX 3060 ou mieux (12 Go de VRAM) ou Apple Silicon M1 ou plus récent
• CPU : 8 cœurs ou plus

Pour les gros modèles (70B+)

• RAM : 64-128 Go
• GPU : NVIDIA RTX 4090 (24 Go) ou 2x RTX 3090
• Disque : SSD NVMe

Astuces et conseils

Commandes pipe rapides

echo "Explique Docker en un paragraphe" | ollama run llama3.2

cat error.log | ollama run llama3.2 "Qu'est-ce qui cause ces erreurs ?"

git diff | ollama run llama3.2 "Résume ces changements de code"

Garder le modèle en mémoire

OLLAMA_KEEP_ALIVE=-1 ollama serve

Une valeur de -1 garde le modèle en mémoire indéfiniment, ce qui élimine le temps de chargement.

Requêtes en parallèle

OLLAMA_NUM_PARALLEL=4 ollama serve

Permet de traiter 4 requêtes simultanément : utile quand plusieurs utilisateurs partagent un même serveur.

Monitoring

ollama ps

Affiche les modèles actuellement chargés, l'utilisation mémoire et l'heure de dernière utilisation.

FAQ

Ollama est-il gratuit ?

Oui, Ollama est entièrement gratuit et open source sous licence MIT. Il n'y a ni forfaits payants, ni limites, ni coûts cachés.

Quels GPU sont pris en charge ?

NVIDIA avec CUDA (capacité de calcul 5.0 ou plus), Apple Silicon avec Metal, AMD avec ROCm, et Vulkan comme solution de repli.

Puis-je lancer un modèle sans GPU ?

Oui, mais ce sera nettement plus lent. L'inférence sur CPU fonctionne, en particulier pour les modèles plus petits (1B-7B).

De combien d'espace disque ai-je besoin ?

Ça dépend du modèle. Llama 3.2 3B fait environ 2 Go, Llama 3.1 8B environ 4,9 Go, Llama 3.1 70B environ 43 Go.

Puis-je utiliser des modèles de Hugging Face ?

Oui, Ollama prend en charge l'import de modèles au format GGUF via Modelfile. De nombreux modèles Hugging Face sont aussi disponibles directement dans la bibliothèque Ollama.

Comment partager Ollama avec d'autres sur le réseau ?

Configure OLLAMA_HOST=0.0.0.0:11434 et vérifie que le port est ouvert dans ton pare-feu.

Ollama prend-il en charge le function calling ?

Oui, les versions récentes d'Ollama prennent en charge le tool calling, qui permet aux modèles d'invoquer des fonctions externes.

Quelle différence avec ChatGPT/Claude ?

ChatGPT et Claude sont des services cloud : tes données partent vers les serveurs d'OpenAI ou d'Anthropic. Ollama fait tourner les modèles en local : les données ne quittent jamais ton ordinateur. Les modèles locaux sont généralement plus petits et moins performants que les meilleurs modèles cloud, mais ils offrent une confidentialité totale.

Puis-je lancer plusieurs modèles en même temps ?

Oui, et par défaut il n'y a rien à régler : le serveur garde jusqu'à trois modèles chargés par GPU en même temps, et trois aussi en fonctionnement sur CPU. La variable OLLAMA_MAX_LOADED_MODELS permet d'augmenter ou de réduire ce nombre. Chaque modèle utilise sa propre RAM ou VRAM, et si le suivant ne tient pas, les requêtes patientent en file d'attente jusqu'à ce qu'un modèle précédent soit déchargé.

La couche cloud, ou la fin de la localité pure

Un changement mérite d'être signalé, que les articles plus anciens ne prennent pas en compte, et qui complique l'image simple selon laquelle « Ollama, c'est un modèle sur ton propre ordinateur ».

Le projet propose aujourd'hui aussi de faire tourner des modèles dans le cloud, facturés selon l'usage du matériel graphique plutôt qu'au token. L'intérêt est concret : les mêmes commandes et la même API servent à la fois un modèle local et un modèle distant, donc tu peux développer sur un petit modèle chez toi et puiser dans des ressources externes quand une tâche a besoin d'un modèle plus gros, sans changer de code.

Je ne donne volontairement aucun tarif précis ici, car les récapitulatifs qui circulent en ligne ne sont pas d'accord entre eux sur les montants de chaque forfait. Vérifie les valeurs actuelles directement auprès du fournisseur.

Une chose mérite d'être remarquée, cela dit, car elle pèse sur la pertinence de cet outil. Si ta raison de te tourner vers des modèles locaux est de garder les données sur ta propre machine, alors utiliser un modèle cloud annule cette raison. Ce n'est pas une critique du projet, puisque les deux options sont présentées clairement, mais lors d'un déploiement dans une organisation, ça vaut le coup de décider explicitement laquelle des deux l'équipe a le droit d'utiliser, avant que quelqu'un n'appelle par réflexe un modèle distant sur des données qui ne devraient jamais sortir.

Quand un modèle local a du sens, et quand il n'en a pas

La réponse honnête est plus mesurée que le récit enthousiaste qui entoure ce sujet.

Ça a du sens partout où les données ne peuvent pas quitter la machine ou l'organisation. Aucun service externe ne surpasse cet argument, et c'est la raison réelle la plus courante pour choisir cette voie.

Ça a du sens pour un travail répétitif à fort volume et à faible difficulté : classification, étiquetage, extraction de données depuis du texte, génération d'embeddings. Là, l'écart de qualité entre un modèle local et le meilleur modèle commercial est faible, tandis que l'écart de coût sur des centaines de milliers d'appels est énorme.

Ça a du sens pour l'apprentissage et le prototypage, car l'absence de compteur qui tourne change la façon de travailler. Tu peux expérimenter sans te soucier du coût d'une tentative ratée.

Ça n'a pas de sens là où la qualité du raisonnement sur des tâches difficiles compte. Les modèles qui tiennent sur du matériel courant sont une classe en dessous des meilleurs modèles commerciaux comme Claude, et à l'écriture de code, à l'analyse de longs documents ou sur des tâches à plusieurs étapes, cette différence se ressent, elle n'est pas cosmétique.

Ça n'a pas de sens non plus comme façon d'économiser à petite échelle. L'électricité, le matériel et le temps passé sur la configuration coûtent plus cher, à quelques centaines d'appels par mois, qu'une facture d'API. L'économie commence au volume où la facture d'un service externe devient visible dans le budget.

Intégrer Ollama dans du code existant

Le plus grand avantage pratique ici, c'est une API compatible avec l'interface connue des services commerciaux. Ça veut dire qu'une bibliothèque cliente écrite pour un autre service fonctionne après avoir changé l'adresse de base et la clé, sans réécrire la logique.

Ce même mécanisme fait que les outils d'orchestration, dont LangChain et LlamaIndex, traitent un modèle local comme n'importe quel autre fournisseur. En construisant de la génération augmentée par la recherche, tu peux donc tout garder en interne : le modèle d'embeddings, la base vectorielle et le modèle qui génère la réponse.

Deux différences avec les services commerciaux valent la peine d'être gardées en tête, et elles ne se révèlent que dans le code. La première, c'est l'absence de mise en file d'attente pour toi : le serveur gère un nombre limité de requêtes simultanées et commence à les mettre en file sous charge, ce qui se traduit par un temps de réponse qui augmente plutôt que par une erreur. Avec un seul utilisateur, c'est un détail ; avec une dizaine, ça devient un mur, et le bon outil est alors vLLM, qui regroupe les requêtes à la volée et maintient le débit au lieu d'allonger la file, au prix d'une configuration plus difficile et d'une carte qui contient tout le modèle. La seconde, c'est le premier appel après une pause un peu longue, où le modèle se charge en mémoire et la réponse arrive avec un délai perceptible.

Le code source et les versions se trouvent dans le dépôt Ollama, et le catalogue de modèles se trouve sur le site du projet.