Wie viel RAM benötige ich, um Gemma 4 lokal auszuführen?

Gemma 4 E2B und E4B laufen mit nur 5GB RAM bei 4-bit quantization — jeder moderne Laptop ist dafür geeignet. Das 26B MoE Modell benötigt etwa 18GB RAM (passt in den 24GB VRAM einer RTX 4090). Das 31B Dense Modell benötigt etwa 20GB RAM. Für die CPU-only Ausführung sollten 20-30% mehr RAM als die Größe der Modellgewichte eingeplant werden.

Welches Gemma 4 Modell sollte ich für die lokale Nutzung wählen?

Für Laptops ohne dedizierte GPU: E2B (schnellst, am leichtesten). Für Laptops mit einer GPU oder Desktops: E4B (bessere Qualität, immer noch leichtgewichtig). Für Desktops mit einer RTX 4090 oder vergleichbar: 26B MoE (bestes Quality-to-Compute-Verhältnis). Für Workstations mit 24GB+ VRAM: 31B Dense (höchste Qualität). Das 26B MoE Modell ist der Sweet Spot für die meisten Entwickler.

Ist Gemma 4 für die lokale Nutzung kostenlos?

Ja. Gemma 4 ist unter Apache 2.0 lizenziert, was eine uneingeschränkte Nutzung einschließlich kommerzieller Anwendungen erlaubt. Ollama ist ebenfalls kostenlos und Open Source. Die einzigen Kosten fallen für Ihre Hardware an. Es gibt keine API-Gebühren, keine Nutzungslimits und keine Lizenzbeschränkungen.

Wie schnell ist Gemma 4 lokal im Vergleich zu Cloud APIs?

Auf einer RTX 4090 generiert Gemma 4 E4B 80-120 tokens per second. Das 26B MoE generiert 30-50 tokens/sec. Das 31B Dense generiert 20-35 tokens/sec. Cloud APIs wie Google AI Studio mögen bei den größten Modellen schneller sein, verursachen aber eine Network Latency von 100-500ms pro Request. Für die interaktive Nutzung fühlt sich die lokale inference bei den kleineren Modellen sofortig an.

Kann ich Gemma 4 lokal als API für meine Anwendungen nutzen?

Ja. Ollama stellt eine lokale REST API auf Port 11434 bereit, die mit dem OpenAI API-Format kompatibel ist. Jede Anwendung, jedes Framework oder Tool, das die OpenAI API unterstützt, kann eine Verbindung zum lokalen Gemma 4 herstellen, indem die Base URL auf http://localhost:11434/v1 gesetzt wird. Dies umfasst Python, Node.js und die meisten AI Frameworks.

Unterstützt Gemma 4 GPU-Beschleunigung mit Ollama?

Ja. Ollama erkennt und nutzt automatisch NVIDIA GPUs (CUDA), Apple Silicon (Metal) und AMD GPUs (ROCm). Es ist keine zusätzliche Konfiguration erforderlich — wenn Ihre GPU über genügend VRAM verfügt, um das Modell zu laden, wird Ollama sie automatisch verwenden. NVIDIA hat zudem RTX-optimierte Versionen von Gemma 4 veröffentlicht, um weitere Performance-Gewinne zu erzielen.

Wichtigste Erkenntnis

Gemma 4 lokal auszuführen dauert mit Ollama weniger als 5 Minuten: Installieren Sie Ollama, führen Sie einen Befehl aus, und Sie haben ein voll funktionsfähiges KI-Modell auf Ihrer eigenen Hardware laufen – mit null API-Kosten, ohne dass Daten Ihren Rechner verlassen und ohne Nutzungsbeschränkungen unter Apache 2.0. Das E2B Modell läuft auf jedem Laptop. Das 26B MoE Modell passt auf eine einzige RTX 4090 und liefert eine Qualität, die Modellen mit der 10-fachen Anzahl aktiver Parameter Konkurrenz macht.

Gemma 4 lokal ausführen: Die vollständige Anleitung

Warum Gemma 4 lokal ausführen?

Bevor wir in die Einrichtung eintauchen, erfahren Sie hier, warum lokale Inferenz im Jahr 2026 wichtig ist:

Privatsphäre — Ihre Daten verlassen niemals Ihren Rechner. Es werden keine Prompts an externe Server gesendet. Dies ist entscheidend für proprietären Code, rechtliche Dokumente, medizinische Daten oder andere sensible Informationen.
Kosten — Null Kosten pro Token nach der einmaligen Hardware-Investition. Vielnutzer sparen hunderte von Dollar pro Monat im Vergleich zu API-Preisen.
Latenz — Keine Netzwerk-Verzögerungen. Die E2B und E4B Modelle antworten auf moderner Hardware in Millisekunden.
Zuverlässigkeit — Keine API-Rate-Limits, keine Ausfälle, keine Richtlinienänderungen durch Provider. Ihr Modell ist immer verfügbar.
Anpassbarkeit — Sie können das Modell unter Apache 2.0 frei feintunen, quantisieren und modifizieren.
Offline-Zugriff — Funktioniert ohne Internetverbindung, sobald das Modell heruntergeladen wurde.

Gemma 4 ist besonders gut für den lokalen Einsatz geeignet, da Google die kleineren Modelle speziell für Edge- und On-Device-Anwendungen entwickelt hat. Die E2B und E4B Modelle sind keine bloßen Nebenprodukte — es sind erstklassige Modelle, die für die Beschränkungen lokaler Hardware optimiert wurden.

Voraussetzungen

Hardware-Anforderungen nach Modell

Modell	Minimaler RAM	Empfohlener VRAM	Nur CPU möglich?	Speicherplatz
E2B (4-bit)	5 GB	4 GB	Ja	~1.5 GB
E4B (4-bit)	5 GB	4 GB	Ja	~2.8 GB
E4B (FP16)	9 GB	9 GB	Langsam	~9 GB
26B MoE (4-bit)	18 GB	16 GB	Sehr langsam	~15 GB
26B MoE (FP16)	52 GB	48 GB	Nein	~52 GB
31B Dense (4-bit)	20 GB	18 GB	Sehr langsam	~18 GB
31B Dense (FP16)	62 GB	48 GB+	Nein	~62 GB

Wichtigste Erkenntnis: Wenn Sie einen Laptop besitzen, der nach 2022 hergestellt wurde, können Sie E2B oder E4B ausführen. Wenn Sie eine RTX 4090 (24GB VRAM) oder einen Apple M-Serie Mac mit 32GB+ RAM haben, können Sie das 26B MoE oder 31B Dense mit 4-bit Quantisierung ausführen.

Software-Anforderungen

Betriebssystem: macOS, Linux oder Windows
Ollama: Version 0.6+ (Download von ollama.com)
GPU-Treiber (optional): NVIDIA CUDA 12+ für NVIDIA GPUs, keine zusätzlichen Treiber für Apple Silicon erforderlich

Schritt 1: Ollama installieren

macOS

Laden Sie es von ollama.com/download herunter oder nutzen Sie Homebrew:

brew install ollama

Linux

Einzeiliges Installations-Skript:

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

Windows

Laden Sie den Installer von ollama.com/download herunter und führen Sie ihn aus. Ollama läuft unter Windows als Hintergrunddienst.

Installation überprüfen

ollama --version

Sie sollten ollama version 0.6.x oder höher sehen. Wenn eine Versionsnummer erscheint, ist Ollama korrekt installiert.

Quelle: Ollama Installationsanleitung

Schritt 2: Ein Gemma 4 Modell laden

Wählen Sie das Modell, das zu Ihrer Hardware passt:

Für Laptops und leichte Workloads

# Kleinstes Modell — läuft auf jedem modernen Laptop (5GB RAM)
ollama pull gemma4:e2b

# Kleines Modell mit breiteren Fähigkeiten (5-9GB RAM)
ollama pull gemma4:e4b

Für Desktops mit dedizierter GPU

# Beste Effizienz — Flaggschiff-Qualität bei 3.8B aktiven Parametern (18GB RAM)
ollama pull gemma4:26b-moe

# Höchste Qualität — volle 31B Parameter (20GB RAM)
ollama pull gemma4:31b

Spezifizierung der Quantisierung

Standardmäßig lädt Ollama die empfohlene Quantisierung für jedes Modell (meist Q4_K_M für ein gutes Verhältnis von Qualität zu Größe). Sie können andere Quantisierungen spezifizieren:

# Höhere Qualität, größere Datei
ollama pull gemma4:31b-q5_K_M

# Kleinere Datei, etwas geringere Qualität
ollama pull gemma4:31b-q3_K_M

# Volle Präzision (erfordert viel mehr RAM)
ollama pull gemma4:31b-fp16

Der Download dauert je nach Internetverbindung einige Minuten. Die Modellgrößen variieren von ~1.5GB (E2B 4-bit) bis ~62GB (31B FP16).

Schritt 3: Gemma 4 ausführen

Interaktiver Chat

ollama run gemma4:e4b

Dies öffnet eine interaktive Chat-Sitzung. Geben Sie Ihren Prompt ein und drücken Sie Enter:

>>> What are the key differences between REST and GraphQL APIs?

Das Modell antwortet direkt in Ihrem Terminal. Geben Sie /bye ein, um den Chat zu beenden.

Einzelner Prompt (Nicht-interaktiv)

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

Mit Thinking Mode

Gemma 4 unterstützt einen konfigurierbaren Thinking Mode für komplexe Aufgaben. Aktivieren Sie diesen durch Hinzufügen eines System-Prompts:

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

Für Aufgaben in den Bereichen Mathematik, Logik und komplexe Analyse verbessert der Thinking Mode die Antwortqualität erheblich. Das Modell generiert über 4.000 Tokens an internen Überlegungen, bevor es die endgültige Antwort ausgibt.

Schritt 4: Die lokale API verwenden

Ollama stellt eine REST API unter localhost:11434 bereit, die mit dem OpenAI API Format kompatibel ist. Das bedeutet, dass jedes Tool oder jede Bibliothek, die OpenAI's API unterstützt, mit einer einfachen Änderung der URL eine Verbindung zu Ihrem lokalen Gemma 4 herstellen kann.

Testen der API mit curl

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

OpenAI-kompatibler Endpunkt

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

Quelle: Ollama API Dokumentation

Schritt 5: In Ihre Anwendung integrieren

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# Nutzung
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

Python mit OpenAI SDK

from openai import OpenAI

# Verweis auf lokales Ollama anstelle von OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama erfordert keinen echten API key
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Nutzung mit LangChain

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

Nutzung mit LlamaIndex

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

Quantisierungsoptionen erklärt

Quantisierung reduziert die Modellgröße und den Speicherverbrauch, indem Zahlen mit geringerer Präzision zur Darstellung der Modellgewichte verwendet werden. Der Kompromiss besteht zwischen Qualität und Ressourcenverbrauch:

Quantisierung	Bits pro Gewicht	Auswirkung auf die Qualität	Speicherersparnis	Bestens geeignet für
FP16	16 bits	Keine (volle Qualität)	Basiswert	Server mit reichlich VRAM
Q8_0	8 bits	Vernachlässigbar	~50%	Hochwertige lokale Inferenz
Q6_K	6 bits	Sehr gering	~62%	Qualitätsfokussierte lokale Nutzung
Q5_K_M	5 bits	Gering	~69%	Gute Balance
Q4_K_M	4 bits	Klein	~75%	Empfohlener Standard
Q3_K_M	3 bits	Mittelmäßig	~81%	Begrenzte Hardware
Q2_K	2 bits	Erheblich	~87%	Extreme Einschränkungen

Q4_K_M ist für die meisten Benutzer der ideale Punkt. Der Qualitätsunterschied zu FP16 ist so gering, dass die meisten Aufgaben ununterscheidbare Ergebnisse liefern, während die Speicherersparnis von 75% den Unterschied ausmacht, ob ein Modell einen Server benötigt oder auf einem Laptop läuft.

Die richtige Quantisierung wählen

Für Gemma 4 E2B/E4B: Verwenden Sie den Standard (Q4_K_M). Diese Modelle sind bereits so klein, dass eine höhere Quantisierung das Benutzererlebnis nicht maßgeblich verändert.

Für Gemma 4 26B MoE: Q4_K_M passt in 18GB RAM, was innerhalb der 24GB VRAM einer RTX 4090 liegt und Platz für den KV cache lässt. Wenn Sie 48GB+ VRAM haben (A6000, duale GPUs), ziehen Sie Q8_0 für geringfügig bessere Qualität in Betracht.

Für Gemma 4 31B Dense: Q4_K_M mit 20GB passt knapp auf eine RTX 4090. Q5_K_M liefert etwas bessere Ergebnisse, benötigt aber ~24GB, was den gesamten verfügbaren VRAM verbraucht. Wenn Sie 32GB+ VRAM haben (RTX 5090, A6000), sind Q6_K oder Q8_0 das Upgrade wert.

Leistungsoptimierung

GPU-Offloading

Ollama verlagert Modellschichten automatisch auf die GPU, wenn VRAM verfügbar ist. Wenn nur ein Teil des Modells in den VRAM passt, teilt Ollama die Last zwischen GPU und CPU auf. Sie können dies steuern:

# Alle Schichten auf die GPU erzwingen (schlägt fehl, wenn VRAM nicht ausreicht)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Nur CPU erzwingen (nützlich für Tests)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Konfiguration des Kontextfensters

Standardmäßig verwendet Ollama aus Effizienzgründen ein Kontextfenster von 2048 Tokens. Um die vollen Kontext-Fähigkeiten von Gemma 4 zu nutzen:

# Kontextfenster auf 32K Tokens setzen
ollama run gemma4:26b-moe --num-ctx 32768

# Kontextfenster auf 128K Tokens setzen (erfordert mehr RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Wichtig: Größere Kontextfenster verbrauchen mehr RAM für den KV cache. Ein 128K Kontextfenster beim 31B Modell kann 8-16GB zusätzlichen RAM über die Modellgewichte hinaus erfordern. Beginnen Sie mit 32K und erhöhen Sie nur, wenn Ihr Anwendungsfall es erfordert.

Gleichzeitige Anfragen

Ollama unterstützt die gleichzeitige Bearbeitung mehrerer Anfragen:

# Bis zu 4 gleichzeitige Anfragen zulassen
OLLAMA_NUM_PARALLEL=4 ollama serve

Jede gleichzeitige Anfrage verursacht zusätzlichen Speicherbedarf für ihren KV cache. Auf einer 24GB GPU, auf der das 26B MoE mit Q4_K_M (~18GB) läuft, haben Sie etwa 6GB Spielraum – genug für 2-3 gleichzeitige Anfragen mit kurzen Kontexten.

Keep-Alive-Einstellungen

Standardmäßig hält Ollama Modelle nach der letzten Anfrage für 5 Minuten im Speicher geladen. Passen Sie dies an Ihren Anwendungsfall an:

# Modell für 1 Stunde geladen lassen
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Modell dauerhaft geladen lassen
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Sofort nach jeder Anfrage entladen (spart Speicher)
OLLAMA_KEEP_ALIVE=0 ollama serve

NVIDIA RTX Optimierung

NVIDIA hat optimierte Builds von Gemma 4 für RTX GPUs veröffentlicht. Diese Optimierungen beinhalten:

Eigene CUDA Kernel für den Attention-Mechanismus von Gemma 4
TensorRT-LLM Integration für schnellere Inferenz
Flash Attention Unterstützung für reduzierten Speicherverbrauch bei langem Kontext
Optimiertes KV cache Management für besseren Durchsatz

NVIDIA-optimiertes Gemma 4 installieren

Wenn Sie eine GPU der RTX 4000 oder 5000 Serie besitzen:

# GPU überprüfen
nvidia-smi

# NVIDIA-optimierte Version laden (falls in Ollama verfügbar)
ollama pull gemma4:31b-nvidia

Alternativ können Sie NVIDIA's AI Workbench oder TensorRT-LLM direkt für maximale Performance nutzen. Die NVIDIA-optimierten Versionen können auf RTX GPUs eine um 30-50% schnellere Inferenz im Vergleich zu Standard-Ollama-Builds bieten.

Leistungs-Benchmarks aus der Praxis

Gemessen auf gängigen Hardware-Konfigurationen:

Tokens pro Sekunde (Generationsgeschwindigkeit)

Modell	RTX 4090 (24GB)	RTX 3090 (24GB)	M3 Max (36GB)	Nur CPU (32GB)
E2B (Q4)	~150 tok/s	~120 tok/s	~100 tok/s	~30 tok/s
E4B (Q4)	~100 tok/s	~80 tok/s	~70 tok/s	~15 tok/s
26B MoE (Q4)	~40 tok/s	~30 tok/s	~25 tok/s	~3 tok/s
31B Dense (Q4)	~30 tok/s	~20 tok/s	~20 tok/s	~2 tok/s

Kontext: Die menschliche Lesegeschwindigkeit liegt bei etwa 4-5 Tokens pro Sekunde. Jedes Modell, das über 10 tok/s generiert, fühlt sich bei interaktiver Nutzung "sofortig" an. Die E2B und E4B Modelle sind schnell genug für Echtzeit-Streaming auf fast jeder Hardware.

Zeit bis zum ersten Token (Latenz)

Modell	RTX 4090	M3 Max	Nur CPU
E2B	<100ms	<200ms	<500ms
E4B	<200ms	<300ms	~1s
26B MoE	~500ms	~1s	~5s
31B Dense	~800ms	~1.5s	~8s

Bei interaktiven Anwendungen ist die Zeit bis zum ersten Token wichtiger als die reine Generationsgeschwindigkeit. Die E2B und E4B Modelle beginnen fast augenblicklich mit der Generierung, selbst auf der CPU, was sie ideal für Echtzeit-Chat-Interfaces macht.

Häufige Anwendungsfälle

Lokaler Coding-Assistent

Nutzen Sie Gemma 4 als privaten Coding-Assistenten, der Ihren Code niemals an externe Server sendet:

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

Kombinieren Sie dies mit VS Code Erweiterungen wie Continue oder Twinny, die Ollama als Backend unterstützen.

Dokumentenanalyse

Verarbeiten Sie sensible Dokumente lokal:

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

Mit 256K Kontext kann das 31B Modell Dokumente bis zu ~750 Seiten verarbeiten — ausreichend für die meisten Verträge, Forschungsarbeiten und technischen Dokumentationen.

Lokales RAG (Retrieval-Augmented Generation)

Kombinieren Sie Gemma 4 mit einer lokalen Vektordatenbank für ein vollständig privates RAG System:

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# Nutze Gemma 4 für Embeddings und Generation
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Erstelle Vector Store aus Ihren Dokumenten
vectorstore = Chroma.from_documents(documents, embeddings)

# Abfrage mit RAG
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

KI-Funktionen in Anwendungen einbauen

Für Entwickler, die Anwendungen mit KI-Funktionen bauen, ist die lokale Ausführung von Gemma 4 über die Ollama API der schnellste Weg zu einem funktionierenden Prototyp. Die OpenAI-kompatible API bedeutet, dass Sie mit dem lokalen Gemma 4 für die Entwicklung beginnen und für die Produktion auf Cloud-APIs umsteigen können, ohne den Anwendungscode zu ändern.

Plattformen wie ZBuild können die Anwendungsinfrastruktur — Frontend, Backend, Authentifizierung, Datenbank — übernehmen, während Sie sich auf die KI-Integrationsschicht konzentrieren. Verweisen Sie während der Entwicklung auf localhost:11434 und wechseln Sie zu einem Cloud-Endpunkt, wenn Sie bereit für die Skalierung sind.

Fehlerbehebung

"Out of memory" Fehler

Wenn Speicherfehler auftreten:

Versuchen Sie eine kleinere Quantisierung: ollama pull gemma4:31b-q3_K_M
Verringern Sie das Kontextfenster: --num-ctx 4096
Schließen Sie andere GPU-intensive Anwendungen
Wechseln Sie zu einem kleineren Modell: Das 26B MoE liefert eine Qualität nahe am 31B bei geringeren Speicherkosten

Langsame Generationsgeschwindigkeit

Wenn die Generierung langsamer als erwartet ist:

Prüfen Sie die GPU-Auslastung: nvidia-smi (sollte hohe GPU-Nutzung zeigen)
Stellen Sie sicher, dass das Modell vollständig in den VRAM passt — teilweises CPU-Offloading ist dramatisch langsamer
Verringern Sie --num-ctx, um VRAM für Berechnungen freizugeben
Prüfen Sie, ob andere Prozesse die GPU nutzen

Modell nicht gefunden

Falls ollama run gemma4:26b-moe fehlschlägt:

# Verfügbare Modelle auflisten
ollama list

# Nach Gemma 4 Modellen suchen
ollama search gemma4

# Das spezifische Modell laden
ollama pull gemma4:26b-moe

API-Verbindung abgelehnt

Wenn Anwendungen keine Verbindung zu localhost:11434 herstellen können:

# Prüfen, ob Ollama läuft
ollama list

# Den Ollama Server manuell starten
ollama serve

# Den Port prüfen
curl http://localhost:11434/api/tags

Entscheidungsbaum zur Modellauswahl

Nutzen Sie dies, um schnell das richtige Modell zu wählen:

Haben Sie eine dedizierte GPU mit 16GB+ VRAM?

Ja → Wollen Sie maximale Qualität oder maximale Effizienz?
- Maximale Qualität → gemma4:31b (Q4_K_M, benötigt 20GB)
- Maximale Effizienz → gemma4:26b-moe (Q4_K_M, benötigt 18GB)
Nein → Haben Sie 8GB+ RAM?
- Ja → gemma4:e4b (Q4_K_M, bessere Qualität)
- Nein → gemma4:e2b (Q4_K_M, läuft auf 5GB)

Für die meisten Entwickler mit einem modernen Desktop oder Gaming-PC: Beginnen Sie mit gemma4:26b-moe. Es bietet das beste Verhältnis von Qualität zu Ressourcen in der gesamten Gemma 4 Familie.

Was Sie bauen können

Mit Gemma 4 lokal im Hintergrund haben Sie ein kostenloses KI-Backend für:

Chat-Anwendungen mit vollständiger Privatsphäre der Konversationen
Code-Analyse-Tools, die auf proprietären Codebases arbeiten
Pipelines zur Dokumentenverarbeitung für sensible Daten
Lokale KI-Assistenten, die offline funktionieren
KI-Funktionen prototypisieren, bevor Cloud-API-Kosten anfallen
Feingetunte Modelle für domänenspezifische Aufgaben (Apache 2.0 erlaubt dies frei)

Die Apache 2.0 Lizenz bedeutet, dass alles, was Sie bauen, Ihnen gehört — keine Nutzungsbeschränkungen, keine Umsatzbeteiligung, keine Genehmigung erforderlich. Führen Sie es lokal aus, stellen Sie es auf Ihren Servern bereit, betten Sie es in Ihre Produkte ein. So sieht wahrhaft offene KI aus.

Gemma 4 lokal in 5 Minuten ausführen: Vollständiger Ollama Setup-Guide (2026)