De quelle quantité de RAM ai-je besoin pour exécuter Gemma 4 localement ?

Gemma 4 E2B et E4B fonctionnent avec seulement 5GB RAM avec une quantization 4-bit — n'importe quel ordinateur portable moderne convient. Le modèle 26B MoE nécessite environ 18GB RAM (tient dans les 24GB VRAM d'une RTX 4090). Le modèle 31B Dense nécessite environ 20GB RAM. Pour une exécution CPU uniquement, ajoutez 20-30 % de RAM supplémentaire par rapport au poids du modèle.

Quel modèle Gemma 4 dois-je choisir pour une utilisation locale ?

Pour les ordinateurs portables sans GPU dédié : E2B (le plus rapide, le plus léger). Pour les ordinateurs portables avec GPU ou les ordinateurs de bureau : E4B (meilleure qualité, reste léger). Pour les ordinateurs de bureau avec une RTX 4090 ou équivalent : 26B MoE (meilleur rapport qualité/calcul). Pour les stations de travail avec 24GB+ VRAM : 31B Dense (qualité maximale). Le 26B MoE est le choix idéal pour la plupart des développeurs.

L'utilisation locale de Gemma 4 est-elle gratuite ?

Oui. Gemma 4 est publié sous licence Apache 2.0, ce qui permet une utilisation sans restriction, y compris pour des applications commerciales. Ollama est également gratuit et open source. Le seul coût est votre matériel. Il n'y a pas de frais d'API, pas de limites d'utilisation et aucune restriction de licence.

Quelle est la vitesse de Gemma 4 en local par rapport aux API cloud ?

Sur une RTX 4090, Gemma 4 E4B génère 80-120 tokens per second. Le 26B MoE génère 30-50 tokens/sec. Le 31B Dense génère 20-35 tokens/sec. Les API cloud comme Google AI Studio peuvent être plus rapides pour les modèles les plus volumineux, mais ajoutent une latence réseau de 100-500ms par requête. Pour une utilisation interactive, l'inférence locale sur les modèles plus petits semble instantanée.

Puis-je utiliser Gemma 4 localement comme API pour mes applications ?

Oui. Ollama expose une REST API locale sur le port 11434 compatible avec le format OpenAI API. Toute application, framework ou outil prenant en charge l'OpenAI API peut se connecter à Gemma 4 localement en pointant la base URL vers http://localhost:11434/v1. Cela inclut Python, Node.js et la plupart des frameworks d'IA.

Gemma 4 prend-il en charge l'accélération GPU avec Ollama ?

Oui. Ollama détecte et utilise automatiquement les GPU NVIDIA (CUDA), Apple Silicon (Metal) et les GPU AMD (ROCm). Aucune configuration supplémentaire n'est requise — si votre GPU dispose de suffisamment de VRAM pour charger le modèle, Ollama l'utilisera automatiquement. NVIDIA a également publié des versions optimisées pour RTX de Gemma 4 pour des gains de performance supplémentaires.

Ce qu'il faut retenir

Exécuter Gemma 4 localement prend moins de 5 minutes avec Ollama : installez Ollama, lancez une commande, et vous disposez d'un modèle AI pleinement capable tournant sur votre propre matériel avec 0 coût d'API, 0 donnée quittant votre machine, et 0 restriction d'utilisation sous Apache 2.0. Le modèle E2B fonctionne sur n'importe quel ordinateur portable. Le modèle 26B MoE tient sur une seule RTX 4090 et offre une qualité qui rivalise avec des modèles ayant 10x son nombre de paramètres actifs.

Exécuter Gemma 4 localement : Le guide complet

Pourquoi exécuter Gemma 4 localement ?

Avant de plonger dans la configuration, voici pourquoi l'inférence locale est importante en 2026 :

Confidentialité — Vos données ne quittent jamais votre machine. Aucun prompt n'est envoyé à des serveurs externes. Crucial pour le code propriétaire, les documents juridiques, les données médicales ou toute information sensible.
Coût — Zéro coût par tokens après l'investissement matériel initial. Les utilisateurs intensifs économisent des centaines de dollars par mois par rapport aux tarifs d'API.
Latence — Pas d'allers-retours réseau. Les modèles E2B et E4B répondent en millisecondes sur du matériel moderne.
Fiabilité — Pas de limites de débit d'API, pas de pannes, pas de changements de politique du fournisseur. Votre modèle est toujours disponible.
Personnalisation — Fine-tune, quantize et modifiez le modèle librement sous Apache 2.0.
Accès hors ligne — Fonctionne sans connexion internet une fois le modèle téléchargé.

Gemma 4 est particulièrement bien adapté au déploiement local car Google a conçu les plus petits modèles spécifiquement pour une utilisation en périphérie (edge) et sur appareil. Les modèles E2B et E4B ne sont pas des réflexions après coup — ce sont des modèles de premier ordre optimisés pour les contraintes du matériel local.

Prérequis

Configuration matérielle requise par modèle

Modèle	RAM minimum	VRAM recommandée	Viable en CPU uniquement ?	Espace disque
E2B (4-bit)	5 GB	4 GB	Oui	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Oui	~2.8 GB
E4B (FP16)	9 GB	9 GB	Lent	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Très lent	~15 GB
26B MoE (FP16)	52 GB	48 GB	Non	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Très lent	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Non	~62 GB

Point clé : Si vous avez un ordinateur portable fabriqué après 2022, vous pouvez exécuter E2B ou E4B. Si vous avez une RTX 4090 (24GB VRAM) ou un Mac Apple M-series avec 32GB+ de RAM, vous pouvez exécuter le 26B MoE ou le 31B Dense avec une quantization 4-bit.

Prérequis logiciels

Système d'exploitation : macOS, Linux, ou Windows
Ollama : Version 0.6+ (télécharger sur ollama.com)
GPU drivers (optionnel) : NVIDIA CUDA 12+ pour les GPU NVIDIA, aucun driver supplémentaire n'est nécessaire pour Apple Silicon

Étape 1 : Installer Ollama

macOS

Téléchargez sur ollama.com/download ou utilisez Homebrew :

brew install ollama

Linux

Script d'installation en une ligne :

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

Windows

Téléchargez l'installateur sur ollama.com/download et exécutez-le. Ollama s'exécute comme un service en arrière-plan sur Windows.

Vérifier l'installation

ollama --version

Vous devriez voir ollama version 0.6.x ou plus. Si vous voyez un numéro de version, Ollama est correctement installé.

Source : Guide d'installation Ollama

Étape 2 : Récupérer un modèle Gemma 4

Choisissez le modèle qui correspond à votre matériel :

Pour les ordinateurs portables et les charges de travail légères

# Plus petit modèle — fonctionne sur n'importe quel ordinateur portable moderne (5GB RAM)
ollama pull gemma4:e2b

# Petit modèle avec des capacités plus larges (5-9GB RAM)
ollama pull gemma4:e4b

Pour les ordinateurs de bureau avec un GPU dédié

# Meilleure efficacité — qualité phare avec 3.8B paramètres actifs (18GB RAM)
ollama pull gemma4:26b-moe

# Plus haute qualité — 31B paramètres complets (20GB RAM)
ollama pull gemma4:31b

Spécifier la quantization

Par défaut, Ollama récupère la quantization recommandée pour chaque modèle (généralement Q4_K_M pour un bon équilibre entre qualité et taille). Vous pouvez spécifier différentes quantizations :

# Plus haute qualité, plus grande taille
ollama pull gemma4:31b-q5_K_M

# Plus petite taille, qualité légèrement inférieure
ollama pull gemma4:31b-q3_K_M

# Précision complète (nécessite beaucoup plus de RAM)
ollama pull gemma4:31b-fp16

Le téléchargement prendra quelques minutes selon votre connexion internet. La taille des modèles varie de ~1.5GB (E2B 4-bit) à ~62GB (31B FP16).

Étape 3 : Exécuter Gemma 4

Chat interactif

ollama run gemma4:e4b

Ceci ouvre une session de chat interactive. Tapez votre prompt et appuyez sur Entrée :

>>> What are the key differences between REST and GraphQL APIs?

Le modèle répondra directement dans votre terminal. Tapez /bye pour quitter.

Prompt unique (non interactif)

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

Avec le mode réflexion (Thinking Mode)

Gemma 4 prend en charge un mode réflexion configurable pour les tâches complexes. Activez-le en ajoutant un prompt système :

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

Pour les tâches de mathématiques, de logique et d'analyse complexe, le mode réflexion améliore considérablement la qualité des réponses. Le modèle générera plus de 4,000 tokens de raisonnement interne avant de produire sa réponse finale.

Étape 4 : Utiliser l'API locale

Ollama expose une API REST sur localhost:11434 qui est compatible avec le format d'API OpenAI. Cela signifie que n'importe quel outil ou bibliothèque prenant en charge l'API de OpenAI peut se connecter à votre Gemma 4 local avec un simple changement d'URL.

Tester l'API avec curl

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

Point de terminaison compatible OpenAI

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

Source : Documentation de l'API Ollama

Étape 5 : Intégrer à votre application

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# Utilisation
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

Python avec le SDK OpenAI

from openai import OpenAI

# Pointer vers l'instance locale Ollama au lieu d'OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama ne nécessite pas de véritable clé API
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Utilisation avec LangChain

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

Utilisation avec LlamaIndex

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

Explication des options de quantization

La quantization réduit la taille du modèle et l'utilisation de la mémoire en utilisant des nombres de précision inférieure pour représenter les poids du modèle. Le compromis se fait entre la qualité et l'utilisation des ressources :

Quantization	Bits par poids	Impact sur la qualité	Économie de mémoire	Idéal pour
FP16	16 bits	Aucun (qualité totale)	Référence	Serveurs avec beaucoup de VRAM
Q8_0	8 bits	Négligeable	~50%	Inférence locale de haute qualité
Q6_K	6 bits	Très mineur	~62%	Utilisation locale axée sur la qualité
Q5_K_M	5 bits	Mineur	~69%	Bon équilibre
Q4_K_M	4 bits	Faible	~75%	Défaut recommandé
Q3_K_M	3 bits	Modéré	~81%	Matériel contraint
Q2_K	2 bits	Significatif	~87%	Contraintes extrêmes

Q4_K_M est le point idéal pour la plupart des utilisateurs. La différence de qualité par rapport au FP16 est suffisamment faible pour que la plupart des tâches produisent des résultats indiscernables, tandis que les économies de mémoire de 75% font la différence entre "nécessite un serveur" et "fonctionne sur mon ordinateur portable".

Choisir la bonne quantization

Pour Gemma 4 E2B/E4B : Utilisez la valeur par défaut (Q4_K_M). Ces modèles sont déjà assez petits pour qu'une quantization plus élevée ne change pas de manière significative l'expérience utilisateur.

Pour Gemma 4 26B MoE : Q4_K_M tient dans 18GB de RAM, ce qui correspond aux 24GB de VRAM d'une RTX 4090 avec de la place pour le cache KV. Si vous avez 48GB+ de VRAM (A6000, double GPU), considérez Q8_0 pour une qualité légèrement meilleure.

Pour Gemma 4 31B Dense : Q4_K_M à 20GB tient dans une RTX 4090 avec des marges serrées. Q5_K_M produit des résultats légèrement meilleurs mais nécessite ~24GB, consommant toute la VRAM disponible. Si vous avez 32GB+ de VRAM (RTX 5090, A6000), Q6_K ou Q8_0 valent l'amélioration.

Optimisation des performances

Déchargement GPU (GPU Offloading)

Ollama décharge automatiquement les couches du modèle sur le GPU lorsque de la VRAM est disponible. Si seule une partie du modèle tient dans la VRAM, Ollama répartit entre le GPU et le CPU. Vous pouvez contrôler cela :

# Forcer toutes les couches sur le GPU (échoue si la VRAM est insuffisante)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Forcer le mode CPU uniquement (utile pour les tests)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Configuration de la fenêtre de contexte

Par défaut, Ollama utilise une fenêtre de contexte de 2048 tokens pour plus d'efficacité. Pour utiliser les pleines capacités de contexte de Gemma 4 :

# Définir la fenêtre de contexte à 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Définir la fenêtre de contexte à 128K tokens (nécessite plus de RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Important : Les fenêtres de contexte plus larges consomment plus de RAM pour le cache KV. Une fenêtre de contexte de 128K sur le modèle 31B peut nécessiter 8-16GB de RAM supplémentaire au-delà des poids du modèle. Commencez par 32K et n'augmentez que si votre cas d'utilisation l'exige.

Requêtes simultanées

Ollama prend en charge le traitement de plusieurs requêtes simultanément :

# Autoriser jusqu'à 4 requêtes simultanées
OLLAMA_NUM_PARALLEL=4 ollama serve

Chaque requête simultanée ajoute une surcharge de mémoire pour son cache KV. Sur un GPU de 24GB exécutant le 26B MoE en Q4_K_M (~18GB), vous avez environ 6GB de marge — assez pour 2-3 requêtes simultanées avec des contextes courts.

Paramètres de maintien en mémoire (Keep-Alive)

Par défaut, Ollama garde les modèles chargés en mémoire pendant 5 minutes après la dernière requête. Ajustez cela selon votre cas d'utilisation :

# Garder le modèle chargé pendant 1 heure
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Garder le modèle chargé indéfiniment
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Décharger immédiatement après chaque requête (économise de la mémoire)
OLLAMA_KEEP_ALIVE=0 ollama serve

Optimisation NVIDIA RTX

NVIDIA a publié des versions optimisées de Gemma 4 pour les GPU RTX. Ces optimisations incluent :

Kernels CUDA personnalisés pour le mécanisme d'attention de Gemma 4
Intégration TensorRT-LLM pour une inférence plus rapide
Support Flash Attention pour une utilisation réduite de la mémoire lors de l'inférence à contexte long
Gestion optimisée du cache KV pour un meilleur débit

Installer Gemma 4 optimisé par NVIDIA

Si vous avez un GPU de la série RTX 4000 ou 5000 :

# Vérifier votre GPU
nvidia-smi

# Récupérer la version optimisée par NVIDIA (si disponible dans Ollama)
ollama pull gemma4:31b-nvidia

Alternativement, utilisez NVIDIA AI Workbench ou TensorRT-LLM directement pour des performances maximales. Les versions optimisées par NVIDIA peuvent fournir une inférence 30-50% plus rapide sur les GPU RTX par rapport aux builds standards de Ollama.

Benchmarks de performance en conditions réelles

Mesurés sur des configurations matérielles courantes :

Tokens par seconde (Vitesse de génération)

Modèle	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	CPU uniquement (32GB)
E2B (Q4)	~150 tok/s	~120 tok/s	~100 tok/s	~30 tok/s
E4B (Q4)	~100 tok/s	~80 tok/s	~70 tok/s	~15 tok/s
26B MoE (Q4)	~40 tok/s	~30 tok/s	~25 tok/s	~3 tok/s
31B Dense (Q4)	~30 tok/s	~20 tok/s	~20 tok/s	~2 tok/s

Contexte : La vitesse de lecture humaine est d'environ 4-5 tokens par seconde. Tout modèle générant plus de 10 tok/s semble "instantané" pour une utilisation interactive. Les modèles E2B et E4B sont assez rapides pour du streaming en temps réel sur presque n'importe quel matériel.

Temps jusqu'au premier token (Latence)

Modèle	RTX 4090	M3 Max	CPU uniquement
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

Pour les applications interactives, le temps jusqu'au premier token importe plus que la vitesse de génération. Les modèles E2B et E4B commencent à générer presque instantanément, même sur CPU, ce qui les rend idéaux pour les interfaces de chat en temps réel.

Cas d'utilisation courants

Assistant de code local

Utilisez Gemma 4 comme un assistant de code privé qui n'envoie jamais votre code à des serveurs externes :

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

Associez cela à des extensions VS Code comme Continue ou Twinny qui prennent en charge Ollama comme backend.

Analyse de documents

Traitez des documents sensibles localement :

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

Avec un contexte de 256K, le modèle 31B peut traiter des documents allant jusqu'à ~750 pages — suffisant pour la plupart des contrats, articles de recherche et documentations techniques.

RAG local (Retrieval-Augmented Generation)

Combinez Gemma 4 avec une base de données vectorielle locale pour un système RAG entièrement privé :

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# Utiliser Gemma 4 pour les embeddings et la génération
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Créer un store vectoriel à partir de vos documents
vectorstore = Chroma.from_documents(documents, embeddings)

# Requête avec RAG
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

Intégration de fonctionnalités AI dans les applications

Pour les développeurs créant des applications avec des capacités AI, exécuter Gemma 4 localement via l'API de Ollama est le chemin le plus rapide vers un prototype fonctionnel. L'API compatible OpenAI signifie que vous pouvez commencer avec Gemma 4 local pour le développement et passer aux API cloud pour la production sans changer le code de l'application.

Des plateformes comme ZBuild peuvent gérer l'infrastructure de l'application — frontend, backend, authentification, base de données — pendant que vous vous concentrez sur la couche d'intégration AI. Pointez le point de terminaison AI de votre application vers localhost:11434 pendant le développement et passez à un point de terminaison cloud lorsque vous êtes prêt à passer à l'échelle.

Dépannage

Erreurs "Out of memory"

Si vous voyez des erreurs de mémoire :

Essayez une quantization plus petite : ollama pull gemma4:31b-q3_K_M
Réduisez la fenêtre de contexte : --num-ctx 4096
Fermez les autres applications gourmandes en GPU
Passez à un modèle plus petit : le 26B MoE offre une qualité proche du 31B pour un coût mémoire inférieur

Vitesse de génération lente

Si la génération est plus lente que prévu :

Vérifiez l'utilisation du GPU : nvidia-smi (devrait montrer une utilisation élevée du GPU)
Assurez-vous que le modèle tient entièrement dans la VRAM — le déchargement partiel sur CPU est radicalement plus lent
Réduisez --num-ctx pour libérer de la VRAM pour le calcul
Vérifiez si d'autres processus utilisent le GPU

Modèle non trouvé

Si ollama run gemma4:26b-moe échoue :

# Lister les modèles disponibles
ollama list

# Rechercher des modèles Gemma 4
ollama search gemma4

# Récupérer le modèle spécifique
ollama pull gemma4:26b-moe

Connexion API refusée

Si les applications ne peuvent pas se connecter à localhost:11434 :

# Vérifier si Ollama est en cours d'exécution
ollama list

# Démarrer le serveur Ollama manuellement
ollama serve

# Vérifier le port
curl http://localhost:11434/api/tags

Arbre de décision pour la sélection du modèle

Utilisez ceci pour choisir rapidement le bon modèle :

Avez-vous un GPU dédié avec 16GB+ de VRAM ?

Oui → Voulez-vous une qualité maximale ou une efficacité maximale ?
- Qualité maximale → gemma4:31b (Q4_K_M, nécessite 20GB)
- Efficacité maximale → gemma4:26b-moe (Q4_K_M, nécessite 18GB)
Non → Avez-vous 8GB+ de RAM ?
- Oui → gemma4:e4b (Q4_K_M, meilleure qualité)
- Non → gemma4:e2b (Q4_K_M, fonctionne sur 5GB)

Pour la plupart des développeurs avec un ordinateur de bureau moderne ou un PC de jeu : Commencez par gemma4:26b-moe. Il offre le meilleur rapport qualité-ressources de toute la famille Gemma 4.

Ce que vous pouvez construire

Avec Gemma 4 s'exécutant localement, vous disposez d'un backend AI à coût zéro pour :

Applications de chat avec une confidentialité totale des conversations
Outils d'analyse de code qui fonctionnent sur des bases de code propriétaires
Pipelines de traitement de documents pour des données sensibles
Assistants AI locaux qui fonctionnent hors ligne
Prototypage de fonctionnalités AI avant de s'engager dans des coûts d'API cloud
Modèles fine-tuned pour des tâches spécifiques à un domaine (Apache 2.0 le permet librement)

La licence Apache 2.0 signifie que tout ce que vous construisez vous appartient — aucune restriction d'utilisation, aucun partage de revenus, aucune approbation nécessaire. Exécutez-le localement, déployez-le sur vos serveurs, intégrez-le dans vos produits. C'est à cela que ressemble une AI véritablement ouverte.

Exécuter Gemma 4 localement en 5 minutes : Guide d'installation complet Ollama (2026)