Dépôt GitHub officiel : github.com/ollama/ollama
Catalogue de modèles & Site : ollama.com/library • Licence : MIT (100 % Open-Source)

Ce que Docker a accompli il y a dix ans pour la conteneurisation des applications Linux, Ollama l’a réalisé pour l’exécution locale des grands modèles de langage (LLM), des modèles de vision (VLM) et des modèles d’embeddings.

Avant Ollama, déployer un modèle open-weights (Llama, Qwen-Coder, Mistral, DeepSeek, Gemma) sur sa propre station de travail ou son serveur Linux nécessitait de compiler manuellement llama.cpp avec les bons drapeaux d’accélération matérielle (CUDA, ROCm, Metal, Vulkan, AVX-512), de télécharger des poids bruts sur Hugging Face, de gérer les templates Jinja de chat propres à chaque architecture et d’écrire son propre serveur d’API. Ollama a condensé toute cette complexité en un binaire unique en Go pilotable par une commande devenue universelle : ollama run.

1. Architecture interne : Comment Ollama orchestre llama.cpp et la VRAM

Sous son interface CLI minimaliste, Ollama fonctionne selon une architecture client-serveur analogue au démon Docker (ollama serve écoutant par défaut sur 127.0.0.1:11434) :

┌─────────────────────────────────────────────────────────────────────────┐
│             CLIENTS & AGENTS (Aider, LibreChat, Continue, SDK)          │
│     GET/POST /api/chat • /api/embed • /v1/chat/completions (OpenAI)     │
└───────────────────────────────────┬─────────────────────────────────────┘
                                    │ HTTP REST / Streaming NDJSON / SSE
                                    ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                      DÉMON OLLAMA (Go Orchestrator)                     │
│  • Gestion du cycle de vie des modèles en mémoire (Keep-Alive / LRU)    │
│  • Ordonnancement concurrent (OLLAMA_NUM_PARALLEL & OLLAMA_MAX_LOADED)  │
│  • Application des templates de chat, Grammaires JSON & Tool Calling    │
└───────────────────────────────────┬─────────────────────────────────────┘
                                    │ CGo / Subprocess Runner
                                    ▼
┌─────────────────────────────────────────────────────────────────────────┐
│                MOTEUR D'INFÉRENCE GGML / LLAMA.CPP + GPU                │
│  • Poids quantifiés GGUF (Q4_K_M, Q5_K_M, Q8_0, FP16)                   │
│  • Offloading automatique des couches (Layers) GPU VRAM ↔ RAM Système   │
│  • FlashAttention & Quantification du KV Cache (f16 / q8_0 / q4_0)      │
└─────────────────────────────────────────────────────────────────────────┘

Le format GGUF et le calcul de dimensionnement VRAM

Ollama s’appuie sur le format binaire GGUF (GPT-Generated Unified Format), conçu pour le chargement instantané par mmap() et la quantification par blocs (K-Quants). Comprendre les suffixes de quantification permet de choisir le compromis optimal entre précision et empreinte mémoire :

Astuce SRE (Quantification du KV Cache) : Lorsque vous augmentez la fenêtre de contexte (num_ctx) à 32768 ou 65536 tokens, le cache Clé-Valeur (KV Cache) peut consommer plusieurs gigaoctets de VRAM supplémentaires. En activant OLLAMA_FLASH_ATTENTION=1 et OLLAMA_KV_CACHE_TYPE=q8_0 sur le serveur, vous divisez par deux la mémoire consommée par le contexte sans dégrader la qualité des réponses !

2. Le Modelfile : Infrastructure-as-Code pour vos modèles locaux

Tout comme un Dockerfile permet de versionner une image conteneur, le Modelfile d’Ollama permet de figer de manière reproductible un modèle de base, sa fenêtre de contexte, sa température et son prompt système métier :

# Modelfile : Architecte Code & Sécurité (basé sur Qwen 2.5 Coder)
FROM qwen2.5-coder:32b-instruct-q4_K_M

# Paramètres déterministes pour la génération et l'audit de code
PARAMETER temperature 0.1
PARAMETER top_p 0.9
PARAMETER num_ctx 32768
PARAMETER stop "<|im_end|>"

SYSTEM """
Tu es un ingénieur logiciel senior et auditeur DevSecOps.
Réponds toujours avec le code minimal, robuste et directement exécutable.
Ne génère jamais de code spéculatif ni d'abstraction superflue.
"""

Il suffit ensuite de compiler et d’exécuter ce profil en deux commandes :

ollama create sre-coder:32b -f ./Modelfile
ollama run sre-coder:32b

3. Fonctionnalités avancées : Sorties Structurées (JSON Schema), Tool Calling et Embeddings

Ollama ne se limite plus à la génération de texte libre. Il intègre nativement les briques indispensables aux pipelines d’ingénierie IA :

A. Sorties structurées garanties par grammaire (format JSON Schema)

Pour intégrer un LLM local dans un backend Python ou Go sans risquer un crash de parsing JSON, Ollama contraint l’échantillonnage des tokens via une grammaire formelle correspondant exactement à votre schéma Pydantic / JSON Schema :

curl -s http://localhost:11434/api/chat -d '{
  "model": "qwen2.5-coder:14b",
  "messages": [
    {"role": "user", "content": "Analyse ce log : CRIT [sshd] Failed password for root from 198.51.100.42 port 54122"}
  ],
  "stream": false,
  "format": {
    "type": "object",
    "properties": {
      "severity": {"type": "string", "enum": ["INFO", "WARN", "CRIT"]},
      "service": {"type": "string"},
      "source_ip": {"type": "string"},
      "block_recommended": {"type": "boolean"}
    },
    "required": ["severity", "service", "source_ip", "block_recommended"]
  }
}' | jq -r '.message.content'

B. Compatibilité native avec le SDK OpenAI (/v1/chat/completions)

N’importe quelle application conçue pour l’API OpenAI (Aider, LibreChat, Continue.dev, LangChain, LlamaIndex) peut basculer sur Ollama en changeant uniquement base_url :

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # Clé symbolique requise par le SDK mais ignorée localement
)

response = client.chat.completions.create(
    model="sre-coder:32b",
    messages=[{"role": "user", "content": "Écris un healthcheck HTTP en Go pur sans dépendance externe."}],
)
print(response.choices[0].message.content)

4. Déploiement Docker Compose durci en production

Pour exécuter Ollama en tant que service permanent avec accélération GPU NVIDIA et réglages optimisés pour le multi-utilisateurs :

services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless-stopped
    ports:
      - "127.0.0.1:11434:11434"
    environment:
      - OLLAMA_KEEP_ALIVE=15m
      - OLLAMA_NUM_PARALLEL=4
      - OLLAMA_MAX_LOADED_MODELS=2
      - OLLAMA_FLASH_ATTENTION=1
      - OLLAMA_KV_CACHE_TYPE=q8_0
    volumes:
      - ./ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

5. Pourquoi Ollama est le socle du « Zero-Cloud Privacy »

Lorsqu’il s’agit d’indexer des documents privés (coffre-fort administratif, contrats, dossiers médicaux, journaux d’infrastructure ou code propriétaire sous NDA), envoyer ces données vers une API externe est souvent inacceptable. En combinant Ollama pour l’inférence conversationnelle et ses modèles d’embeddings locaux (nomic-embed-text, bge-m3), vous disposez d’une chaîne IA 100 % hors-ligne, souveraine, gratuite à l’usage et exempte de toute télémétrie externe.

• Dépôt GitHub officiel : https://github.com/ollama/ollama
• Bibliothèque officielle de modèles : https://ollama.com/library
• Documentation de l’API REST : https://github.com/ollama/ollama/blob/main/docs/api.md