Comment Exécuter un LLM en Local avec Ollama

Chaque appel à une API de LLM hébergée envoie votre prompt vers le serveur de quelqu’un d’autre et vous facture par token. Coupez la connexion, et elle arrête de répondre. Ollama supprime ces deux problèmes : il récupère un modèle à poids ouverts sur votre machine et le sert via une API REST sur localhost:11434. Un seul binaire fait office de gestionnaire de modèles, de client de chat et de serveur.

Ce qu’Ollama fait réellement

Ollama encapsule llama.cpp et des moteurs d’inférence similaires, si bien que vous ne touchez jamais à un flag de compilateur ni à un chemin de bibliothèque CUDA. ollama pull llama3.2 récupère un fichier de modèle quantifié (format GGUF) depuis le registre d’Ollama plutôt que depuis Hugging Face, même s’il sait aussi importer des fichiers GGUF directement depuis Hugging Face. Quand vous exécutez le modèle, ses poids sont envoyés à un serveur en arrière-plan qui les charge en RAM (ou en VRAM, s’il trouve un GPU compatible), les garde en mémoire quelques minutes après votre dernière requête pour que la suivante soit rapide, puis les libère dès que vous arrêtez de poser des questions.

La CLI, l’API et le système de Modelfiles reposent tous sur la même tâche : mettre les poids en mémoire, router les requêtes vers eux.

Comment installer Ollama et exécuter votre premier modèle

Sous Linux ou macOS :

1

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

Sous Windows, exécutez l’installeur depuis ollama.com, ou utilisez :

1

irm https://ollama.com/install.ps1 | iex

Dans les deux cas, vous obtenez la CLI ollama et un serveur en arrière-plan qui écoute sur le port 11434. Récupérez un petit modèle et parlez-lui :

1
2

ollama pull llama3.2
ollama run llama3.2

ollama run vous place dans un prompt interactif. Posez une question, lisez la réponse, /bye pour quitter. Trois autres commandes que vous utiliserez constamment :

1
2
3

ollama list   # les modèles récupérés, avec leur taille sur le disque
ollama ps     # les modèles actuellement chargés en mémoire
ollama rm llama3.2   # libère l'espace disque

llama3.2 est un bon premier choix : environ 2 Go, assez rapide pour tourner sur le CPU d’un ordinateur portable. Ce n’est pas le modèle le plus performant de sa catégorie de taille. gemma4 domine actuellement le segment des petits modèles et gère aussi les images, et qwen3-coder est le meilleur choix si vous testez de l’assistance au code. Commencez quand même par llama3.2, car cela confirme que votre installation fonctionne avant de vous engager dans un téléchargement de 20 Go.

Comment dialoguer avec Ollama via son API REST

Le prompt interactif sert à vérifier que tout fonctionne. Tout ce que vous construisez appelle l’API. Le format natif d’Ollama ressemble à ceci :

1
2
3
4
5

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Write a one-line commit message for a typo fix in README.md",
  "stream": false
}'

Avec "stream": false, vous recevez un seul objet JSON, incluant eval_count et eval_duration, suffisant pour mesurer les tokens par seconde sur votre propre matériel. Passez-le à true et vous obtenez à la place une série d’objets de réponse partielle, ce dont une interface de chat a besoin.

Pour les conversations à plusieurs tours, /api/chat prend un tableau messages dans le même format que celui utilisé par l’API d’OpenAI :

1
2
3
4
5
6
7

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "What port does Ollama listen on by default?"}
  ],
  "stream": false
}'

Ollama reproduit aussi nativement le format de l’API OpenAI sur /v1, si bien que les SDK officiels d’OpenAI fonctionnent avec lui sans modification :

1
2
3
4
5
6
7
8
9

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": "Summarize this changelog in two sentences."}],
)
print(response.choices[0].message.content)

Ollama ignore api_key, mais le constructeur du SDK en exige une, donc n’importe quelle chaîne non vide convient. C’est ce qui en fait le moyen le plus rapide de pointer un outil déjà basé sur OpenAI vers un modèle local : vous changez base_url et laissez le reste du code tel quel.

Un autre endpoint compte si vous assemblez une pipeline de retrieval-augmented generation en local. POST /api/embed transforme du texte en vecteurs à l’aide d’un modèle d’embedding (nomic-embed-text est le choix habituel), ce qu’un modèle de chat seul ne vous donne pas.

Comment exécuter Ollama dans Docker

Si tout le reste sur la machine est déjà un conteneur, Ollama fournit une image officielle plutôt que de vous demander d’installer quoi que ce soit sur l’hôte :

1
2
3
4
5

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

Le volume nommé n’est pas optionnel en pratique : sans lui, chaque modèle récupéré disparaît dès que le conteneur est supprimé. Pour récupérer et exécuter un modèle dans le conteneur en cours d’exécution :

1

docker exec -it ollama ollama run llama3.2

Sur une machine avec un GPU NVIDIA, installez d’abord le NVIDIA Container Toolkit sur l’hôte, puis ajoutez un seul flag :

1
2
3
4
5

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

Les GPU AMD utilisent un tag d’image différent et des montages de périphériques au lieu de --gpus :

1
2
3
4
5

docker run -d --device /dev/kfd --device /dev/dri \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama:rocm

La même chose sous forme de service Docker Compose conserve le port et le volume, rien de plus :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama

volumes:
  ollama:

Exposer ce conteneur au-delà de localhost est le travail d’un reverse proxy avec TLS devant, comme pour n’importe quel autre service backend. Ollama n’intègre aucune authentification, donc un port 11434 accessible depuis le réseau est un serveur de modèles que n’importe qui peut utiliser.

Comment personnaliser un modèle avec un Modelfile

Un Modelfile fixe un system prompt, une température et une séquence d’arrêt sur un modèle existant sans le réentraîner. Créez un fichier nommé Modelfile :

1
2
3
4
5
6
7
8

FROM llama3.2

PARAMETER temperature 0.3

SYSTEM """
You are a terse code reviewer. Reply with the diff and one sentence of
rationale. Never restate the code you were not asked to change.
"""

Puis construisez-le et exécutez-le :

1
2

ollama create code-reviewer -f Modelfile
ollama run code-reviewer

code-reviewer apparaît désormais comme sa propre entrée dans ollama list, même si les poids sont exactement ceux utilisés par llama3.2. Seuls le system prompt et les paramètres d’échantillonnage sont intégrés. L’avantage, c’est que chaque client appelant ce nom hérite de la configuration sans avoir à l’envoyer.

Quelle taille de modèle convient à votre RAM

Le nombre dans le nom d’un modèle est son nombre de paramètres, et il prédit assez bien la quantité de RAM (ou de VRAM, pour l’inférence sur GPU) dont vous avez besoin :

Ces chiffres supposent la quantification en 4 bits qu’Ollama récupère par défaut : au prix d’une petite perte de qualité de sortie, elle divise par environ quatre la taille du téléchargement et l’encombrement mémoire par rapport aux poids en pleine précision. Pour résumer du texte ou rédiger des messages de commit, la quantification n’est pas ce que vous remarquerez. Manquer de RAM, si. Une fois que le modèle déborde sur le swap disque, il passe de lent à inutilisable, une différence bien plus importante qu’un point de précision.

Quand Ollama n’est pas le bon outil

Ollama est conçu pour un seul utilisateur parlant à un seul modèle sur une seule machine. Il ne fait aucun batching de requêtes ni aucun ordonnancement permettant à un GPU de servir efficacement des dizaines d’utilisateurs simultanés, ce qui est le rôle de vLLM, TGI ou d’une API hébergée. Si vous placez un modèle local devant du trafic réel, mesurez le débit d’Ollama sous charge concurrente avant de vous engager : une seule instance s’effondre bien avant un serveur avec un vrai batching.

Ce n’est pas non plus un outil de fine-tuning. Un Modelfile change un system prompt et des paramètres d’échantillonnage, jamais les poids. Entraîner le modèle à un nouveau comportement à partir de vos propres exemples relève d’un pipeline à part.

Aucune de ces deux limites ne concerne un développeur sur son ordinateur portable. Récupérez un modèle qui tient confortablement sous votre plafond de RAM, exécutez-le une fois depuis la CLI, puis interrogez-le avec curl sur /api/generate. Si la réponse revient en quelques secondes et correspond à ce que vous attendiez, vous disposez d’un serveur d’inférence local que n’importe quel outil compatible OpenAI peut utiliser.

Articles associés

• Qu’est-ce que le RAG : Retrieval-Augmented Generation
• Qu’est-ce que Docker Compose et Comment l’Utiliser
• Qu’est-ce qu’un Reverse Proxy et Comment Il Fonctionne