DEV Community

Cover image for Gemma 4 als API Backend betreiben
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

Gemma 4 als API Backend betreiben

TL;DR: Google hat im April 2026 Gemma 4 veröffentlicht – eine offene Familie von vier Modellen unter Apache 2.0, die auf Standard-Benchmarks Modelle übertreffen, die 20-mal größer sind. Sie können die Gemma 4 API über Google AI Studio, Vertex AI oder lokal mit Ollama und vLLM nutzen. Mit Apidogs Smart Mock generieren Sie automatisch realistische API-Antworten aus Ihren OpenAPI-Schemata, ohne eigene Mock-Regeln schreiben zu müssen.

Testen Sie Apidog noch heute

Einleitung

Die meisten Open-Source-KI-Modelle erfordern einen Kompromiss: Entweder viel Leistung oder einfache Bereitstellung. Große Modelle laufen nicht lokal, kleine Modelle liefern schwache Ergebnisse bei komplexen Aufgaben. Gemma 4 durchbricht diesen Kompromiss.

Gemma 4 ist Googles leistungsstärkste offene Modellfamilie. Das 31B Dense Modell liegt auf Platz 3 aller offenen Modelle bei Arena AI und schlägt viele 20-mal größere Modelle. Das 26B MoE erreicht Platz 6. Beide laufen auf einer 80-GB-GPU. Die E2B- und E4B-Modelle funktionieren komplett offline auf Smartphones und Edge-Geräten.

Für API-Entwickler relevant: Gemma 4 unterstützt nativ Funktionsaufrufe, strukturierte JSON-Ausgabe und große Kontextfenster (bis 256K Token). Ideal für KI-gestützte API-Tools – von Testdatengenerierung über Mocking bis zur API-Antwortanalyse.

💡Wenn Sie mit Gemma 4 arbeiten und KI-Antworten nach OpenAPI-Spezifikation validieren müssen, generiert Apidogs Smart Mock Engine automatisch schema-konforme Mock-Antworten. Keine individuellen Mock-Regeln nötig – Smart Mock liest Ihr Schema und liefert passende Daten. Laden Sie Apidog kostenlos herunter und integrieren Sie es in Ihren Gemma 4 API-Workflow.

Was ist Gemma 4 und was ist neu?

Gemma 4 ist die vierte Generation offener Sprachmodelle von Google DeepMind. Seit dem Start 2024 wurden Gemma-Modelle über 400 Millionen Mal heruntergeladen, die Community hat über 100.000 Varianten gebaut – das „Gemmaverse“.

Gemma 4 ist unter Apache 2.0-Lizenz veröffentlicht. Sie können das Modell kommerziell nutzen, verändern und weitergeben – ohne Einschränkungen. Wichtig für Unternehmen, die volle Kontrolle benötigen.

Wichtigste Neuerung: „Intelligenz pro Parameter“. Das 31B Dense Modell liefert Top-Leistung zu einem Bruchteil der Kosten von GPT-4 oder Claude 3 Sonnet. Auf Arena AI schlägt Gemma 4 31B sogar 600B-Parameter-Modelle.

Die wichtigsten Neuerungen gegenüber Gemma 3:

  • Native multimodale Eingabe: Alle Gemma 4 Modelle verarbeiten Bilder und Videos, E2B/E4B zusätzlich Audio.
  • Längere Kontextfenster: E2B/E4B: 128K Token, 26B/31B: 256K Token – genug für ganze Repos.
  • Agenten-Workflows: Native Funktionsaufrufe, strukturierte JSON-Ausgabe und System-Prompts.
  • Fortgeschrittene Argumentation: Das 31B-Modell ist deutlich besser in Mathematik und multistep Reasoning.
  • 140+ Sprachen: Nativ trainiert, nicht nur aus Englisch übersetzt.
  • Apache 2.0-Lizenz: Volle rechtliche Klarheit für kommerzielle Nutzung.

Gemma 4 Modellvarianten und Fähigkeiten

Vier Größen – für verschiedene Hardware:

Modell Parameter Aktive Parameter (Inferenz) Kontext Am besten geeignet für
E2B Effektive 2B ~2B 128K Mobil, IoT, Offline-Edge
E4B Effektive 4B ~4B 128K Telefone, Raspberry Pi, Jetson Orin
26B MoE 26B gesamt ~3.8B aktiv 256K Latenzempfindliche Serveraufgaben
31B Dense 31B 31B 256K Höchste Qualität, Forschung, Fine-Tuning

E2B/E4B setzen auf Mixture-of-Experts: Nur ein Bruchteil der Parameter wird pro Token genutzt. Entwickelt mit Qualcomm/MediaTek, laufen sie offline auf Android (AICore Preview).

26B MoE aktiviert nur 3,8B Parameter pro Inferenz, ideal für schnelle Server-Deployments.

31B Dense ist der Qualitätsführer – optimal fürs Fine-Tuning und domänenspezifische Aufgaben.

Für API-Tools ist 26B MoE meist das beste Verhältnis aus Geschwindigkeit und Qualität, 31B Dense für komplexe, strukturierte JSON-Ausgaben. Alle Modelle unterstützen Funktionsaufrufe und JSON-Ausgabe.

Gemma 4 API einrichten: Schritt für Schritt

Drei Wege zur Nutzung: Google AI Studio (am schnellsten), Vertex AI (Enterprise) oder lokal mit Ollama/vLLM.

Option 1: Google AI Studio (Prototyping)

1. Gehen Sie zu Google AI Studio und erstellen Sie ein (kostenloses) Konto. Generieren Sie einen API-Key.

2. Installieren Sie das SDK:

pip install google-genai

3. Erster API-Aufruf:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemma-4-31b-it")

response = model.generate_content(
    "Generate a JSON object for a user account with id, email, and created_at fields."
)

print(response.text)

4. Für strukturierte JSON-Ausgabe:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

prompt = """
Generate 3 sample user objects for an e-commerce API. 
Each user should have: id (integer), email (string), username (string), 
created_at (ISO 8601 timestamp), and subscription_tier (free|pro|enterprise).
Return as a JSON array.
"""

response = model.generate_content(prompt)
users = json.loads(response.text)
print(json.dumps(users, indent=2))

Option 2: Lokale Bereitstellung mit Ollama

1. Installieren Sie Ollama von ollama.com. Laden Sie das Modell:

ollama pull gemma4

2. Starten Sie den Server:

ollama serve

3. OpenAI-kompatibler API-Call:

import requests
import json

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "gemma4",
        "messages": [
            {
                "role": "user",
                "content": "Generate a valid JSON response for a REST API /products endpoint. Include id, name, price, and stock fields."
            }
        ],
        "stream": False
    }
)

result = response.json()
print(result["message"]["content"])

Option 3: Funktionsaufrufe für API-Orchestrierung

Mit Funktionsaufrufen können Sie Tools definieren, die das Modell gezielt aufruft:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

tools = [
    {
        "function_declarations": [
            {
                "name": "get_api_schema",
                "description": "Retrieve the OpenAPI schema for a given endpoint path",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "endpoint_path": {
                            "type": "string",
                            "description": "The API endpoint path, e.g. /users/{id}"
                        },
                        "method": {
                            "type": "string",
                            "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
                        }
                    },
                    "required": ["endpoint_path", "method"]
                }
            }
        ]
    }
]

model = genai.GenerativeModel("gemma-4-31b-it", tools=tools)

response = model.generate_content(
    "I need to test the GET /users/{id} endpoint. What schema should the response follow?"
)

if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call
    print(f"Model called function: {fc.name}")
    print(f"With args: {dict(fc.args)}")

Dieses Funktionsaufruf-Muster ist optimal für agentenbasierte API-Testpipelines.

Erstellen von KI-gestützten API-Mocks mit Gemma 4

Nutzen Sie Gemma 4, um realistische Mock-Daten direkt aus einem OpenAPI-Schema zu generieren:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "order_number": {"type": "string", "pattern": "^ORD-[0-9]{6}$"},
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered", "cancelled"]},
        "total": {"type": "number", "minimum": 0},
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "integer"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "unit_price": {"type": "number"}
                }
            }
        },
        "created_at": {"type": "string", "format": "date-time"}
    }
}

prompt = f"""
Generate 5 realistic mock responses for an order management API.
Each response must conform exactly to this JSON Schema:
{json.dumps(schema, indent=2)}

Make the data realistic: use realistic prices, product IDs, and varied statuses.
Return as a JSON array of 5 order objects.
"""

response = model.generate_content(prompt)
mock_orders = json.loads(response.text)
print(json.dumps(mock_orders, indent=2))

Gemma 4 versteht JSON-Schema-Einschränkungen (Enum, Muster etc.) und liefert passende Mock-Daten – ideal für echtes API-Mocking.

Sie können für jeden Endpunkt Ihres OpenAPI-Schemas Mocks generieren. Für komplexe Fälle können Sie die komplette Spezifikation als Prompt einbinden – dank 256K Kontextfenster auch für große APIs.

Effizienter Workflow: Exportieren Sie Ihre Apidog-Sammlung als OpenAPI, prompten Sie Gemma 4 und erhalten Sie automatisch pro Endpunkt realistische Testfälle.

Testen von Gemma 4 API-Antworten mit Apidog

Nach der Generierung von Testdaten/API-Antworten mit Gemma 4 sollten Sie das Ergebnis gegen Ihr Schema validieren. Hier kommt Apidogs Test-Szenario-Modul ins Spiel.

Schritt-für-Schritt-Workflow:

  1. Endpunkt importieren: In Apidog neuen Endpunkt anlegen, auf Ihren Gemma 4 Wrapper oder direkt Google AI Studio zeigen. Antwortschema definieren.
  2. Smart Mock verwenden: Mit Apidogs Smart Mock automatisch realistische Antworten aus dem Schema generieren lassen.
  3. Testszenario anlegen: Im „Tests“-Modul ein Szenario erstellen, Gemma 4 API-Aufruf als Schritt hinzufügen, dann Assertions.
  4. Assertions konfigurieren: Prüfen Sie Statuscode, Header und v.a. das JSON-Feld candidates[0].content.parts[0].text. Extrahieren Sie per „Extract Variable“-Prozessor die KI-Ausgabe und nutzen Sie sie in Folgeschritten.
  5. Datengesteuertes Testen: CSV/JSON-Testdaten importieren, z.B. 50 Prompt-Varianten gleichzeitig testen – ideal für robuste API-Workflows.

Die Einrichtung dauert ca. 15 Minuten, danach können Sie den Workflow automatisiert in Ihrer CI/CD-Pipeline (über Apidog CLI) nutzen.

Praktische Anwendungsfälle

  • API-Testdatengenerierung: Mit Gemma 4s JSON-Modus & OpenAPI-Schema in Minuten Hunderte realistische Testdatensätze erstellen.
  • Intelligentes API-Mocking: Kontextuelle Mocks, z.B. für Produktsuch-APIs, ohne jeden Fall hardcoden zu müssen.
  • API-Dokumentationsgenerierung: 256K Kontext erlaubt komplette Codebasen als Prompt, inkl. automatischer OpenAPI-Spezifikation durch Funktionsaufrufe.
  • Antwortschema-Validierung: KI-Analyse von API-Antworten, inkl. Schemaverletzungen und komplexer Fehlererkennung.
  • Automatisiertes Schreiben von Regressionstests: Gemma 4 kann auf Basis Ihrer API-Spezifikation und Fehlerreports gezielt Testfälle erzeugen, die echte Fehler abfangen.

Gemma 4 im Vergleich zu anderen offenen Modellen für die API-Nutzung

Modell Parameter Kontext JSON-Ausgabe Funktionsaufruf Lizenz
Gemma 4 31B 31B 256K Nativ Nativ Apache 2.0
Gemma 4 26B MoE 26B (3.8B aktiv) 256K Nativ Nativ Apache 2.0
Llama 3.3 70B 70B 128K Über Prompt Über Prompt Llama Community
Mistral 7B 7B 32K Über Prompt Begrenzt Apache 2.0
Qwen 2.5 72B 72B 128K Nativ Nativ Apache 2.0

Kritisch für API-Tools: nativer JSON-Modus, Funktionsaufruf, Kontextlänge. Gemma 4 26B/31B bieten alles. Llama 3.3 70B benötigt doppelt so viel Hardware wie Gemma 4 31B, bietet aber keine native JSON- oder Funktionsaufruf-Unterstützung. Mistral 7B ist sehr schnell, aber das Kontextfenster ist zu klein für große APIs. Qwen 2.5 72B ist stark, braucht aber viel Hardware.

Die Apache 2.0-Lizenz von Gemma 4 bietet volle Rechtssicherheit, was bei Llama (Community License) nicht immer gegeben ist.

Empfehlung: Für die meisten API-Entwicklungen starten Sie mit Gemma 4 26B MoE (Latenz) oder 31B (Qualität).

Fazit

Gemma 4 ist eine offene, leistungsfähige Alternative zu proprietären KI-APIs im API-Tooling. Dank Apache 2.0-Lizenz und nativer Funktionsaufrufe/JSON-Modus ist die Integration in API-Workflows ohne komplexes Prompt Engineering direkt möglich.

Vier Modellgrößen erlauben flexible Hardware-Auswahl. Das 26B MoE Modell ist optimal für schnelle, skalierbare API-Entwicklung.

Kombinieren Sie Gemma 4 mit Apidog, um KI-generierte Daten effizient zu validieren. Nutzen Sie Gemma 4 für Testdatengenerierung, Apidogs Smart Mock zum Prototypen und deren Testszenarien für die Validierung. Damit bauen Sie robuste, KI-gestützte APIs mit minimalem Aufwand.

FAQ

Was ist Gemma 4? Gemma 4 ist Google DeepMinds neueste Familie offener Sprachmodelle (E2B, E4B, 26B MoE, 31B Dense, Apache 2.0), veröffentlicht April 2026. Das 31B-Modell ist auf Platz 3 der Arena AI Bestenliste.

Ist Gemma 4 kostenlos nutzbar? Die Modellgewichte sind unter Apache 2.0 frei nutzbar; Sie zahlen nur für Rechenleistung (Google AI Studio: Freistufe mit Limits, Vertex AI: Cloud-Raten).

Kann Gemma 4 strukturiertes JSON ausgeben? Ja, via response_mime_type: "application/json" im Google Generative AI SDK. Für APIs essenziell.

Wie schneidet Gemma 4 im Vergleich zu GPT-4o bei der API-Entwicklung ab? GPT-4o ist proprietär, kein On-Prem-Hosting, höhere API-Kosten. Gemma 4 31B kann lokal und kostenlos laufen und ist bei Reasoning-Benchmarks konkurrenzfähig.

Kann ich Gemma 4 mit eigenen API-Daten feinabstimmen? Ja, Fine-Tuning über Google AI Studio, Vertex AI oder Drittanbieter-Tools wie Hugging Face TRL möglich – besonders für domänenspezifische APIs sinnvoll.

Welche Hardware benötige ich für lokale Nutzung? 31B/26B laufen auf einer 80-GB-NVIDIA H100 (bfloat16). Quantisierte Versionen laufen auf Consumer-GPUs (16–24 GB VRAM). E4B/E2B laufen auf Smartphones, Raspberry Pi, Jetson.

Unterstützt Gemma 4 Funktionsaufrufe? Ja, alle Modelle. Tools werden als JSON deklariert, das Modell ruft sie kontextgesteuert auf und gibt strukturierte Argumente aus.

Wie teste ich Gemma 4 API-Antworten automatisch? Mit Apidogs Testszenarien: Endpunkt importieren, Anfrageschritte definieren, Assertions hinzufügen, Szenario lokal/CLI/CI ausführen.

Top comments (0)