Gemma 4 + Ollama + Claude Code : le guide ultime pour coder localement sans payer

INSTALLER OLLAMA : LE MOTEUR QUI FAIT TOURNER GEMMA 4

Ollama, c'est un peu le moteur de jeu qui permet à votre ordinateur de faire tourner des modèles d'IA comme Gemma 4 sans avoir besoin d'un supercalculateur. La première étape ? L'installer. Sur macOS ou Linux, une seule ligne de commande suffit :

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

Pour vérifier que tout fonctionne, tapez :

ollama version

Si vous voyez une version 0.22.x ou supérieure (en mai 2026), c'est bon signe. Sur Windows, il faut télécharger l'installateur directement depuis ollama.com. Si vous voulez utiliser le GPU de votre machine, l'installation dans WSL2 est recommandée.

VÉRIFIER QUE OLLAMA TOURNE BIEN

Avant de continuer, assurez-vous que le service est actif. Dans votre navigateur, allez sur :

http://localhost:11434

Si vous voyez s'afficher "Ollama is running", tout est prêt. Sinon, lancez manuellement Ollama avec :

ollama serve

TÉLÉCHARGER GEMMA 4 : LE MODÈLE QUI COMPREND VOTRE CODE

Gemma 4, c'est un modèle d'IA spécialisé dans le raisonnement technique. La version recommandée pour ce setup est gemma4:26b, un modèle de 26 milliards de paramètres qui n'en active que 3,8 milliards à chaque utilisation. Autrement dit, il est puissant mais pas gourmand. Le téléchargement prend environ 18 Go :

ollama pull gemma4:26b

Pendant le téléchargement, vous pouvez vérifier sa progression avec :

ollama ps

Si vous avez une machine puissante, vous pouvez aussi télécharger la version gemma4:31b pour comparer les performances. Une fois terminé, listez les modèles disponibles avec :

ollama list

Vous devriez voir gemma4:26b avec sa taille et sa date de modification.

INSTALLER CLAUDE CODE : L'AGENT QUI FAIT LE TRAVAIL À VOTRE PLACE

Claude Code, c'est un peu un assistant de Développement qui utilise l'IA pour automatiser des tâches complexes. Pour l'installer, vous avez besoin de Node.js 18 ou supérieur. Vérifiez votre version avec :

node --version

Si tout est bon, installez Claude Code avec :

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

Puis vérifiez l'installation :

claude --version

CRÉER UNE VERSION DE GEMMA 4 ADAPTÉE À CLAUDE CODE

Gemma 4 standard n'est pas optimisé pour les sessions agentiques (où l'IA doit enchaîner les actions : lire un fichier, écrire du code, lancer des tests.). Pour éviter les erreurs de fenêtre de contexte (quand l'IA oublie le début de votre code), il faut créer une version personnalisée. Créez d'abord le dossier :

mkdir -p ~/.ollama/Modelfiles

Puis créez un fichier nommé gemma4-claude dans ce dossier avec le contenu suivant :

FROM gemma4:26b

PARAMETER num_ctx 65536
PARAMETER temperature 0.2
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.15
PARAMETER num_predict 4096

SYSTEM """You are a senior software engineer operating as a coding agent.

When working with code:
- Read files before editing them. Never assume file contents.
- Make one focused change at a time and verify it before proceeding.
- When a tool call fails, examine the error carefully before retrying.
  Do not retry with identical parameters. Diagnose first.
- Prefer surgical edits over full file rewrites.
- Run tests after each meaningful change, not after a batch of changes.
- If you are uncertain about the codebase structure, read more files
  rather than guessing.

Be precise and methodical. Avoid explaining what you are about to do
when you could simply do it."""

Ensuite, construisez cette version personnalisée avec :

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

Vérifiez que tout est bon avec :

ollama list

Vous devriez voir apparaître gemma4-claude à côté de gemma4:26b. Testez rapidement avec :

ollama run gemma4-claude "What is the time complexity of binary search and why?"

Si l'IA répond en quelques secondes avec une explication technique claire, c'est que tout fonctionne.

CONFIGURER CLAUDE CODE POUR UTILISER VOTRE MODÈLE LOCAL

Claude Code a besoin de savoir où trouver votre modèle local. Créez un dossier .claude dans votre projet et un fichier settings.json avec ce contenu :

{
  "env": {
    "ANTHROPICBASEURL": "http://localhost:11434",
    "ANTHROPICAUTHTOKEN": "ollama",
    "ANTHROPICAPIKEY": "",
    "ANTHROPIC_MODEL": "gemma4-claude",
    "ANTHROPICDEFAULTSONNET_MODEL": "gemma4-claude",
    "ANTHROPICDEFAULTHAIKU_MODEL": "gemma4-claude",
    "ANTHROPICDEFAULTOPUS_MODEL": "gemma4-claude",
    "CLAUDECODEDISABLEEXPERIMENTALBETAS": "1"
  }
}

Ce fichier indique à Claude Code d'utiliser votre modèle local gemma4-claude au lieu de passer par les serveurs d'Anthropic. Le paramètre CLAUDECODEDISABLEEXPERIMENTALBETAS: "1" désactive les fonctionnalités expérimentales qui pourraient causer des instabilités.

VÉRIFIER QUE TOUT FONCTIONNE AVANT DE CODER VRAIMENT

Pour éviter de perdre du temps sur des erreurs stupides, lancez ce script de vérification :

pip install httpx
python verifylocalsetup.py

Ce script fait 4 tests :

• Vérifie que Ollama est bien lancé
• Vérifie que votre modèle personnalisé gemma4-claude est disponible
• Teste un appel basique à l'API Messages d'Anthropic
• Vérifie que l'IA peut appeler des outils (comme lire un fichier ou exécuter une commande)

Si les 4 tests passent, vous êtes prêt à coder. Sinon, le script vous indiquera exactement quoi corriger.

LANCER UNE SESSION AGENTIQUE : L'IA QUI CODERA À VOTRE PLACE

Placez-vous dans un dossier de projet et lancez Claude Code :

cd ~/projects/my-service
claude

À l'intérieur de l'interface, donnez-lui une tâche concrète comme :

Voici ce que fait l'IA en arrière-plan :

→ readfile("src/userservice.py")
  Reading 247 lines.

→ list_files("src/")
  Found: user_service.py, models.py, db.py, exceptions.py

→ read_file("src/models.py")
  Reading 89 lines.

→ writefile("tests/testuser_service.py", [contenu des tests])
  Written: 312 lines

→ bash("python -m pytest tests/testuserservice.py -v 2>&1")
  Running 14 tests.
  FAILED tests/testuserservice.py::testupdateemail_invalid
    AssertionError: Expected ValidationError, got None

→ readfile("src/userservice.py")  [relit la méthode update_email]
  .

→ writefile("tests/testuser_service.py", [tests corrigés])
  Patched testupdateemail_invalid assertion

→ bash("python -m pytest tests/testuserservice.py -v 2>&1")
  14 passed in 1.23s

En moins d'une minute, l'IA a lu votre code, écrit des tests, détecté une erreur, corrigé le problème et relancé les tests avec succès. Tout cela sans que vous ayez à toucher à quoi que ce soit.

OPTIMISER LES PERFORMANCES : ÉVITER LES PIÈGES

Avec un modèle aussi puissant, la mémoire peut devenir un problème. Voici comment optimiser :

Si vous manquez de mémoire, deux solutions :

• Réduire la fenêtre de contexte dans votre Modelfile : passez de 65536 à 32768 tokens
• Activer la quantification du cache KV avec :

export OLLAMAKVCACHETYPE=q80
pkill ollama && ollama serve

Cette quantification réduit légèrement la qualité mais économise énormément de mémoire.

GARDER LE MODÈLE CHARGÉ POUR ÉVITER LES TEMPS D'ATTENTE

Chaque fois que vous relancez Ollama, le modèle doit être rechargé en mémoire. Pour éviter ça, gardez-le chargé en permanence :

export OLLAMAKEEPALIVE=-1

Ou ajoutez cette ligne dans votre fichier de configuration shell (~/.zshrc ou ~/.bashrc) pour que ce soit automatique. Vous pouvez aussi le faire via l'API Ollama :

curl http://localhost:11434/api/generate \
  -d '{"model": "gemma4-claude", "keep_alive": -1}'

Cette commande "épingle" le modèle en mémoire jusqu'à ce que vous le déchargiez explicitement ou redémarriez Ollama.

POURQUOI CELA CHANGE TOUT : GEMMA 4 VS LES AUTRES MODÈLES

Gemma 4 n'est pas un simple modèle de plus. C'est une révolution pour les développeurs :

Cette différence s'explique par l'architecture MoE (Mixture of Experts) de Gemma 4. Au lieu d'utiliser tous ses 26 milliards de paramètres à chaque utilisation, il n'en active que 3,8 milliards. C'est comme avoir une équipe d'experts spécialisés : à chaque question, seul l'expert pertinent est sollicité. Résultat ? Une puissance comparable à un modèle de 31 milliards de paramètres, mais avec une consommation bien moindre.

Autre avantage majeur : la licence Apache 2.0. Contrairement aux versions précédentes de Gemma qui avaient des restrictions commerciales floues, cette version est totalement libre. Vous pouvez l'intégrer dans vos outils internes, l'utiliser dans vos produits ou l'exécuter dans vos pipelines de production sans avoir à passer par une revue juridique.

LES QUATRE VARIANTES DE GEMMA 4 : QUELLE VERSION CHOISIR ?

Google DeepMind a sorti quatre versions de Gemma 4, chacune adaptée à un usage différent :

• E2B (2 milliards de paramètres effectifs) : pour les appareils mobiles ou les Raspberry Pi
• E4B (4 milliards de paramètres effectifs) : pour les ordinateurs portables
• 26B MoE (26 milliards de paramètres, 3,8 milliards activés) : pour les postes de travail
• 31B Dense (31 milliards de paramètres) : pour les serveurs puissants

La version 26B MoE est le meilleur compromis pour la plupart des développeurs : assez puissante pour gérer des projets complexes, mais assez légère pour tourner sur une machine standard.

LES LIMITES À CONNAÎTRE AVANT DE SE LANCER

Même avec cette configuration optimisée, il y a quelques points d'attention :

• La mémoire vive : Gemma 4 26B a besoin d'au moins 16 Go de VRAM. Si vous avez moins, optez pour la version 4B ou 2B.
• Les erreurs de contexte : Même avec une fenêtre de 65536 tokens, l'IA peut parfois oublier des détails si votre projet est très volumineux. Dans ce cas, réduisez la taille du contexte ou divisez votre projet en modules plus petits.
• Les appels d'outils : L'IA doit être capable de produire des blocs tool_use valides pour que Claude Code fonctionne. Si ce n'est pas le cas, vérifiez votre Modelfile et assurez-vous que le paramètre temperature est bien à 0,2.
• Les performances : Sur une première utilisation, le chargement du modèle peut prendre plusieurs minutes. Prévoyez du temps pour les premières sessions.

CE QUE ÇA CHANGE POUR LES DÉVELOPPEURS : FINIES LES FACTURES EXORBITANTES

Imaginez : vous travaillez sur un projet avec 4 services différents. Votre agent IA enchaîne 400 appels API en une après-midi pour lire des fichiers, écrire du code, lancer des tests et corriger les bugs. Résultat ? Une notification : "Vous avez dépassé la limite douce". Chaque token coûte de l'argent. Chaque prompt envoie votre code propriétaire sur un serveur tiers. Les limites de taux interrompent vos sessions longues. La seule solution ? Payer plus.

Avec cette configuration locale, tout cela disparaît. Votre code reste sur votre machine. Vous n'avez plus de limite de tokens. Vous pouvez enchaîner les sessions sans interruption. Et surtout : c'est gratuit.

LE VERDICT : UNE CONFIGURATION QUI VA BOULEVERSER VOTRE QUOTIDIEN

Ce setup n'est pas pour tout le monde. Il demande un peu de technique et une machine capable de suivre. Mais pour ceux qui osent se lancer, c'est une révolution :

• Plus de dépendance aux serveurs cloud
• Plus de factures salées pour des tokens
• Plus de limites de taux qui gâchent vos sessions
• Une IA qui comprend votre code et agit comme un vrai assistant

Si vous êtes prêt à investir 15 minutes pour configurer tout ça, vous ne reviendrez plus en arrière. Votre workflow de développement va changer du tout au tout.

Alors, prêt à coder localement avec Gemma 4, Ollama et Claude Code ? Suivez le guide, et lancez votre première session agentique dès aujourd'hui.