---
title: 'Ollama mit OpenCode verwenden: Leitfaden zur Einrichtung lokaler Modelle'
description: >-
  OpenCode mit Ollama verbinden, um lokale Inferenz für Programmier-Agenten zu
  nutzen. Mit Konfigurationsbeispielen, Modellauswahl, Performance-Hinweisen und
  Lösungen für häufige Probleme mit lokalen Modellen.
date: 2026-04-27T00:00:00.000Z
location: 'San Francisco, CA – 27. April 2026'
image: /images/ollama-opencode-setup-hero.jpg
keywords: >-
  ollama opencode, opencode ollama, opencode lokales modell, opencode lokales
  llm, ollama mit opencode verwenden
faq:
  - question: Kann OpenCode Ollama nutzen?
    answer: >-
      Ja. OpenCode kann Ollama über den OpenAI-kompatiblen lokalen Endpunkt
      unter http://localhost:11434/v1 nutzen. Füge Ollama als Provider hinzu,
      verwende einen Platzhalter-API-Key und setze den Modellnamen exakt so, wie
      er in „ollama list“ erscheint.
  - question: Welches lokale Modell sollte ich mit OpenCode verwenden?
    answer: >-
      Starte mit Gemma 4 oder Qwen3.5, wenn du 16 bis 32 GB Arbeitsspeicher
      hast. Größere Modelle können besser sein, werden bei toolintensiven
      Coding-Sessions aber schnell langsamer.
  - question: Ist OpenCode mit Ollama gut genug für echtes Programmieren?
    answer: >-
      Es eignet sich gut für Erklärungen, kleine Änderungen, Boilerplate und
      private Code-Reviews. Bei längeren Multi-File-Refactorings ist es dagegen
      deutlich schwächer; hier ist ein Cloud-Fallback weiterhin nützlich.
locale: de-de
translationKey: ollama-opencode-setup
---
OpenCode mit Ollama ist das Setup, das viele wünschen, wenn sie es leid sind, jeden Coding-Prompt an eine Cloud-API zu schicken. Es funktioniert – ist aber auch langsamer und fehleranfälliger, als die Demos vermuten lassen.

Was man realistisch erwarten sollte, ist einfach: Lokales OpenCode eignet sich hervorragend für kleine, private, wiederkehrende Aufgaben. Für eine unübersichtliche Multi-File-Migration ist es nicht das richtige Modell – es sei denn, du magst es, ständig danebenzusitzen und aufzupassen.

## Ollama installieren

Unter macOS:

```bash
brew install --cask ollama-app
open -a Ollama
```

Unter Linux:

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

Lade anschließend ein Modell herunter:

```bash
ollama pull gemma4
```

Prüfe, ob es verfügbar ist:

```bash
ollama list
```

Verwende den exakten Modellnamen aus dieser Ausgabe in deiner OpenCode-Konfiguration.

## OpenCode konfigurieren

OpenCode unterstützt OpenAI-kompatible Provider. Ollama bietet einen kompatiblen Endpunkt unter folgender Adresse an:

```text
http://localhost:11434/v1
```

Füge in deiner OpenCode-Konfiguration einen Ollama-Provider hinzu:

```jsonc
{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:latest": {}
      }
    }
  }
}
```

Falls OpenCode eine Authentifizierung anfordert, verwende einen Platzhalter-API-Key:

```json
{
  "ollama": {
    "type": "api",
    "key": "ollama"
  }
}
```

Starte OpenCode neu und wähle in der Modellauswahl das Ollama-Modell aus.

## Modelle für den Einstieg

#### Gemma 4

Gute erste Wahl. Es eignet sich für Erklärungen, einfache Änderungen und kleinere Coding-Aufgaben. Im Vergleich zu größeren Coding-Modellen läuft es auch auf schwächerer Hardware.

#### Qwen3.5

Für Code oft besser, besonders wenn du eine größere Variante ausführen kannst. Die Modelle der 27B-Klasse sind deutlich nützlicher als kleine Modelle, benötigen aber ordentlich Arbeitsspeicher.

#### Llama 3.3

Gutes Allround-Modell, wenn du die Hardware dafür hast. Auf kleineren Laptops weniger praktisch.

## Performance-Erwartungen

Was in aktuellen Threads zu lokalen Modellen offen zugegeben wird: Prompts können funktionieren, der Code kann gut sein – und trotzdem kann sich das Ganze langsam anfühlen, sobald sich Tool-Aufrufe häufen.

Das ist normal. Ein Programmier-Agent ist kein einzelner Chat-Request. Er liest Dateien, plant, bearbeitet, prüft Ausgaben und läuft in Schleifen. Bei lokaler Inferenz wird jede Schleife spürbarer.

So bleibt es erträglich:

- Kontext klein halten
- Kleinere Modelle für einfache Änderungen verwenden
- Das Modell warm halten
- Speicherintensive Anwendungen schließen
- Einen Cloud-Fallback für lange Refactorings nutzen

## Ollama warm halten

```bash
export OLLAMA_KEEP_ALIVE="-1"
```

Starte Ollama danach neu. Das vermeidet wiederholte Kaltstarts während einer Coding-Session.

## Wann ein Cloud-Fallback sinnvoll ist

Verwende lokales OpenCode für:

- Unbekannten Code lesen
- Kleine Änderungen entwerfen
- Tests generieren
- Fehler erklären
- Mit privaten Dateien arbeiten

Verwende ein Cloud-Modell für:

- Multi-File-Refactorings
- Schwieriges Debugging
- Architekturänderungen
- Alles, was du nicht Zeile für Zeile durchsehen möchtest

Das beste Setup ist nicht rein lokal, sondern lokal-first.

## Verwandte Anleitungen

Wenn dein eigentliches Ziel speziell Gemma 4 ist, lies [Gemma 4 mit Ollama einrichten](/blog/gemma-4-ollama-setup-guide/). Falls du OpenClaw statt OpenCode verwendest, nutze [Gemma 4 mit OpenClaw](/blog/gemma-4-ollama-openclaw-setup/).

<a href="https://app.haimaker.ai/sign-up?utm_source=openclaw_blog&utm_medium=cta&utm_campaign=ollama_opencode" class="cta-button">CLOUD-FALLBACK MIT HAIMAKER EINRICHTEN</a>