DEV Community

Cover image for Gemma 4 lokal mit Ollama ausführen: Eine vollständige Anleitung
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

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.

Testen Sie Apidog noch heute

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 eine schnelle, private KI-Schicht zum Generieren von Mock-Daten, Schreiben von Testszenarien und Validieren von API-Antworten, ohne Daten an einen Remote-Server zu senden.

💡 Sobald Gemma 4 lokal läuft, kann Apidogs Smart Mock realistische API-Antwortdaten aus Ihrem Schema generieren, unter Verwendung derselben Art von KI-gestützter Inferenz. Sie definieren die Form Ihrer API einmal; Apidog übernimmt die Mock-Daten. Das passt gut zu lokalen Modell-Experimenten, bei denen Sie konsistente, schema-konforme Testdaten wünschen, ohne Fixtures manuell schreiben zu müssen.

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.

Gemma 4 Modelle

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 %.
  • Mixture-of-Experts-Architektur (MoE). Die 26B-Variante verwendet MoE mit nur 4 Milliarden aktiven Parametern während der Inferenz.
  • Längerer Kontext. E2B und E4B unterstützen 128K Token; 26B/31B bieten 256K.
  • Natives Funktions-Calling. Alle Modelle unterstützen strukturierte Tool-Nutzung out-of-the-box.
  • Audio- und Bildeingabe. E2B/E4B akzeptieren Audio- und Bilddaten.
  • Denkmodi. Chain-of-Thought kann pro Anfrage an- oder ausgeschaltet werden.

Gemma 4 Modellvarianten erklärt

Vor dem Download: Wählen Sie das Modell passend zu Ihrer Hardware.

Modell Größe auf Festplatte Kontext Architektur Am besten geeignet für
gemma4:e2b 7.2 GB 128K Dense Laptops, Edge, Audio/Bild
gemma4:e4b 9.6 GB 128K Dense Die meisten Entwickler
gemma4:26b 18 GB 256K MoE (4B aktiv) Beste Qualität pro GB
gemma4:31b 20 GB 256K Dense Maximale Qualität

Das e4b-Modell ist die Standardeinstellung bei ollama run gemma4. Es läuft auf Consumer-GPUs ab 10+ GB VRAM und Apple Silicon.

Die 26b MoE-Variante ist optimal für hohe Qualität bei geringeren Ressourcen (~20+ GB RAM).

Voraussetzungen

  • Ollama v0.20.0+ ist erforderlich.

Version prüfen:

ollama --version
Enter fullscreen mode Exit fullscreen mode

Aktualisieren:

# macOS
brew upgrade ollama

# Linux
curl -fsSL https://ollama.com/install.sh | sh
Enter fullscreen mode Exit fullscreen mode

Windows: Installer herunterladen.

Hardware-Anforderungen:

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

Gemma 4 installieren und ausführen

Standardmodell herunterladen und ausführen:

ollama run gemma4
Enter fullscreen mode Exit fullscreen mode

Gemma 4 in Ollama laufen lassen

Beim ersten Start werden ~9,6 GB geladen. Testen Sie direkt:

>>> Welche HTTP-Statuscodes gibt es für Clientfehler?
Enter fullscreen mode Exit fullscreen mode

Spezifische Varianten:

# Edge-Modell
ollama run gemma4:e2b

# MoE-Modell
ollama run gemma4:26b

# Flaggschiff
ollama run gemma4:31b
Enter fullscreen mode Exit fullscreen mode

Vorab nur herunterladen:

ollama pull gemma4
ollama pull gemma4:26b
Enter fullscreen mode Exit fullscreen mode

Verfügbare Modelle listen:

ollama list
Enter fullscreen mode Exit fullscreen mode

Die lokale Gemma 4 API verwenden

Ollama stellt unter http://localhost:11434 eine lokale REST-API bereit.

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
  }'
Enter fullscreen mode Exit fullscreen mode

Chat-Vervollständigung (OpenAI-kompatibel) 

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"
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Python-Client 

import requests

def ask_gemma4(prompt: str, model: str = "gemma4"):
    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)
Enter fullscreen mode Exit fullscreen mode

OpenAI Python SDK 

from openai import OpenAI

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

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)
Enter fullscreen mode Exit fullscreen mode

Funktions-Calling mit Gemma 4 verwenden

Gemma 4 unterstützt natives Funktions-Calling: Definieren Sie ein Tool-Schema und erhalten Sie strukturiertes JSON passend zu Ihrer Funktionssignatur.

Beispiel:

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}
Enter fullscreen mode Exit fullscreen mode

Das Modell extrahiert automatisch die Parameter und liefert ein gültiges JSON-Objekt.

Denkmodus aktivieren

Für komplexe Aufgaben wie Testszenarien oder API-Spezifikationsanalyse aktivieren Sie die Chain-of-Thought-Argumentation:

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)
Enter fullscreen mode Exit fullscreen mode

Für einfache Prompts deaktivieren Sie den Denkmodus, um Latenz zu vermeiden.

Gemma 4 API-Antworten mit Apidog testen

Sobald Ihre lokale Gemma 4 Instanz läuft, können Sie die API-Endpunkte systematisch mit Apidog testen.

Gemma 4 API mit Apidog testen

1. Ollama API-Spezifikation importieren: Erstellen Sie ein neues Projekt in Apidog und fügen Sie die Basis-URL http://localhost:11434 hinzu.

2. Endpunkte definieren:

  • 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 zu listen

3. Testszenario einrichten: Verbinden Sie mehrere Anfragen mit Assertionen:

  1. GET /api/tags – prüft, dass gemma4 gelistet ist
  2. POST /api/generate – prüft, dass das response-Feld nicht leer ist
  3. POST /v1/chat/completions – validiert das Antwortformat

Nutzen Sie den Extract Variable Prozessor von Apidog, um Antworten zwischen Schritten weiterzugeben und Multi-Turn-Flows zu testen.

4. Antwort-Schemas validieren: Apidogs Contract Testing validiert API-Antworten gegen Ihre OpenAPI-Spezifikation. Definieren Sie das erwartete Antwortschema und testen Sie nach Modell-Updates auf breaking changes.

5. Smart Mock für parallele Entwicklung: Mit Smart Mock generiert Apidog automatisch schema-konforme Antworten, sodass Frontend-Teams unabhängig vom Modellstand arbeiten können.

Multimodale Eingabe mit Gemma 4

E2B/E4B-Modelle akzeptieren Bilder als base64-kodierte Strings:

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"
                }
            ]
        }
    ]
)
Enter fullscreen mode Exit fullscreen mode

Ideal zur Analyse von Architekturdiagrammen, API-Doku-Screenshots oder zur Bilddaten-Extraktion.

Häufige Probleme und Lösungen

  • Modell nicht gefunden: Führen Sie ollama pull gemma4 aus oder prüfen Sie mit ollama list.
  • Langsame Inferenz auf CPU: Nutzen Sie gemma4:e2b für bessere CPU-Performance.
  • Speicherfehler: Prüfen Sie VRAM/Memory mit ollama ps. Wechseln Sie ggf. auf kleinere Modelle.
  • Apple Silicon-Ladeprobleme: Ollama 0.20.0 unterstützt MLX; aktualisieren Sie ggf.
  • Port belegt: Starten Sie mit anderem Port: OLLAMA_HOST=0.0.0.0:11435 ollama serve.
  • Abgeschnittene Antworten: Erhöhen Sie das Kontextfenster: "options": {"num_ctx": 8192} im JSON-Body.

Gemma 4 vs. andere lokale Modelle

Modell Beste Größe Kontext Funktions-Calling Coding-Benchmark
Gemma 4 e4b (9.6 GB) 128K-256K Nativ 80% LiveCodeBench
Llama 3.3 70B-Q4 (40 GB) 128K Nativ ~60% LiveCodeBench
Qwen3.6-Plus 72B-Q4 (44 GB) 128K Nativ Stark
Mistral Small 24B (14 GB) 128K Nativ Moderat

Besonders die MoE-Variante (26b) von Gemma 4 liefert mit 18 GB Speicher nahezu Flaggschiff-Qualität bei hoher Geschwindigkeit.

Fazit

Gemma 4 mit Ollama ist eines der leistungsfähigsten lokalen Setups für Entwickler. Die Installation dauert zwei Befehle, das Standardmodell läuft auf den meisten Maschinen. Der Qualitätsgewinn gegenüber Gemma 3 ist signifikant.

Starten Sie mit ollama run gemma4, testen Sie Ihre Endpunkte mit Apidog, und wählen Sie das passende Modell gemäß Tabelle.

Für Teams, die auf Gemma 4 aufbauen, ermöglicht die Kombination aus lokaler Inferenz, Apidogs Smart Mock und Testszenarien einen vollständigen, unabhängigen Entwicklungszyklus.

FAQ

Wie aktualisiere ich Gemma 4 in Ollama, wenn eine neue Version herauskommt?

Führen Sie ollama pull gemma4 erneut aus. Ollama lädt nur Änderungen.

Kann ich Gemma 4 auf einem Computer ohne GPU ausführen?

Ja, aber langsam. Mit CPU erreichen Sie 1–3 Tokens/Sekunde (e2b empfohlen).

Was ist der Unterschied zwischen gemma4:e2b und gemma4:e4b?

Beide sind dichte Edge-Modelle. E4B ist größer und besser für komplexe Aufgaben, E2B ist kleiner und unterstützt Audio.

Funktioniert Gemma 4 mit LangChain und LlamaIndex?

Ja. Beide Frameworks unterstützen Ollama als Backend (http://localhost:11434, Modellname gemma4).

Ist die lokale Gemma 4 API kompatibel mit Code für die OpenAI API?

Meistens ja. Nutzen Sie /v1/chat/completions, ändern Sie base_url und verwenden Sie einen beliebigen api_key.

Wie verwende ich den Denkmodus von Gemma 4?

Übergeben Sie "think": true im extra_body-Parameter beim OpenAI SDK oder direkt im JSON-Body.

Kann ich Gemma 4 anderen Maschinen im Netzwerk bereitstellen?

Ja, starten Sie Ollama mit OLLAMA_HOST=0.0.0.0:11434 ollama serve.

Welches ist das beste Gemma 4 Modell für API-Entwicklungsaufgaben?

Für Mock-Daten und Tests: e4b. Für komplexe Analysen: 26b (MoE).

Top comments (0)