Skip to content
Zurück zu Technik
GenAI · 8 Min. Lesezeit

Gemma 4 in Claude Code einbinden — Ein praxistaugliches Lokal-plus-Cloud-Setup

Eine Schritt-für-Schritt-Anleitung, wie man Gemma 4 lokal über LM Studio betreibt und es direkt aus einer Claude-Code-Session heraus aufruft — für Offline-Reasoning, Batch-Verarbeitung, datenschutzsensible Inhalte und kostenlose Erstentwürfe, die bei Bedarf an Claude übergeben werden.

In einem früheren Artikel habe ich beschrieben, warum Gemma 4 plötzlich als eigenständiges lokales Modell ernst zu nehmen ist. Dies ist die praktische Fortsetzung: wie man es in den täglichen Claude-Code-Workflow einbindet, sodass die beiden Modelle zusammenarbeiten — Gemma 4 erledigt die günstige, lokale, datenschutzsensible Fleißarbeit, Claude übernimmt das schwere Reasoning und mehrstufige agentische Aufgaben.

Das gesamte Setup dauert etwa fünf Minuten. Man bekommt einen OpenAI-kompatiblen Endpunkt auf localhost:1234, und jeder inline ausgeführte ! curl- oder ! python3-Block in einer Claude-Code-Session kann damit reden. Kein neues SDK, keine Cloud-Abhängigkeit, kein Token-Budget für die lokalen Sprünge.

Warum überhaupt verdrahten

Es ist verlockend, lokale LLMs und Frontier-Cloud-LLMs als Konkurrenten zu betrachten. Sind sie aber nicht — sie ergänzen sich, und die spannendsten Workflows packen sie in dieselbe Schleife:

  • Vorfilterung — Gemma 4 liest lokal 200 Dokumente und holt die fünf relevanten heraus, die dann an Claude für den tieferen Reasoning-Schritt übergeben werden
  • Datenschutzsensible Daten — Kunden-PII, medizinische Daten oder proprietärer Code bleiben für die heiklen Teile auf dem Gerät; nur die abstrahierte Frage geht an Claude
  • Batch-Jobs über Nacht — Tausende von Dateien lokal zusammenfassen, klassifizieren oder transformieren, ohne ein einziges API-Token zu verbrennen
  • Erstentwürfe — grobe Outlines, Code-Skelette oder Test-Stubs lokal erzeugen und sie dann von Claude verfeinern lassen
  • Kostendeckel — Aufgaben, bei denen “gut genug” wirklich gut genug ist, komplett am Claude-Budget vorbeirouten

Das Muster ist einfach: Gemma für Breite und Datenschutz, Claude für Tiefe und Komplexität. Sie zu verdrahten heißt, beides innerhalb einer einzigen Claude-Code-Session erledigen zu können, ohne das Terminal zu verlassen.

Voraussetzungen

  • LM Studio installiert (brew install --cask lm-studio oder Download von lmstudio.ai)
  • Eine Gemma-4-Variante in LM Studio heruntergeladen. Ich betreibe die 26B A4B (MoE) auf einem M2 Ultra; die 4B-Dense-Variante läuft problemlos auf einem Basis-MacBook der M-Serie
  • Claude Code auf macOS, authentifiziert, in einem Projekt, in dem es vertretbar ist, Shell-Befehle auszuführen
  • Ein paar Minuten Geduld beim erstmaligen Laden des Modells in den VRAM

Schritt 1 — Den lokalen Server in LM Studio starten

  1. LM Studio öffnen
  2. Das Gemma-4-Modell aus dem Model-Picker (oben in der Mitte) laden
  3. In der linken Seitenleiste auf den Tab Local Server wechseln
  4. Auf Start Server klicken

LM Studio bindet sich standardmäßig an http://localhost:1234 und stellt eine OpenAI-kompatible REST-API bereit. Genau das ist die Magie — alles, was mit dem OpenAI-SDK reden kann, redet mit Gemma 4 nach einer einzigen Änderung der Base-URL. Kein eigener Client, kein spezieller Wrapper, kein Glue-Code.

Ein grüner Indikator und eine Logzeile bestätigen, dass das Modell geladen ist. LM Studio bleibt im Hintergrund laufen.

Schritt 2 — Die Verbindung aus Claude Code prüfen

In einer Claude-Code-Session lassen sich Shell-Befehle inline mit vorangestelltem ! ausführen. Damit prüft man, ob der Server erreichbar ist:

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

Die Antwort sollte ein JSON mit dem geladenen Modell sein. Den exakten Modellnamen notieren — er wird für die API-Aufrufe weiter unten gebraucht. LM Studio nutzt Identifier wie google/gemma-4-26b-a4b statt eines freundlichen gemma-4, und ein Tippfehler hier ist die häufigste Ursache, warum Schritt 3 scheitert.

Dann eine Completion testen:

! 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'

Wenn ein zusammenhängender Satz zurückkommt, ist die Verkabelung fertig. Der Rest ist Workflow.

Schritt 3 — Gemma 4 aus einem Python-Skript aufrufen

Für alles jenseits eines One-Shot-Curl gehört ein kleiner Python-Helfer ins Projekt. Entweder von Claude Code schreiben lassen oder direkt einfügen:

# 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:])))

Jetzt kann aus Claude Code heraus alles in das Skript gepiped werden:

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

Beim ersten Aufruf bietet Claude Code an, das openai-Paket zu installieren, falls es fehlt — annehmen.

Schritt 4 — Gemma 4 als Subagent in einer Claude-Session nutzen

Hier wird der Workflow interessant. Statt die Gemma-Aufrufe selbst zu orchestrieren, lässt man Claude sie als Subtasks abschicken.

Ein Prompt-Muster, das gut funktioniert:

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 generiert die Schleife, ruft den lokalen Endpunkt für jede Datei auf, schreibt den Index — und verbrennt nie sein eigenes Kontextfenster mit den Rohinhalten der Dokumente. Der Bulk-Read-Pass hat null Cloud-Tokens gekostet.

Der entscheidende Satz ist “don’t read the files yourself — delegate to Gemma.” Ohne ihn liest Claude hilfsbereit alles selbst, was den Sinn der Sache aushebelt.

Weitere Delegationsmuster, die ich nutze:

  • “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”

Das letzte Beispiel ist die schönste Variante des Musters: Gemma entwirft, Claude prüft. Bulk-Durchsatz vom lokalen Modell und Qualitätskontrolle vom Cloud-Modell, in einer einzigen agentischen Schleife.

Schritt 5 — Output direkt in Notizen oder Repo pipen

Ein Einzeiler, der eine Gemma-Antwort direkt in den Obsidian-Inbox schreibt:

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

Oder ein Entwurfsgerüst für einen Artikel ins Repo legen und von Claude verfeinern lassen:

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

Dann zu Claude sagen: “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.” Den Rohdurchgang hat man kostenlos erledigt, den Feinschliff in voller Qualität.

LM-Studio-Einstellungen, auf die es wirklich ankommt

EinstellungEmpfehlungWarum
Context length8192+ (Gemma 4 unterstützt bis zu 128K)Genug Spielraum für Multi-Dokument-Zusammenfassungen
GPU offloadMax layers (Metal auf dem Mac)Ohne das ist die Inferenz quälend langsam
Temperature0,3 für Extraktion, 0,7 für DraftingNiedrig für “Fakten”, höher für “Ideen”
Server port1234 (Standard)Passt zu jedem Beispiel, das man online findet
Keep model in memoryAnVermeidet das 5–15-Sekunden-Reload zwischen Aufrufen

Der mit Abstand größte Performance-Gewinn auf Apple Silicon ist GPU offload auf max. Wenn sich Gemma 4 träge anfühlt, liegt es fast immer daran.

Troubleshooting

Connection refused auf Port 1234 — Der LM-Studio-Server läuft nicht. Im Tab Local Server den grünen Indikator prüfen. Wenn der Port belegt ist, in den LM-Studio-Einstellungen ändern und die neue URL den Skripten übergeben.

Model not found-Fehler — Der Modellname im API-Aufruf passt nicht zu dem, was LM Studio bereitstellt. curl -s http://localhost:1234/v1/models | jq ausführen und das exakte id-Feld kopieren. LM-Studio-Identifier enthalten Slashes und Versions-Suffixe, die sich leicht vertippen lassen.

Langsame Inferenz — Drei übliche Schuldige: GPU offload nicht maximiert, eine andere GPU-hungrige App zieht VRAM (Final Cut, Blender, Stable Diffusion), oder es wurde eine Quantisierung geladen, die für die Hardware zu aggressiv ist. Für das beste Geschwindigkeits-/Qualitätsverhältnis auf dem Mac eine 4-bit- oder 5-bit-MLX-Variante ausprobieren.

openai-Paket nicht installiert — ! pip install openai aus Claude Code heraus ausführen. Das OpenAI-SDK ist der offizielle Client für jeden OpenAI-kompatiblen Endpunkt, einschließlich LM Studio, Ollama, vLLM und Together.

Müll-Output / Wiederholungsschleifen — Fast immer ein Temperature-Problem. Für Extraktionsaufgaben auf 0,3 senken und sicherstellen, dass max_tokens gesetzt ist, damit das Modell nicht aus dem Ruder läuft.

Was das freischaltet

Sobald das verdrahtet ist, erweitert sich das mentale Modell von “was Claude Code kann”. Plötzlich lautet die Frage nicht mehr sollte ich diese Aufgabe überhaupt laufen lassen?, sondern welches Modell soll sie übernehmen? An den meisten Tagen sieht meine Aufteilung ungefähr so aus:

  • Gemma 4 (lokal) — Bulk-Reads, Zusammenfassung, Klassifikation, Extraktion, Format-Konvertierung, Erstentwürfe, alles Datenschutzsensible
  • Claude (Cloud) — Architekturentscheidungen, mehrstufige Refactors, Code-Reviews, alles, wo Falschliegen teuer ist
  • Beide, in derselben Schleife — Gemma entwirft → Claude prüft → man liefert aus

Das ist der hybride KI-Workflow, über den ich seit einem Jahr schreibe, in seiner konkretesten Form: zwei Modelle, ein Terminal, keine Reibung. Die Frontier-vs.-Local-Debatte ist vorbei. Die spannende Frage ist jetzt, wie man sie orchestriert.

Wichtigste Erkenntnisse

  • LM Studio stellt eine OpenAI-kompatible API bereit — kein eigener Client, kein Glue-Code
  • Claude Code kann sie mit ! curl- oder ! python3-Inline-Blöcken aufrufen, kein Plugin nötig
  • Bulk-Arbeit an Gemma delegieren, das Kontextfenster von Claude für schwieriges Reasoning freihalten
  • Gemma 4 auf Apple Silicon (Metal, GPU offload auf max) ist für interaktiven Einsatz im Bereich 4B–26B schnell genug
  • Die Kosten für dieses hybride Setup liegen praktisch bei null — jeder Gemma-Aufruf ist kostenlos
  • Das stärkste Muster ist Gemma entwirft, Claude prüft in einer einzigen agentischen Schleife
claude-code gemma4 lm-studio local-llm hybrid-ai openai-compatible apple-silicon tutorial