Gemma 4 (26B MoE, 4B aktiv)

Deploye Gemma 4 (26B MoE, 4B aktiv) von Google auf Clore.ai — das Open-Weight-Modell, veröffentlicht im April 2026, das aufstieg zu

Status (April 2026): Gemma 4 wurde am 2. April 2026 von Google als die nächste Generation der Gemma-Open-Weight-Familie veröffentlicht. Es werden zwei Varianten ausgeliefert: ein 31B-Dense Modell (google/gemma-4-31b-it) und ein 26B MoE mit ~4B aktiven Parametern (google/gemma-4-26b-it). Beide werden unter den standardmäßigen Gemma-Nutzungsbedingungen unter huggingface.co/google/gemma-4-26b-it und huggingface.co/google/gemma-4-31b-it.

Gemma 4 ist Googles erster MoE-Beitrag in der Gemma-Reihe und die erste Gemma-Veröffentlichung, die bis an die Spitze der LMSYS Arena aufgestiegen ist (Anbieter berichten #3 insgesamt bei Veröffentlichung, und lag bei Faktentreue und Befolgen von Anweisungen knapp vor mehreren Closed-Source-Modellen). Die Schlagzeile ist die MoE-Variante: 26B Gesamtparameter, ~4B aktiv pro Token, was Ihnen Befolgen von Anweisungen nahe der Spitze zu den Inferenzkosten eines kleinen Dense-Modells bietet.

Für Clore.ai-Nutzer ist die praktische Schlussfolgerung einfach — das 26B MoE läuft problemlos auf einer einzelnen RTX 4090 (24 GB) mit FP8- oder 4-Bit-Quantisierung (~10 tok/s) und erreicht produktionsrelevanten Durchsatz auf einer einzelnen H100 80 GB (~40+ tok/s) und macht Gemma-Qualität beim Befolgen von Anweisungen für etwa ~$1.04/Stunde auf dem Marktplatz erreichbar. Die 31B-Dense-Variante ist das leistungsfähigere, aber teurere Geschwistermodell und benötigt zum Bereitstellen 2× RTX 4090 oder 1× H100.

Hauptfunktionen

• MoE-Architektur (26B-Variante) — 26B Gesamtparameter, ~4B aktiviert pro Token; zahlen Sie Inferenzkosten der 4B-Klasse für Qualität der 26B-Klasse

• Dense-Fallback (31B-Variante) — für Teams, die die Vorhersagbarkeit und die Reife des Toolings von Dense-Inferenz bevorzugen

• 128K-Kontextfenster — Fragen und Antworten über lange Dokumente, RAG über mittelgroße Codebasen, mehrstufige Agenten-Schleifen

• Starkes Befolgen von Anweisungen — Gemma 4 ist ausdrücklich für Werkzeugnutzung, strukturierte Ausgabe und treues Befolgen von Vorgaben optimiert

• Mehrsprachig — die vollständige mehrsprachige Abdeckung von Gemma 3 wurde übernommen, plus eine erweiterte nicht-englische Benchmark-Suite

• Offene Gewichte, Gemma-Bedingungen — für die meisten kommerziellen Anwendungen kostenlos; prüfen Sie die Gemma-Richtlinie für verbotene Nutzung vor dem Ausliefern

• Erstklassige Tooling-Unterstützung — von Haus aus unterstützt in vLLM, SGLang, Ollama und Hugging Face Transformers

Wählen Sie Ihre Variante

Variante	Gesamtparameter	Aktiv	Kontext	Empfohlene Quantisierung	Empfohlene Clore-GPU
Gemma 4 26B MoE (gemma-4-26b-it)	26B	~4B pro Token	128K	FP8 oder 4-Bit-GPTQ	1× RTX 4090 (24 GB, quantisiert)
Gemma 4 31B Dense (gemma-4-31b-it)	31B	31B (alle)	128K	FP8 oder BF16	1× H100 (80 GB, BF16)

Praktische Wahl: Für 90 % der Single-GPU-Bereitstellungen wählen Sie Gemma 4 26B MoE auf FP8. Sie erhalten die herausragende Arena-Qualität mit ~10–15 tok/s auf einer 4090 und ~40+ tok/s auf einer H100, ohne die Latenzkosten der dichten 31B-Inferenz.

---

Serveranforderungen

Komponente	26B MoE (4-Bit, 4090)	26B MoE (FP8, H100)	31B Dense (BF16, H100)
GPU-VRAM	24 GB	80 GB	80 GB
System-RAM	32 GB	64 GB	64 GB
Festplatte	60 GB NVMe	80 GB NVMe	90 GB NVMe
Netzwerk	100 Mbit/s für HF-Pull	1 Gbit/s bevorzugt	1 Gbit/s bevorzugt
CUDA	12.8+	12.8+	12.8+
Treiber	550+	555+	555+

Planen Sie zusätzlich ~20 % VRAM-Reserve über dem statischen Gewichtsbedarf ein, um den KV-Cache bei langen Kontexten abzudecken. Die Einstellung --gpu-memory-utilization 0.90 in vLLM ist ein guter Standard.

---

Schnellbereitstellung auf CLORE.AI

Der schnellste Weg: Mieten Sie eine einzelne GPU, ziehen Sie das Standard- vllm/vllm-openai Image und stellen Sie das Modell mit einer OpenAI-kompatiblen API bereit. Unten ist das docker-compose-Layout, das im Rest dieser Anleitungen verwendet wird — passen Sie den Modellnamen und die Tensor-Parallel-Größe anhand der oben gewählten Variante an.

Option A — Gemma 4 26B MoE auf einer einzelnen GPU (vLLM, FP8)

version: "3.8"
services:
  vllm:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    volumes:
      - hf_cache:/root/.cache/huggingface
    command: >
      --model google/gemma-4-26b-it
      --quantization fp8
      --max-model-len 32768
      --gpu-memory-utilization 0.90
      --served-model-name gemma-4-26b
      --trust-remote-code
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    shm_size: "8gb"

volumes:
  hf_cache:

# Starten Sie es
HF_TOKEN=hf_xxx docker compose up -d

# Protokolle verfolgen, während die Gewichte heruntergeladen werden
docker compose logs -f vllm

Lizenzfreigabe: Gemma-Modelle auf Hugging Face erfordern, dass Sie Googles Bedingungen einmal pro Konto akzeptieren. Öffnen Sie die Modellseite im Browser, klicken Sie auf "Acknowledge license", und exportieren Sie dann HF_TOKEN damit der Container die Gewichte abrufen kann.

Option B — Gemma 4 31B Dense auf H100 (vLLM, BF16)

docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \\
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  --ipc=host \
  vllm/vllm-openai:latest \
  --model google/gemma-4-31b-it \
  --dtype bfloat16 \\
  --max-model-len 32768 \
  --gpu-memory-utilization 0.90 \
  --served-model-name gemma-4-31b

Option C — Gemma 4 31B Dense auf 2× RTX 4090 (FP8, tensor-parallel)

docker run --gpus all -p 8000:8000 \
  -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \\
  -v ~/.cache/huggingface:/root/.cache/huggingface \\
  --ipc=host \
  vllm/vllm-openai:latest \
  --model google/gemma-4-31b-it \
  --quantization fp8 \
  --tensor-parallel-size 2 \
  --max-model-len 16384 \
  --gpu-memory-utilization 0.90 \
  --served-model-name gemma-4-31b

Option D — Schnelles lokales Testen mit Ollama

Für Experimente der Laptop-Klasse kapselt Ollama die GGUF-Community-Builds. Rechnen Sie damit, dass Quantisierungen ein paar Tage nach der offiziellen Veröffentlichung erscheinen.

# Sobald ein Community-GGUF veröffentlicht wurde
ollama pull gemma4:26b-moe-q4_k_m
ollama run gemma4:26b-moe-q4_k_m

# OpenAI-kompatible API auf :11434
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \\
  -d '{
    "model": "gemma4:26b-moe-q4_k_m",
    "messages": [{"role":"user","content":"Fassen Sie den MoE-Routing-Ansatz in zwei Sätzen zusammen."}]
  }'

Siehe die Ollama-Leitfaden für allgemeine Einrichtung, Modellverwaltung und Persistenztipps.

---

Anwendungsbeispiele

Der vLLM-Container stellt eine OpenAI-kompatible API auf :8000. Alles, was das OpenAI-Chat-Completions-Schema versteht, funktioniert direkt.

Chat-Completions mit curl

curl http://localhost:8000/v1/chat/completions \\
  -H "Content-Type: application/json" \\
  -d '{
    "model": "gemma-4-26b",
    "messages": [
      {"role": "system", "content": "You are a careful technical writer."},
      {"role": "user", "content": "Explain MoE routing in three sentences without using analogies."}
    ],
    "max_tokens": 512,
    "temperature": 0.7
  }'

Python (OpenAI-Client)

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

resp = client.chat.completions.create(
    model="gemma-4-26b",
    messages=[
        {"role": "system", "content": "You answer in plain text, no markdown."},
        {"role": "user", "content": "Give me a 5-bullet code review checklist for a Go HTTP handler."},
    ],
    temperature=0.7,
    max_tokens=1024,
)
print(resp.choices[0].message.content)

Streaming-Antworten

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY")

stream = client.chat.completions.create(
    model="gemma-4-26b",
    messages=[{"role": "user", "content": "Write a haiku about distributed inference."}],
    stream=True,
    max_tokens=128,
)

for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
print()

Hugging Face Transformers (Offline-Nutzung)

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "google/gemma-4-26b-it"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    load_in_4bit=True,  # Passt das MoE auf eine einzelne 24-GB-Karte
)

messages = [
    {"role": "user", "content": "Refactor this Python function for readability:\n\ndef f(x): return [i for i in x if i%2==0 and i>10]"},
]
input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)
output = model.generate(input_ids, max_new_tokens=512, do_sample=True, temperature=0.7)
print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True))

---

Leistungstipps

• Verwenden Sie FP8 auf Hopper. Auf der H100 benötigt der FP8-Checkpoint ungefähr halb so viel Speicher wie BF16, ohne messbaren Qualitätsverlust bei Aufgaben zum Befolgen von Anweisungen. Übergeben Sie --quantization fp8 an vLLM.

• Verwenden Sie 4-Bit-GPTQ auf Ada (RTX 4090). Für die MoE-Variante auf einer einzelnen 4090 ist ein Community-GPTQ-4-Bit-Build der praktische Sweet Spot — erwarten Sie ~10–15 tok/s. Ollamas Q4_K_M-GGUF-Builds liefern ähnliche Qualität mit einfacherer Bedienung.

• Tensor-Parallelismus für 31B Dense. Über 2× RTX 4090 hinweg übergeben Sie --tensor-parallel-size 2. Begrenzen Sie den Kontext auf das, was Sie tatsächlich benötigen (--max-model-len 16384) — jede Verdopplung des Kontexts verdoppelt ungefähr den Speicherbedarf des KV-Caches.

• Experten-Parallelismus für das MoE. Bei Multi-GPU-Setups für das 26B MoE kann vLLMs --enable-expert-parallel bei höheren Batchgrößen einen spürbaren Durchsatzschub geben. Für Single-GPU ist das überdimensioniert.

• Chunked Prefill für lange Kontexte. Wenn Sie über 32K hinausgehen, fügen Sie --enable-chunked-prefill zu vLLM hinzu. Dadurch bleibt die Prefill-Latenz beherrschbar und Stalls auf dem Decode-Pfad werden verhindert.

• Gewichte vorab ziehen. Für temporäre Clore-Mieten binden Sie ein persistentes Volume ein unter /root/.cache/huggingface damit nachfolgende Ausführungen den 50–60-GB-Download überspringen.

• Wählen Sie das richtige Serving-Backend. vLLM ist die sichere Standardeinstellung. SGLang gewinnt auf Hopper bei Workloads mit hoher Parallelität oft; siehe die vLLM-Leitfaden für den umfassenderen Vergleich.

---

Benchmarks

Vom Anbieter veröffentlichte Zahlen — unabhängige Verifizierung steht noch aus. Die folgenden Zahlen stammen aus Googles Launch-Material vom 2. April 2026. Unabhängige Nachbildungen auf privaten Evaluierungen treffen noch ein. Behandeln Sie das Arena-Ranking und die Faktentreue-Werte als Richtwerte, nicht als absolute Werte.

Benchmark	Gemma 4 26B MoE	Gemma 4 31B Dense	Referenz
LMSYS Arena (insgesamt)	#3 bei Veröffentlichung	ca. #5 bei Veröffentlichung	vom Anbieter gemeldet
Befolgen von Anweisungen (IFEval)	Anbieter berichten starke Verbesserungen gegenüber Gemma 3	Anbieter berichten starke Verbesserungen gegenüber Gemma 3	vom Anbieter gemeldet
Faktentreue (SimpleQA / ähnlich)	übertrifft laut Google mehrere Closed-Source-Modelle	vergleichbar	vom Anbieter gemeldet
Mehrsprachig (Global-MMLU)	Anbieter berichten Parität mit viel größeren Modellen	bester Gemma-Wert bisher	vom Anbieter gemeldet

Gemma-4s Positionierungsargument lautet „nützlicher pro aktivem Parameter“, nicht „bloßer HumanEval-König“. Wenn Sie reine Codegenerierung brauchen, vergleichen Sie mit GLM-5.1 (Spitzenklasse beim Coden) oder Qwen3.5 (bester Dense-Vertreter der 35B-Klasse). Wenn Sie agentische Schleifen mit langem Horizont benötigen, ist GLM-5.1 weiterhin das schärfere Werkzeug.

---

Fehlerbehebung

Problem	Lösung
OutOfMemoryError Laden des 26B MoE auf 24 GB	Wechseln Sie zu FP8 (--quantization fp8) oder 4-Bit (load_in_4bit=True in Transformers). Senken Sie --max-model-len auf 16384, um den KV-Cache zu verkleinern.
OutOfMemoryError Laden von 31B Dense auf H100	BF16 bei 32K Kontext ist auf 80 GB gerade noch an der Grenze. Senken Sie --max-model-len auf 16384 oder wechseln Sie zu FP8.
Hugging-Face-Download schlägt mit 403 fehl	Sie haben die Gemma-Lizenz auf der Modellseite nicht akzeptiert. Öffnen Sie die URL im Browser, bestätigen Sie die Bedingungen und ziehen Sie dann erneut mit einem Token, der Lese Berechtigung.
Sehr langsames erstes Token	Kaltes Laden der Gewichte (~30–60 s bei der ersten Anfrage) plus Prefill bei langen Eingaben. Führen Sie nach dem Start des Servers eine Dummy-Warm-up-Anfrage aus. Fügen Sie --enable-chunked-prefill für Workloads mit langem Kontext hinzu.
Verstümmelte Ausgabe / Wiederholungsschleifen	Überprüfen Sie die Chat-Vorlage — tokenizer.apply_chat_template ist erforderlich; verketten Sie nicht system+user Strings manuell. Setzen Sie temperature=0.7 und top_p=0.95 für die allgemeine Verwendung.
Werkzeug- / JSON-Ausgabe unzuverlässig	Verwenden Sie vLLMs --guided-decoding-backend oder übergeben Sie ein JSON-Schema über response_format. Das Modell hält sich gut an Vorgaben, aber unstrukturierte Prompts driften dennoch ab.
nicht unterstützte Quantisierung Fehler in vLLM	Aktualisieren Sie auf eine vLLM-Version, die nach April 2026 veröffentlicht wurde (pip install -U vllm --pre). Die Gemma-4-Architektur benötigt die neuesten Konfigurationsparser.

---

FAQ

Gemma 4 vs. Llama 4? Verschiedene Formen für verschiedene Aufgaben. Llama 4 Scout ist 109B/17B-aktiv mit einem hervorgehobenen 10M-Kontext — großartig, wenn Sie dem Modell enorme Eingaben vorwerfen müssen. Gemma 4 26B MoE ist insgesamt viel kleiner (26B statt 109B), aktiviert pro Token weniger Parameter (4B statt 17B) und ist deutlich stärker auf Befolgen von Anweisungen und Faktentreue optimiert. Bei knappen VRAM-Budgets und Qualität pro Parameter gewinnt Gemma 4. Bei absurd langer Kontextlänge gewinnt Llama 4 Scout.

Wie viel VRAM für Gemma 4 26B MoE?

• 4-Bit-GGUF / GPTQ: passt in 24 GB (einzelne RTX 4090), ~10–15 tok/s.

• FP8: komfortabel auf 40 GB, schnell auf 80 GB (H100) mit ~40+ tok/s.

• BF16 voll: ~55 GB Gewichte plus KV-Cache — planen Sie für eine 80 GB Karte.

Kann ich Gemma 4 kommerziell nutzen? Ja, unter den standardmäßigen Gemma-Nutzungsbedingungen. Prüfen Sie die Gemma-Richtlinie für verbotene Nutzung vor der Bereitstellung — es gibt Einschränkungen für bestimmte Anwendungsfälle (Täuschung, Erzeugung von CSAM, illegale Aktivitäten), und Sie müssen Lizenzhinweise an nachgelagerte Nutzer weitergeben. Es ist kein Apache-2.0-/MIT-Modell — es ist Open-Weight unter einer Nutzungsrichtlinie. Wenn Sie eine vollständig uneingeschränkte Lizenz benötigen, Qwen3.5 (Apache 2.0) oder GLM-5.1 (MIT) sind Alternativen.

Gemma 4 vs. DeepSeek-V4? DeepSeek-V4 ist eine andere Gewichtsklasse — ~1T Parameter, multimodal, 1M Kontext. Verwenden Sie DeepSeek-V4, wenn Sie rohe Leistungsfähigkeit brauchen und über einen ernsthaften GPU-Rack verfügen. Verwenden Sie Gemma 4 26B MoE, wenn Sie starkes Befolgen von Anweisungen auf einer einzelnen GPU und Wert auf Bare Metal Mieten auf Clore legen. Gemma 4 ist der Kandidat für das „beste Modell, das auf eine 4090 passt“; DeepSeek-V4 ist der Kandidat für „ich bezahle für 8× H200“.

Unterstützt Gemma 4 Vision- / multimodale Eingaben? Die Hauptveröffentlichung von Gemma 4 ist rein textbasiert und instruktionsoptimiert (*-it). Google hat Textveröffentlichungen historisch mit PaliGemma-Vision-Varianten gefolgt — verfolgen Sie huggingface.co/google für Updates. Für ein heutiges Open-Model mit Bildverarbeitung schauen Sie sich Kimi K2.5 oder Llama 4 Scout.

---

Verwandte Leitfäden

• vLLM — Produktions-Serving-Backend, das in diesem Leitfaden verwendet wird

• Ollama — schnellster Weg zum lokalen Testen mit GGUF-Builds

• Llama 4 — Metas MoE-Alternative mit 10M Kontext

• GLM-5.1 — Coding-MoE der Spitzenklasse (744B/40B-aktiv), wenn Gemmas Größenklasse nicht ausreicht

• Qwen3.5 — Apache-2.0-35B-Dense, die andere starke Single-GPU-Option

• Gemma 3 — die Vorgängergeneration, nützliche Basis für die Migration

Links

• Gemma 4 26B MoE auf Hugging Face

• Gemma 4 31B Dense auf Hugging Face

• Gemma-Nutzungsbedingungen

• Gemma-Richtlinie für verbotene Nutzung

• vLLM-Dokumentation

• SGLang-Repo