> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/gemma4.md). # Gemma 4 (26B MoE, 4B aktiv) {% hint style="info" %} **Status (April 2026):** Gemma 4 wurde am **2. April 2026** von Google als nächste Generation der Gemma-Open-Weight-Familie veröffentlicht. Es gibt zwei Varianten: ein **31B dichtes** 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** auf [huggingface.co/google/gemma-4-26b-it](https://huggingface.co/google/gemma-4-26b-it) und [huggingface.co/google/gemma-4-31b-it](https://huggingface.co/google/gemma-4-31b-it). {% endhint %} Gemma 4 ist Googles erster MoE-Beitrag in der Gemma-Linie und die erste Gemma-Veröffentlichung, die an die Spitze der LMSYS Arena aufstieg (laut Herstellerangaben **#3 insgesamt bei Veröffentlichung**, und ließ dabei mehrere geschlossene Modelle bei Faktentreue und Befolgen von Anweisungen hinter sich). Die wichtigste Zahl ist die MoE-Variante: **26B Gesamtparameter, \~4B pro Token aktiv**, was eine Anweisungsbefolgung nahe dem Spitzenfeld bei den Inferenzkosten eines kleinen dichten Modells ermöglicht. Für Clore.ai-Nutzer ist die praktische Erkenntnis einfach — das 26B MoE läuft problemlos auf einer einzelnen **RTX 4090 (24GB)** mit FP8- oder 4-Bit-Quantisierung (\~10 tok/s) und erreicht produktionstauglichen Durchsatz auf einer einzelnen **H100 80GB** (\~40+ tok/s), wodurch Gemma-Qualität bei der Anweisungsbefolgung auf dem Marktplatz für etwa 0,5–2 $/Tag erreichbar wird. Die 31B-Dense-Variante ist die leistungsfähigere, aber auch teurere Schwester und benötigt zum Bereitstellen 2× RTX 4090 oder 1× H100. ## Wichtige Funktionen * **MoE-Architektur (26B-Variante)** — 26B Gesamtparameter, \~4B pro Token aktiviert; zahlen Sie Inferenzkosten der 4B-Klasse für Qualität der 26B-Klasse * **Dichter Fallback (31B-Variante)** — für Teams, die die Vorhersagbarkeit und die ausgereiftere Tooling-Landschaft dichter Inferenz bevorzugen * **128K-Kontextfenster** — Fragen und Antworten über lange Dokumente, RAG über mittelgroße Codebasen, mehrstufige Agenten-Schleifen * **Starke Anweisungsbefolgung** — Gemma 4 ist ausdrücklich für Tool-Nutzung, strukturierten Output und zuverlässige Befolgung von Einschränkungen optimiert * **Mehrsprachig** — die vollständige Mehrsprachigkeit von Gemma 3 wird fortgeführt, plus eine erweiterte nicht-englische Benchmark-Suite * **Open Weights, Gemma-Bedingungen** — für die meisten kommerziellen Anwendungen kostenlos; prüfen Sie die [Gemma-Richtlinie für verbotene Nutzung](https://ai.google.dev/gemma/prohibited_use_policy) vor dem Einsatz * **Erstklassiges Tooling** — out of the box 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](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (24GB, quantisiert) | | **Gemma 4 31B Dense** (`gemma-4-31b-it`) | 31B | 31B (alle) | 128K | FP8 oder BF16 | 1× [H100](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (80GB, BF16) | {% hint style="success" %} **Praktische Wahl:** Für 90 % der Einzel-GPU-Bereitstellungen nehmen Sie **Gemma 4 26B MoE auf FP8**. Sie erhalten die Arena-Spitzenqualität bei etwa 10–15 tok/s auf einer 4090 und \~40+ tok/s auf einer H100, ohne die Latenzkosten einer dichten 31B-Inferenz. {% endhint %} *** ## Serveranforderungen | Komponente | 26B MoE (4-Bit, 4090) | 26B MoE (FP8, H100) | 31B Dense (BF16, H100) | | ---------- | ---------------------- | ------------------- | ---------------------- | | GPU-VRAM | 24GB | 80GB | 80GB | | System-RAM | 32GB | 64GB | 64GB | | Speicher | 60GB NVMe | 80GB NVMe | 90GB NVMe | | Netzwerk | 100 Mbit/s für HF-Pull | 1 Gbit/s bevorzugt | 1 Gbit/s bevorzugt | | CUDA | 12.1+ | 12.4+ | 12.4+ | | Treiber | 550+ | 555+ | 555+ | Planen Sie zusätzlich etwa 20 % VRAM-Reserve über den statischen Gewichtsbedarf hinaus ein, um den KV-Cache bei langen Kontexten abzudecken. Die Einstellung `--gpu-memory-utilization 0.90` in vLLM ist ein guter Standardwert. *** ## Schnelle Bereitstellung auf CLORE.AI Der schnellste Weg: eine einzelne GPU mieten, das standardmäßige `vllm/vllm-openai` Image ziehen und das Modell mit einer OpenAI-kompatiblen API bereitstellen. Unten steht das docker-compose-Layout, das im Rest dieser Anleitungen verwendet wird — passen Sie den Modellnamen und die Tensor-Parallel-Größe an die oben gewählte Variante an. ### Option A — Gemma 4 26B MoE auf einer einzelnen GPU (vLLM, FP8) ```yaml 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: ``` ```bash # Starten Sie es HF_TOKEN=hf_xxx docker compose up -d # Logs verfolgen, während die Gewichte heruntergeladen werden docker compose logs -f vllm ``` {% hint style="info" %} **Lizenzfreischaltung:** Gemma-Modelle auf Hugging Face erfordern, dass Sie Googles Bedingungen einmal pro Konto akzeptieren. Besuchen Sie die Modellseite im Browser, klicken Sie auf „Lizenz bestätigen“, und exportieren Sie dann `HF_TOKEN` damit der Container die Gewichte herunterladen kann. {% endhint %} ### Option B — Gemma 4 31B Dense auf H100 (vLLM, BF16) ```bash 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) ```bash 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 auf Laptop-Niveau kapselt Ollama die Community-Builds im GGUF-Format. Rechnen Sie damit, dass Quantisierungen ein paar Tage nach der offiziellen Veröffentlichung erscheinen. ```bash # 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 den [Ollama-Leitfaden](/guides/guides_v2-de/sprachmodelle/ollama.md) für allgemeine Einrichtung, Modellverwaltung und Hinweise zur Persistenz. *** ## Anwendungsbeispiele Der vLLM-Container stellt eine OpenAI-kompatible API auf `:8000`. Alles, was das OpenAI-Chat-Completions-Schema unterstützt, funktioniert direkt. ### Curl-Chat-Completions ```bash curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -d '{ "model": "gemma-4-26b", "messages": [ {"role": "system", "content": "Sie sind ein sorgfältiger technischer Autor."}, {"role": "user", "content": "Erklären Sie MoE-Routing in drei Sätzen ohne Vergleiche."} ], "max_tokens": 512, "temperature": 0.7 }' ``` ### Python (OpenAI-Client) ```python 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": "Antworten Sie in einfachem Text, ohne Markdown."}, {"role": "user", "content": "Geben Sie mir eine Code-Review-Checkliste mit 5 Stichpunkten für einen Go-HTTP-Handler."}, ], temperature=0.7, max_tokens=1024, ) print(resp.choices[0].message.content) ``` ### Streaming-Antworten ```python 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": "Schreiben Sie ein Haiku über verteilte Inferenz."}], 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) ```python 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 24GB-Karte ) messages = [ {"role": "user", "content": "Überarbeiten Sie diese Python-Funktion zur besseren Lesbarkeit:\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 H100 ist der FP8-Checkpoint ungefähr halb so groß im Speicher wie BF16, ohne messbaren Qualitätsverlust bei Aufgaben zur Anweisungsbefolgung. Ü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 — rechnen Sie mit \~10–15 tok/s. Ollamas Q4\_K\_M-GGUF-Builds liefern ähnliche Qualität bei einfacherer Bedienung. * **Tensorparallelismus 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 brauchen (`--max-model-len 16384`) — jede Verdopplung des Kontexts verdoppelt ungefähr den KV-Cache-Bedarf. * **Expertenparallelismus für das MoE.** Auf Multi-GPU-Setups für das 26B MoE kann vLLMs `--enable-expert-parallel` bei größeren Batchgrößen einen spürbaren Durchsatzgewinn bringen. Für eine einzelne GPU ist das übertrieben. * **Chunked Prefill für lange Kontexte.** Wenn Sie über 32K hinausgehen, fügen Sie `--enable-chunked-prefill` zu vLLM hinzu. Das hält die Prefill-Latenz beherrschbar und verhindert Stalls auf dem Decode-Pfad. * **Gewichte vorab laden.** Für kurzlebige Clore-Mieten binden Sie ein persistentes Volume unter `/root/.cache/huggingface` ein, damit nachfolgende Läufe den 50–60GB-Download überspringen. * **Wählen Sie das richtige Serving-Backend.** vLLM ist die sichere Standardwahl. SGLang gewinnt auf Hopper bei Workloads mit hoher Parallelität oft; siehe den [vLLM-Leitfaden](/guides/guides_v2-de/sprachmodelle/vllm.md) für den breiteren Vergleich. *** ## Benchmarks {% hint style="warning" %} **Vom Anbieter veröffentlichte Zahlen — unabhängige Verifizierung steht noch aus.** Die untenstehenden Werte stammen aus Googles Veröffentlichungsmaterial vom 2. April 2026. Unabhängige Nachrechnungen in privaten Evals laufen noch ein. Betrachten Sie das Arena-Ranking und die Faktentreue-Werte als Tendenz, nicht als absolut. {% endhint %} | Benchmark | Gemma 4 26B MoE | Gemma 4 31B Dense | Referenz | | -------------------------------- | ----------------------------------------------------------------- | ----------------------------------------------------------------- | ---------------------- | | LMSYS Arena (gesamt) | #3 bei Veröffentlichung | \~#5 bei Veröffentlichung | laut Herstellerangaben | | Anweisungsbefolgung (IFEval) | laut Herstellerangaben deutliche Verbesserungen gegenüber Gemma 3 | laut Herstellerangaben deutliche Verbesserungen gegenüber Gemma 3 | laut Herstellerangaben | | Faktentreue (SimpleQA / ähnlich) | schlägt laut Google mehrere geschlossene Modelle | vergleichbar | laut Herstellerangaben | | Mehrsprachig (Global-MMLU) | laut Herstellerangaben Parität mit deutlich größeren Modellen | bester Gemma-Wert bisher | laut Herstellerangaben | Die Positionierungsargumentation von Gemma 4 lautet „mehr Nutzen pro aktivem Parameter“, nicht „roher HumanEval-König“. Wenn Sie reine Codegenerierung benötigen, vergleichen Sie es mit [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) (Spitzenklasse-Coding) oder [Qwen3.5](/guides/guides_v2-de/sprachmodelle/qwen35.md) (beste dichte 35B-Klasse). Wenn Sie Agenten-Loops über lange Horizonte brauchen, ist GLM-5.1 weiterhin das schärfere Werkzeug. *** ## Fehlerbehebung | Problem | Lösung | | -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `OutOfMemoryError` beim Laden des 26B MoE auf 24GB | 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` 31B Dense auf H100 laden | BF16 bei 32K Kontext ist auf 80GB genau 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 laden Sie dann erneut mit einem Token herunter, der `read` -Scope besitzt. | | Sehr langsames erstes Token | Kalter Gewichtsladevorgang (\~30–60s bei der ersten Anfrage) plus Prefill bei langen Eingaben. Führen Sie nach dem Start des Servers eine Dummy-Aufwärmanfrage aus. Fügen Sie `--enable-chunked-prefill` für Workloads mit langem Kontext hinzu. | | Fehlerhafte Ausgabe / Wiederholungsschleifen | Prüfen Sie die Chat-Vorlage — `tokenizer.apply_chat_template` ist erforderlich; verketten Sie nicht `system`+`user` Zeichenketten manuell. Setzen Sie `temperature=0.7` und `top_p=0.95` für den allgemeinen Gebrauch. | | Tool-/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. | | `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 Config-Parser. | *** ## FAQ **Gemma 4 vs. Llama 4?** Unterschiedliche Formen für unterschiedliche Aufgaben. [Llama 4 Scout](/guides/guides_v2-de/sprachmodelle/llama4.md) ist 109B/17B-aktiv mit einem markanten 10M-Kontext — großartig, wenn Sie riesige Eingaben ins Modell werfen müssen. Gemma 4 26B MoE ist in den Gesamtparametern deutlich kleiner (26B vs. 109B), aktiviert pro Token weniger Parameter (4B vs. 17B) und ist stärker auf Anweisungsbefolgung und Faktentreue optimiert. Bei knappen VRAM-Budgets und Qualität pro Parameter gewinnt Gemma 4. Bei absurd langen Kontexten gewinnt Llama 4 Scout. **Wie viel VRAM braucht Gemma 4 26B MoE?** * 4-Bit GGUF / GPTQ: passt in **24GB** (eine einzelne RTX 4090), \~10–15 tok/s. * FP8: komfortabel auf **40GB**, schnell auf **80GB** (H100) mit \~40+ tok/s. * BF16 vollständig: \~55GB Gewichte plus KV-Cache — planen Sie für eine **80GB** Karte. **Kann ich Gemma 4 kommerziell nutzen?** Ja, unter den standardmäßigen Gemma-Nutzungsbedingungen. Prüfen Sie die [Gemma-Richtlinie für verbotene Nutzung](https://ai.google.dev/gemma/prohibited_use_policy) vor dem Einsatz — es gibt Einschränkungen bei bestimmten Anwendungsfällen (Täuschung, Erzeugung von CSAM, illegale Aktivitäten), und Sie müssen die Lizenzhinweise an nachgelagerte Nutzer weitergeben. Es ist kein Apache-2.0-/MIT-Modell — es ist ein Open-Weight-Modell unter einer Nutzungsrichtlinie. Wenn Sie eine vollständig uneingeschränkte Lizenz brauchen, [Qwen3.5](/guides/guides_v2-de/sprachmodelle/qwen35.md) (Apache 2.0) oder [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) (MIT) sind Alternativen. **Gemma 4 vs. DeepSeek-V4?** [DeepSeek-V4](/guides/guides_v2-de/sprachmodelle/deepseek-v4.md) ist eine andere Gewichtsklasse — \~1T Parameter, multimodal, 1M Kontext. Nutzen Sie DeepSeek-V4, wenn Sie rohe Leistungsfähigkeit brauchen und ein ernsthaftes GPU-Rack haben. Nutzen Sie Gemma 4 26B MoE, wenn Sie starke Anweisungsbefolgung auf einer **einzelnen GPU** wollen und sich für Mietkosten von etwa 1–2 $/Tag auf Clore interessieren. Gemma 4 ist der Kandidat „bestes Modell, das auf eine 4090 passt“; DeepSeek-V4 ist der Kandidat „ich zahle für 8× H200“. **Unterstützt Gemma 4 Vision-/multimodale Eingaben?** Die wichtigste Veröffentlichung von Gemma 4 ist ein nur-textbasiertes, instruction-tuned Modell (`*-it`). Google hat auf Text-Veröffentlichungen historisch mit PaliGemma-Vision-Varianten reagiert — verfolgen Sie [huggingface.co/google](https://huggingface.co/google) für Updates. Für ein heute bildfähiges offenes Modell sehen Sie sich [Kimi K2.5](/guides/guides_v2-de/sprachmodelle/kimi-k2.md) oder [Llama 4 Scout](/guides/guides_v2-de/sprachmodelle/llama4.md). *** ## Verwandte Leitfäden * [vLLM](/guides/guides_v2-de/sprachmodelle/vllm.md) — in dieser Anleitung verwendetes Produktions-Serving-Backend * [Ollama](/guides/guides_v2-de/sprachmodelle/ollama.md) — schnellster Weg zum lokalen Testen mit GGUF-Builds * [Llama 4](/guides/guides_v2-de/sprachmodelle/llama4.md) — Metas MoE-Alternative mit 10M Kontext * [GLM-5.1](/guides/guides_v2-de/sprachmodelle/glm-5-1.md) — Coding-MoE der Spitzenklasse (744B/40B-aktiv), wenn Gemmas Größenklasse nicht ausreicht * [Qwen3.5](/guides/guides_v2-de/sprachmodelle/qwen35.md) — dichte 35B mit Apache 2.0, die andere starke Single-GPU-Option * [Gemma 3](/guides/guides_v2-de/sprachmodelle/gemma3.md) — die Vorgängergeneration, nützlicher Ausgangspunkt für die Migration ### Links * [Gemma 4 26B MoE auf Hugging Face](https://huggingface.co/google/gemma-4-26b-it) * [Gemma 4 31B Dense auf Hugging Face](https://huggingface.co/google/gemma-4-31b-it) * [Gemma-Nutzungsbedingungen](https://ai.google.dev/gemma/terms) * [Gemma-Richtlinie für verbotene Nutzung](https://ai.google.dev/gemma/prohibited_use_policy) * [vLLM-Dokumentation](https://docs.vllm.ai) * [SGLang-Repository](https://github.com/sgl-project/sglang) --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/gemma4.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.