---
title: Gemma 4 mit OpenCode über Ollama einrichten (Anleitung 2026)
description: >-
Google Gemma 4 lokal ausführen und mit OpenCode als Coding-Assistent im
Terminal verbinden. Vollständige Anleitung zur Einrichtung von Ollama und
OpenCode auf dem Mac.
date: 2026-04-04T00:00:00.000Z
location: 'San Francisco, CA – 4. April 2026'
image: /images/gemma-4-ollama-opencode-setup-hero.jpg
keywords: >-
gemma 4 opencode, ollama gemma 4, OpenCode lokales Modell, gemma 4 ollama
Einrichtung, gemma 4 lokal ausführen, OpenCode ollama Anleitung
faq:
- question: Kann ich Gemma 4 als lokales Modell in OpenCode verwenden?
answer: >-
Ja. Installiere Ollama, lade das gemma4-Modell mit dem Befehl ollama pull
gemma4 herunter und füge Ollama in ~/.config/opencode/opencode.jsonc als
benutzerdefinierten Provider hinzu. Verwende den
@ai-sdk/openai-compatible-Adapter mit baseURL http://localhost:11434/v1.
Wechsle in OpenCode mit /models zu diesem Modell.
- question: Wie viel RAM benötigt Gemma 4 für den Betrieb mit OpenCode?
answer: >-
Das Standardmodell Gemma 4 8B benötigt geladen ca. 9,6 GB. Ein Mac mit 16
GB Unified Memory kann es problemlos zusammen mit OpenCode betreiben. Die
26B-Variante benötigt 24 GB oder mehr und ist für die meisten
Consumer-Rechner nicht empfehlenswert.
- question: Ist Gemma 4 schnell genug für interaktives Coding in OpenCode?
answer: >-
Auf Apple Silicon mit Ollama v0.19+ läuft Gemma 4 8B dank des MLX-Backends
mit brauchbarer Geschwindigkeit. Codevervollständigung, Erklärungen und
einfache Änderungen funktionieren gut. Für komplexe Aufgaben, die die
Denkleistung von Frontier-Modellen erfordern, kannst du Haimaker als
zweiten Provider für den Zugriff auf Cloud-Modelle hinzufügen.
locale: de-de
translationKey: gemma-4-ollama-opencode-setup
---
OpenCode ist ein Coding-Assistent für das Terminal, der mit jeder OpenAI-kompatiblen API kommuniziert. Verbindest du ihn mit einer lokalen Ollama-Instanz, auf der Gemma 4 läuft, hast du einen kostenlosen Coding-Assistenten, der deinen Code nicht an einen Server schickt.
So richtest du ihn auf einem Mac mit Apple Silicon ein: Ollama installieren, Gemma 4 herunterladen und mit OpenCode verbinden.
## Voraussetzungen
- Mac mit Apple Silicon (M1/M2/M3/M4/M5) und mindestens 16 GB Unified Memory
- macOS mit installiertem Homebrew
- OpenCode installiert (siehe [opencode.ai](https://opencode.ai) oder Installation über deinen Paketmanager)
Das Standardmodell Gemma 4 8B benötigt geladen ca. 9,6 GB. Mit 16 GB Unified Memory hast du genug Spielraum, um Ollama und OpenCode zusammen problemlos zu betreiben.
## Schritt 1: Ollama installieren
```bash
brew install --cask ollama-app
```
Dadurch wird `Ollama.app` in `/Applications/` und die `ollama`-CLI unter `/opt/homebrew/bin/ollama` installiert.
## Schritt 2: Ollama starten
```bash
open -a Ollama
```
Warte, bis das Menüleisten-Symbol erscheint, und prüfe dann, ob der Server läuft:
```bash
ollama list
```
## Schritt 3: Gemma 4 herunterladen
```bash
ollama pull gemma4
```
Dabei werden ca. 9,6 GB heruntergeladen. Überprüfe mit:
```bash
ollama list
# NAME ID SIZE MODIFIED
# gemma4:latest ... 9.6 GB ...
```
Teste das Modell:
```bash
ollama run gemma4:latest "Hello, what model are you?"
```
Prüfe die GPU-Beschleunigung:
```bash
ollama ps
# Should show CPU/GPU split, e.g. 14%/86% CPU/GPU
```
Ollama v0.19+ auf Apple Silicon nutzt automatisch Apples MLX-Framework für schnellere Inferenz.
## Schritt 4: OpenCode für Gemma 4 konfigurieren
OpenCode verwendet die Konfigurationsdatei `~/.config/opencode/opencode.jsonc`. Füge Ollama als benutzerdefinierten Provider hinzu:
```jsonc
{
"provider": {
"ollama": {
"npm": "@ai-sdk/openai-compatible",
"options": {
"baseURL": "http://localhost:11434/v1"
},
"models": {
"gemma4:latest": {}
}
}
}
}
```
Da Ollama lokal läuft, brauchst du keinen API-Key. OpenCode erwartet jedoch einen Auth-Eintrag. Ergänze deshalb einen Platzhalter in `~/.local/share/opencode/auth.json`:
```json
{
"ollama": {
"type": "api",
"key": "ollama"
}
}
```
Starte OpenCode neu und wechsle mit `/models` zu `ollama/gemma4:latest`.
## Schritt 5: Gemma 4 im Speicher halten
Ollama entlädt Modelle standardmäßig nach fünf Minuten Inaktivität. Bei einem Coding-Assistenten, den du den ganzen Tag nutzt, führt das zu unnötigen Kaltstarts.
Setze Keep-Alive auf unendlich:
```bash
launchctl setenv OLLAMA_KEEP_ALIVE "-1"
```
Starte Ollama neu, damit die Änderung wirksam wird. Damit die Einstellung über Neustarts hinweg erhalten bleibt, füge Folgendes in `~/.zshrc` ein:
```bash
export OLLAMA_KEEP_ALIVE="-1"
```
Start bei Anmeldung aktivieren: Klicke auf das Ollama-Menüleisten-Symbol → **Bei Anmeldung starten**.
#### Automatisches Vorladen beim Start
Erstelle einen Launch Agent, damit Gemma 4 nach jedem Neustart sofort einsatzbereit ist:
```bash
cat << 'EOF' > ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
Label
com.ollama.preload-gemma4
ProgramArguments
/opt/homebrew/bin/ollama
run
gemma4:latest
RunAtLoad
StartInterval
300
StandardOutPath
/tmp/ollama-preload.log
StandardErrorPath
/tmp/ollama-preload.log
EOF
launchctl load ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
```
Dadurch bleibt das Modell alle fünf Minuten durch einen leeren Prompt im Speicher.
## Wofür sich Gemma 4 in OpenCode gut eignet
Gemma 4 8B ist kostenlos und läuft lokal – und ist überraschend nützlich für die alltägliche Coding-Arbeit:
- **Code-Erklärungen.** Frag, was eine Funktion tut, wie ein Modul aufgebaut ist oder was ein regulärer Ausdruck findet. Die Antworten sind klar und bei üblichen Codebasen in der Regel korrekt.
- **Schnelle Änderungen.** Tippfehler beheben, einen Import aktualisieren, ein Feld in einer Typdefinition ergänzen oder eine Variable umbenennen. Änderungen an einzelnen Dateien sind die Stärke des Modells.
- **Boilerplate-Generierung.** Konfigurationsdateien, Test-Stubs, Scaffolding für API-Routen, Dockerfile-Vorlagen. Gängige Muster, die kein tiefgehendes Reasoning erfordern.
- **Hilfe bei Shell-Befehlen.** Ein `git`-Flag oder einen `jq`-Filter vergessen? Gemma 4 liefert dir den Befehl – ohne Umweg über Stack Overflow.
## Wo die Grenzen liegen
- **Mehrstufige Denkaufgaben.** Aufgaben, die Planung über mehrere Dateien hinweg oder das Verständnis komplexer Kontrollflüsse erfordern, führen oft zu unvollständigen Ergebnissen.
- **Große Refactorings.** Wenn du koordinierte Änderungen über eine gesamte Codebasis hinweg benötigst, verliert das 8B-Modell leicht den Überblick. Es arbeitet Datei für Datei, verliert aber das große Ganze aus den Augen.
- **Edge Cases und subtile Bugs.** Gemma 4 erkennt offensichtliche Probleme, übersieht aber Bugs, die tiefes Domänenwissen oder das Durchdenken von Grenzfällen erfordern.
## Der nächste Schritt: Haimaker für Cloud-Modelle ergänzen
Gemma 4 deckt lokal die Grundlagen ab. Wenn du an Grenzen stößt – komplexes Debugging, Refactorings über mehrere Dateien oder alles, was tiefgehendes Reasoning erfordert – brauchst du ein Cloud-Modell. [Haimaker](https://haimaker.ai) gibt dir einen einzigen API-Key für Claude Opus, GPT-5, Gemini Pro und andere.
Füge Haimaker als zweiten Provider neben Ollama hinzu:
```jsonc
{
"provider": {
"ollama": {
"npm": "@ai-sdk/openai-compatible",
"options": {
"baseURL": "http://localhost:11434/v1"
},
"models": {
"gemma4:latest": {}
}
},
"haimaker": {
"npm": "@ai-sdk/openai-compatible",
"options": {
"baseURL": "https://api.haimaker.ai/v1"
},
"models": {
"anthropic/claude-sonnet-4-6": {},
"openai/gpt-5": {},
"google/gemini-2.5-pro": {}
}
}
}
}
```
Trage deinen Haimaker-API-Key in `~/.local/share/opencode/auth.json` ein:
```json
{
"ollama": {
"type": "api",
"key": "ollama"
},
"haimaker": {
"type": "api",
"key": "YOUR_HAIMAKER_API_KEY"
}
}
```
Jetzt kannst du in OpenCode mit `/models` zwischen lokalen und Cloud-Modellen wechseln. Nutze Gemma 4 für schnelle Aufgaben und wechsel zu Sonnet oder GPT-5, wenn es anspruchsvoll wird.
Registriere dich auf [haimaker.ai](https://haimaker.ai), um deinen API-Key zu erhalten, und wirf einen Blick in den [Modellkatalog](https://haimaker.ai/models).
JETZT HAIMAKER-API-KEY HOLEN
## Fehlerbehebung
**Provider erscheint nicht in /models.** Starte OpenCode nach dem Bearbeiten der Konfigurationsdateien neu. Änderungen an `opencode.jsonc` werden während der Laufzeit nicht übernommen.
**Fehler „Model not found".** Stelle sicher, dass die Modell-ID in deiner Konfiguration exakt dem entspricht, was Ollama meldet. Führe `ollama list` aus und übernimm den angezeigten Namen – üblicherweise `gemma4:latest`.
**Authentifizierungsfehler bei Ollama.** Obwohl Ollama keine Authentifizierung benötigt, erwartet das Provider-System von OpenCode einen Eintrag in `auth.json`. Der Platzhalter `"key": "ollama"` genügt.
**Langsame Antworten.** Stelle sicher, dass du Ollama v0.19+ verwendest, um auf Apple Silicon die MLX-Beschleunigung zu nutzen. Prüfe mit `ollama --version`. Beende außerdem Apps, die denselben Unified Memory beanspruchen – meistens ist es der Browser mit vielen offenen Tabs.
**Probleme mit dem Kontextfenster.** Gemma 4 unterstützt große Kontextfenster. Auf Hardware mit 16 GB solltest du Eingaben unter 32K Tokens halten, um eine stabile Ausgabequalität zu gewährleisten. Wenn die Antwortqualität bei langen Prompts nachlässt, liegt es wahrscheinlich daran.
## Nützliche Ollama-Befehle
| Befehl | Beschreibung |
|---|---|
| `ollama list` | Heruntergeladene Modelle auflisten |
| `ollama ps` | Laufende Modelle und Speichernutzung anzeigen |
| `ollama run gemma4:latest` | Interaktiver Chat |
| `ollama stop gemma4:latest` | Modell aus dem Speicher entladen |
| `ollama pull gemma4:latest` | Auf die neueste Version aktualisieren |
| `ollama rm gemma4:latest` | Modell löschen |
---
*Nutzt du Haimaker bereits mit OpenCode? Die vollständige [Anleitung zur Einrichtung benutzerdefinierter Provider](/blog/how-to-add-haimaker-opencode) zeigt dir, wie du weitere Modelle hinzufügst.*