Ollama : définition, fonctionnement et usage en local

Ollama est un outil qui transforme un ordinateur en serveur de modèles de langage. Une commande suffit pour télécharger un LLM à poids ouverts et discuter avec lui dans le terminal ; en arrière-plan, une API locale permet à n'importe quelle application de l'interroger comme elle interrogerait un service cloud.

Apparu en 2023, au moment où les modèles ouverts de type Llama devenaient utilisables sur du matériel grand public, Ollama a repris une idée familière aux développeurs : celle de Docker. On « tire » un modèle d'une bibliothèque comme on tire une image, on le lance avec run, et on le personnalise avec un fichier de configuration, le Modelfile, dont la syntaxe rappelle celle d'un Dockerfile. L'outil est écrit en Go et distribué sous licence MIT.

Sous le capot, Ollama s'appuie sur l'écosystème de llama.cpp, la bibliothèque d'inférence en C/C++ qui a rendu possible l'exécution de LLM sur CPU et sur les puces Apple. Les modèles sont stockés au format GGUF, généralement dans une version quantifiée, ce qui réduit leur taille d'un facteur trois à quatre par rapport à la version 16 bits. C'est ce qui permet de faire tourner un modèle de plusieurs milliards de paramètres sur un ordinateur portable.

À retenir : Ollama est pensé pour le poste de travail et le prototypage. Il rend l'exécution locale d'un LLM triviale, mais ce n'est pas un serveur conçu pour des centaines d'utilisateurs simultanés.

Une fois Ollama installé, les commandes essentielles tiennent en quelques lignes :

ollama pull llama3.2      # télécharge le modèle
ollama run llama3.2       # ouvre une conversation dans le terminal
ollama list               # liste les modèles installés
ollama ps                 # affiche les modèles chargés en mémoire
ollama rm llama3.2        # supprime un modèle

Le service écoute sur http://localhost:11434. L'API REST native se teste avec curl :

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [{"role": "user", "content": "Explique la quantization en deux phrases."}],
  "stream": false
}'

Côté Python, on peut utiliser la bibliothèque officielle ou, pour garder un code portable, le SDK OpenAI pointé vers l'endpoint compatible :

from openai import OpenAI

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

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Donne trois idées de projets avec un LLM local."}],
)
print(response.choices[0].message.content)

Le même code fonctionnera plus tard avec une API cloud ou un serveur vLLM en changeant simplement base_url et model. C'est l'une des raisons pour lesquelles Ollama est si utilisé pour prototyper un RAG ou un agent avant de choisir l'infrastructure définitive. Notre tutoriel Ollama : exécuter des LLM en local détaille l'installation et le choix des modèles.

Le Modelfile décrit un modèle dérivé d'un modèle existant. Il ne réentraîne rien : il fixe des paramètres et des instructions appliqués à chaque requête.

FROM llama3.2

PARAMETER temperature 0.3
PARAMETER num_ctx 8192

SYSTEM """
Tu es l'assistant du support interne. Tu réponds en français,
en trois phrases maximum, et tu indiques quand tu ne sais pas.
"""

ollama create support-fr -f Modelfile
ollama run support-fr

FROM désigne le modèle de base (un nom de la bibliothèque ou un fichier GGUF local), PARAMETER règle la génération (température, taille de contexte en tokens, séquences d'arrêt) et SYSTEM définit le prompt système. D'autres instructions permettent de modifier le modèle de chat ou d'ajouter un adaptateur LoRA.

Un modèle de 8 milliards de paramètres stocké en 16 bits pèse environ 16 Go, hors de portée de la plupart des portables. La quantization réduit la précision de chaque poids, par exemple à 4 bits, et ramène ce même modèle autour de 5 Go, avec une perte de qualité souvent modérée.

Le format GGUF, issu de l'écosystème llama.cpp, regroupe en un seul fichier les poids quantifiés, le tokenizer et les métadonnées du modèle. Les noms des variantes indiquent le niveau de quantization : Q4_K_M (4 bits, bon compromis courant), Q8_0 (8 bits, plus fidèle et plus lourd), etc. Dans Ollama, une étiquette de modèle comme llama3.2:3b ou qwen2.5:7b correspond par défaut à une version quantifiée choisie pour son équilibre entre taille et qualité.

En pratique, la règle est simple : le modèle doit tenir dans la mémoire du GPU (ou dans la mémoire unifiée d'un Mac) pour être rapide. S'il déborde, une partie du calcul bascule sur le CPU et la vitesse chute nettement.

Pour le détail du match entre les deux outils locaux, voir notre comparatif LM Studio vs Ollama.

Rien n'empêche d'installer Ollama sur un serveur, et la variable OLLAMA_HOST permet d'écouter sur le réseau plutôt qu'en local. Plusieurs points doivent cependant être anticipés :

• Sécurité : l'API n'a pas d'authentification intégrée. Elle doit être placée derrière un reverse proxy qui contrôle les accès, jamais exposée directement.
• Concurrence : Ollama peut traiter quelques requêtes en parallèle (réglable via OLLAMA_NUM_PARALLEL), mais son ordonnancement n'est pas conçu pour des dizaines d'utilisateurs simultanés.
• Mémoire : les modèles sont chargés et déchargés à la demande ; un temps de chargement s'ajoute à la première requête après une période d'inactivité, sauf à ajuster OLLAMA_KEEP_ALIVE.
• Mise à l'échelle : Ollama fonctionne sur un seul nœud ; répartir la charge entre plusieurs machines demande une couche supplémentaire.

Pour une équipe réduite ou un outil interne, ces limites sont souvent acceptables. Au-delà, la bonne pratique consiste à garder Ollama pour le développement et à servir le même modèle avec vLLM en production.