Lokales Coding-Modell mit Ollama in der IDE nutzen

Cloud-basierte Code-Assistenten senden Quellcode an fremde Infrastruktur, was in vielen Projekten vertraglich oder regulatorisch ausgeschlossen ist. Mit Ollama betreibst du ein Coding-Modell auf eigener Hardware und sprichst es aus VS Code, JetBrains oder Zed über eine lokale HTTP-API an. Diese Anleitung führt von der Installation bis zum funktionierenden Inline-Autocomplete.

Was ist ein Ollama Coding Model?

Ein Ollama Coding Model ist ein lokal ausgeführtes Sprachmodell wie qwen2.5-coder, das Ollama als HTTP-Dienst auf Port 11434 bereitstellt und das IDE-Plugins für Chat, Code-Edits und Fill-in-the-Middle-Autocomplete ansprechen.

Wichtig ist die Trennung zweier Rollen. Chat und Refactoring brauchen ein instruktionsgetuntes Modell, das Anweisungen versteht. Das Inline-Autocomplete braucht ein kleines Base-Modell, das Fill-in-the-Middle (FIM) beherrscht, also Code zwischen Prefix und Suffix ergänzt statt eine Antwort zu formulieren.

Voraussetzungen

• Linux-Host mit Ubuntu 24.04 LTS oder Debian 12 und einem Konto mit sudo-Rechten
• Ollama 0.6 oder neuer (ältere Versionen kennen OLLAMA_CONTEXT_LENGTH nicht)
• Optional eine NVIDIA-GPU mit Treiber 550 oder neuer, geprüft per nvidia-smi
• VS Code 1.90 oder neuer mit der Erweiterung Continue 1.0 oder neuer
• Mindestens 20 GB freier Speicherplatz unter /usr/share/ollama/.ollama/models

Eine skalierbare Cloud-VPS mit 8 vCPU und 16 GB RAM genügt für Modelle bis 7B im CPU-Modus. Rechne dort aber mit 5 bis 15 Tokens pro Sekunde, was für Chat brauchbar ist und für Inline-Autocomplete zu langsam bleibt.

Ollama installieren

Installiere Ollama über das offizielle Setup-Skript. Es legt den Benutzer ollama, eine systemd-Unit und bei erkannter NVIDIA-Karte die CUDA-Runtime an.

$ curl -fsSL https://ollama.com/install.sh | sh
$ ollama --version
$ systemctl status ollama --no-pager

Die Ausgabe von systemctl status muss active (running) zeigen. Wenn eine GPU vorhanden ist, protokolliert der Dienst die erkannte Karte:

$ sudo journalctl -u ollama --no-pager | grep -i "inference compute"

Modelle für Chat und Autocomplete laden

Lade zwei Modelle, eines pro Rolle. Das -base-Tag ist hier kein Detail am Rand: ein Instruct-Modell im Autocomplete-Slot antwortet mit Erklärungstext, der dann als Codevorschlag im Editor landet.

$ ollama pull qwen2.5-coder:7b
$ ollama pull qwen2.5-coder:1.5b-base
$ ollama list

Ein erster Funktionstest ohne IDE:

$ ollama run qwen2.5-coder:7b "Schreibe eine Python-Funktion, die eine CSV-Datei streamend zeilenweise liest."

Wie viel VRAM braucht ein lokales Coding-Modell?

Ein lokales Coding-Modell in 4-Bit-Quantisierung belegt rund 0,7 GB VRAM pro Milliarde Parameter plus 1 bis 2 GB für den KV-Cache, ein 7B-Modell läuft damit ab 8 GB VRAM vollständig auf der GPU.

Beide Modelle laufen parallel, solange die Summe in den VRAM passt. Für Autocomplete plus 7B-Chat reichen 12 GB komfortabel. Passt das nicht in vorhandene Hardware, lässt sich derselbe Stack unverändert auf einer GPU-Instanz für LLM-Inference betreiben und per Tunnel von mehreren Arbeitsplätzen aus nutzen.

Ollama für den Zugriff aus der IDE konfigurieren

Ollama bringt keine Authentifizierung mit. Wer den Dienst auf 0.0.0.0 bindet, stellt ein offenes Inferenz-Endpoint ins Netz. Binde ihn deshalb auf Loopback und leite den Port per SSH weiter.

Lege ein systemd-Override an:

$ sudo systemctl edit ollama

[Service]
Environment="OLLAMA_HOST=127.0.0.1:11434"
Environment="OLLAMA_KEEP_ALIVE=30m"
Environment="OLLAMA_CONTEXT_LENGTH=8192"
Environment="OLLAMA_NUM_PARALLEL=2"
Environment="OLLAMA_FLASH_ATTENTION=1"

Die Werte im Einzelnen:

• OLLAMA_KEEP_ALIVE hält das Modell im VRAM. Der Standard von 5 Minuten führt dazu, dass das Autocomplete-Modell nach jeder Pause neu geladen wird und die erste Vervollständigung mehrere Sekunden braucht.
• OLLAMA_CONTEXT_LENGTH setzt das Kontextfenster. Der Standard von 4096 Tokens ist für Code-Kontext plus Prompt oft zu klein, 8192 ist ein guter Kompromiss zwischen Nutzen und VRAM.
• OLLAMA_NUM_PARALLEL erlaubt gleichzeitige Requests, damit ein laufender Chat-Request das Autocomplete nicht blockiert.

Übernimm die Änderung:

$ sudo systemctl daemon-reload
$ sudo systemctl restart ollama

Läuft Ollama auf einem entfernten Host, öffne den Tunnel lokal. Danach ist der Dienst unter http://localhost:11434 erreichbar, ohne dass der Port öffentlich hängt.

$ ssh -N -L 11434:127.0.0.1:11434 <benutzer>@<server-ip>

graph LR
    A["VS Code + Continue"] -->|"Chat / Edit"| T["SSH-Tunnel localhost:11434"]
    A -->|"FIM-Autocomplete"| T
    T --> B["Ollama-Dienst auf dem Host"]
    B --> C{"Modell schon im VRAM?"}
    C -->|"ja"| D["Antwort ohne Ladezeit"]
    C -->|"nein"| E["Modell laden, dann antworten"]
    D --> F["Vorschlag im Editor"]
    E --> F

IDE anbinden

Installiere die Erweiterung Continue aus dem VS Code Marketplace. Ab Version 1.0 liest Continue die YAML-Konfiguration aus ~/.continue/config.yaml, das frühere config.json gilt als veraltet.

VS Code mit Continue konfigurieren

Schreibe die Datei ~/.continue/config.yaml. Jedes Modell bekommt genau die Rollen, für die es gedacht ist.

name: lokaler-assistent
version: 1.0.0
schema: v1
models:
  - name: Qwen2.5 Coder 7B
    provider: ollama
    model: qwen2.5-coder:7b
    apiBase: http://localhost:11434
    roles:
      - chat
      - edit
      - apply
    defaultCompletionOptions:
      contextLength: 8192
  - name: Qwen2.5 Coder 1.5B FIM
    provider: ollama
    model: qwen2.5-coder:1.5b-base
    apiBase: http://localhost:11434
    roles:
      - autocomplete
    defaultCompletionOptions:
      maxTokens: 256

Speichern genügt, Continue lädt die Konfiguration neu. Öffne eine Python- oder Go-Datei und beginne eine Funktionssignatur. Der Vorschlag erscheint als grauer Inline-Text und wird mit Tab übernommen.

JetBrains und Zed

Das Continue-Plugin für IntelliJ, PyCharm und GoLand nutzt dieselbe Datei ~/.continue/config.yaml. Eine getrennte Pflege ist nicht nötig. Zed spricht Ollama direkt an, ohne Plugin, über die eigene Einstellungsdatei:

{
  "language_models": {
    "ollama": {
      "api_url": "http://localhost:11434"
    }
  }
}

Verifikation

Prüfe zuerst, welche Modelle der Dienst kennt:

$ curl -s http://127.0.0.1:11434/api/tags | jq -r '.models[].name'
qwen2.5-coder:1.5b-base
qwen2.5-coder:7b

Danach kontrollierst du, ob die Modelle tatsächlich auf der GPU rechnen. Die Spalte PROCESSOR ist der entscheidende Wert:

$ ollama ps
NAME                       ID           SIZE     PROCESSOR    UNTIL
qwen2.5-coder:7b           2b0496514337 6.0 GB   100% GPU     29 minutes from now
qwen2.5-coder:1.5b-base    d7387fd6a2ed 2.1 GB   100% GPU     29 minutes from now

Zuletzt testest du Fill-in-the-Middle direkt gegen die API. Der Parameter suffix liefert dem Modell den Code nach der Einfügestelle, genau wie das Plugin es tut:

$ curl -s http://127.0.0.1:11434/api/generate -d '{"model":"qwen2.5-coder:1.5b-base","prompt":"def fib(n):","suffix":"    return result","stream":false,"options":{"num_predict":48}}' | jq -r .response

Die Antwort muss reiner Python-Code sein. Erscheint Prosa oder ein Markdown-Codeblock, steckt ein Instruct-Modell im Autocomplete-Slot.

Troubleshooting

• Autocomplete liefert Erklärungstext statt Code. Im autocomplete-Slot steht ein Instruct-Modell. Wechsle auf ein Tag mit -base und starte die IDE neu.
• ollama ps zeigt 100% CPU oder eine gemischte Aufteilung. Das Modell passt nicht in den VRAM. Wähle eine kleinere Variante, senke OLLAMA_CONTEXT_LENGTH oder entlade konkurrierende Modelle mit ollama stop <modell>.
• connection refused auf Port 11434. Der Dienst hört auf einer anderen Adresse oder der Tunnel steht nicht. Prüfe mit sudo ss -tlnp | grep 11434 und kontrolliere das Override mit systemctl show ollama --property=Environment.
• Erste Vervollständigung nach jeder Pause dauert Sekunden. OLLAMA_KEEP_ALIVE ist zu kurz. 30 Minuten halten das kleine Modell dauerhaft geladen und kosten nur wenige GB VRAM.

Fazit

Mit zwei Modellen, einem Base-Modell für Autocomplete und einem Instruct-Modell für Chat, bekommst du eine Code-Assistenz, die den Quellcode nicht verlässt. Halte ollama ps im Blick: sobald ein Modell auf die CPU ausweicht, sinkt die Antwortzeit so stark, dass Inline-Vorschläge unbrauchbar werden. Als nächster Schritt lohnt sich die Codebase-Indizierung in Continue über ein Embedding-Modell, damit Fragen den gesamten Projektkontext einbeziehen.

Weiterlesen

• Die Ollama-API aus eigenen Anwendungen ansprechen
• Ollama auf Ubuntu 24.04 installieren und als Dienst betreiben
• Ollama im Docker-Container betreiben
• Ollama im Netzwerk freigeben: Port, Bind-Adresse und Absicherung
• Ollama, LM Studio oder llama.cpp: Welches Werkzeug wofür?
• Ollama mit MCP-Servern verbinden: Werkzeuge für lokale Modelle
• Ollama-Modelle verwalten: aktualisieren, aufräumen, Speicher sparen
• Open WebUI als Oberfläche für Ollama einrichten
• Was ist Ollama? Funktionsweise, Modelle und Einsatzgebiete