Brancher Gemma 4 sur Claude Code — un setup local-plus-cloud qui fonctionne

Dans un article précédent, j’expliquais pourquoi Gemma 4 méritait soudain d’être pris au sérieux comme modèle local autonome. Voici la suite pratique : comment le brancher sur votre workflow Claude Code quotidien pour que les deux modèles travaillent ensemble — Gemma 4 s’occupant du travail local, sensible et bon marché, et Claude se chargeant du raisonnement difficile et des tâches agentiques multi-étapes.

L’ensemble du setup prend environ cinq minutes. Vous obtenez un endpoint compatible OpenAI sur localhost:1234, et n’importe quel bloc inline ! curl ou ! python3 à l’intérieur d’une session Claude Code peut lui parler. Pas de nouveau SDK, pas de dépendance cloud, aucun budget de tokens pour les sauts locaux.

Pourquoi les brancher ensemble

Il est tentant de traiter les LLM locaux et les LLM cloud de pointe comme des concurrents. Ils ne le sont pas — ils sont complémentaires, et les workflows les plus intéressants les mettent dans la même boucle :

Pré-filtrage — laissez Gemma 4 lire 200 documents en local et faire remonter les 5 qui comptent, puis transmettez-les à Claude pour l’étape de raisonnement approfondi
Données sensibles — gardez les PII clients, les données médicales ou le code propriétaire sur l’appareil pour les passages sensibles ; n’envoyez à Claude que la question abstraite
Traitements par lots de nuit — résumez, classifiez ou transformez des milliers de fichiers en local sans brûler le moindre token d’API
Brouillons de premier jet — générez des plans grossiers, des squelettes de code ou des stubs de tests en local, puis demandez à Claude de les affiner
Plafond de coût — pour les tâches où “assez bon” est vraiment assez bon, sortez-les complètement de votre budget Claude

Le motif est simple : Gemma pour la largeur et la confidentialité, Claude pour la profondeur et la complexité. Les brancher ensemble vous permet de faire les deux à l’intérieur d’une seule session Claude Code sans quitter le terminal.

Prérequis

LM Studio installé (brew install --cask lm-studio ou téléchargement depuis lmstudio.ai)
Une variante de Gemma 4 téléchargée dans LM Studio. Je fais tourner le 26B A4B (MoE) sur un M2 Ultra ; la variante 4B dense fonctionne très bien sur un MacBook M-series de base
Claude Code lancé sur macOS, authentifié, et à l’intérieur d’un projet où vous êtes à l’aise pour exécuter des commandes shell
Quelques minutes de patience la première fois que vous chargez le modèle en VRAM

Étape 1 — Démarrer le serveur local dans LM Studio

Ouvrez LM Studio
Chargez votre modèle Gemma 4 depuis le sélecteur de modèles (en haut au centre)
Basculez vers l’onglet Local Server dans la barre latérale gauche
Cliquez sur Start Server

LM Studio se lie à http://localhost:1234 par défaut et expose une API REST compatible OpenAI. C’est la dernière partie qui fait toute la magie — tout ce qui sait parler au SDK OpenAI peut parler à Gemma 4 avec un simple changement d’URL de base. Pas de client custom, pas de wrapper spécial, pas de code de glue.

Vous verrez un indicateur vert et une ligne de log confirmant que le modèle est chargé. Laissez LM Studio tourner en arrière-plan.

Étape 2 — Vérifier la connexion depuis Claude Code

Dans une session Claude Code, vous pouvez exécuter des commandes shell inline en les préfixant par !. Utilisez ça pour confirmer que le serveur est joignable :

! curl -s http://localhost:1234/v1/models | jq

Vous devriez voir une réponse JSON listant le modèle chargé. Notez le nom exact du modèle — vous en aurez besoin pour les appels d’API ci-dessous. LM Studio utilise des identifiants comme google/gemma-4-26b-a4b plutôt qu’un sympathique gemma-4, et une faute de frappe ici est la raison la plus fréquente d’échec à l’étape 3.

Testez ensuite une complétion :

! curl -s http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "google/gemma-4-26b-a4b",
    "messages": [{"role": "user", "content": "Explain RAG in one sentence."}],
    "temperature": 0.5
  }' | jq -r '.choices[0].message.content'

Si vous récupérez une phrase cohérente, la plomberie est terminée. Le reste, c’est du workflow.

Étape 3 — Appeler Gemma 4 depuis un script Python

Pour tout ce qui dépasse un curl ponctuel, déposez un petit helper Python dans votre projet. Demandez à Claude Code de l’écrire pour vous, ou collez ceci directement :

# scripts/gemma.py
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key="lm-studio",  # any non-empty string works
)

def ask_gemma(prompt: str, system: str = "You are a concise technical assistant.") -> str:
    response = client.chat.completions.create(
        model="google/gemma-4-26b-a4b",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": prompt},
        ],
        temperature=0.3,
        max_tokens=2048,
    )
    return response.choices[0].message.content


if __name__ == "__main__":
    import sys
    print(ask_gemma(sys.stdin.read() if not sys.stdin.isatty() else " ".join(sys.argv[1:])))

Vous pouvez maintenant lui pipe n’importe quoi depuis Claude Code :

! cat README.md | python3 scripts/gemma.py "Summarise this in 5 bullets"

La première fois que vous l’exécutez, Claude Code proposera d’installer le package openai s’il manque — acceptez.

Étape 4 — Utiliser Gemma 4 comme sous-agent dans une session Claude

C’est ici que le workflow devient intéressant. Au lieu d’orchestrer manuellement les appels à Gemma, laissez Claude les dispatcher comme des sous-tâches.

Un pattern de prompt qui marche bien :

Use the local Gemma 4 API at localhost:1234 (OpenAI-compatible, model google/gemma-4-26b-a4b) to summarise every .md file under docs/ into a single bullet per file. Save the result as docs-index.md. Don’t read the files yourself — delegate the per-file summarisation to Gemma to keep your context clean.

Claude va générer la boucle, appeler l’endpoint local pour chaque fichier, écrire l’index, et ne brûlera jamais sa propre fenêtre de contexte sur le contenu brut des documents. Vous venez de dépenser zéro token cloud sur la passe de lecture en masse.

La phrase clé est « don’t read the files yourself — delegate to Gemma ». Sans elle, Claude lira docilement tout lui-même, ce qui annule l’intérêt.

Autres patterns de délégation que j’utilise :

« Run Gemma over every commit message in the last 30 days and categorise them as feature / fix / refactor / chore »
« Use Gemma to extract the function signatures from these 40 Python files and write them to api-surface.txt »
« Translate these German UI strings to French via Gemma and review the result yourself before writing the file »

Ce dernier est la plus jolie version du pattern : Gemma rédige, Claude relit. Vous obtenez le débit en masse du modèle local et le contrôle qualité du modèle cloud, dans une seule boucle agentique.

Étape 5 — Pipe la sortie directement dans vos notes ou votre dépôt

Un one-liner qui envoie une réponse de Gemma directement dans votre inbox Obsidian :

! python3 scripts/gemma.py "Brief intro to MoE routing" \
  > ~/Library/Mobile\ Documents/iCloud~md~obsidian/Documents/The\ Vault/Inbox/moe-intro.md

Ou générez un squelette de brouillon d’article dans votre dépôt et laissez Claude le raffiner :

! python3 scripts/gemma.py "Outline a 6-section article about local LLMs vs. cloud LLMs in 2026" \
  > drafts/local-vs-cloud-outline.md

Puis dites à Claude : « Read drafts/local-vs-cloud-outline.md and turn it into a finished article matching the voice of src/content/tech/gemma4-local-coding.md. » Vous venez de faire la passe brouillon gratuitement et la passe de finition à pleine qualité.

Les réglages LM Studio qui comptent vraiment

Réglage	Recommandé	Pourquoi
Context length	8192+ (Gemma 4 supporte jusqu’à 128K)	Assez de marge pour résumer plusieurs documents
GPU offload	Max layers (Metal sur Mac)	Sans ça, l’inférence est péniblement lente
Temperature	0.3 pour l’extraction, 0.7 pour la rédaction	Plus bas pour les “faits”, plus haut pour les “idées”
Server port	1234 (par défaut)	Correspond à tous les exemples que vous trouverez en ligne
Keep model in memory	On	Évite le rechargement de 5 à 15 secondes entre les appels

Le plus gros gain de performance sur Apple Silicon, c’est GPU offload réglé au max. Si votre Gemma 4 vous semble lent, c’est presque toujours pour cette raison.

Dépannage

Connection refused sur le port 1234 — Le serveur de LM Studio ne tourne pas. Vérifiez l’onglet Local Server et confirmez l’indicateur vert. Si le port est pris, changez-le dans les réglages de LM Studio et passez la nouvelle URL à vos scripts.

Erreur Model not found — Le nom de modèle dans votre appel d’API ne correspond pas à ce que LM Studio sert. Lancez curl -s http://localhost:1234/v1/models | jq et copiez exactement le champ id. Les identifiants LM Studio contiennent des slashs et des suffixes de version faciles à mal taper.

Inférence lente — Trois coupables habituels : GPU offload pas au max, une autre application gourmande en GPU qui mange la VRAM (Final Cut, Blender, Stable Diffusion), ou vous avez chargé une quantization trop agressive pour votre matériel. Essayez un build MLX 4-bit ou 5-bit pour le meilleur compromis vitesse/qualité sur Mac.

Package openai non installé — Lancez ! pip install openai depuis Claude Code. Le SDK OpenAI est le client officiel pour tout endpoint compatible OpenAI, y compris LM Studio, Ollama, vLLM et Together.

Sortie incohérente / boucles de répétition — Presque toujours un problème de température. Descendez à 0.3 pour les tâches d’extraction, et assurez-vous que max_tokens est défini pour que le modèle ne s’emballe pas.

Ce que ça débloque

Une fois ce câblage en place, votre modèle mental de “ce que Claude Code peut faire” s’élargit. Soudain, la question n’est plus est-ce que je dois lancer cette tâche du tout ? mais quel modèle doit la lancer ? La plupart des jours, mon partage ressemble à peu près à ça :

Gemma 4 (local) — lectures en masse, résumés, classification, extraction, conversion de format, premiers brouillons, tout ce qui est sensible côté confidentialité
Claude (cloud) — décisions architecturales, refactorings multi-étapes, revue de code, tout ce où se tromper coûte cher
Les deux, dans la même boucle — Gemma rédige → Claude relit → vous expédiez

C’est le workflow IA hybride dont je parle depuis un an, mais sous sa forme la plus concrète : deux modèles, un terminal, zéro friction. Le débat frontière-vs-local est clos. La question intéressante, désormais, c’est comment vous les orchestrez.

À retenir

LM Studio expose une API compatible OpenAI — pas de client custom, pas de code de glue
Claude Code peut l’appeler avec des blocs inline ! curl ou ! python3, sans plugin
Déléguez le travail en masse à Gemma, gardez le contexte de Claude propre pour le raisonnement difficile
Gemma 4 sur Apple Silicon (Metal, GPU offload au max) est assez rapide pour un usage interactif de 4B à 26B
Le coût de ce setup hybride est à peu près nul — chaque appel à Gemma est gratuit
Le pattern le plus puissant, c’est Gemma rédige, Claude relit dans une seule boucle agentique