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

1. L'usage cible

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 ✨

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

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

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)

Chat généraliste

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

Code

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

Agents (tool calling)

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

Vision

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

→ Détails dans Vision avec Ollama.

RAG / embeddings

Rang	Modèle	Tag Ollama	VRAM	Dimensions
🥇	nomic-embed-text	`nomic-embed-text`	0.3 Go	768
🥈	mxbai-embed-large	`mxbai-embed-large`	0.6 Go	1024
🥉	granite-embedding	`granite-embedding`	0.5 Go	768

→ Détails dans Embeddings avec Ollama.

Cheat sheet VRAM

Quel modèle pour combien de VRAM ? Vue d'ensemble (mai 2026, Q4_K_M) :

VRAM disponible	Modèle recommandé chat	Modèle recommandé code	Vision
4 Go	`phi3`, `gemma:2b`	`qwen2.5-coder:1.5b`	❌
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`

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

Mes recommandations finales

Vous voulez un seul modèle qui fait tout ? Mon choix par défaut en 2026 :

🏆 `qwen3` — le couteau suisse

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

🥈 `gemma4` — si vous voulez du multimodal

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

🥉 `llama4:scout` — si vous avez 10 Go et voulez le top du raisonnement

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

Stack recommandée par profil

Développeur solo, MacBook M3/M4 16 Go

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

Équipe DevOps, serveur GPU 24 Go

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

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

Q : Le modèle X est sorti hier, pourquoi pas dans la liste ? R : Cette cheat sheet est figée au 26 mai 2026. Pour le toujours à jour, consultez ollama.com/library et HuggingFace Open LLM Leaderboard.

Q : Comment savoir si un modèle supporte le tool calling ? R : Sur ollama.com, chaque modèle liste ses capabilities. Sinon, testez en pratique avec le code du guide Tool Calling — si tool_calls est vide à la 1re question, le modèle ne supporte pas.

Q : Q4_K_M vs Q8_0 — quelle différence ? R : Q4_K_M (default Ollama) divise la taille par 4 avec une perte de qualité imperceptible sur la plupart des tâches. Q8_0 double la taille pour ~1-2 % de gain de qualité. Pour 99 % des cas, Q4_K_M suffit.

Q : Mon modèle Q4 est en mode CPU only et lent. Pourquoi ? R : Le modèle ne tient pas en VRAM → Ollama bascule en CPU+RAM, 5-20× plus lent. Vérifiez avec ollama ps et nvidia-smi. Réduisez num_ctx (taille de contexte) ou prenez un modèle plus petit.

Q : Comment forcer Ollama à utiliser un modèle quantifié différemment ? R : Suffix dans le tag : ollama pull qwen3:7b-q8_0 (si dispo). Le tag par défaut est généralement la version Q4_K_M.

À 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.