Publié le 2 avril 2026 · Lecture : 15 min

Ollama : héberger un LLM localement en 2026 — guide complet

1. Pourquoi faire tourner un LLM en local ?

La question revient souvent : pourquoi se compliquer la vie avec une installation locale quand ChatGPT, Claude ou Mistral Le Chat sont accessibles en un clic ? La réponse tient en quatre raisons concrètes.

Ollama est aujourd'hui l'outil le plus simple pour y parvenir. En une commande, vous téléchargez et lancez Llama 3, Mistral, Gemma, Qwen, DeepSeek ou des dizaines d'autres modèles open source. Il expose automatiquement une API REST locale compatible avec l'interface OpenAI.

Comment fonctionne Ollama ? — Pipeline complet

2. Installation d'Ollama

Ollama supporte officiellement macOS (Apple Silicon et Intel), Linux et Windows. L'installation est conçue pour être aussi simple que possible.

2.1 macOS

Téléchargez le fichier .dmg depuis ollama.com/download et glissez l'application dans votre dossier Applications. Sur Apple Silicon (M1/M2/M3/M4), Ollama peut utiliser le moteur MLX d'Apple et profite de la mémoire unifiée — vous n'avez pas besoin de GPU discret, la RAM fait office de VRAM. Le backend effectif (MLX, Metal, llama.cpp) dépend de la version d'Ollama et de la configuration.

# Vérifier que le service tourne
ollama --version

# Premier modèle : Llama 3.2 3B (léger, ~2 Go)
ollama run llama3.2:3b

2.2 Linux

Une seule commande suffit pour installer Ollama et l'enregistrer comme service systemd :

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

# Vérifier le service
systemctl status ollama

# Le service démarre automatiquement avec le système
# API disponible sur http://localhost:11434

Pour le support GPU NVIDIA, Ollama détecte automatiquement CUDA si les drivers NVIDIA sont installés. Pour AMD, Ollama utilise ROCm sur Linux — la compatibilité dépend du GPU et de la version de ROCm installée, vérifiez la matrice de compatibilité officielle AMD avant de vous lancer.

2.3 Windows

Téléchargez le fichier OllamaSetup.exe depuis ollama.com/download/windows. L'installation configure automatiquement le service en arrière-plan. Support GPU NVIDIA via CUDA. Note : le support GPU AMD sous Windows est très limité — ROCm est principalement développé pour Linux. Pour les GPU AMD, préférez Linux.

3. Premiers pas : télécharger et lancer un modèle

Tout Ollama se contrôle via la commande ollama. Voici les commandes essentielles :

# Télécharger et lancer un modèle (mode interactif)
ollama run mistral

# Télécharger sans lancer
ollama pull llama3.1:8b

# Lister les modèles installés
ollama list

# Supprimer un modèle
ollama rm mistral

# Utiliser depuis la ligne de commande (non interactif)
ollama run llama3.1:8b "Résume ce texte en 3 points : ..."

# Voir les modèles en cours d'exécution
ollama ps

# Informations sur un modèle
ollama show mistral

La première commande ollama run télécharge le modèle si absent, puis ouvre un chat interactif. Pour quitter, tapez /bye.

3.1 Le format des noms de modèles

Les modèles Ollama suivent le format nom:tag. Le tag désigne la variante (taille + quantisation) :

# Tag "latest" par défaut (version recommandée)
ollama pull mistral

# Tag explicite : version 8B, quantisation Q4_K_M
ollama pull llama3.1:8b-instruct-q4_K_M

# Version plus grande
ollama pull llama3.1:70b

# Modèle de code
ollama pull qwen2.5-coder:7b

4. Quels modèles choisir ? Comparatif 2026

La bibliothèque Ollama (ollama.com/library) recense des centaines de modèles. Voici les plus utilisés en 2026, organisés par cas d'usage :

4.1 Usage général — conversation, raisonnement, résumé

4.2 Code — génération et complétion

4.3 Raisonnement — DeepSeek-R1

DeepSeek-R1 est disponible dans plusieurs tailles sur Ollama et constitue l'option open source la plus performante pour les tâches de raisonnement complexe (mathématiques, logique, code avancé). Certaines variantes exposent une trace de raisonnement entre balises <think> — ce comportement dépend du modèle, de sa version et du prompt utilisé. Les versions récentes ont tendance à masquer ce raisonnement par défaut.

# Version 7B — accessible avec 8 Go VRAM
ollama pull deepseek-r1:7b

# Version 32B — pour GPU haut de gamme
ollama pull deepseek-r1:32b

5. VRAM et RAM requis par modèle

La règle fondamentale : le modèle doit tenir entièrement en VRAM pour tourner à pleine vitesse GPU. Si la VRAM est insuffisante, Ollama bascule automatiquement une partie des couches sur le CPU (RAM système), ce qui dégrade significativement les performances.

5.1 Tableau de référence par palier hardware

5.2 Estimer la VRAM nécessaire

La formule approximative pour un modèle en Q4_K_M :

Exemples : 7B × 0,5 + 1 = ~4,5 Go · 13B × 0,5 + 1 = ~7,5 Go · 70B × 0,5 + 1 = ~36 Go

5.3 Benchmarks tokens/s par GPU — indicatif

Les chiffres ci-dessous sont des mesures représentatives relevées par la communauté sur des modèles en quantisation Q4_K_M, contexte court (≤2K tokens). Les performances varient selon le prompt, le KV cache et la charge système.

6. API Python : intégration dans vos applications

Ollama propose une bibliothèque Python officielle (ollama) qui simplifie l'intégration dans vos scripts et applications.

6.1 Installation

pip install ollama

6.2 Chat simple

from ollama import chat

response = chat(
    model='mistral',
    messages=[
        {'role': 'user', 'content': 'Explique la quantisation des LLM en 3 points.'}
    ]
)

print(response.message.content)

6.3 Streaming (tokens en temps réel)

from ollama import chat

stream = chat(
    model='llama3.1:8b',
    messages=[{'role': 'user', 'content': 'Écris une fonction Python pour trier une liste.'}],
    stream=True
)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

6.4 Conversation multi-tours (historique)

from ollama import chat

messages = []

def ask(user_input: str) -> str:
    messages.append({'role': 'user', 'content': user_input})
    response = chat(model='mistral', messages=messages)
    reply = response.message.content
    messages.append({'role': 'assistant', 'content': reply})
    return reply

print(ask("Bonjour, quel est ton rôle ?"))
print(ask("Rappelle-moi ce que tu m'as dit."))  # Garde le contexte

6.5 Génération d'embeddings

Ollama supporte également les embeddings vectoriels, utiles pour la recherche sémantique et les pipelines RAG :

import ollama

# nomic-embed-text : modèle dédié aux embeddings
response = ollama.embed(
    model='nomic-embed-text',
    input='Paris est la capitale de la France.'
)

embedding = response['embeddings'][0]
print(len(embedding))  # 768 dimensions pour nomic-embed-text

6.6 Client asynchrone (asyncio)

import asyncio
from ollama import AsyncClient

async def main():
    client = AsyncClient()
    response = await client.chat(
        model='llama3.1:8b',
        messages=[{'role': 'user', 'content': 'Qu'est-ce que l'asyncio en Python ?'}]
    )
    print(response.message.content)

asyncio.run(main())

7. Compatibilité OpenAI : migrer sans changer le code

L'un des atouts majeurs d'Ollama est son endpoint compatible avec l'API OpenAI. Si vous avez déjà du code qui utilise le SDK openai, vous pouvez basculer sur un modèle local en changeant deux lignes.

7.1 Via le SDK Python OpenAI

from openai import OpenAI

# Deux changements seulement par rapport à l'API OpenAI classique :
client = OpenAI(
    base_url='http://localhost:11434/v1',  # ← Ollama local
    api_key='ollama'                      # ← Valeur arbitraire, non vérifiée
)

response = client.chat.completions.create(
    model='llama3.1:8b',
    messages=[
        {'role': 'system', 'content': 'Tu es un assistant expert en Python.'},
        {'role': 'user', 'content': 'Comment fonctionne un décorateur ?'}
    ]
)

print(response.choices[0].message.content)

7.2 Via curl (API REST brute)

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "mistral",
    "messages": [
      {"role": "user", "content": "Résume en 2 phrases : quest-ce que le RAG ?"}
    ]
  }'

8. Quantisation : Q4, Q6, Q8 — laquelle choisir ?

La quantisation compresse les poids du modèle de 16 bits (FP16) vers moins de bits, réduisant la VRAM nécessaire au prix d'une légère perte de qualité. Ollama utilise le format GGUF avec plusieurs niveaux de quantisation.

Pour spécifier un format de quantisation dans Ollama, ajoutez-le au nom du tag :

# Q4_K_M (par défaut pour la plupart des modèles)
ollama pull llama3.1:8b-instruct-q4_K_M

# Q8 pour meilleure qualité si VRAM disponible
ollama pull llama3.1:8b-instruct-q8_0

9. Cas d'usage : quand local > cloud ?

Un LLM local n'est pas toujours la meilleure solution — GPT-4o ou Claude 3.5 Sonnet restent supérieurs sur les tâches de raisonnement complexe. Mais il existe des contextes où le local est objectivement meilleur :

9.1 Données sensibles et conformité RGPD

Dossiers médicaux, contrats juridiques, données clients, communications internes — tout ce qui ne peut pas transiter par des serveurs tiers. Avec Ollama, le traitement reste sur votre infrastructure. C'est la principale raison d'adoption en entreprise.

9.2 Volume élevé de tokens

Si vous traitez des millions de tokens par jour (analyse de documents, batch processing, génération de contenu à grande échelle), le coût API cloud devient prohibitif. Le seuil de rentabilité dépend de votre GPU, mais pour une RTX 4090 amortie, chaque token après ~6 mois est gratuit.

9.3 Latence et temps réel

Pour les applications nécessitant une réponse en <200ms — chatbots embarqués, complétion de code en temps réel, assistants vocaux — le réseau introduit une latence incompressible. En local sur GPU performant, le time-to-first-token est de l'ordre de 10-50ms.

9.4 Environnements hors ligne

Usines, sites isolés, avions, sous-marins, installations militaires — partout où la connectivité est absente ou non fiable. Un LLM local tourne sans internet.

9.5 Exemple concret : pipeline de classification locale

import ollama
import json

def classify_document(text: str) -> dict:
    """Classifie un document en local — zéro donnée envoyée en externe."""
    prompt = f"""Classifie ce document dans une des catégories suivantes :
    [contrat, facture, email, rapport, autre]

    Document : {text[:500]}

    Réponds uniquement en JSON : {{"categorie": "...", "confiance": 0.0-1.0, "raison": "..."}}"""

    response = ollama.generate(
        model='mistral',
        prompt=prompt,
        format='json'  # Structured output
    )

    return json.loads(response['response'])

# Usage
result = classify_document("Facture n°2024-001 — Prestation de conseil IA — 5 000 €")
print(result)
# {"categorie": "facture", "confiance": 0.97, "raison": "Présence de numéro de facture et montant"}

10. Limites et points de vigilance

FAQ

ollama run llama3.1:8b --num-ctx 32768

OLLAMA_HOST=0.0.0.0 ollama serve

# Modelfile
FROM /chemin/vers/mon-modele.gguf
SYSTEM "Tu es un assistant expert en IA."

# Créer le modèle
ollama create mon-modele -f Modelfile

# Utiliser
ollama run mon-modele

Conclusion

Ollama a démocratisé l'hébergement local de LLM. Ce qui nécessitait une expertise approfondie en 2023 (compiler llama.cpp, gérer les dépendances CUDA, écrire des serveurs d'inférence) se fait maintenant en une commande. En 2026, l'écosystème est mature : des dizaines de modèles de qualité, une API compatible OpenAI, une bibliothèque Python officielle, et un support multi-plateforme solide.

Le local ne remplace pas le cloud pour tous les cas d'usage — GPT-4o et Claude conservent une longueur d'avance sur les tâches de raisonnement très complexe. Mais pour la confidentialité des données, les volumes élevés, la latence zéro et le travail hors ligne, un LLM local avec Ollama est souvent la meilleure solution technique et économique.