Lokal und Kostenlos: Dein Eigener KI-Code-Assistent mit Ollama

Servus, liebe smoth.me-Community! Als alter Hase im Homelab und auf diversen Linux-Kisten habe ich in den letzten Jahren so ziemlich jeden Trend mitgemacht. Und was soll ich sagen? KI ist definitiv mehr als nur ein Trend – sie ist ein Game Changer, besonders wenn es ums Coden geht. Aber mal ehrlich, die monatlichen Kosten für Dienste wie "Claude Code" oder andere kommerzielle KI-Assistenten können ganz schön ins Geld gehen. 200 Euro im Monat? Puh, das ist selbst für mein Hobbybudget oft zu viel des Guten. Ich dachte mir, das muss doch auch anders gehen, lokal und vor allem: kostenlos!

Genau das habe ich mir vorgenommen, und ich teile heute meine Erfahrungen mit dir, wie du dir deinen eigenen, lokalen KI-Code-Assistenten einrichtest. Stell dir vor, du hast die Power eines intelligenten Helfers direkt auf deiner Maschine, ohne Cloud-Abhängigkeiten oder wiederkehrende Kosten. Klingt gut, oder? Lass uns das angehen!

Mein Ziel war es, eine Lösung zu finden, die performant genug ist, um im Alltag wirklich nützlich zu sein, aber gleichzeitig die Hardware in meinem Homelab nicht überfordert. Nach einigem Herumprobieren bin ich bei Ollama gelandet, kombiniert mit einem passenden Open-Source-Modell und meiner Lieblings-IDE, VS Code. Das Ergebnis hat mich wirklich überzeugt. Du wirst sehen, es ist einfacher, als du vielleicht denkst.

Voraussetzungen: Was du brauchst

Bevor wir loslegen, lass uns kurz checken, ob du alles am Start hast. In meiner Erfahrung ist eine gute Vorbereitung die halbe Miete und erspart dir später eine Menge Kopfschmerzen. Glaub mir, ich hab schon oft genug Lehrgeld bezahlt, weil ich zu ungeduldig war.

Hardware-Anforderungen

Prozessor (CPU): Ein moderner Mehrkernprozessor ist Pflicht. Je mehr Kerne und je höher der Takt, desto besser. Modelle wie codellama können auch CPU-only laufen, aber das wird dann schnell zäh.
Arbeitsspeicher (RAM): Hier gilt: Viel hilft viel! Für kleinere Modelle (z.B. 7B-Parameter) solltest du mindestens 8 GB RAM zur Verfügung haben. Wenn du größere Modelle (13B oder mehr) nutzen willst oder generell eine flüssigere Erfahrung möchtest, sind 16 GB oder sogar 32 GB RAM deutlich besser. Das Modell muss ja irgendwie in den Speicher passen.
Speicherplatz (SSD): Eine schnelle SSD ist essenziell. Die Modelle sind nicht klein (mehrere GB pro Modell), und du willst ja nicht ewig warten, bis sie geladen sind. Rechne mit mindestens 10-20 GB freiem Speicherplatz für Ollama und ein paar Modelle.
Grafikkarte (GPU) - Optional, aber dringend empfohlen: Wenn du eine NVIDIA-Grafikkarte mit CUDA-Unterstützung hast (GTX 10-Serie oder neuer, RTX-Serie), nutze sie! Das beschleunigt die Inferenz massiv. Für AMD-Karten gibt es ROCm, aber die Unterstützung ist oft noch etwas hakeliger. Ich persönlich setze auf NVIDIA, da ist die Kompatibilität am besten. Ohne GPU läuft es, aber es ist wie mit dem Fahrrad bergauf fahren, statt einen E-Scooter zu nehmen.

Software-Anforderungen

Betriebssystem: Ein aktuelles Linux-System (z.B. Ubuntu 22.04 LTS oder Debian 11/12) ist ideal. Ollama unterstützt auch macOS und Windows (via WSL2), aber ich persönlich bin auf Linux am liebsten unterwegs.
Terminal/SSH-Zugang: Klar, du bist Admin, das ist gesetzt.
curl: Für die Installation von Ollama. Sollte eigentlich auf jedem System vorhanden sein.
VS Code: Das ist unsere Entwicklungsumgebung der Wahl. Du kannst natürlich auch andere IDEs nutzen, aber die Integration ist hier am einfachsten.

Schritt-für-Schritt-Anleitung: Dein lokaler KI-Code-Assistent

Jetzt wird's ernst! Wir richten das System ein, als gäbe es kein Morgen. Folge den Schritten genau, und du wirst bald deinen eigenen KI-Helfer haben.

Schritt 1: Ollama installieren

Ollama ist das Herzstück unserer Lösung. Es ist ein großartiges Tool, das es super einfach macht, große Sprachmodelle (LLMs) lokal auszuführen. Die Installation ist kinderleicht:

Öffne ein Terminal auf deinem Linux-System und führe den folgenden Befehl aus:

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

Dieser Befehl lädt ein Installationsskript herunter und führt es aus. Es kümmert sich um die Installation des Ollama-Dienstes und richtet ihn so ein, dass er automatisch startet. Das hat mir schon viel Zeit gespart, weil ich mich nicht um Systemd-Units kümmern musste.

Nach der Installation kannst du überprüfen, ob Ollama läuft:

ollama --version

Du solltest eine Ausgabe ähnlich wie ollama version is 0.1.32 (oder neuer) sehen. Wenn das klappt, sind wir auf dem richtigen Weg!

Schritt 2: Dein erstes Coding-Modell herunterladen

Ollama ist installiert, jetzt brauchen wir ein Modell, das uns beim Coden helfen kann. Es gibt viele Modelle, aber für Code-Aufgaben hat sich Code Llama als sehr fähig erwiesen. Ich empfehle, mit einer der kleineren Varianten zu starten, um die Performance auf deiner Hardware zu testen. Die 7B-Parameter-Modelle sind ein guter Kompromiss zwischen Leistung und Ressourcenverbrauch.

Wir laden das codellama-Modell herunter. Es gibt verschiedene Varianten (z.B. codellama:7b, codellama:13b, codellama:34b und auch -instruct oder -python Varianten). Für den Anfang empfehle ich codellama:7b-instruct, da es speziell für Anweisungen optimiert ist und nicht zu viel RAM frisst.

ollama pull codellama:7b-instruct

Der Download kann je nach Internetgeschwindigkeit und Modellgröße eine Weile dauern. Sei geduldig! Das Modell ist immerhin mehrere Gigabyte groß. Währenddessen kannst du dir schon mal einen Kaffee machen.

Sobald der Download abgeschlossen ist, kannst du eine Liste deiner installierten Modelle anzeigen lassen:

ollama list

Du solltest codellama:7b-instruct in der Liste sehen. Perfekt!

Schritt 3: VS Code und die "Continue"-Erweiterung installieren

Jetzt bringen wir die KI in deine Entwicklungsumgebung. Ich nutze dafür VS Code und die Erweiterung "Continue". Es gibt auch andere, wie "CodeGPT", aber "Continue" bietet eine nahtlose Integration und ist extrem flexibel, was lokale Modelle angeht.

VS Code installieren: Falls du es noch nicht hast, lade VS Code von der offiziellen Webseite herunter und installiere es.
"Continue" Erweiterung installieren:
- Öffne VS Code.
- Gehe zum Extensions-Tab (Strg+Shift+X oder Cmd+Shift+X).
- Suche nach "Continue" (von Continue).
- Klicke auf "Installieren".

Schritt 4: "Continue" mit Ollama konfigurieren

Nachdem "Continue" installiert ist, müssen wir es noch sagen, dass es Ollama nutzen soll. Das geht ganz einfach über die Einstellungen der Erweiterung.

"Continue" Side Panel öffnen: Klicke auf das Continue-Icon in der linken Seitenleiste von VS Code (sieht aus wie ein Pfeil, der einen Kreis bildet).
Einstellungen öffnen: Im Continue-Panel klicke auf das Zahnrad-Symbol (Settings).
Konfiguration anpassen: Du wirst eine config.json (oder ~/.continue/config.json) sehen oder erstellen müssen. Hier trägst du ein, welche Modelle und Provider du nutzen möchtest.

Hier ist ein Beispiel, wie deine config.json aussehen könnte. Achte darauf, dass du den korrekten Modellnamen verwendest, den du in Schritt 2 heruntergeladen hast (z.B. codellama:7b-instruct):

{
  "models": [
    {
      "name": "codellama",
      "provider": "ollama",
      "model": "codellama:7b-instruct",
      "temperature": 0.5
    }
  ],
  "defaultModel": "codellama",
  "completionOptions": {
    "temperature": 0.5,
    "maxTokens": 1000
  },
  "tabAutocompleteModel": {
    "name": "codellama",
    "provider": "ollama",
    "model": "codellama:7b-instruct",
    "temperature": 0.2
  },
  "slashCommands": [
    {
      "name": "/edit",
      "description": "Edits the currently open file with instructions",
      "prompt": "{{ selectedText }}",
      "model": "codellama"
    },
    {
      "name": "/explain",
      "description": "Explains the selected code",
      "prompt": "Explain the following code:\n```{{ selectedText }}```",
      "model": "codellama"
    }
  ]
}

Wichtige Hinweise zur Konfiguration:

"name": "codellama": Das ist der interne Name, den du in Continue verwenden wirst.
"provider": "ollama": Sagt Continue, dass es Ollama als Backend nutzen soll.
"model": "codellama:7b-instruct": Hier gibst du den genauen Namen des Modells an, das du mit ollama pull heruntergeladen hast.
"temperature": Dieser Wert steuert die "Kreativität" des Modells. Niedrigere Werte (z.B. 0.2) machen die Antworten vorhersehbarer und präziser, höhere Werte (z.B. 0.8) experimenteller. Für Code würde ich meistens niedrigere Werte empfehlen.
"slashCommands": Das ist super praktisch! Du kannst eigene Befehle definieren, um schnell bestimmte Aktionen auszuführen (z.B. Code erklären oder refaktorieren). Probier das unbedingt aus!

Speichere die config.json ab. "Continue" sollte die Änderungen automatisch erkennen.

Schritt 5: Erster Testlauf und Produktivitätsschub

Jetzt kommt der spannende Teil: Wir testen unseren neuen KI-Kollegen! Öffne eine Code-Datei in VS Code.

Du kannst "Continue" auf verschiedene Arten nutzen:

Im Chat-Fenster: Klicke auf das Continue-Icon in der Seitenleiste. Dort kannst du direkt mit dem Modell chatten und Anweisungen geben.
Inline-Vorschläge: Tippe in deiner Code-Datei los. "Continue" kann versuchen, Code-Vervollständigungen oder Vorschläge zu machen.
Ausgewählten Code bearbeiten: Markiere einen Code-Abschnitt, den du ändern oder erklären lassen möchtest. Klicke dann mit der rechten Maustaste und wähle "Continue: Edit" oder nutze einen der definierten Slash-Befehle (z.B. /explain im Chat-Fenster und referenziere den Code).

Mein Tipp: Starte mit einfachen Aufgaben. Lass dir eine kleine Funktion in Python schreiben, die zwei Zahlen addiert, oder frage nach einer Erklärung für einen regulären Ausdruck. So bekommst du ein Gefühl für die Fähigkeiten des Modells und die Interaktion mit "Continue".

Ein Beispiel im Chat-Panel:

/edit
Generate a Python function that calculates the nth Fibonacci number using recursion.

Oder du markierst eine Funktion und fragst im Chat:

/explain
Explain the selected code.

Das hat mir schon unzählige Male geholfen, komplexe Funktionen schnell zu verstehen oder Boilerplate-Code zu generieren.

Häufige Fehler und Lösungen

Wie bei jeder neuen Einrichtung können Stolpersteine auftreten. Hier sind ein paar, die mir in meiner Homelab-Karriere begegnet sind, und wie du sie behebst:

Problem 1: Ollama-Dienst läuft nicht oder ist nicht erreichbar

Manchmal startet der Ollama-Dienst nicht richtig oder ist aus irgendeinem Grund nicht erreichbar.

Symptom: VS Code Extension kann keine Verbindung herstellen, oder ollama list gibt einen Fehler aus.
Lösung:
1. Dienststatus prüfen: Überprüfe den Status des Ollama-Dienstes:
```
sudo systemctl status ollama
```
  Wenn er nicht läuft, starte ihn neu:
```
sudo systemctl start ollama
```
2. Port prüfen: Standardmäßig läuft Ollama auf Port 11434. Stelle sicher, dass dieser Port nicht von einer anderen Anwendung belegt ist oder durch eine Firewall blockiert wird.
```
netstat -tulpen | grep 11434
```
  Wenn etwas anderes diesen Port belegt, musst du entweder die andere Anwendung stoppen oder Ollama auf einem anderen Port konfigurieren (was etwas aufwendiger ist und selten nötig).

Problem 2: Modell kann nicht heruntergeladen werden oder wird nicht gefunden

Gerade bei großen Modellen kann der Download mal abbrechen oder das Modell wird nicht richtig erkannt.

Symptom: ollama pull codellama:7b-instruct bricht ab, oder "Continue" kann das Modell nicht laden.
Lösung:
1. Speicherplatz prüfen: Stelle sicher, dass du genügend freien Speicherplatz hast. Ein abgebrochener Download kann trotzdem temporäre Dateien hinterlassen.
```
df -h /
```
2. Erneut versuchen: Manchmal hilft es einfach, den ollama pull Befehl erneut auszuführen. Ollama kann oft an der Stelle weitermachen, wo der Download abgebrochen ist.
3. Modellname prüfen: Überprüfe die Schreibweise des Modellnamens in der config.json von "Continue" und stelle sicher, dass sie exakt mit dem Namen übereinstimmt, den du mit ollama list siehst. Groß- und Kleinschreibung sind wichtig!

Problem 3: Schlechte Performance oder "Out of Memory" Fehler

Wenn die KI extrem langsam ist oder du Fehlermeldungen bezüglich des Speichers bekommst, ist das meist ein Ressourcenproblem.

Symptom: Antworten dauern ewig, System wird langsam, Fehlermeldungen wie "Out of memory".
Lösung:
1. Kleineres Modell nutzen: Wenn du ein großes Modell (z.B. codellama:13b oder 34b) verwendest und nicht genügend RAM oder eine potente GPU hast, wechsle zu einer kleineren Variante (z.B. codellama:7b-instruct). Das ist oft der größte Hebel.
2. RAM prüfen: Überwache deinen Arbeitsspeicher während der Nutzung:
```
free -h
```
  Wenn der RAM voll ist, liegt es daran.
3. GPU-Nutzung prüfen (NVIDIA): Wenn du eine NVIDIA-GPU hast, schau, ob sie auch wirklich genutzt wird:
```
watch -n 0.5 nvidia-smi
```
  Du solltest eine Auslastung sehen, wenn das Modell inferiert. Wenn nicht, überprüfe deine Treiberinstallation und die Ollama-Installation (Ollama sollte GPU-Unterstützung automatisch erkennen und aktivieren, wenn die Treiber korrekt sind).
4. Swap-Space prüfen: Ein ausreichend großer Swap-Space kann bei knappem RAM helfen, aber es wird die Performance stark beeinträchtigen. Es ist eher eine Notlösung als eine echte Lösung für Performance.

Fazit und Nächste Schritte

Da haben wir es! Du hast jetzt deinen eigenen, lokalen KI-Code-Assistenten am Laufen. Das ist nicht nur eine enorme Ersparnis gegenüber den teuren Cloud-Diensten, sondern gibt dir auch die volle Kontrolle über deine Daten und deine Entwicklungsumgebung. In meiner Erfahrung ist das ein unglaublich befreiendes Gefühl, zu wissen, dass mein Code und meine Prompts nicht irgendwo in der Cloud landen.

Was kannst du als Nächstes tun?

Experimentiere mit anderen Modellen: Ollama bietet eine breite Palette an Modellen. Probiere mal andere Code-Modelle oder auch allgemeine Sprachmodelle aus, um zu sehen, welche am besten zu deinen Bedürfnissen passen. Schau einfach mal auf der Ollama-Webseite vorbei oder nutze ollama run <modellname> um Modelle direkt auszuprobieren.
Verfeinere deine Prompts: Die Qualität der Antworten hängt stark von der Qualität deiner Prompts ab. Übe, präzise und klare Anweisungen zu geben.
Erkunde weitere "Continue"-Features: Die Erweiterung kann noch viel mehr! Schau dir die Dokumentation an, um das volle Potenzial auszuschöpfen.
Hardware-Upgrade: Wenn du von der Performance begeistert bist und mehr willst, könnte ein Upgrade auf eine bessere GPU oder mehr RAM der nächste logische Schritt für dein Homelab sein.

Ich hoffe, dieser Guide hilft dir dabei, deine Produktivität zu steigern und gleichzeitig dein Budget zu schonen. Viel Spaß beim Coden mit deinem neuen KI-Assistenten!