Gemma 4 lokal mit Ollama ausführen: Eine vollständige Anleitung

Kurz gesagt

Gemma 4 wurde am 3. April 2026 veröffentlicht, und Ollama v0.20.0 fügte noch am selben Tag Unterstützung hinzu. Sie können das Standardmodell gemma4:e4b in zwei Befehlen herunterladen und ausführen. Dieser Leitfaden führt Sie durch die Einrichtung, Modellauswahl, API-Nutzung und wie Sie Ihre lokalen Gemma 4 Endpunkte mit Apidog testen.

Einleitung

Google veröffentlichte Gemma 4 am 2. April 2026. Innerhalb von 24 Stunden lieferte Ollama v0.20.0 mit vollständiger Unterstützung für alle vier Modellvarianten aus.

Für Entwickler ist das wichtig. Gemma 4 ist keine kleine Verbesserung. Es erreicht 89,2 % beim AIME 2026, verglichen mit 20,8 % bei Gemma 3. Die Bewertung im Coding-Benchmark stieg von 110 ELO auf 2150 bei Codeforces. Sie erhalten natives Funktions-Calling, konfigurierbare Denkmodi und ein 256K Kontextfenster bei den größeren Varianten. All dies läuft auf Ihrer eigenen Hardware.

Wenn Sie API-gestützte Apps entwickeln, ermöglicht das lokale Setup etwas Nützliches: eine schnelle, private KI-Schicht zum Generieren von Mock-Daten, zum Schreiben von Testszenarien und zum Validieren von API-Antworten, ohne Daten an einen Remote-Server zu senden.

Dieser Leitfaden deckt alles ab, von der Installation bis zum ersten lokalen API-Aufruf.

Was ist neu in Gemma 4

Gemma 4 wird mit vier Modellvarianten mit deutlich unterschiedlichen Fähigkeiten ausgeliefert.

Das unterscheidet es von Gemma 3:

• Argumentation und Codierung. Das 31B-Modell erreicht 80 % auf LiveCodeBench v6. Das frühere Gemma 3 27B erreichte 29,1 %. Diese Lücke ist keine schrittweise Verbesserung; es ist eine andere Leistungsklasse.
• Mixture-of-Experts-Architektur (MoE). Die 26B-Variante verwendet MoE mit nur 4 Milliarden aktiven Parametern während der Inferenz. Sie erhalten nahezu Flaggschiff-Qualität zu einem Bruchteil der Rechenkosten.
• Längerer Kontext. Die Edge-Modelle E2B und E4B unterstützen 128K Token. Die 26B- und 31B-Modelle erweitern dies auf 256K, genug, um große Codebasen oder API-Spezifikationsdateien in einem einzigen Prompt unterzubringen.
• Natives Funktions-Calling. Alle Gemma 4 Modelle unterstützen strukturierte Tool-Nutzung sofort. Sie können ein Funktionsschema definieren und das Modell gibt gültiges JSON zurück, das diesem Schema entspricht, ohne Prompt-Engineering-Tricks.
• Audio- und Bildeingabe. Die E2B- und E4B-Modelle akzeptieren Audio- und Bildereingaben mit variabler Auflösung zusätzlich zu Text.
• Denkmodi. Sie können die Chain-of-Thought-Argumentation des Modells pro Anfrage aktivieren oder deaktivieren. Für einfache Suchvorgänge überspringen Sie diese. Für komplexe Codierungs- oder Mathematikprobleme schalten Sie sie ein.

Gemma 4 Modellvarianten erklärt

Bevor Sie etwas herunterladen, wählen Sie das richtige Modell für Ihre Hardware aus:

Das e4b-Modell ist die Standardeinstellung, wenn Sie ollama run gemma4 ausführen. Es passt auf die meisten Consumer-GPUs mit 10+ GB VRAM und läuft auf Apple Silicon Unified Memory recht schnell.

Die 26b MoE-Variante ist der Geheimtipp. Da pro Token nur 4 Milliarden Parameter aktiviert werden, ist die Inferenzgeschwindigkeit näher an einem 4B-Modell, während die Qualität einem 13B-Modell nahekommt. Wenn Sie 20+ GB RAM haben, ist dies einen Versuch wert.

Voraussetzungen

Sie benötigen Ollama v0.20.0 oder neuer. Frühere Versionen enthalten keine Gemma 4 Unterstützung.

Überprüfen Sie Ihre aktuelle Version:

ollama --version

Wenn Sie eine ältere Version verwenden, aktualisieren Sie:

# macOS
brew upgrade ollama

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

Unter Windows laden Sie den neuesten Installer von ollama.com herunter.

Hardware-Anforderungen:

• gemma4:e2b: mindestens 8 GB RAM (16 GB empfohlen)
• gemma4:e4b: 10 GB VRAM oder 16 GB Unified Memory
• gemma4:26b: 20+ GB RAM oder Unified Memory
• gemma4:31b: 24 GB VRAM oder 32 GB Unified Memory

Gemma 4 installieren und ausführen

Das Standard-e4b-Modell herunterladen und ausführen:

ollama run gemma4

Dies lädt beim ersten Ausführen etwa 9,6 GB herunter und versetzt Sie dann in eine interaktive Sitzung. Geben Sie eine Nachricht ein, um es zu testen:

>>> Welche HTTP-Statuscodes gibt es für Clientfehler?

Um eine bestimmte Variante auszuführen:

# Edge-Modell, geringerer Fußabdruck
ollama run gemma4:e2b

# MoE-Modell, bestes Verhältnis von Qualität zu Größe
ollama run gemma4:26b

# Vollständiges Flaggschiff
ollama run gemma4:31b

Zum Herunterladen ohne sofortige Ausführung:

ollama pull gemma4
ollama pull gemma4:26b

Überprüfen Sie, welche Modelle Sie haben:

ollama list

Die lokale Gemma 4 API verwenden

Ollama stellt eine lokale REST-API unter http://localhost:11434 bereit. Sobald das Modell heruntergeladen ist, können Sie es von jedem HTTP-Client aus ansprechen, ohne die interaktive CLI starten zu müssen.

Eine Vervollständigung generieren

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Schreiben Sie eine JSON-Antwort für einen API-Endpunkt für Benutzerprofile",
    "stream": false
  }'

Chat-Vervollständigung (OpenAI-kompatibler Endpunkt)

Ollama unterstützt auch das OpenAI Chat-Format:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "Generieren Sie einen realistischen JSON-Mock für eine E-Commerce-Bestellungs-API-Antwort"
      }
    ]
  }'

Python-Client

import requests

def ask_gemma4(prompt: str, model: str = "gemma4") -> str:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("Listen Sie die Felder auf, die eine Zahlungs-API-Antwort enthalten sollte")
print(result)

Das OpenAI Python SDK verwenden

Da Ollamas API OpenAI-kompatibel ist, können Sie das offizielle SDK auf Ihre lokale Instanz richten:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # vom SDK benötigt, aber von Ollama ungenutzt
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "Sie generieren realistische API-Antwortdaten im JSON-Format."
        },
        {
            "role": "user",
            "content": "Generieren Sie eine Beispielantwort für einen GET /users/{id} Endpunkt"
        }
    ]
)

print(response.choices[0].message.content)

Funktions-Calling mit Gemma 4 verwenden

Gemma 4 unterstützt natives Funktions-Calling. Sie definieren ein Tool-Schema und das Modell gibt strukturiertes JSON zurück, das Ihrer Funktionssignatur entspricht.

Dies ist nützlich für den Aufbau von Agenten, die Ihre APIs programmatisch aufrufen:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "Einen Benutzer anhand der ID von der API abrufen",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "Die eindeutige Benutzer-ID"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "Ob die Bestellhistorie enthalten sein soll"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "Benutzer 42 mit seiner Bestellhistorie abrufen"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}

Das Modell extrahiert die korrekten Parameter aus natürlicher Sprache und gibt ein gültiges JSON-Objekt zurück, das Ihrem Schema entspricht. Keine Regex-Analyse oder Bereinigung der Ausgabe erforderlich.

Denkmodus aktivieren

Für komplexe Aufgaben wie das Schreiben von Testszenarien oder die Analyse von API-Spezifikationen können Sie die Chain-of-Thought-Argumentation von Gemma 4 aktivieren:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "Entwerfen Sie ein vollständiges Testszenario für eine Zahlungsabwicklungs-API mit Randfällen"
        }
    ],
    extra_body={"think": True}
)

print(response.choices[0].message.content)

Für einfachere Anfragen, wie das Generieren eines einzelnen Mock-Wertes, überspringen Sie den Denkmodus. Er fügt eine Latenz hinzu, die Sie nicht benötigen.

Gemma 4 API-Antworten mit Apidog testen

Sobald Ihre lokale Gemma 4 Instanz läuft, möchten Sie die API-Endpunkte systematisch testen. Apidog erledigt dies ohne zusätzliche Tools.

Die Ollama API-Spezifikation importieren. Ollamas lokaler Server stellt Standard-REST-Endpunkte bereit. Erstellen Sie ein neues Projekt in Apidog und fügen Sie die Basis-URL http://localhost:11434 hinzu.

Ihre Endpunkte definieren. Fügen Sie die Endpunkte hinzu, die Sie testen:

• POST /api/generate für Single-Turn-Vervollständigungen
• POST /v1/chat/completions für Multi-Turn-Chat
• GET /api/tags um verfügbare Modelle aufzulisten

Ein Testszenario einrichten. In Apidog verbindet ein Testszenario mehrere Anfragen mit Assertionen dazwischen. Für das Gemma 4 Testing:

1. Schritt 1: GET /api/tags, um zu überprüfen, dass gemma4 in der Modellliste erscheint
2. Schritt 2: POST /api/generate, um einen Prompt zu senden und zu überprüfen, dass das response-Feld nicht leer ist
3. Schritt 3: POST /v1/chat/completions, um eine Chat-Nachricht zu senden und zu überprüfen, dass die Antwort Ihrem erwarteten Format entspricht

Verwenden Sie Apidogs Extract Variable Prozessor, um die Antwort aus Schritt 2 zu erfassen und an Schritt 3 weiterzugeben. Dadurch können Sie Multi-Turn-Konversationsabläufe automatisch testen.

Antwort-Schemas validieren. Apidogs Contract Testing validiert API-Antworten gegen Ihre OpenAPI-Spezifikation. Definieren Sie die erwartete Antwortform für jeden Gemma 4 Endpunkt und führen Sie dann nach Modell-Updates Vertragstests durch, um alle breaking changes im API-Format von Ollama abzufangen.

Smart Mock für parallele Entwicklung. Wenn Ihr Backend von Gemma 4 Antworten abhängt, Sie aber möchten, dass Frontend-Teams arbeiten können, ohne auf das lokale Modell zu warten, generiert Apidogs Smart Mock automatisch schema-konforme Antworten aus Ihrer API-Spezifikation. Definieren Sie, wie eine Gemma 4 Antwort aussieht, und Smart Mock liefert auf Anfrage realistische Daten.

Multimodale Eingabe mit Gemma 4

Die E2B- und E4B-Modelle akzeptieren Bilder neben Text. Übergeben Sie Bilder als base64-kodierte Zeichenketten:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Beschreiben Sie den in diesem Diagramm gezeigten API-Flow und identifizieren Sie potenzielle Fehlerpfade"
                }
            ]
        }
    ]
)

Dies ist nützlich für die Analyse von Architekturdiagrammen, die Überprüfung von API-Dokumentations-Screenshots oder die Extraktion von Daten aus Bildern, die Ihre API verarbeiten muss.

Häufige Probleme und Lösungen

Ollama meldet, dass das Modell nicht gefunden wurde. Führen Sie zuerst ollama pull gemma4 aus oder überprüfen Sie dies mit ollama list.

Langsame Inferenz auf der CPU. Gemma 4 ist GPU-optimiert. Auf reinen CPU-Maschinen erwarten Sie 1-3 Tokens pro Sekunde beim e4b-Modell. Verwenden Sie gemma4:e2b für eine bessere CPU-Leistung.

Fehler wegen Speichermangel. Überprüfen Sie Ihren verfügbaren VRAM oder Unified Memory mit ollama ps. Wenn das Modell zu groß ist, wechseln Sie zu gemma4:e2b (7,2 GB).

Modell wird nicht auf Apple Silicon geladen. Ollama 0.20.0 hat in der Vorschau MLX-Unterstützung für Apple Silicon hinzugefügt. Wenn Sie eine ältere Ollama-Version verwenden, aktualisieren Sie zuerst.

Port bereits belegt. Wenn etwas anderes Port 11434 verwendet, legen Sie einen benutzerdefinierten Port fest: OLLAMA_HOST=0.0.0.0:11435 ollama serve.

Antworten werden abgeschnitten. Erhöhen Sie das Kontextfenster in Ihrer Anfrage: Fügen Sie "options": {"num_ctx": 8192} zu Ihrem JSON-Body hinzu.

Gemma 4 vs. andere lokale Modelle

Gemma 4's Vorteil ist die MoE 26B-Variante. Mit 18 GB liefert sie nahezu Flaggschiff-Qualität mit 4 Mrd. aktiven Parametern zur Inferenzzeit, was Ihnen mehr Tokens pro Sekunde ermöglicht als jedes der größeren dichten Modelle in dieser Liste.

Für reine Coding-Aufgaben ist das 31B-Modell konkurrenzfähig mit viel größeren Modellen. Für Edge-Bereitstellungen oder Laptops läuft e2b mit unter 8 GB.

Fazit

Gemma 4 mit Ollama ist derzeit eine der leistungsfähigsten lokalen Setups. Die Installation dauert zwei Befehle. Das Standardmodell läuft auf den meisten Entwicklermaschinen. Und der Sprung in der Argumentations- und Codequalität gegenüber Gemma 3 ist erheblich.

Beginnen Sie mit ollama run gemma4, testen Sie die API mit Apidog, um sicherzustellen, dass Ihre Endpunkte wie erwartet funktionieren, und wählen Sie dann die richtige Variante für Ihre Arbeitslast basierend auf der obigen Modelltabelle.

Für Teams, die API-gestützte Funktionen auf Basis von Gemma 4 entwickeln, bietet die Kombination aus lokaler Inferenz mit Apidogs Smart Mock und Test-Szenarien einen vollständigen Entwicklungszyklus ohne externe Abhängigkeiten.

FAQ

Wie aktualisiere ich Gemma 4 in Ollama, wenn eine neue Version herauskommt?Führen Sie ollama pull gemma4 erneut aus. Ollama überprüft die neueste Version und lädt nur das herunter, was sich geändert hat.

Kann ich Gemma 4 auf einem Computer ohne GPU ausführen?Ja, aber es ist langsam. Erwarten Sie 1-3 Tokens pro Sekunde auf der CPU. Das e2b-Modell ist die praktischste Option für reine CPU-Maschinen.

Was ist der Unterschied zwischen gemma4:e2b und gemma4:e4b?Beide sind dichte, „effektive“ Modelle, optimiert für Edge-Hardware. E4B hat mehr Parameter und bewältigt komplexe Argumentation besser. E2B ist kleiner und unterstützt Audioeingabe. Für die meisten Textaufgaben ist e4b die bessere Standardeinstellung.

Funktioniert Gemma 4 mit LangChain und LlamaIndex?Ja. Beide Frameworks unterstützen Ollama als Backend. Richten Sie den Ollama-Provider auf http://localhost:11434 aus und verwenden Sie gemma4 als Modellnamen.

Ist die lokale Gemma 4 API kompatibel mit Code, der für die OpenAI API geschrieben wurde?Größtenteils ja. Ollamas /v1/chat/completions Endpunkt folgt dem OpenAI-Format. Ändern Sie base_url auf http://localhost:11434/v1 und api_key auf eine beliebige nicht leere Zeichenkette. Die meisten OpenAI SDK-Aufrufe funktionieren ohne Änderungen.

Wie verwende ich den Denkmodus von Gemma 4?Übergeben Sie "think": true im extra_body-Parameter, wenn Sie das OpenAI SDK verwenden, oder fügen Sie "think": true dem übergeordneten JSON-Body bei direkten API-Aufrufen hinzu. Deaktivieren Sie es für einfache Aufgaben, um die Latenz zu reduzieren.

Kann ich Gemma 4 anderen Maschinen in meinem Netzwerk zur Verfügung stellen?Ja. Starten Sie Ollama mit OLLAMA_HOST=0.0.0.0:11434 ollama serve und andere Maschinen können es unter Ihrer IP-Adresse auf Port 11434 erreichen.

Welches ist das beste Gemma 4 Modell für API-Entwicklungsaufgaben?Für die Generierung von Mock-Daten und das Schreiben von Testfällen bietet e4b die richtige Balance aus Geschwindigkeit und Qualität. Für komplexe Spezifikationsanalysen oder Architekturprüfungen liefert das 26b MoE-Modell bessere Ergebnisse ohne die Kosten des vollständigen 31B-Modells.