Wie man Gemma 4 31B lokal ausfuehrt: Unsloth, Ollama, llama.cpp und HuggingFace

Google DeepMind hat Gemma 4 Anfang 2026 veroeffentlicht, und die 31B Instruktion-optimierte Variante trifft einen Sweetspot: gross genug, um bei Reasoning-Benchmarks mit proprietaren Modellen mitzuhalten, klein genug, um auf einer vernuenftigen Consumer-GPU zu laufen. Sie erzielt 85,2% bei MMLU Pro und 89,2% bei AIME 2026 ohne Werkzeuge -- das bringt sie in dieselbe Liga wie Modelle, die doppelt so gross sind.

Die Frage war schon immer: "Wie kriege ich das Ding eigentlich zum Laufen?" Ein 30,7B-Parameter-Modell in voller Praezision braucht etwa 62 GB VRAM. Das hat niemand auf einer einzelnen Karte herumliegen. Aber mit der richtigen Quantisierung und den richtigen Tools kriegst du es auf einer 24GB RTX 4090 zum Laufen, oder du lagerst teilweise auf die CPU aus, wenn du eine 16GB-Karte hast. Wir empfehlen LightNode als VPS-Anbieter, wenn du GPU-Instanzen ohne langfristige Bindung moechtest.

Dieser Leitfaden behandelt vier Methoden, wobei Unsloth als primaere Empfehlung fuer die meisten gilt.

Inhaltsverzeichnis

1. Ueberblick ueber die Gemma 4 Modellfamilie
2. Hardware-Anforderungen
3. Methode 1: Unsloth Studio (Empfohlen)
4. Methode 2: Ollama
5. Methode 3: llama.cpp
6. Methode 4: HuggingFace Transformers
7. GGUF-Quantisierungsformate verstehen
8. Performance-Tipps
9. Fehlerbehebung
10. Welche Methode solltest du waehlen?

Gemma 4 Model Family Overview

Gemma 4 gibt es in vier Groessen. Die richtige Wahl ist wichtig, weil der Hardware-Sprung zwischen ihnen steil ist.

Variante	Gesamtparameter	Aktive Parameter	Kontext	Modalitaeten	Am besten fuer
E2B	5,1B	2,3B effektiv	128K	Text, Bild, Audio	Handys, Raspberry Pi
E4B	8B	4,5B effektiv	128K	Text, Bild, Audio	Laptops, nur-CPU
26B A4B (MoE)	25,2B	3,8B aktiv	256K	Text, Bild	Schnelle Inferenz, weniger VRAM
31B (Dense)	30,7B	30,7B	256K	Text, Bild	Maximale Qualitaet

Die 26B A4B ist die clevere: 25,2B Gesamtparameter, aber nur 3,8B sind waehrend der Inferenz aktiv, dank einer Mixture-of-Experts-Architektur (8 aktive Experten von 128, plus 1 geteilter). Sie laeuft fast so schnell wie ein 4B-Modell und liefert Qualitaet nahe der vollen 31B. Wenn deine GPU 12-16GB VRAM hat, ist die 26B A4B in Q4-Quantisierung wahrscheinlich deine beste Wahl.

Die 31B Dense ist die, auf die sich dieser Leitfaden konzentriert. Das ist das volle Modell mit allen Parametern bei jedem Forward-Pass aktiv. Beste Qualitaet, hoechste Hardware-Anforderungen.

Alle vier Varianten unterstuetzen konfigurierbaren Thinking-Modus (Chain-of-Thought-Reasoning), native System-Prompts, Function Calling und 140+ Sprachen.

Hardware Requirements

Bevor du eine Methode waehlst, schau dir an, welche Hardware du zur Verfuegung hast.

Fuer Gemma 4 31B-it

Quantisierung	VRAM noetig	Qualitaetsverlust	Typische Hardware
FP16 (volle Praezision)	~62 GB	Keiner	A100, mehrere GPUs
Q8_0 (8-bit)	~32 GB	Vernachlaessigbar	RTX 4090 (24GB) + CPU-Offload
Q5_K_M (5-bit)	~22 GB	Minimal	RTX 4090, RTX 3090
Q4_K_M (4-bit)	~18 GB	Gering	RTX 4080, RTX 3090
Q3_K_M (3-bit)	~14 GB	Spuerbar	RTX 4070, teilweiser Offload

Fuer Gemma 4 26B A4B (MoE)

Quantisierung	VRAM noetig	Qualitaetsverlust	Typische Hardware
Q5_K_M	~14 GB	Minimal	RTX 4070 Ti
Q4_K_M	~10 GB	Gering	RTX 4070, RTX 3080
Q3_K_M	~8 GB	Spuerbar	RTX 4060 Ti 8GB

Wenn du nur eine CPU hast, laufen die E4B- oder E2B-Varianten problemlos. Die 31B auf der CPU ist technisch moeglich, aber quaelend langsam (erwartungsweise 1-3 Token/Sekunde auf einer modernen CPU).

RAM-Anforderung: Rechne 8-16GB System-RAM zusaetzlich zur VRAM fuer den Runtime-Overhead, mehr wenn du Schichten auf die CPU auslagerst.

Methode 1: Unsloth Studio (Empfohlen)

Unsloth ist der einfachste Weg, Gemma 4 lokal auszufuehren. Es ist eine Web-UI, die Modell-Download, Quantisierungsauswahl und Inferenz in einem Paket erledigt. Funktioniert auf Windows, Linux, macOS und WSL.

Warum Unsloth

• One-Click-Modellsuche und -download von HuggingFace
• Waehlt automatisch die richtige GGUF-Quantisierung fuer deine Hardware
• Eingebaute Chat-Oberflaeche mit Unterstuetzung fuer Bilder, PDFs und Dokumente
• Tool Calling und Websuche eingebaut
• Code-Ausfuehrungssandbox
• Kein Kommandozeilen-Gefrickel

Installation

macOS, Linux, WSL:

curl -fsSL https://unsloth.ai/install.sh | sh

Windows (PowerShell):

irm https://unsloth.ai/install.ps1 | iex

Docker:

docker run -d -e JUPYTER_PASSWORD="mypassword" \
  -p 8888:8888 -p 8000:8000 -p 2222:22 \
  -v $(pwd)/work:/workspace/work \
  --gpus all \
  unsloth/unsloth

Starten

unsloth studio -H 0.0.0.0 -p 8888

Oeffne http://localhost:8888 in deinem Browser. Du siehst die Unsloth Studio-Oberflaeche.

Gemma 4 31B ausfuehren

1. Nach dem Modell suchen: Gib in der Modellsuche gemma-4-31B ein
2. Quantisierung waehlen: Unsloth hostet vorkantisierte GGUF-Dateien. Fuer eine 24GB-GPU waehle Q4_K_M oder Q5_K_M. Fuer 16GB nimm Q3_K_M
3. Herunterladen: Klicke auf Download. Die Q4_K_M-Variante ist etwa 18GB gross
4. Chatten starten: Nach dem Download laedt das Modell automatisch in die Chat-Oberflaeche

Unsloth bietet diese GGUF-Varianten fuer Gemma 4 31B-it:

Datei	Groesse	Quantisierung
gemma-4-31B-it-Q3_K_M.gguf	~14 GB	3-bit (ausgeglichen)
gemma-4-31B-it-Q4_K_M.gguf	~18 GB	4-bit (empfohlen)
gemma-4-31B-it-Q5_K_M.gguf	~22 GB	5-bit (hohe Qualitaet)
gemma-4-31B-it-Q6_K.gguf	~26 GB	6-bit (nahezu verlustfrei)
gemma-4-31B-it-Q8_0.gguf	~32 GB	8-bit (praktisch verlustfrei)

Das HuggingFace-Repo findest du unter unsloth/gemma-4-31B-it-GGUF.

Die Chat-Oberflaeche nutzen

Unsloth Studios Chat unterstuetzt:

• Textkonversationen mit Thinking-Modus-Schalter
• Bild-Uploads: Ziehe Bilder per Drag & Drop fuer visuelle Fragebeantwortung
• PDF/DOCX-Uploads: Dokumentinhalte extrahieren und besprechen
• Code-Ausfuehrung: Das Modell kann Code in einer Sandbox schreiben und testen
• Benutzerdefinierte System-Prompts: Verhalten und Persona festlegen

Um Gemma 4s Thinking-Modus zu aktivieren, schalte die "Thinking"-Option in den Chat-Einstellungen um. Das aktiviert Chain-of-Thought-Reasoning, bei dem das Modell Probleme Schritt fuer Schritt durchgeht, bevor es die finale Antwort gibt.

Fine-Tuning mit Unsloth

Wenn du ueber Inferenz hinausgehen willst, kann Unsloth auch Training:

• LoRA Fine-Tuning: Trainiere Adapter mit bis zu 70% weniger VRAM
• GRPO Reinforcement Learning: Die effizienteste RL-Bibliothek
• Data Recipes: Erstelle automatisch Trainingsdatensaetze aus PDFs, CSVs, DOCX-Dateien
• Multi-GPU-Support: Jetzt verfuegbar, Verbesserungen in Arbeit

Fuer Gemma 4 31B Fine-Tuning brauchst du mindestens eine 24GB-GPU mit QLoRA (4-bit-quantisiertes Training).

Unsloth aktualisieren

Fuehre einfach den gleichen Installationsbefehl nochmal aus:

# macOS/Linux/WSL
curl -fsSL https://unsloth.ai/install.sh | sh

# Windows
irm https://unsloth.ai/install.ps1 | iex

Methode 2: Ollama

Ollama ist der schnellste Weg zum Starten, wenn du die Kommandozeile bevorzugst. Es erledigt Modell-Downloads, GPU-Erkennung und Serving automatisch.

Installation

# macOS
brew install ollama

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

# Windows
# Download von https://ollama.com/download

Gemma 4 ausfuehren

# 31B-Modell pullen und starten
ollama run gemma4:31b-it

# Oder die kleinere MoE-Variante fuer weniger VRAM
ollama run gemma4:26b-a4b-it

# Oder die kleineren Dense-Modelle
ollama run gemma4:e4b-it
ollama run gemma4:e2b-it

Ollama quantisiert standardmaessig auf Q4_K_M. Wenn du eine andere Quantisierung moechtest:

# Mit spezifischer Quantisierung starten
ollama run gemma4:31b-it-q5_K_M

Die API nutzen

Ollama stellt eine lokale API auf Port 11434 bereit:

import requests

response = requests.post('http://localhost:11434/api/chat', json={
    "model": "gemma4:31b-it",
    "messages": [
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to merge two sorted lists."}
    ],
    "stream": False
})

print(response.json()['message']['content'])

Ollama Vor- und Nachteile

Vorteile: Keine Konfiguration, automatische GPU-Erkennung, aufgeraeumte CLI, API-Server inklusive, einfaches Modellmanagement.

Nachteile: Weniger Quantisierungsoptionen als llama.cpp, keine eingebaute Bildunterstuetzung fuer alle Modelle (aktuelle Kompatibilitaet pruefen), weniger Kontrolle ueber Inferenzparameter.

Methode 3: llama.cpp

Fuer maximale Kontrolle ueber Quantisierung, Speichernutzung und Inferenzparameter ist llama.cpp die richtige Wahl. Es ist das, was Ollama und Unsloth unter der Haube fuer GGUF-Inferenz antreibt.

Aus dem Quellcode bauen

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

# Mit CUDA-Support (NVIDIA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)

# Mit Metal-Support (macOS Apple Silicon)
cmake -B build -DGGML_METAL=ON
cmake --build build --config Release -j$(nproc)

# Nur CPU
cmake -B build
cmake --build build --config Release -j$(nproc)

Das GGUF-Modell herunterladen

Hol dir das quantisierte Modell aus Unsloths HuggingFace-Repo:

# huggingface-cli installieren
pip install huggingface-hub

# Q4_K_M herunterladen (empfohlen fuer 24GB-GPUs)
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models

# Oder Q5_K_M fuer bessere Qualitaet
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q5_K_M.gguf \
  --local-dir ./models

Das Modell ausfuehren

# Einfacher Chat
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64 \
  -p "You are a helpful assistant.\nUser: Explain quantum computing in simple terms.\nAssistant:"

Wichtige Flags:

• -ngl 99: Alle Schichten auf die GPU auslagern. Reduziere diese Zahl, wenn du nicht genug VRAM hast (z.B. -ngl 40 lagert etwa zwei Drittel der Schichten aus)
• -c 8192: Kontextlaenge in Token. Erhoehe bis zu 256K fuer lange Dokumente, aber mehr Kontext braucht mehr VRAM
• --temp 1.0: Google empfiehlt temperature=1.0 fuer Gemma 4
• --top-p 0.95 und --top-k 64: Empfohlene Sampling-Parameter

Einen Server starten

./build/bin/llama-server \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -c 8192 \
  --host 0.0.0.0 \
  --port 8080 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 64

Dann erreichst du die Web-UI unter http://localhost:8080 oder rufst die OpenAI-kompatible API auf:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8080/v1", api_key="unused")

response = client.chat.completions.create(
    model="gemma-4-31b",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Write a Rust function to reverse a linked list."}
    ]
)

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

GPU-Offload-Strategie

Wenn deine GPU nicht genug VRAM fuer das vollstaendige Modell hat, kannst du Schichten zwischen GPU und CPU aufteilen:

# Fuer eine 16GB-GPU mit dem Q4-Modell (~18GB gesamt)
# Etwa 40 Schichten auf die GPU auslagern, der Rest auf die CPU
./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 40 \
  -c 4096

Das laeuft langsamer als vollstaendiger GPU-Offload, passt aber auf kleinere Karten. Erwarte etwa 5-15 Token/Sekunde, je nach CPU und wie viele Schichten du auslagerst.

Methode 4: HuggingFace Transformers

Wenn du eine Anwendung baust und programmatische Kontrolle brauchst, gibt dir HuggingFace Transformers direkten Zugriff auf das Modell mit voller Praezision oder benutzerdefinierter Quantisierung.

Installation

pip install -U transformers torch accelerate

Fuer Bildunterstuetzung:

pip install -U transformers torch torchvision accelerate

In voller Praezision ausfuehren (62GB+ VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain the difference between TCP and UDP."},
]

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=False
)

inputs = processor(text=text, return_tensors="pt").to(model.device)
input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(**inputs, max_new_tokens=1024)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Mit 4-bit-Quantisierung ausfuehren (18GB VRAM)

from transformers import AutoProcessor, AutoModelForCausalLM, BitsAndBytesConfig

MODEL_ID = "google/gemma-4-31B-it"

# 4-bit-Quantisierungskonfiguration
quantization_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_compute_dtype=torch.float16
)

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    quantization_config=quantization_config,
    device_map="auto"
)

Bilder verarbeiten

Das 31B-Modell unterstuetzt Text- und Bildeingabe:

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "google/gemma-4-31B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://example.com/photo.jpg"},
            {"type": "text", "text": "Describe what you see in this image."}
        ]
    }
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]
outputs = model.generate(**inputs, max_new_tokens=512)
response = processor.decode(outputs[0][input_len:], skip_special_tokens=False)
result = processor.parse_response(response)
print(result)

Thinking-Modus aktivieren

Gemma 4 unterstuetzt Chain-of-Thought-Reasoning. Aktiviere es mit enable_thinking=True:

text = processor.apply_chat_template(
    messages,
    tokenize=False,
    add_generation_prompt=True,
    enable_thinking=True  # Aktiviert den Reasoning-Modus
)

Wenn Thinking aktiviert ist, gibt das Modell sein internes Reasoning gefolgt von der finalen Antwort aus. Nutze processor.parse_response(response), um das Thinking von der Antwort zu trennen.

GGUF-Quantisierungsformate verstehen

Wenn du GGUF-Dateien herunterlaedst, siehst du viele Suffixe. Hier ist, was sie in der Praxis bedeuten.

Format	Bits	Groesse (31B)	Wann nutzen
Q8_0	8-bit	~32 GB	Beste Qualitaet, braucht 32GB+ VRAM
Q6_K	6-bit	~26 GB	Nahezu verlustfrei, 24GB+ VRAM
Q5_K_M	5-bit	~22 GB	Sweetspot fuer Qualitaet/Groesse
Q4_K_M	4-bit	~18 GB	Beste Balance, passt auf 24GB-GPU
Q3_K_M	3-bit	~14 GB	Kleinere GPU, etwas Qualitaetsverlust
Q2_K	2-bit	~10 GB	Notloesung, spuerbare Verschlechterung

Meine Empfehlung: Q4_K_M fuer 24GB-GPUs, Q5_K_M, wenn du die zusaetzlichen 4GB entbehren kannst. Der Qualitaetsunterschied zwischen Q4_K_M und Q5_K_M ist in Benchmarks messbar, aber bei normaler Nutzung kaum zu merken. Unter Q3_K_M zu gehen lohnt sich nur, wenn du keine andere Wahl hast.

Das Suffix _K_M bedeutet "K-Quantisierung, mittel." Es gibt auch _K_S (klein, mehr Kompression) und _K_L (gross, weniger Kompression) Varianten. _K_M ist die Standardempfehlung.

Performance-Tipps

Kontextlaenge verwalten

Gemma 4 31B unterstuetzt bis zu 256K Token Kontext, aber jeder Token im Kontext kostet VRAM. Ein paar praktische Richtwerte:

• 4K Token: Problemlos auf jeder GPU, die das Modell fasst
• 8K Token: Standard fuer die meisten Konversationen, immer noch komfortabel
• 32K Token: Braucht etwa 4-6GB zusaetzliche VRAM je nach Quantisierung
• 128K+ Token: Erfordert ordentlich VRAM oder aggressives Offloading

Starte mit -c 8192 und erhoehe nur, wenn du es brauchst.

Sampling-Parameter

Google empfiehlt diese Einstellungen fuer Gemma 4:

temperature = 1.0
top_p = 0.95
top_k = 64

Die unterscheiden sich von dem, was die meisten Modelle nutzen. Nutze nicht temperature=0.7 mit Gemma 4; es ist auf temperature=1.0 trainiert und liefert damit bessere Ergebnisse.

Flash Attention

Wenn du HuggingFace Transformers nutzt, aktiviere Flash Attention fuer schnellere Inferenz und geringeren Speicherverbrauch:

model = AutoModelForCausalLM.from_pretrained(
    MODEL_ID,
    attn_implementation="flash_attention_2",
    device_map="auto"
)

Das erfordert pip install flash-attn und eine kompatible GPU (die meisten NVIDIA RTX-Karten funktionieren).

Multi-GPU-Setup

Wenn du mehrere GPUs hast, erledigt device_map="auto" in Transformers das automatische Aufteilen. Fuer llama.cpp:

./build/bin/llama-cli \
  -m ./models/gemma-4-31B-it-Q4_K_M.gguf \
  -ngl 99 \
  -ts 1,1 \  # Gleichmaessig auf 2 GPUs aufteilen
  -c 8192

Fehlerbehebung

Out of Memory (CUDA OOM)

Das haeufigste Problem. Loesungen in absteigender Verzweiflung:

1. Kleinere Quantisierung nutzen: Wechsle von Q5 auf Q4 oder Q4 auf Q3
2. Kontextlaenge reduzieren: -c von 8192 auf 4096 oder 2048 senken
3. Auf CPU auslagern: -ngl reduzieren, um einige Schichten auszulagern
4. Die 26B A4B MoE-Variante nutzen: Gleiche Qualitaetsstufe, ein Bruchteil des VRAM
5. Die E4B-Variante nutzen: Laeuft auf allem

Langsame Inferenz auf der CPU

Wenn du auf der CPU laeufst, erwarte 1-3 Token/Sekunde fuer das 31B-Modell. Optionen:

• Wechsle zum E4B- oder E2B-Modell (10-20 tok/s auf CPU)
• Nutze eine GPU-Cloud-Instanz (LightNode bietet GPU-VPS-Optionen)
• Baue llama.cpp mit aktivierten CPU-Instruktionssaetzen (AVX2, AVX-512)

Modell-Download-Fehler

Die Q4_K_M-Datei ist etwa 18GB. Wenn der Download staendig fehlschlaegt:

# huggingface-cli mit Fortsetzungsunterstuetzung nutzen
huggingface-cli download unsloth/gemma-4-31B-it-GGUF \
  gemma-4-31B-it-Q4_K_M.gguf \
  --local-dir ./models \
  --local-dir-use-symlinks False

Oder nutze einen Download-Manager mit Fortsetzungsunterstuetzung. Das HuggingFace-CDN kann bei grossen Dateien unzuverlaessig sein.

"Model not supported"-Fehler

Stelle sicher, dass du die neueste Version deiner Tools nutzt. Gemma 4 ist neu und aeltere Versionen von llama.cpp, Ollama und Transformers unterstuetzen es nicht:

# llama.cpp aktualisieren
cd llama.cpp && git pull && cmake --build build --config Release -j$(nproc)

# Ollama aktualisieren
ollama pull gemma4:31b-it  # Aktualisiert automatisch, wenn noetig

# Transformers aktualisieren
pip install -U transformers

Welche Methode solltest du waehlen?

Szenario	Beste Methode
Du willst eine GUI und das Terminal nicht anfassen	Unsloth Studio
Du willst die schnellste Einrichtung, CLI ist okay	Ollama
Du brauchst maximale Kontrolle ueber die Inferenz	llama.cpp
Du baust eine Anwendung	HuggingFace Transformers
Du hast begrenzte VRAM (8-16GB)	Unsloth oder Ollama mit Q3/Q4
Du hast 24GB+ VRAM	Jede Methode, nutze Q4_K_M oder Q5_K_M
Du brauchst Bildverstaendnis	Unsloth Studio oder HuggingFace Transformers
Du willst Fine-Tuning	Unsloth (LoRA/GRPO-Training eingebaut)

Fuer die meisten, die gerade erst anfangen, ist Unsloth Studio der Weg des geringsten Widerstands. Installieren, nach Gemma 4 suchen, eine Quantisierung waehlen, die zur GPU passt, und loslegen. Der ganze Prozess dauert etwa 15 Minuten von der Installation bis zum ersten Gespraech.

Wenn du dich mit dem Terminal auskennst und einfach nur das Modell ausfuehren willst, bringt dich Ollama mit zwei Befehlen ans Ziel. Und wenn du programmatischen Zugriff brauchst oder etwas auf dem Modell aufbaust, gibt dir HuggingFace Transformers mit 4-bit-Quantisierung die volle Python-API.

Zusammenfassung

Gemma 4 31B lokal auszufuehren ist bemerkenswert praktisch geworden. Vor einem Jahr waere ein 30B-Modell auf diesem Qualitaetsniveau ein Forschungsprojekt gewesen. Jetzt ist es ein 15-Minuten-Einrichtungsprozess mit Unsloth oder Ollama, und es laeuft auf Consumer-Hardware, die du heute kaufen kannst.

Das Modell selbst haelt gegen proprietare Alternativen bei Reasoning, Coding und multimodalen Aufgaben stand. 256K Kontext, eingebauter Thinking-Modus, Bildverstaendnis und Function Calling machen es wirklich nutzbar fuer echte Arbeit, nicht nur zum Experimentieren.

Fuer das Hosting des Modells auf einer entfernten GPU bietet LightNode GPU-VPS-Instanzen mit stuenlicher Abrechnung, sodass du eine hochfahren kannst, wenn du sie brauchst, und herunterfaehrst, wenn nicht.

Die Gemma 4 Model Card auf HuggingFace hat die vollstaendigen technischen Details, und das Unsloth GGUF-Repo hat alle quantisierten Varianten zum Download bereit.