Quel modèle Ollama choisir en 2026 ? Cheat sheet Llama 4, Qwen 3, Gemma 4

Vous ouvrez ollama.com/library et vous voyez Llama 4, Qwen 3, Gemma 4, Kimi K2, DeepSeek-R1, Mistral, Phi, GLM-5… plus de 100 modèles. Lequel pour votre cas ? Lequel pour votre VRAM ? Lequel parle bien français ? Ce guide est une cheat sheet à jour de mai 2026 avec des benchmarks réels mesurés sur NVIDIA H100.

Ce que vous allez apprendre

• 4 critères pour choisir un modèle Ollama (usage, VRAM, licence, multilingue)
• Top 3 par cas d'usage (chat, code, agents, vision, RAG/embeddings)
• Cheat sheet VRAM : quel modèle pour 4 / 8 / 12 / 24 / 80 Go de VRAM
• Benchmarks réels mesurés sur H100 PCIe 80 Go

4 critères pour choisir

Quatre questions suffisent à éliminer 90 % du catalogue, et elles se posent dans cet ordre. L'usage écarte les familles inadaptées (un modèle d'embeddings ne discute pas), la VRAM fixe la taille maximale, la licence décide si vous pouvez l'exploiter commercialement, et la qualité en français départage ce qu'il reste. Inverser cet ordre fait perdre du temps : un modèle parfait en français mais qui ne tient pas dans votre GPU reste inutilisable.

1. L'usage cible

Un modèle est entraîné pour une famille de tâches et se dégrade nettement hors de son domaine. Les modèles d'embeddings ne génèrent aucun texte, les modèles « thinking » consomment des centaines de tokens de raisonnement avant de répondre, ce qui les rend inadaptés à un chat interactif.

• Chat généraliste → modèles équilibrés (Llama 4, Qwen 3, Gemma 4)
• Code (génération, complétion) → modèles spécialisés (Qwen 3.6 Coder, DeepSeek Coder)
• Agents (tool calling) → modèles avec function calling natif (Qwen 3, Gemma 4)
• Vision → multimodaux (Gemma 4, Llama 3.2 Vision)
• RAG (embeddings) → modèles d'embeddings (nomic-embed-text, mxbai-embed)
• Raisonnement complexe → modèles « thinking » (DeepSeek-R1, Kimi K2.6)

2. La VRAM disponible

La quantification Q4_K_M par défaut d'Ollama divise la taille mémoire par ~4 par rapport au FP16 original. Estimation rapide pour Q4_K_M :

Paramètres modèle	VRAM nécessaire (Q4)
3B	~2 Go
7B-8B	~5 Go
13B	~8 Go
30-32B	~22 Go
70B	~45 Go
MoE 17B actif / 109B total (Llama 4 Scout)	~10 Go

Glissez pour voir

Les modèles MoE (Mixture of Experts) comme Llama 4 sont la révolution 2026 : 109 B total mais seulement 17 B actifs par token, donc ils tiennent sur un GPU 10 Go.

3. La licence

La licence d'un modèle porte sur les poids, pas sur le code d'Ollama : le fait de pouvoir télécharger un modèle ne dit rien du droit de l'exploiter en production. Deux points à vérifier avant de figer un choix, le seuil d'utilisateurs de la Llama Community License et l'existence de clauses d'attribution sur les sorties générées.

Licence	Usage commercial	Modèles concernés
Apache 2.0	Libre	Qwen 3, Gemma 4, Kimi K2
Llama Community License	Sous conditions (<700 M MAU)	Llama 3.x, Llama 4
MIT	Libre	Mistral, DeepSeek
Propriétaire	Restreint	Certains modèles spécialisés

Glissez pour voir

Pour un projet en entreprise, toujours vérifier la licence avant de partir en prod.

4. Le multilingue (le français en particulier)

Tous les modèles ne se valent pas en français. Mon ressenti après tests intensifs (mai 2026) :

• Excellent : Qwen 3, Gemma 4, Mistral (français natif)
• Bon : Llama 4, DeepSeek-R1
• Moyen : Phi, Llama 3.2 Vision (préfère l'anglais)

Top 3 par cas d'usage (mai 2026)

Cinq classements, un par usage identifié plus haut. La colonne VRAM indique la taille des poids quantifiés, pas l'occupation réelle en mémoire GPU : comptez systématiquement plus large, le détail du calcul est donné avec les benchmarks. Les tags Ollama sont ceux de ollama.com/library à la date de rédaction, un tag peut être renommé ou pointer vers une quantification différente après une mise à jour.

Chat généraliste

Le chat est l'usage où le français fait le plus de différence, et où la latence perçue compte plus que le débit brut. Les trois modèles retenus tiennent tous sous 10 Go de poids, c'est-à-dire dans un GPU grand public.

Rang	Modèle	Tag Ollama	VRAM	Note
1	Qwen 3	qwen3	5 Go	Le meilleur compromis ; français impeccable
2	Llama 4 Scout (MoE)	llama4:scout	10 Go	109 B total, 17 B actifs ; raisonne bien
3	Gemma 4	gemma4	10 Go	Apache 2.0, 256 K context

Glissez pour voir

Code

Le code est l'usage le plus gourmand : la marche est nette entre un modèle 7 B et un 27 B, et elle se paie en VRAM. Le pourcentage SWE-bench mesure la résolution de vrais tickets GitHub, c'est le seul benchmark de cette liste qui reflète un travail de développement complet plutôt qu'une complétion de fonction isolée.

Rang	Modèle	Tag Ollama	VRAM	Note
1	Qwen 3.6 Coder 27B	qwen3.6:27b	22 Go	77.2 % SWE-bench (sortie mai 2026)
2	DeepSeek Coder V2	deepseek-coder-v2	22 Go	Excellent sur Python, JS, Rust
3	Kimi K2.6	kimi-k2.6	80 Go	Top-tier mais énorme (MoE 42 B actif / 1 T total)

Glissez pour voir

Agents (tool calling)

Pour un agent, le critère décisif n'est pas la qualité de la prose mais la régularité du format : un modèle qui invente un nom d'argument une fois sur vingt casse la boucle d'exécution. Vérifiez que le modèle déclare bien la capacité tools sur sa fiche Ollama, sans quoi l'appel d'outil est simulé par prompt et devient nettement moins fiable.

Rang	Modèle	Tag Ollama	VRAM	Note
1	Qwen 3	qwen3	5 Go	Le plus stable sur tool calling (hallucinations rares d'arguments)
2	Gemma 4	gemma4	10 Go	Function calling natif entraîné dans les poids
3	Llama 4 Scout	llama4:scout	10 Go	Bon, mais nouveau dans Ollama (à confirmer)

Glissez pour voir

Vision

Les modèles multimodaux acceptent une image en entrée en plus du texte. Peu d'entre eux combinent vision et appel d'outils, ce qui oblige souvent à faire tourner deux modèles en parallèle et à additionner leur VRAM. La marche entre le 11 B et le 90 B de Llama 3.2 Vision est brutale, 8 Go contre 64 Go.

Rang	Modèle	Tag Ollama	VRAM	Note
1	Gemma 4	gemma4	10 Go	Vision + tool calling combinés (avril 2026)
2	Llama 3.2 Vision 11B	llama3.2-vision	8 Go	Alternative légère ; meilleure en anglais
3	Llama 3.2 Vision 90B	llama3.2-vision:90b	64 Go	Pour GPU pro uniquement (H100, A100)

Glissez pour voir

Détails dans Vision avec Ollama.

RAG / embeddings

Un modèle d'embeddings transforme un texte en vecteur, il ne répond à aucune question. Il pèse quelques centaines de mégaoctets et tourne à côté du modèle de chat sans le concurrencer. Le nombre de dimensions est structurant : il fixe la taille de votre base vectorielle et change de modèle impose de réindexer tout le corpus.

Rang	Modèle	Tag Ollama	VRAM	Dimensions
1	nomic-embed-text	nomic-embed-text	0.3 Go	768
2	mxbai-embed-large	mxbai-embed-large	0.6 Go	1024
3	granite-embedding	granite-embedding	0.5 Go	768

Glissez pour voir

Détails dans Embeddings avec Ollama.

Cheat sheet VRAM

Cette table croise la VRAM disponible et les trois usages principaux, en Q4_K_M. Les valeurs entre parenthèses sont la taille des poids seuls, la marge restante sert au KV cache et aux buffers de calcul. En dessous de 8 Go, la vision est hors de portée, et sur 4 Go seuls les modèles 2-3 B tiennent avec un contexte réduit.

VRAM disponible	Modèle recommandé chat	Modèle recommandé code	Vision
4 Go	phi3, gemma:2b	qwen2.5-coder:1.5b	hors de portée
8 Go	qwen3 (5 Go)	qwen2.5-coder:7b	llama3.2-vision
12 Go	gemma4 (10 Go), llama4:scout	qwen3 + IDE	gemma4
24 Go	qwen3 + tout en RAM	qwen3.6:27b, deepseek-coder-v2	gemma4
80 Go (H100)	kimi-k2.6 (MoE), llama3.3 (70B)	Toute la stack	llama3.2-vision:90b

Glissez pour voir

Benchmarks réels mesurés (NVIDIA H100, Ollama 0.24)

Mesures effectuées avec le lab inference/ollama-models-2026 du dépôt lab-ia-mcp. Trois prompts standards : chat français, code Python, orchestration d'outils.

Modèle	VRAM mesurée	Tokens/s (chat)	TTFT (ms)
qwen3	26 Go (KV cache inclus)	~160	115
gemma4	~32 Go	~120	~150
llama3.1	~22 Go	~140	~120
mistral	~18 Go	~100	~180

Glissez pour voir

Pourquoi 26 Go pour qwen3 qui ne fait que 5 Go au pull ?

La taille du modèle au pull (5.2 Go pour qwen3) est la taille des poids quantifiés sur disque. En VRAM, Ollama charge :

• Les poids (~5 Go)
• Le KV cache (proportionnel à la longueur de contexte, pour 4 K context : ~5-10 Go)
• Les buffers de calcul (~10 Go)

D'où ~25-30 Go au total en VRAM allouée, même pour un « petit » modèle 7-8 B.

Mes recommandations finales

Vous voulez un seul modèle qui fait tout ? Mon choix par défaut en 2026 se fait sur trois critères cumulés : qualité du français, stabilité du tool calling, et empreinte VRAM assez faible pour cohabiter avec un modèle d'embeddings sur le même GPU. Les trois modèles ci-dessous répondent à des profils différents ; le premier est celui que j'installe par réflexe sur une machine neuve.

Premier choix : qwen3, le polyvalent par défaut

Il ne gagne aucune catégorie de justesse, mais il est le seul à ne perdre nulle part, et ses 5 Go laissent de la place pour le reste de la pile.

• Pour : Chat français impeccable
• Pour : Tool calling le plus stable
• Pour : Structured Outputs fiable
• Pour : 5 Go de VRAM seulement
• Pour : Apache 2.0
• Contre : Pas de vision (mais Gemma 4 compense)

Deuxième choix : gemma4, si vous voulez du multimodal

C'est le seul modèle de cette sélection à accepter des images et à appeler des outils, ce qui évite d'en faire tourner deux en parallèle. Il coûte 5 Go de plus que qwen3.

• Pour : Vision + tool calling combinés (unique en 2026)
• Pour : Apache 2.0, 256 K context
• Pour : Excellent en français
• Contre : Plus gourmand (10 Go VRAM)

Troisième choix : llama4:scout, si vous avez 10 Go et voulez le top du raisonnement

Son architecture MoE lui donne la profondeur d'un très gros modèle pour l'empreinte mémoire d'un moyen, au prix d'une génération plus lente. Vérifiez la licence avant tout usage commercial.

• Pour : MoE 17 B actif / 109 B total
• Pour : Raisonnement riche
• Contre : Plus lent qu'un dense 7-8 B
• Contre : Llama Community License (à vérifier)

Stack recommandée par profil

Ollama garde les modèles en mémoire un temps limité après le dernier appel, puis les décharge. Vous pouvez donc installer plus de modèles que votre GPU n'en tient simultanément, tant qu'ils ne servent pas en même temps. Les trois piles ci-dessous respectent cette contrainte : chacune peut tourner sur le matériel indiqué sans basculer en CPU.

Développeur solo, MacBook M3/M4 16 Go

La mémoire est unifiée sur Apple Silicon, elle est donc partagée avec le système : visez 60 % du total au maximum pour les modèles.

ollama pull qwen3              # chat + agents + structured
ollama pull nomic-embed-text   # embeddings pour RAG

Équipe DevOps, serveur GPU 24 Go

Le modèle de code et le modèle de chat ne cohabitent pas dans 24 Go : Ollama décharge l'un pour charger l'autre, ce qui ajoute quelques secondes au premier appel après bascule.

ollama pull qwen3               # chat / agents
ollama pull qwen3.6:27b         # code (utilisation alternée)
ollama pull gemma4              # vision
ollama pull nomic-embed-text    # RAG

Production GPU H100 80 Go

Avec 80 Go, la contrainte n'est plus la place mais le temps de chargement : gardez le modèle par défaut résident en allongeant keep_alive, et acceptez la latence de bascule sur les modèles spécialisés.

ollama pull qwen3               # défaut
ollama pull gemma4              # vision + tools
ollama pull llama3.3            # raisonnement long
ollama pull kimi-k2.6           # code top-tier
ollama pull mxbai-embed-large   # RAG haute qualité

FAQ : Questions fréquentes

Ces cinq questions reviennent systématiquement après une première installation. Deux d'entre elles portent sur la quantification, le réglage qui décide si votre modèle tient en VRAM ou s'écroule sur le processeur.

Un modèle est sorti hier, pourquoi n'est-il pas dans la liste ?

Cette page est figée à une date de relevé. La bibliothèque Ollama évolue en continu : consultez ollama.com/library pour l'état courant, et le Open LLM Leaderboard de HuggingFace pour les classements.

Comment savoir si un modèle gère le tool calling ?

La commande ollama show <modele> affiche une section Capabilities qui liste ce que le modèle sait faire. La page du modèle sur ollama.com donne la même information avant téléchargement.

Q4_K_M ou Q8_0, quelle différence ?

La quantification réduit la précision des poids pour diminuer la taille. Q4_K_M divise environ par quatre par rapport au format 16 bits, Q8_0 par deux. Q4_K_M suffit dans la grande majorité des usages.

Quelle quantification Ollama télécharge-t-il par défaut ?

Cela dépend du modèle. Q4_K_M est fréquent sur les modèles de taille moyenne, mais les très petits modèles sont souvent publiés en Q8_0 ou Q4_0. La commande ollama show affiche la quantification réellement installée.

Mon modèle tourne en CPU et il est lent, pourquoi ?

Le modèle ne tient pas dans la VRAM disponible, Ollama bascule alors sur le processeur et la mémoire vive, ce qui est nettement plus lent. La commande ollama ps indique la répartition entre CPU et GPU.

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À retenir

• Mai 2026 : Llama 4 (MoE), Qwen 3 (chat/tools), Gemma 4 (vision+tools), Kimi K2.6 (code top), DeepSeek-R1 (raisonnement) dominent.
• Quantification Q4_K_M par défaut : taille / 4 sans perte sensible.
• MoE change la donne : Llama 4 Scout = 109 B total mais 10 Go VRAM seulement.
• Mon défaut généraliste : qwen3. Si vision : gemma4.
• Multilingue FR : Qwen 3 et Gemma 4 sont au top. Llama 4 et DeepSeek bons mais préfèrent l'anglais.

Prochaines étapes

Sorties structurées Ollama Forcer du JSON valide en sortie de n'importe quel modèle 2026.

Tool Calling avec Ollama Faire des agents locaux avec qwen3 ou gemma4.

Vision avec Ollama Analyser des images en local avec Gemma 4 ou Llama 3.2 Vision.

Retour à la formation Ollama Vue d'ensemble : installation, modèles, Python, agents.

×

📖 Voir la documentation →