Ollama

À quoi ça sert

Les LLMs (large language models) modernes pèsent plusieurs Go et demandent normalement un GPU. Ollama résout deux problèmes :

• Quantification automatique — Ollama télécharge des versions compressées (4-bit, 5-bit) qui tiennent sur un PC normal (8-16 Go de RAM). Un modèle 7B tourne sur un MacBook récent ou un PC avec carte graphique modeste.
• API HTTP standard — un serveur local sur le port 11434 expose une API REST style OpenAI : tu envoies un prompt, tu reçois une réponse. Plus besoin de comprendre PyTorch ou Transformers pour utiliser un LLM.

Cas d'usage typiques :

• Prototyper sans coût — tester une idée d'application LLM (chatbot, résumé, RAG) sans payer chaque requête à OpenAI.
• Données sensibles — quand tu ne peux pas légalement envoyer les prompts à un service externe (santé, juridique, RGPD strict).
• Air-gapped — fonctionne hors-ligne, ce qui est intéressant pour démos, formation, embarqué.

Un exemple d'usage

Après installation, tu lances un modèle et tu lui parles en une seule ligne :

ollama run llama3.2
# > Comment résoudre une équation du second degré ?
# Pour résoudre ax² + bx + c = 0, on utilise…

Pour l'utiliser depuis Python, on parle à son API HTTP via httpx :

import httpx

response = httpx.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "llama3.2",
        "messages": [{"role": "user", "content": "Résume en 3 puces : python est…"}],
        "stream": False,
    },
    timeout=60.0,
)
print(response.json()["message"]["content"])

Le modèle tourne sur ta machine, la requête ne sort jamais du localhost, et l'API ressemble à celle d'OpenAI — du coup beaucoup de libs et frameworks (LangChain, LlamaIndex) savent parler à Ollama avec le même code qu'à OpenAI.

How-to : installer et utiliser Ollama

1. Installer Ollama

   Ollama est un binaire natif (pas une lib Python). Sur Linux :

   bash Copier

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

   Sur macOS et Windows, c'est une appli graphique téléchargeable depuis ollama.com. Une fois installé, le démon tourne en arrière-plan et expose le port 11434 en local.

   Alternative : Docker

   Si tu préfères ne rien installer en natif : docker run -d -p 11434:11434 ollama/ollama. Le port et l'API restent identiques côté client. Plus propre pour un projet déployé.

2. Télécharger un modèle

   La galerie est sur ollama.com/library. On télécharge avec pull (style Docker) :

   bash Copier

   ollama pull llama3.2          # 2 Go, généraliste rapide
   ollama pull mistral           # 4 Go, qualité supérieure
   ollama pull qwen2.5:7b        # 4 Go, multilingue (bon en français)
   ollama pull nomic-embed-text  # embeddings (pour RAG)
   
   ollama list                  # voir ce qui est installé
   ollama rm llama3.2            # désinstaller

   Le format nom:taille permet de choisir la version (3b, 7b, 13b, 70b…). Plus c'est gros, plus c'est bon, plus il faut de RAM. Un 7B-quantized tient bien sur 8 Go de RAM.

3. Chatter en CLI

   bash Copier

   ollama run llama3.2
   >>> Bonjour, qui es-tu ?
   Je suis Llama 3.2…
   
   # Ctrl-D pour quitter
   
   # Mode "one-shot" sans interactif
   ollama run llama3.2 "Écris un haïku sur Python"

4. Appeler l'API HTTP depuis Python

   Deux endpoints clés : /api/chat (style messages) et /api/generate (prompt brut). Avec httpx :

   python Copier

   import httpx
   
   def chat(prompt: str, model: str = "llama3.2") -> str:
       r = httpx.post(
           "http://localhost:11434/api/chat",
           json={
               "model": model,
               "messages": [{"role": "user", "content": prompt}],
               "stream": False,
           },
           timeout=120.0,
       )
       r.raise_for_status()
       return r.json()["message"]["content"]
   
   print(chat("Explique l'overfitting en 2 phrases"))

5. Streaming (réponse mot par mot)

   Pour un chatbot, on veut afficher la réponse au fur et à mesure plutôt que d'attendre la fin. Avec stream=True, Ollama renvoie des chunks JSON :

   python Copier

   import httpx, json
   
   with httpx.stream(
       "POST", "http://localhost:11434/api/chat",
       json={"model": "llama3.2",
             "messages": [{"role": "user", "content": "…"}],
             "stream": True},
       timeout=120,
   ) as r:
       for line in r.iter_lines():
           chunk = json.loads(line)
           print(chunk["message"]["content"], end="", flush=True)

6. Embeddings pour le RAG

   Ollama propose aussi des modèles d'embeddings (transforment du texte en vecteurs) — base de toute architecture RAG :

   python Copier

   r = httpx.post(
       "http://localhost:11434/api/embeddings",
       json={"model": "nomic-embed-text", "prompt": "Bonjour le monde"},
   )
   vec = r.json()["embedding"]      # liste de ~768 floats

7. Personnaliser un modèle (Modelfile)

   Comme un Dockerfile, on peut définir un système prompt et des paramètres dans un Modelfile :

   text (Modelfile) Copier

   FROM llama3.2
   
   SYSTEM """
   Tu es un assistant DevOps. Réponds en français,
   en mode pragmatique, avec un exemple bash quand possible.
   """
   
   PARAMETER temperature 0.3

   bash Copier

   ollama create devops-bot -f Modelfile
   ollama run devops-bot

Aide-mémoire

ollama pull <model>
ollama run <model> ["prompt"]
ollama list
ollama rm <model>
ollama create <nom> -f Modelfile

httpx.post("http://localhost:11434/api/chat", json={
    "model": "llama3.2",
    "messages": [{"role": "user", "content": "…"}],
    "stream": False,
})

httpx.post("http://localhost:11434/api/embeddings", json={
    "model": "nomic-embed-text", "prompt": "…",
})

Ollama et le reste de l'écosystème

• httpx — le client naturel pour parler à l'API REST d'Ollama depuis Python. Pas besoin de SDK spécifique.
• Hugging Face — philosophie proche (modèles open-source en local), mais HF est plus bas-niveau (PyTorch direct). Ollama est plus simple pour prototyper côté application ; HF reste meilleur pour fine-tuner.
• Docker — Ollama propose une image officielle. Pratique pour déployer un LLM local dans un docker-compose à côté d'une API FastAPI.
• FastAPI — pattern classique : ton API FastAPI fait un appel httpx async vers Ollama, agrège avec d'autres sources, renvoie au frontend.
• Streamlit — la façon la plus rapide de prototyper un chatbot Ollama : un st.chat_input, un appel HTTP, un st.write. Démo opérationnelle en 30 lignes.
• Pydantic — typer les réponses d'Ollama (OllamaResponse avec message.content) rend le code plus sûr et auto-complété.

Pour aller plus loin

• Site officiel : ollama.com
• Galerie de modèles : ollama.com/library
• Documentation API : github.com/ollama/ollama/blob/main/docs/api.md
• SDK Python officiel (alternative à httpx) : github.com/ollama/ollama-python