Gemma 4 et Claude Code : révolution locale de la programmation

Une nouvelle ère pour la programmation agentique locale

Imaginez un scénario où un flux de travail multi-agents est capable de lire des fichiers, d'écrire des correctifs, d'exécuter des tests et de répéter ces actions à travers quatre services différents, le tout en réalisant 400 appels API en une seule après-midi. Un message d'alerte vous informe que vous avez dépassé la limite de votre forfait. Chaque token représente un coût, chaque prompt envoie votre code à un serveur tiers, et les restrictions de taux interrompent les sessions prolongées. La seule solution semble être de payer davantage.

Gemma 4 : une avancée technologique significative

Le modèle Gemma 4, avec ses 26 milliards de paramètres, n'active que 3,8 milliards de ces paramètres à chaque passage. Il atteint un score de 77,1% sur LiveCodeBench v6 et 86,4% sur τ2-bench, des benchmarks qui évaluent spécifiquement les capacités d'un modèle à utiliser des outils, à exécuter des étapes et à gérer des erreurs dans un flux de travail complexe. Comparé à son prédécesseur, Gemma 3 27B, qui n'atteignait que 6,6% sur ces mêmes tests, cette mise à jour représente une avancée majeure. Cela signifie que Gemma 4 peut exécuter une boucle agentique avec Claude Code sans déformer constamment ses paramètres d'appel de fonction.

Construire une pile technologique efficace

Cet article détaille la construction d'une pile technologique complète : Ollama pour servir Gemma 4 localement, le Modelfile pour éviter les échecs de fenêtre de contexte dans les sessions agentiques, le fichier settings.json qui connecte Claude Code à l'endpoint local, un script de vérification pour s'assurer que tout fonctionne correctement avant de l'appliquer à du code réel, et une analyse honnête des problèmes potentiels et de leurs solutions. Cet article s'adresse à des ingénieurs qui ont déjà une compréhension des grands modèles de langage (LLMs) et des coûts associés aux boucles agentiques.

Gemma 4 : une licence plus permissive

Publié le 2 avril 2026 sous Apache 2.0, Gemma 4 est le modèle à poids ouverts le plus performant de Google DeepMind à ce jour. Il est disponible en quatre variantes : E2B (2B effectifs), E4B (4B effectifs), 26B MoE, et 31B Dense. Le modèle 26B MoE utilise 128 petits experts et active seulement 8 par token plus un expert partagé, offrant une qualité proche de 31B à un coût de calcul considérablement réduit.

Les versions précédentes de Gemma étaient sous une licence Google personnalisée avec des restrictions d'utilisation commerciale ambiguës, souvent considérées comme un obstacle par les équipes juridiques des entreprises. Avec la licence Apache 2.0, Gemma 4 permet une intégration plus facile dans des outils internes, le déploiement de produits, ou l'exécution dans des pipelines de production sans nécessiter de révision juridique approfondie.

Les performances de Gemma 4 en chiffres

Les performances de Gemma 4 sont mesurées sur plusieurs benchmarks clés :

• Gemma 4 31B Dense
• τ2-bench pour l'utilisation d'outils agentiques
• LiveCodeBench v6
• AIME 2026 pour les mathématiques

Exigences matérielles pour Gemma 4

Avant de télécharger un modèle de 18 Go, il est crucial de comprendre les exigences matérielles. La famille Gemma 4 a été conçue pour s'adapter à une large gamme d'appareils, des appareils edge aux stations de travail, et les quatre variantes reflètent cette diversité.

Installation d'Ollama, Gemma 4 et Claude Code

Étape 1 : Installer Ollama

Pour macOS et Linux, l'installation se fait en une seule ligne :

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

Il est essentiel de vérifier que la version est 0.14.0+ pour le support de l'API Anthropic Messages. L'endpoint compatible avec Anthropic a été ajouté en janvier 2026, et la version attendue d'Ollama est 0.22.x ou supérieure (à partir de mai 2026).

Pour Windows, il faut télécharger l'installateur natif depuis https://ollama.com. L'utilisation de WSL2 est recommandée pour un passage GPU sur Windows.

Après l'installation, Ollama démarre en tant que service en arrière-plan sur le port 11434. Pour vérifier son bon fonctionnement :

curl http://localhost:11434

La réponse attendue est qu'Ollama est en cours d'exécution.

Étape 2 : Télécharger Gemma 4

Pour le 26B MoE, recommandé pour cette configuration, le téléchargement est d'environ 18 Go :

ollama pull gemma4:26b

Pendant le téléchargement, il est conseillé de vérifier la progression pour s'assurer que tout se déroule correctement.

Il est également possible de télécharger le 31B pour comparaison sur du matériel capable :

ollama pull gemma4:31b

Une fois le téléchargement terminé, il doit afficher gemma4:26b avec la taille et la date de modification.

Étape 3 : Installer Claude Code

Prérequis : Node.js 18 ou version ultérieure. Vérifiez la version :

node --version

Installez Claude Code CLI globalement :

npm install -g @anthropic-ai/claude-code

Vérifiez l'installation :

claude --version

Avec Ollama en cours d'exécution et Gemma 4 téléchargé, l'étape suivante est d'exporter les variables d'environnement et de lancer Claude Code.

La fenêtre de contexte par défaut d'Ollama pour Gemma 4 est de 4K tokens, alors que la fenêtre de contexte réelle de Gemma 4 est de 128K–256K. Ce 4K par défaut n'est pas une suggestion, c'est ce qu'Ollama utilisera à moins que vous ne le remplaciez. Dans une session agentique Claude Code qui lit des fichiers sources, conserve l'historique de conversation et maintient les résultats d'appels d'outils à travers plusieurs tours, 4K tokens s'épuisent rapidement.

Sans le remplacement de contexte, Claude Code perd la trace du contenu des fichiers en cours d'édition, oublie les instructions antérieures et produit des modifications fragmentées. Par exemple, lorsqu'un agent essaie de refactoriser une classe de service de 200 lignes, il oublie que la seconde moitié existe. L'agent ne soulève pas d'erreur, mais travaille sur une vue incomplète du fichier, produisant une sortie partiellement correcte qui casse en aval.

La solution est un Modelfile qui intègre la taille de contexte correcte et d'autres paramètres d'inférence dans une variante de modèle nommée. Créez ce fichier :

~/.ollama/Modelfiles/gemma4-claude

• Variante Gemma 4 26B MoE ajustée pour les sessions agentiques Claude Code.
• Intègre la fenêtre de contexte, la température et l'invite système dans le modèle.
• Afin que chaque session Claude Code commence avec la bonne configuration.

Créez le répertoire Modelfiles s'il n'existe pas :

mkdir -p ~/.ollama/Modelfiles

Enregistrez le contenu du Modelfile ci-dessus à ce chemin, puis construisez :

ollama create gemma4-claude -f ~/.ollama/Modelfiles/gemma4-claude

Vérifiez que la variante a été créée, elle doit afficher gemma4-claude aux côtés de gemma4:26b.

Test rapide : vérifiez qu'il se charge et répond :

ollama run gemma4-claude "Quelle est la complexité temporelle de la recherche binaire et pourquoi ?"

Attendez-vous à une réponse technique claire et concise en quelques secondes.

Connexion de Claude Code au modèle local

Avec la variante de modèle construite, la configuration relie Claude Code à Ollama. Deux variables d'environnement sont essentielles, mais trois variables supplémentaires empêchent les modes de défaillance les plus courants.

L'endpoint compatible avec Anthropic d'Ollama est à http://localhost:11434, pas à http://localhost:11434/v1. Le chemin /v1 est la couche compatible avec OpenAI d'Ollama. Claude Code utilise le protocole Anthropic Messages API, qui se mappe à l'endpoint racine. Utiliser le chemin /v1 produira des erreurs d'authentification ou un comportement inattendu.

Paramètres globaux — ~/.claude/settings.json

Cette configuration s'applique à chaque session Claude Code à travers tous les projets. C'est le bon choix à moins que vous ne changiez fréquemment entre des modèles locaux et cloud par projet.

{
  "ANTHROPIC_BASE_URL": "http://localhost:11434",
  "ANTHROPIC_AUTH_TOKEN": "ollama",
  "ANTHROPIC_API_KEY": "",
  "ANTHROPIC_MODEL": "gemma4-claude",
  "ANTHROPIC_DEFAULT_SONNET_MODEL": "gemma4-claude",
  "ANTHROPIC_DEFAULT_HAIKU_MODEL": "gemma4-claude",
  "ANTHROPIC_DEFAULT_OPUS_MODEL": "gemma4-claude",
  "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS": "1"
}

Chaque variable a son importance :

• ANTHROPIC_BASE_URL redirige tous les appels API de Claude Code des serveurs d'Anthropic vers votre instance locale d'Ollama.

• ANTHROPIC_AUTH_TOKEN doit être défini sur une chaîne non vide ; Ollama ignore la valeur mais Claude Code nécessite que l'en-tête soit présent.

• ANTHROPIC_API_KEY : "" vide explicitement la clé afin que Claude Code ne puisse pas revenir à une véritable clé API Anthropic si une est définie dans votre environnement shell. Sans cela, un ANTHROPIC_BASE_URL mal configuré pourrait silencieusement échouer sur l'API payante.

• ANTHROPIC_MODEL est le nom principal du modèle que Claude Code envoie dans les requêtes. Réglez cela sur votre variante de Modelfile personnalisée, gemma4-claude et non gemma4:26b. Le tag de modèle brut ne porte pas le remplacement de la fenêtre de contexte.

• ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL, et ANTHROPIC_DEFAULT_OPUS_MODEL : Claude Code route en interne différents types de tâches vers différents niveaux de modèles. En définissant les trois sur le même modèle local, vous vous assurez que chaque requête atterrit sur votre instance d'Ollama.