Faites tourner Gemma gratuitement dans Claude Code grâce à Ollama

Le moment où j’ai arrêté de payer pour des jetons de codage IA, c’était un mardi après-midi.

Je brûlais des crédits API Claude sur un pipeline d’automatisation de contenu — rien d’exotique, juste un workflow multi-agents qui scrappait, résumait et reformatait des données provenant de quatre sites web. Le genre de projet où l’on ne se rend pas compte qu’on a effectué 400 appels API avant que le tableau de bord de facturation ne vous envoie une notification polie indiquant que vous avez dépassé votre limite souple. Encore une fois.

J’avais déjà passé en revue tous les modèles Gemma 4 que Google a lancés le 2 avril 2026. Les benchmarks étaient solides. Le modèle Mixture of Experts 26B m’a impressionné par son rapport rapidité/qualité. Mais je n’avais encore intégré aucun de ces modèles dans mon outil quotidien — Claude Code — en remplacement complet de l’inférence cloud. Je pensais que l’écart entre un modèle open source exécuté localement et les serveurs d’Anthropic rendrait l’expérience frustrante.

Je me trompais. Spectaculairement.

En moins d’une heure après avoir configuré Ollama pour servir le modèle 26B de Gemma 4 via l’endpoint compatible Anthropic de Claude Code, j’avais exactement le même workflow d’édition de fichiers, d’appel d’outils, d’exécution bash et de codage multi-étapes pour lequel je payais — mais entièrement sur mon propre matériel. Pas de clé API. Pas de tableau de bord de facturation. Aucune donnée ne quitte ma machine. Et c’était suffisamment rapide pour que j’arrête de vérifier si les réponses étaient plus lentes que la version cloud, car la plupart du temps, la différence était imperceptible.

Ce n’est pas une configuration théorique. Je l’utilise depuis plus d’une semaine sur des projets réels. Voici exactement comment construire le même workflow, quel modèle Gemma 4 choisir selon votre matériel, et là où l’expérience brille vraiment — ainsi que ses limites actuelles.

Pourquoi choisir spécifiquement Gemma 4 — et pas un autre modèle local

J’ai testé de nombreux modèles locaux via Claude Code : Qwen 3.5, Llama 4 Scout, les variantes DeepSeek, les modèles Phi. J’ai même rédigé un guide complet sur l’utilisation gratuite de Claude Code avec Ollama qui détaille l’approche générale. Alors, pourquoi Gemma 4 mérite-t-il un article de configuration dédié ?

Trois raisons, qui se renforcent mutuellement.

L’efficacité des tokens change la donne. Dans mon test pratique de Gemma 4, j’ai mesuré que le modèle 26B utilise environ 2,5 fois moins de tokens de sortie que Qwen 3.5 pour des tâches équivalentes. En local, moins de tokens signifie une génération plus rapide, moins de pression sur la mémoire, et des fenêtres de contexte plus courtes consommées par les réponses du modèle. Dans une boucle de codage agentique où Claude Code enchaîne cinq ou six appels d’outils par tâche, cet écart d’efficacité fait la différence entre un workflow réactif et un autre où l’on a l’impression d’attendre le bus.

L’appel d’outils natif fonctionne sans acrobaties. Google a intégré l’utilisation d’outils directement dans Gemma 4 — il ne s’agit pas d’un simple fine-tuning sur un modèle de base. Concrètement : lorsque Claude Code demande à Gemma 4 de lire un fichier, modifier une fonction ou exécuter une commande shell, le modèle formate l’appel d’outil correctement dès la première tentative, bien plus souvent que les autres modèles de taille comparable que j’ai testés. L’intégration Ollama d’avril 2026 confirme que l’appel d’outils, la lecture et l’édition de fichiers, ainsi que l’exécution bash fonctionnent tous correctement via la couche de compatibilité Anthropic Messages API.

L’architecture Mixture of Experts le rend rapide sur du matériel modeste. Le modèle 26B n’active qu’environ 3,88 milliards de paramètres par inférence. Le reste reste inactif. Résultat : un modèle de 26 milliards de paramètres tourne à des vitesses dignes d’un modèle 4B — environ 300 tokens par seconde sur un Mac Studio M2 Ultra, d’après les benchmarks de Google. Mes propres mesures étaient inférieures à ce chiffre, mais restaient plus rapides que tout autre modèle de capacité comparable que j’ai pu faire tourner en local.

Cette combinaison — rapidité, efficacité, fiabilité des appels d’outils — fait de Gemma 4 le premier modèle local que je recommande vraiment pour un usage quotidien de Claude Code, sans la réserve habituelle du « c’est bien pour les tâches simples ». Il gère du vrai travail de développement.

Mais avant d’installer quoi que ce soit, il faut déterminer quel modèle correspond à votre matériel. Se tromper ici, c’est perdre des heures.

Choisissez le bon modèle Gemma 4 pour votre matériel

Google a livré quatre modèles, et choisir la mauvaise taille est l’erreur la plus courante que je vois chez ceux qui se lancent dans l’IA locale. Trop petit, et vous serez frustré par la qualité des réponses. Trop grand, et l’inférence devient interminable, voire le modèle ne se charge pas du tout.

Voici la gamme avec des exigences matérielles réalistes — pas les chiffres marketing optimistes de Google, mais ce qu’il vous faut réellement pour une expérience Claude Code fluide :

Pour Claude Code en particulier, je recommande de commencer avec le modèle 26B MoE. Voici pourquoi : Claude Code nécessite au moins 64K tokens de contexte pour fonctionner correctement — ses fonctionnalités agentiques reposent sur la capacité à conserver simultanément le contenu des fichiers, l’historique des conversations et les résultats des outils en mémoire. Le modèle 26B répond à cette exigence tout en restant suffisamment rapide pour du codage interactif. Le modèle E4B fonctionne, mais atteint vite ses limites de qualité dès qu’on dépasse l’édition de fichiers simples ou la génération de code basique.

Comment vérifier si votre matériel est adapté. Avant de télécharger 18 Go de poids de modèle pour découvrir que votre machine ne peut pas le faire tourner, utilisez un vérificateur de compatibilité matérielle. Des sites comme WillItRunAI et CanIRun.ai vous permettent de renseigner votre type de GPU, la VRAM, la RAM système et le nombre de cœurs GPU pour obtenir une estimation de compatibilité. Sélectionnez la variante Gemma 4 qui vous intéresse, saisissez vos caractéristiques, et l’outil vous indiquera si l’inférence sera confortable, possible mais lente, ou tout simplement impossible.

Quelques points issus de mes tests sur différents matériels :

• MacBook Pro M4 Pro (48 Go de mémoire unifiée) : Le modèle 26B génère environ 51 tokens par seconde. Très confortable pour du vrai développement.
• M2 Pro (16 Go) : Le modèle 26B atteint 20 à 25 tokens par seconde. Utilisable, mais les pauses se font sentir sur les sorties longues.
• RTX 4090 (24 Go VRAM) : Le modèle dense 31B tourne à environ 41 tokens par seconde. Le 26B MoE est nettement plus rapide — bien au-delà de 60 tokens par seconde.
• RTX 3060 (12 Go VRAM) : Le modèle E4B fonctionne sans accroc. Le 26B se charge avec quantization, mais la mémoire devient vite un facteur limitant.

Si vous disposez d’un Mac Apple Silicon avec 16 Go ou plus de mémoire unifiée, le modèle 26B avec quantization Q4_K_M est votre meilleur choix. Si vous avez un GPU NVIDIA dédié avec 24 Go de VRAM, vous pouvez faire tourner le modèle dense 31B et obtenir la meilleure qualité de sortie.

Maintenant que vous savez quel modèle choisir, passons à la configuration concrète.

Étape 1 : Installer Ollama

Ollama est le serveur de modèles local qui rend tout ce flux de travail possible. Pensez-y comme à Docker pour les modèles de langage : vous récupérez des images de modèles, Ollama gère l’exécution, et vos applications communiquent avec lui via un point de terminaison API local.

Sur macOS :

Téléchargez l’installateur depuis ollama.com ou installez-le via Homebrew :

brew install ollama

Sur Linux :

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

Sur Windows (via WSL) :

Installez d’abord WSL si ce n’est pas déjà fait, puis suivez les instructions Linux à l’intérieur de votre distribution WSL. Un support natif Windows existe, mais WSL offre une expérience plus cohérente avec Claude Code.

Après l’installation, vérifiez qu’Ollama fonctionne :

ollama --version

Vous devriez voir la version 0.6.x ou ultérieure — les versions antérieures n’incluent pas la compatibilité avec l’API Anthropic Messages requise par Claude Code.

Démarrez le serveur Ollama si ce n’est pas fait automatiquement :

ollama serve

Laissez ce processus actif dans un onglet de terminal ou configurez-le comme service en arrière-plan. Toutes les étapes suivantes dépendent du fait qu’Ollama soit actif et à l’écoute sur localhost:11434.

Étape 2 : Récupérez votre modèle Gemma 4

C’est ici que votre choix matériel de la section précédente entre en jeu. Exécutez la commande correspondant au modèle choisi :

# Pour la plupart des utilisateurs — le meilleur compromis entre vitesse et qualité
ollama pull gemma4:26b

# Pour les configurations haut de gamme — qualité maximale
ollama pull gemma4:31b

# Pour les machines plus légères — suffisant pour du code basique
ollama pull gemma4:e4b

Le modèle 26B pèse environ 18 Go. Avec une connexion internet correcte, comptez 5 à 15 minutes pour le téléchargement. Ollama gère automatiquement toute la quantification et l’optimisation — inutile de configurer manuellement des fichiers GGUF ou des scripts de conversion.

Une fois le téléchargement terminé, vérifiez que le modèle s’est bien chargé :

ollama run gemma4:26b "Écris une fonction Python qui inverse une liste chaînée"

Vous devriez obtenir une réponse cohérente en quelques secondes. Si le modèle met plus de 30 secondes à répondre, votre matériel est probablement à la peine — envisagez de passer à la variante E4B.

Configuration critique : définissez la fenêtre de contexte. Claude Code nécessite au moins 64 000 tokens de contexte pour fonctionner correctement. Par défaut, Ollama utilise une fenêtre bien plus petite. Créez un Modelfile pour modifier ce paramètre :

# Créez un Modelfile personnalisé
cat <<EOF > Modelfile
FROM gemma4:26b
PARAMETER num_ctx 65536
EOF

# Créez le modèle personnalisé
ollama create gemma4-claude -f Modelfile

Cela crée une nouvelle variante de modèle appelée gemma4-claude avec une fenêtre de contexte de 65 536 tokens. Utilisez cette variante pour tous vos travaux avec Claude Code. Sans cette étape, Claude Code perdra le fil du contenu des fichiers en cours d’édition, oubliera les instructions précédentes et produira des modifications fragmentées. J’en ai fait l’expérience lorsque mon agent a tenté de refactorer une classe de service de 200 lignes et a tout simplement oublié que la seconde moitié existait.

Étape 3 : Installer Claude Code

Si vous n'avez pas encore installé Claude Code, la configuration est simple sur toutes les plateformes.

Prérequis : Node.js 18+ doit être installé sur votre système.

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

Cela installe l'interface CLI de Claude Code globalement. Elle fonctionne sur macOS, Linux, Windows et WSL.

Vérifiez l'installation :

claude --version

Si vous utilisiez déjà Claude Code avec une clé API Anthropic, aucun problème — nous allons maintenant le rediriger vers votre instance Ollama locale.

Étape 4 : Connecter Claude Code à Ollama

C’est ici que la magie opère. Vous allez indiquer à Claude Code d’envoyer ses requêtes API à votre serveur Ollama local au lieu du cloud d’Anthropic.

Définissez les variables d’environnement. La méthode exacte dépend de votre système d’exploitation et de votre shell.

Pour macOS/Linux (zsh ou bash) :

export ANTHROPIC_BASE_URL="http://localhost:11434"
export ANTHROPIC_AUTH_TOKEN="ollama"
export ANTHROPIC_API_KEY="sk-placeholder"

Ajoutez ces lignes à votre fichier ~/.zshrc ou ~/.bashrc pour les rendre permanentes :

echo 'export ANTHROPIC_BASE_URL="http://localhost:11434"' >> ~/.zshrc
echo 'export ANTHROPIC_AUTH_TOKEN="ollama"' >> ~/.zshrc
echo 'export ANTHROPIC_API_KEY="sk-placeholder"' >> ~/.zshrc
source ~/.zshrc

Pour Windows (PowerShell) :

$env:ANTHROPIC_BASE_URL = "http://localhost:11434"
$env:ANTHROPIC_AUTH_TOKEN = "ollama"
$env:ANTHROPIC_API_KEY = "sk-placeholder"

Pour rendre ces variables permanentes sous Windows, ajoutez-les via Propriétés système > Variables d’environnement ou dans votre profil PowerShell.

Ce qui se passe ici : Ollama expose un point de terminaison API qui imite l’API Messages d’Anthropic. Claude Code ne fait pas la différence. Il envoie les requêtes à ce qu’il croit être le serveur d’Anthropic, Ollama les intercepte, les redirige vers votre modèle Gemma 4 local, puis renvoie les réponses exactement au format attendu par Claude Code. La valeur de ANTHROPIC_API_KEY n’a pas d’importance — elle doit simplement être non vide pour éviter que Claude Code ne signale une clé manquante.

Étape 5 : Lancer et vérifier

Démarrez maintenant Claude Code avec votre modèle Gemma 4 local :

claude --model gemma4-claude

Si vous avez créé le Modelfile personnalisé avec la fenêtre de contexte 65K, utilisez gemma4-claude. Si vous avez sauté cette étape (ne la sautez pas), utilisez directement gemma4:26b.

Vous devriez voir l’interface de Claude Code se charger. Essayez une commande simple pour vérifier que tout est bien connecté :

> Read the current directory and list all files

Claude Code devrait utiliser son outil de lecture de fichiers, appeler le modèle Gemma 4 local via Ollama, et renvoyer une liste formatée du répertoire. Si cela fonctionne, toute votre stack est opérationnelle — l’ensemble des outils de Claude Code fonctionnant avec un modèle local, privé et gratuit.

Dépannage des problèmes courants :

• Erreur "Connection refused" : Le serveur Ollama n’est pas lancé. Ouvrez un terminal séparé et exécutez ollama serve.
• Réponses extrêmement lentes : Votre modèle est trop volumineux pour votre matériel. Passez à une variante plus légère ou augmentez l’utilisation du GPU avec OLLAMA_NUM_GPU=99.
• Claude Code plante sur les fichiers volumineux : La fenêtre de contexte est trop petite. Assurez-vous d’avoir créé le Modelfile personnalisé avec num_ctx 65536.
• Échecs lors des appels d’outils : Vérifiez que vous utilisez Ollama 0.6.x ou supérieur. Les versions antérieures ne prennent pas entièrement en charge le format d’appel d’outils requis par Claude Code.

Si vous préférez que quelqu’un construise cette configuration de A à Z — adaptée à votre matériel, optimisée pour votre flux de travail — je réalise exactement ce type de prestation. Vous pouvez voir mes réalisations sur fiverr.com/s/EgxYmWD.

Ce qui fonctionne vraiment — Tâches de codage réelles que j’ai exécutées

Les guides d’installation ne servent à rien sans un retour honnête sur les performances. J’utilise cette stack Gemma 4 + Ollama + Claude Code depuis plus d’une semaine sur des projets concrets. Voici ce qu’elle gère bien, et là où elle atteint ses limites.

Génération d’UI frontend — solide. J’ai demandé au modèle 26B, via Claude Code, de générer la structure d’un dashboard React avec une barre latérale, un tableau de données, un composant graphique et un mode sombre. Le résultat était propre. Bonne séparation des composants. Classes Tailwind cohérentes. Gestion d’état avec les hooks React sans complexifier inutilement. Pour le prototypage et les outils internes, cela remplace totalement mon besoin d’appeler l’API.

Édition de fichiers multiples — fiable. Le workflow d’édition multi-fichiers de Claude Code — lire un fichier, proposer des modifications, les appliquer, lancer les tests — fonctionne correctement via le pont Ollama. Le modèle Gemma 4 26B formate correctement ses appels d’outils, gère les chemins de fichiers sans confusion et applique des modifications chirurgicales plutôt que de réécrire les fichiers en entier. Je l’ai testé sur un projet Laravel de plus de 40 fichiers, et il a navigué dans la base de code sans perdre le contexte.

Refactoring de code — bon, avec des limites. Je lui ai demandé de refactoriser un contrôleur de 300 lignes en services avec injection de dépendances. Le modèle 26B a découpé la logique en trois services avec des interfaces correctes et une injection par constructeur. Les conventions de nommage étaient raisonnables. Là où il a trébuché : le fichier de test généré pour l’un des services comportait une petite erreur de namespace. Une correction de deux secondes, mais à noter — Claude Opus hébergé dans le cloud aurait fait mieux.

Génération et exécution de commandes Bash — excellent. L’une des fonctionnalités les plus utiles de Claude Code est la génération et l’exécution de commandes shell. Gemma 4 gère cela avec assurance via Ollama. Opérations Git, commandes npm, gestion Docker, manipulation du système de fichiers — le modèle comprend les workflows en ligne de commande et génère les bonnes commandes pour l’OS sur lequel il tourne.

Workflows agents complexes multi-étapes — voici la limite. J’ai mis en place un pipeline en cinq étapes — scraper une page web, extraire des données structurées, les transformer, les écrire en base, puis générer un rapport de synthèse — le modèle 26B a mené à bien les quatre premières étapes, mais s’est embrouillé lors de la synthèse, produisant un rapport qui faisait référence aux données de l’étape deux au lieu de l’étape quatre. En passant le même pipeline sur le modèle dense 31B, le problème a disparu. Cela confirme ce que j’ai observé dans mon test complet de Gemma 4 : le modèle 26B est exceptionnel pour des tâches comportant trois ou quatre étapes de raisonnement, mais commence à perdre en précision sur des chaînes plus longues.

Tâches multimodales — une vraie surprise. Gemma 4 prend en charge la vision nativement, et cela fonctionne via le pont Ollama + Claude Code. Je lui ai fourni une capture d’écran d’un design Figma et demandé de générer le HTML/CSS correspondant. Il a identifié la structure du layout, la palette de couleurs et les choix typographiques avec une précision raisonnable. Ce n’est pas du pixel perfect — mais suffisamment proche pour que le résultat soit une base exploitable, et non une page blanche.

Le schéma que j’ai adopté : utiliser l’installation locale de Gemma 4 pour 80 % de mes tâches de développement — édition de fichiers, scaffolding, refactoring, génération de commandes, prototypes rapides. Basculer sur Claude Opus hébergé pour les 20 % restants qui nécessitent un raisonnement multi-étapes poussé, des décisions architecturales complexes ou la gestion de bases de code avec de fortes interdépendances.

Les compromis honnêtes — Ce que vous perdez en passant au local

Je vous rendrais un mauvais service en présentant cela comme un simple remplacement du service cloud d’Anthropic. Ce n’est pas le cas. Voici ce à quoi vous renoncez.

Le cache de prompts ne fonctionne pas. Le cache de prompts d’Anthropic — qui accélère considérablement les conversations répétées en mémorisant le prompt système et le contexte initial — n’est pas disponible via la couche de compatibilité Ollama à la date d’avril 2026. Chaque requête traite l’intégralité du contexte depuis le début. Pour des interactions courtes, cela n’a aucune importance. Mais lors de longues sessions de code où vous enchaînez plus de 30 échanges, vous remarquerez une latence croissante à mesure que le contexte s’alourdit.

tool_choice n’est pas pris en charge. Claude Code utilise parfois tool_choice pour forcer l’appel d’un outil spécifique — par exemple, exiger que le modèle lise un fichier avant de le modifier. Ce paramètre n’est pas supporté dans le mode de compatibilité API Anthropic d’Ollama. En pratique, Gemma 4 appelle encore les bons outils de façon volontaire la plupart du temps, mais il arrive que le modèle tente de répondre de mémoire alors qu’il devrait lire le fichier. Un léger désagrément, rien de rédhibitoire.

Le plafond de raisonnement est réel. Le modèle 26B de Gemma 4 obtient un score de 31 sur l’indice d’intelligence que je suis à travers les modèles. Qwen 3.5 atteint 42. Claude Opus marque nettement plus. Sur des tâches nécessitant une véritable nouveauté — concevoir un algorithme pour un problème inédit, détecter des erreurs logiques subtiles dans une logique métier complexe, prendre des décisions architecturales en tenant compte de huit contraintes différentes — vous sentirez la différence. Le modèle vous fournit une excellente première ébauche. Passer de cette ébauche à la production nécessite parfois un raffinement humain que les modèles cloud gèrent automatiquement.

Pas de streaming sur certaines plateformes. Selon votre version d’Ollama et votre système d’exploitation, les réponses en streaming peuvent ne pas fonctionner parfaitement. Il se peut que vous voyiez toute la réponse apparaître d’un coup, au lieu d’un token à la fois. Les résultats sont identiques sur le fond — mais l’expérience paraît moins interactive.

Vous êtes responsable des mises à jour. Quand Anthropic met à jour Claude, vous bénéficiez automatiquement des améliorations. Avec un modèle local, vous devez récupérer manuellement les nouvelles versions de Gemma 4 à mesure que Google publie des améliorations de quantification, des correctifs et des variantes fine-tunées. La communauté est active, mais cela reste un processus manuel.

Aucun de ces points n’a tué mon workflow. Les avantages en matière de confidentialité, de rapidité et de coût nul l’emportent largement sur les limitations pour la majorité de mes tâches de code quotidiennes. Mais avancez avec des attentes claires.

Au-delà du code — Ce que cette stack permet d’autre

Une fois Gemma 4 lancé dans Claude Code via Ollama, vous n’êtes plus limité à l’écriture de code. Le framework agentique prend en charge tout workflow que vous pouvez exprimer comme une séquence d’appels d’outils.

Rédaction automatisée d’e-mails. Connectez Claude Code à votre système de fichiers local où résident vos modèles d’e-mails, décrivez les messages dont vous avez besoin, et l’agent génère des brouillons personnalisés. Tout reste local. Aucun contenu d’e-mail ne transite par des serveurs externes.

Recherche de leads et scraping. L’exécution bash de Claude Code combinée au raisonnement de Gemma 4 vous permet de bâtir des pipelines de scraping simples. Récupérez des données de sources publiques, extrayez des informations structurées, formatez-les pour votre CRM. J’ai mis en place des prompts Ollama programmés dans Claude Code qui exécutent ce type de tâches à intervalles réguliers — collecte de données automatisée sans dépendance au cloud.

Analyse et synthèse documentaire. Faites passer des PDF, fichiers markdown ou documentations de code dans le pipeline pour obtenir des synthèses structurées. La capacité multimodale permet même de traiter des captures d’écran et des schémas.

Intégrations Slack et workspace. Grâce aux serveurs MCP (Model Context Protocol) et à l’écosystème d’outils de Claude Code, vous pouvez connecter votre agent Gemma 4 local à Slack, Google Workspace et d’autres outils de productivité. Le modèle gère le raisonnement ; les connexions d’outils s’occupent des actions. Tout s’exécute sur votre machine.

Le fil conducteur : tout workflow où la confidentialité des données est cruciale, où vous souhaitez un coût marginal nul par requête, ou où vous devez lancer des centaines de requêtes automatisées sans vous soucier des limites de taux. C’est là que les modèles locaux ne se contentent pas d’égaler les services cloud — ils les surpassent.

Ce que je ferais différemment si je devais tout recommencer

Après une semaine d’utilisation quotidienne, voici quelques optimisations qui m’auraient fait gagner du temps dès le premier jour.

Définir OLLAMA_NUM_GPU=99 dès le départ. Cela indique à Ollama de déporter autant de couches du modèle que possible sur le GPU. J’ai passé deux jours à me demander pourquoi mon modèle 26B était plus lent que prévu, avant de découvrir qu’Ollama faisait tourner la moitié des couches sur le CPU par défaut. Une simple variable d’environnement a tout réglé :

export OLLAMA_NUM_GPU=99

Créer le Modelfile 65K context avant votre première session Claude Code. J’ai commencé avec la fenêtre de contexte par défaut d’Ollama — 8K ou 16K selon le modèle — et je ne comprenais pas pourquoi Claude Code perdait constamment le fil des fichiers. Le minimum de 65K n’est pas optionnel. C’est indispensable pour que les fonctionnalités agentiques de Claude Code fonctionnent correctement.

Garder une solution cloud de secours configurée. Je n’ai pas supprimé ma clé API Anthropic — j’ai créé un simple alias shell pour basculer entre les modes local et cloud :

alias claude-local='ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_AUTH_TOKEN=ollama claude --model gemma4-claude'
alias claude-cloud='ANTHROPIC_BASE_URL=https://api.anthropic.com claude'

Quand le modèle local atteint ses limites sur une tâche complexe, je passe en mode cloud en deux secondes. Le meilleur des deux mondes.

Surveillez votre VRAM. Si vous êtes sur une machine partagée ou que vous exécutez d’autres applications gourmandes en GPU en même temps qu’Ollama, la concurrence sur la VRAM dégradera silencieusement les performances. Sous macOS, le Moniteur d’activité affiche l’utilisation de la mémoire unifiée. Sous Linux avec NVIDIA, lancez nvidia-smi pour vérifier l’allocation mémoire du GPU. Si votre modèle se dispute la VRAM avec un navigateur qui lit une vidéo accélérée par GPU, vous vous demanderez pourquoi l’inférence est soudainement trois fois plus lente.

La vision d’ensemble — Pourquoi cela compte au-delà des appels API gratuits

Économiser sur les jetons d’IA est l’avantage évident. Mais après une semaine avec ce workflow, ce n’est pas le coût qui me revient sans cesse à l’esprit.

C’est le contrôle.

Chaque ligne de code que je génère via cette pile reste sur ma machine. Chaque projet que j’analyse, chaque fichier que je lis, chaque commande que j’exécute — rien ne transite par un serveur externe. Pour les missions client sous NDA, pour les bases de code propriétaires, pour tout ce qui implique des données sensibles, ce n’est pas une simple fonctionnalité de confort. C’est une exigence de conformité résolue par l’architecture, et non par des accords juridiques.

La vitesse est le second point qui m’a surpris. Sans latence réseau — pas d’aller-retour vers un datacenter, pas d’attente derrière les requêtes d’autres utilisateurs — les temps de réponse dépendent uniquement de mon matériel. Aux heures de pointe, quand les API cloud ralentissent, ma configuration locale reste à la même vitesse. À 2h du matin, quand je suis dans mon flow de code et que j’enchaîne les prompts, il n’y a aucune limitation de débit pour me freiner.

Et la logique de passage à l’échelle s’inverse. Avec les API cloud, plus d’utilisation signifie plus de coûts. Avec l’inférence locale, le coût est fixe — vous possédez déjà le matériel. Que vous fassiez 10 requêtes ou 10 000, votre facture d’électricité ne bouge presque pas. Pour les workflows agentiques qui enchaînent des dizaines d’appels d’outils par tâche, cela rend viables des architectures qui seraient hors de prix via la facturation cloud.

Le fait que Google publie Gemma 4 sous licence Apache 2.0 — la licence open source la plus permissive qui existe — lève le dernier obstacle juridique. Pas de limite d’utilisateurs actifs mensuels comme avec la licence Llama de Meta. Pas de politique d’utilisation acceptable à faire respecter. Liberté commerciale totale. Vous pouvez bâtir des produits dessus, les livrer à vos clients, sans devoir de redevance ni de rapport d’utilisation à personne.

Le futur du développement assisté par l’IA ne consiste pas à choisir entre cloud et local. Il s’agit de combiner les deux — en routant les tâches simples vers votre instance locale de Gemma 4 pour la rapidité et la confidentialité, et en escaladant le raisonnement complexe vers Claude Opus ou GPT quand vous avez besoin de capacités de pointe. Cette configuration, c’est ce futur hybride, disponible aujourd’hui, qui fonctionne dès maintenant.

Une commande pour récupérer le modèle. Trois variables d’environnement pour le connecter. Vingt minutes entre la lecture de cette phrase et le lancement d’un agent IA de code gratuit sur votre propre matériel.

La seule question qui reste, c’est ce que vous allez construire avec.

Foire aux questions

Gemma 4 fonctionne-t-il avec toutes les fonctionnalités de Claude Code via Ollama ?

La lecture et l’édition de fichiers, l’exécution de commandes bash et l’appel d’outils fonctionnent tous correctement en avril 2026. Le cache de prompts et tool_choice (sélection forcée d’outil) ne sont pas pris en charge par la couche de compatibilité d’Ollama. Pour une comparaison complète des capacités, consultez la section sur les compromis ci-dessus.

Quel modèle Gemma 4 est le plus adapté à Claude Code ?

Le modèle 26B MoE offre le meilleur équilibre entre rapidité et qualité pour la plupart des configurations matérielles. Il n’active que 3,88 milliards de paramètres par inférence tout en produisant une qualité de sortie proche de la variante dense 31B. Un minimum de 16 Go de RAM est requis et il est recommandé de configurer une fenêtre de contexte de 65K tokens.

Quelle est la vitesse de Gemma 4 en local par rapport à Claude cloud ?

Sur un MacBook Pro M4 Pro avec 48 Go de mémoire, le modèle 26B génère environ 51 tokens par seconde. Une RTX 4090 permet au modèle 31B d’atteindre environ 41 tokens par seconde. Claude cloud est généralement plus rapide en débit brut, mais l’inférence locale élimine la latence réseau — le temps de réponse du premier token est souvent comparable.

Puis-je faire tourner Gemma 4 sur un MacBook Air ou un ordinateur portable d’entrée de gamme ?

Le modèle E4B (4 milliards de paramètres) fonctionne sur des machines avec 8 Go de RAM et gère les tâches de codage basiques. Pour des workflows Claude Code sérieux, il faut viser le modèle 26B avec au moins 16 Go. Le modèle E2B tourne presque partout mais reste trop limité pour du codage agentique significatif.

Cette configuration est-elle vraiment gratuite, sans coûts cachés ?

Gemma 4 est sous licence Apache 2.0 — gratuit pour tout usage, y compris commercial. Ollama est open source. Claude Code CLI est gratuit à installer. Le seul coût concerne votre matériel et l’électricité. Pas de clés API, pas d’abonnement, pas de suivi d’utilisation, aucune donnée ne quitte votre machine.

Travaillons ensemble

Vous souhaitez développer des systèmes d’IA, automatiser des workflows ou faire évoluer votre infrastructure technologique ? Je serais ravi de vous accompagner.

• Fiverr (développements et intégrations sur mesure) : fiverr.com/s/EgxYmWD
• Portfolio : mejba.me
• Ramlit Limited (solutions pour entreprises) : ramlit.com
• ColorPark (design & branding) : colorpark.io
• xCyberSecurity (services de sécurité) : xcybersecurity.io