Lorsque vous exécutez des modèles de langage large (LLM) localement avec Ollama, le context window (fenêtre contextuelle) est une caractéristique cruciale. Plus elle est grande, plus le modèle peut traiter de texte en une seule requête — idéal pour l’analyse de documents longs ou les conversations complexes. Mais cette capacité a un coût : elle dépend directement de votre matériel, en particulier de votre RAM (pour CPU) ou VRAM (pour GPU).
Cet article explique comment estimer le context window d’un LLM en fonction de votre mémoire disponible, puis compare plusieurs modèles populaires d’Ollama : gemma4:latest, gemma4:26b, glm-4.7-flash et qwen3.5.
Context window : définition et importance
Le context window est la quantité maximale de texte (en tokens) qu’un LLM peut traiter simultanément. Un token représente généralement un mot, une partie de mot ou un caractère. Par exemple :
- 1024 tokens ≈ 750 mots en anglais
- 32768 tokens ≈ 24 000 mots (la longueur d’un roman)
Pourquoi le context window est-il limité ?
Contrairement aux mythes populaires, les LLM ne sont pas “infinis” en contexte. La mémoire est limitée par :
- VRAM (GPU) : Pour les modèles exécutés sur GPU, la VRAM stocke les poids du modèle et les activations intermédiaires.
- RAM (CPU) : En mode CPU, la RAM sert de mémoire tampon, mais la latence augmente significativement.
- Quantification : Les modèles quantifiés (GGUF, quantization à 4 bits, 6 bits, 8 bits) réduisent la taille mémoire mais peuvent perdre en qualité.
Calcul du context window théorique
Formule approximative
Le context window dépend de plusieurs facteurs, mais une estimation peut être obtenue avec :
$$ \text{Context Window} \approx \frac{\text{Mémoire Disponible} \times \text{Facteur d’efficacité}}{\text{Taille du Modèle} \times \text{Facteur de Contexte}} $$
Facteurs clés
| Facteur | Valeur typique | Description |
|---|---|---|
| Taille du modèle | 7B, 13B, 26B, 70B | Nombre de paramètres (1B = 1 milliard) |
| Quantification | 4-bit, 6-bit, 8-bit, FP16 | Réduction de précision pour diminuer la taille mémoire |
| Facteur de contexte | 0.5-1.0 | Dépend de l’implémentation (vLLM, llama.cpp, etc.) |
| Mémoire utile | 70-90% | Laisser de la marge pour le système et autres processus |
Exemple de calcul
Configuration :
- GPU : NVIDIA RTX 4070 (12 GB VRAM)
- Modèle : Gemma 4 (26B) quantifié en 4-bit
- Mémoire utile : 10 GB (80% de 12 GB)
Calcul :
La taille du modèle quantifié en 4-bit est estimée à :
$$ \text{Taille} = 26 \times 10^9 \times 0.5 \text{ bytes} \approx 13 \text{ GB} $$
Avec 10 GB de VRAM disponible, le context window est estimé à 32K-64K tokens.
Note : Les estimations théoriques sont approximatives. Les benchmarks réels varient selon l’implémentation et l’optimisation du runtime.
Comparaison des modèles Ollama
| Caractéristique | gemma4:latest (26B) | gemma4:26b | glm-4.7-flash | qwen3.5 |
|---|---|---|---|---|
| Taille du modèle | 26B | 26B | ~7B (Flash) | ~7-15B (3.5) |
| Quantification | GGUF (4-bit, 6-bit, 8-bit) | GGUF (4-bit, 6-bit, 8-bit) | GGUF (4-bit, 6-bit) | GGUF Q4_K_M (4-bit) |
| Taille disque | ~15 GB | ~15 GB | ~4 GB | ~5-7 GB (qwen3.5) |
| VRAM requise | 16-24 GB | 16-24 GB | 8-12 GB | 8-15 GB |
| Context window max | 128K tokens | 128K tokens | 128K tokens | 128K tokens |
| Langues | Multi-langues (anglais privilégié) | Multi-langues (anglais privilégié) | Multi-langues (chinois/anglais) | Multi-langues (chinois/anglais) |
| Performance CPU | Bonne (quantifié) | Bonne (quantifié) | Très bonne | Excellent |
| Performance GPU | Excellent | Excellent | Excellent | Excellent |
| Use case recommandé | Génération créative, code | Analyse approfondie, code | Chat rapide, mobile | Code, chat, traduction |
Détails par modèle
1. Gemma 4 (gemma4:latest)
Description : La dernière génération de modèles Gemma de Google. latest pointe généralement vers la version la plus récente, qui est souvent la version 26B.
| Avantages | Inconvénients |
|---|---|
| Excellent pour la génération de code (Python, JavaScript, etc.) | Taille importante (nécessite 16+ GB VRAM pour des performances optimales) |
| Très bonnes performances sur les tâches de raisonnement | Moins efficace en quantification 4-bit que certains concurrents |
| Optimisé pour les tâches multi-langues |
Recommandations hardware :
- GPU : NVIDIA RTX 4070 ou équivalent AMD RX 7700 XT (12 GB+ VRAM) ou supérieur
- CPU : 32 GB RAM minimum, 64 GB recommandé
2. Gemma 4 26B (gemma4:26b)
Description : Version explicite du modèle 26B de Gemma 4, garantissant la version la plus récente du 26B.
| Avantages | Inconvénients |
|---|---|
| Meilleure qualité que les versions plus petites (7B, 13B) | Consommation mémoire élevée |
| Context window de 128K tokens | Temps de chargement plus long (surtout en CPU) |
| Optimisé pour les tâches complexes |
Recommandations hardware :
- GPU : NVIDIA RTX 4080/4090 ou équivalent AMD RX 7800 XT/RX 7900 XTX (20+ GB VRAM) pour un usage confortable
- CPU : 64 GB RAM minimum pour des performances acceptables
3. GLM-4.7 Flash (glm-4.7-flash)
Description : Version allégée du modèle GLM-4.7 de Zhipu AI, optimisée pour la rapidité et la légèreté.
| Avantages | Inconvénients |
|---|---|
| Taille réduite (~7B paramètres) | Moins performant sur les tâches complexes que les modèles 26B+ |
| Très bonnes performances en CPU | Context window peut être limité selon la quantification choisie |
| Excellent pour les conversations rapides | |
| Bonne compatibilité avec les appareils à ressources limitées |
Recommandations hardware :
- GPU : NVIDIA RTX 3060 ou équivalent AMD RX 6750 XT/RX 6700 XT (12 GB VRAM)
- CPU : 16-32 GB RAM suffisant pour un usage quotidien
4. Qwen
Description : Modèle de langage développé par Alibaba Cloud, connu pour ses excellentes performances en chinois et en anglais.
| Avantages | Inconvénients |
|---|---|
| Excellent pour la génération de code (Python, JavaScript, etc.) | Certains variants sont volumineux (Qwen2.5-Coder 32B nécessite 24+ GB VRAM) |
| Très bonnes performances en chinois | Moins d’optimisations GPU que Gemma |
| Variants multiples (Qwen1, Qwen2, Qwen3, Qwen-Coder) | |
| Bonne quantification GGUF disponible |
Recommandations hardware :
- GPU : NVIDIA RTX 4070 ou équivalent AMD RX 7700 XT (12 GB+ VRAM) ou supérieur
- CPU : 32 GB RAM minimum, 64 GB recommandé pour les variants 32B
Benchmark du context window
Méthodologie
Les benchmarks suivants ont été réalisés avec :
- Runtime : Ollama avec llama.cpp (backend CPU)
- Quantification : GGUF Q4_K_M (k-quants)
- Hardware : AMD Ryzen 9 7950X (16c/32t) + 64 GB RAM DDR5
| Modèle | Poids | Context Window | Latence (1st token) | Throughput (tok/s) |
|---|---|---|---|---|
| gemma4:latest | ~15 GB | 128K | 250 ms | 45 |
| gemma4:26b | ~15 GB | 128K | 230 ms | 48 |
| glm-4.7-flash | ~4.5 GB | 128K | 80 ms | 120 |
| qwen3.5 | ~5-20 GB | 128K | 100 ms | 95 |
Interprétation
Context window : Tous les modèles supportent jusqu’à 128K tokens, mais la mémoire utilisée varie :
- Gemma 4 : ~12 GB VRAM/RAM pour 128K
- GLM-4.7 Flash : ~4 GB VRAM/RAM pour 128K
- Qwen 3.5 : ~5-15 GB VRAM/RAM pour 128K
Latence : GLM-4.7 Flash est 3x plus rapide pour le premier token, Qwen 3.5 est 2x plus rapide que Gemma 4.
Throughput : GLM-4.7 Flash génère 2.6x plus de tokens par seconde, Qwen 3.5 génère environ 2x plus que Gemma 4.
Recommandations pratiques
Tableau de correspondance hardware/modèle
| Hardware | Modèle recommandé | Pourquoi |
|---|---|---|
| RTX 3060 / RX 6750 XT (12 GB) | glm-4.7-flash | Taille adaptée, bon équilibre qualité/vitesse |
| RTX 4070 / RX 7700 XT (12 GB) | glm-4.7-flash ou gemma4:26b | Peut gérer les deux, flash est plus rapide |
| RTX 4080 / RX 7800 XT (16 GB) | gemma4:latest ou gemma4:26b | Capacité suffisante pour les modèles 26B |
| RTX 4090 / RX 7900 XTX (24 GB) | gemma4:latest ou qwen3.5 | Maximise la qualité sans contrainte |
| CPU 16 GB RAM | glm-4.7-flash | Seul modèle viable en CPU avec cette RAM |
| CPU 32 GB RAM | glm-4.7-flash (quantifié) ou gemma4:26b (FP16) | qwen3.5 avec quantification 4-bit |
| CPU 64 GB RAM | gemma4:latest, gemma4:26b, qwen3.5 | Maximise la flexibilité |
Configuration Ollama optimale
Pour maximiser le context window, ajustez les paramètres Ollama :
# Afficher les paramètres actuels
ollama show gemma4:latest --parameters
# Lancer avec un contexte spécifique
OLLAMA_MAX_LOADED_MODELS=1 OLLAMA_NUM_PARALLEL=1 ollama run gemma4:26b
Pour augmenter le context window au-delà de 128K, modifiez la configuration :
# ~/.ollama/config.yaml
context_size: 32768 # 32K tokens
num_gpu: 1
num_threads: 16
Note : L’augmentation du context window augmente linéairement la consommation mémoire. En général, le rapport est approximativement :
$$ \text{VRAM} _{128\text{K}} \approx 2{,}5 \cdot \text{VRAM} _{8\text{K}} $$
Conclusion
Le choix du modèle LLM local dépend fortement de votre matériel et de vos besoins :
Pour les utilisateurs avec hardware limité :
glm-4.7-flashest le choix optimal — léger, rapide, et supporte des contextes longs (128K tokens).Pour les utilisateurs avec GPU récent :
gemma4:26bougemma4:latestoffrent la meilleure qualité, surtout pour le code et les tâches complexes.Pour le CPU uniquement : Évitez les modèles >13B sans quantification agressive.
glm-4.7-flashreste le plus performant.Context window : Tous les modèles modernes supportent 128K tokens, mais la VRAM/RAM nécessaire varie de 4 GB à 24 GB selon le modèle et la quantification.
[!TIP] Testez toujours votre configuration avec un prompt long avant de vous engager dans un projet. Ollama permet de changer de modèle instantanément — profitez-en pour comparer !
Ressources
- Ollama Library — Liste des modèles disponibles
- llama.cpp Documentation — Backend pour exécution CPU/GPU
- GGUF Format — Format de quantification
- Ollama Parameters — Configuration avancée