Zum Inhalt
KI-BlogBriefing zu künstlicher Intelligenz

Lokale KI

Programmieren mit lokalen Modellen

Kurzantwort

Zum Programmieren mit lokaler KI lädst du ein Code-Modell wie Qwen3-Coder oder Qwen2.5-Coder über Ollama und bindest es mit der Erweiterung Continue oder dem Chat von VS Code ein⁠123. Qwen3-Coder mit 30 Milliarden Parametern belegt 19 GB und passt auf eine Grafikkarte mit 24 GB⁠3. Dein Code verlässt dann den Rechner nicht, die Vorschläge sind aber schwächer als bei großen Cloud-Modellen.

Autor
Veröffentlicht
Geprüft
Lesezeit
7 Minuten
Zugeklappter silberner Laptop auf einem Eichentisch neben einem kleinen schwarzen Server, in dem ein blaues Netzwerkkabel steckt
Mit lokalen Modellen bleibt dein Code auf dem eigenen Rechner. Bild: KI-generiert

Wer Firmencode oder private Projekte nicht an einen Cloud-Dienst schicken will, kann ein Sprachmodell für Code auf dem eigenen Rechner laufen lassen. Dafür brauchst du drei Bausteine: ein Programm, das das Modell ausführt, etwa Ollama, ein passendes Code-Modell und eine Verbindung in deinen Editor⁠1. In VS Code gibt es zwei Wege, die Erweiterung Continue und die eingebaute Verwaltung von Sprachmodellen im Chat⁠12. Beide funktionieren ohne Abo, und im Chat von VS Code laufen lokale Modelle sogar ohne GitHub-Konto und ohne Internetverbindung⁠2.

Gegenüber den Cloud-Werkzeugen zum Programmieren wie Copilot, Cursor oder Claude Code entfällt damit das Abo, dafür rechnet deine eigene Grafikkarte.

Welche Code-Modelle lokal laufen

In der Bibliothek von Ollama stehen mehrere Modelle, die auf Programmieren ausgerichtet sind. Drei Familien eignen sich für den Einstieg:

  • Qwen2.5-Coder gibt es in sechs Größen von 0,5 bis 32 Milliarden Parametern. Die Dateien sind zwischen rund 0,4 und 20 GB groß, alle mit einem Kontextfenster von 32.000 Token⁠5.
  • Qwen3-Coder mit 30 Milliarden Parametern belegt als Download 19 GB und verarbeitet laut Ollama 256.000 Token Kontext⁠3. Nach der Modellkarte hat es 30,5 Milliarden Parameter, von denen je Token nur 3,3 Milliarden aktiv sind; es ist ein Modell nach dem Prinzip Mixture of Experts mit 128 Experten, von denen acht gleichzeitig arbeiten⁠4. Die Lizenz ist Apache 2.0⁠4.
  • Devstral Small 2 hat 24 Milliarden Parameter, belegt 15 GB und ist als Agent für Softwareaufgaben gedacht, die mehrere Dateien betreffen⁠6. Ollama nennt 65,8 Prozent im Test SWE-bench Verified und die Lizenz Apache 2.0⁠6.

Qwen3-Coder ist laut Modellkarte auf das Arbeiten mit Werkzeugen und auf das Verständnis ganzer Repositories ausgelegt und denkt nicht in einem sichtbaren Zwischenschritt vor der Antwort⁠4. Für reine Vorschläge beim Tippen reicht ein kleines Modell wie Qwen2.5-Coder mit 1,5 Milliarden Parametern, das die Anleitung von Continue genau dafür empfiehlt⁠1.

Was deine Grafikkarte schaffen muss

Ein Modell läuft am schnellsten, wenn es vollständig in den Grafikspeicher passt. Als grobe Regel gilt: Die Größe der Modelldatei plus einige Gigabyte für den Kontext müssen in den VRAM passen. Die Dateien in der Ollama-Bibliothek sind bereits quantisiert, ihre Zahlen also mit weniger Stellen gespeichert, damit sie weniger Speicher belegen.

Daraus ergibt sich für die beiden Karten unseres Testrechners folgende Einordnung⁠3567:

  • Mit einer RTX 4090 und 24 GB passt Qwen3-Coder mit 19 GB, es bleibt aber wenig Platz für langen Kontext. Qwen2.5-Coder mit 32 Milliarden Parametern und 20 GB ist ähnlich knapp⁠35.
  • Mit einer RTX 5060 Ti und 16 GB passt Devstral Small 2 mit 15 GB nur knapp. Bequemer läuft dort Qwen2.5-Coder mit 14 Milliarden Parametern und 9 GB⁠56.
  • Mit 8 GB Grafikspeicher bleiben die kleinen Fassungen von Qwen2.5-Coder bis 7 Milliarden Parameter, die 4,7 GB belegen⁠5.

Continue nennt als Richtwert für den Arbeitsspeicher rund 4 GB für Modelle mit 1,5 bis 3 Milliarden Parametern, 8 GB für 7 Milliarden, 16 GB für 13 Milliarden und 32 GB für 32 Milliarden, dazu mindestens 10 GB freien Speicherplatz⁠1. Passt ein Modell nicht vollständig auf die Karte, lagert Ollama Teile in den Arbeitsspeicher aus, und das Tempo sinkt deutlich. Bevor du für ein größeres Modell eine neue Grafikkarte für KI kaufst, schätz den Bedarf mit Modell und Kontextlänge im VRAM-Rechner.

Eine große Grafikkarte mit drei Lüftern und eine kleinere mit zwei Lüftern, seitlich fotografiert auf einer grauen Unterlage
Der Grafikspeicher entscheidet, welches Code-Modell passt. Bild: KI-generiert

Einrichtung mit Ollama und Continue

Die Erweiterung Continue für VS Code verbindet Chat, Bearbeitung und Vorschläge beim Tippen mit Modellen deiner Wahl. Ihre Anleitung beschreibt die Einrichtung mit Ollama so⁠1:

  1. Installiere Ollama und starte den Dienst.
  2. Lade die Modelle mit "ollama pull", zum Beispiel "ollama pull qwen2.5-coder:1.5b" für die Vorschläge und ein größeres Modell für den Chat. Den Befehl "ollama run" brauchst du dafür nicht, er öffnet nur einen Chat im Terminal.
  3. Installiere die Erweiterung Continue in VS Code.
  4. Trag die Modelle in die Konfigurationsdatei config.yaml ein. Jeder Eintrag bekommt einen Namen, den Anbieter "ollama", den Modellnamen und eine Rolle wie chat, edit oder autocomplete.
  5. Prüf mit "ollama list", ob der Modellname in der Konfiguration genau mit dem geladenen Modell übereinstimmt. Schon ein abweichender Zusatz hinter dem Doppelpunkt verhindert die Verbindung.

Für den Agentenmodus von Continue muss das Modell Werkzeugaufrufe unterstützen. Continue nennt Llama 3.1 und Mistral als Modelle, bei denen das bestätigt ist; DeepSeek R1 mit 32 Milliarden Parametern denkt gründlicher, kommt mit Werkzeugen aber nicht zuverlässig zurecht⁠1. Mit "ollama ps" siehst du jederzeit, welches Modell geladen ist und wie viel Speicher es belegt⁠1.

Ohne Erweiterung: lokale Modelle im Chat von VS Code

VS Code kann lokale Modelle auch direkt im eigenen Chat nutzen. Dazu installierst du die offizielle Ollama-Erweiterung aus dem Marketplace und fügst das Modell über den Befehl "Chat: Manage Language Models" hinzu; der früher eingebaute Ollama-Anbieter gilt als veraltet⁠2. Lokale Modelle funktionieren dort laut Microsoft ohne GitHub-Konto, ohne Copilot-Abo und ohne Internetverbindung⁠2.

Zwei Einschränkungen nennt die Dokumentation. Die Vorschläge beim Tippen lassen sich derzeit nicht mit einem lokalen Modell verbinden, sie kommen weiter von Copilot⁠2. Und einige Funktionen wie die semantische Suche brauchen weiterhin ein GitHub-Konto und eine Verbindung⁠2. Damit ein lokales Modell im Agentenmodus erscheint, muss es Werkzeugaufrufe beherrschen⁠2. In Copilot Business und Enterprise muss der Administrator die Nutzung eigener Modelle erst freigeben⁠2. Wer auch beim Tippen nur lokale Vorschläge möchte, nimmt deshalb Continue.

Erste Aufgaben für das lokale Modell

Ein lokales Modell kennt dein Projekt nur so weit, wie du es ihm zeigst. Gib ihm deshalb kleine, klar abgegrenzte Aufgaben mit dem nötigen Code im Kontext. Gut geeignet für den Anfang sind:

  • eine markierte Funktion erklären lassen und nach Randfällen fragen, die sie nicht abdeckt,
  • zu einer bestehenden Funktion Tests schreiben lassen und diese selbst ausführen,
  • eine Fehlermeldung samt der betroffenen Datei übergeben und nach der Ursache fragen,
  • Kommentare und Dokumentation für eine Datei ergänzen lassen.

Bei großen Umbauten über viele Dateien stoßen lokale Modelle schneller an Grenzen, weil der Kontext begrenzt ist und das Modell weniger Überblick hat. Teile solche Aufgaben in Schritte auf und prüf nach jedem Schritt, ob der Code noch läuft. Eine Versionsverwaltung wie Git hilft, misslungene Vorschläge schnell zurückzunehmen. Du kannst das Modell auch zuerst einen Test für die Funktion schreiben lassen und erst danach die Funktion selbst; schlägt der Test fehl, siehst du sofort, welcher Schritt danebenging.

Grenzen gegenüber Cloud-Modellen

Lokale Code-Modelle sind kleiner als die großen Modelle der Cloud-Anbieter. Das merkst du vor allem bei Aufgaben, die viel Überblick verlangen, etwa beim Umbau über viele Dateien oder bei schwer zu findenden Fehlern. Für Erklärungen, kurze Funktionen, Tests und Vorschläge beim Tippen reichen sie nach unserer Einschätzung oft aus. Für anspruchsvolle Agentenarbeit sehen wir sie eher als Ergänzung zu einem Cloud-Werkzeug.

Auch der Kontext ist auf der Karte kürzer, als die Modellkarte angibt. Das ist unsere Rechnung aus Dateigröße und Speicher und keine Messung: Ein langes Kontextfenster braucht zusätzlichen Grafikspeicher für den KV-Cache, und bei einem Modell mit 19 GB bleibt auf einer Karte mit 24 GB davon nur wenig übrig. Qwen3-Coder ließe sich laut Modellkarte zwar bis eine Million Token erweitern, auf einem Heimrechner bleibt das Theorie⁠4.

Der größte Vorteil bleibt der Datenschutz. Ollama und das Modell laufen auf deinem Rechner. Für Code mit Kundendaten, Zugangsdaten oder Geschäftsgeheimnissen ist das ein starkes Argument, und ein Betrieb kann dieselbe Technik als lokale KI im Unternehmen allen Beschäftigten bereitstellen.

Drei flache Flusssteine abnehmender Größe aufeinandergestapelt auf hellem Leinen
Lokale Modelle sind kleiner als die großen Modelle der Cloud. Bild: KI-generiert

Unser Messaufbau

Unser Testrechner hat einen AMD Ryzen 9 7950X3D, 128 GB Arbeitsspeicher, eine RTX 4090 mit 24 GB und eine RTX 5060 Ti mit 16 GB⁠7. Geplant ist eine Messung eines Code-Modells auf der RTX 4090 mit zwei Werten: Token je Sekunde bei der Ausgabe und die Zahl gelöster Aufgaben aus einem festen Satz von zehn Programmieraufgaben. Diese Messung steht noch aus; die Ergebnisse tragen wir hier nach.

Zur Einordnung des Tempos gibt es bisher nur eine Probemessung mit einem kleinen Allzweckmodell: Llama 3.2 mit drei Milliarden Parametern in Q4_K_M lieferte unter Ollama auf der RTX 4090 im Median 282,6 Token pro Sekunde, auf der RTX 5060 Ti 160,9⁠7. Ein Code-Modell mit 30 Milliarden Parametern dürfte deutlich langsamer sein, auch wenn bei Qwen3-Coder je Token nur ein Bruchteil der Parameter rechnet⁠4. Die volle Messreihe mit größeren Modellen erscheint im Praxistest RTX 4090.

Was das für dich heißt

Mit einer Grafikkarte ab 16 GB kannst du lokal programmieren, für schwere Aufgaben bleibt die Cloud stärker.

  1. Sieh nach, wie viel Grafikspeicher deine Karte hat, und wähle danach die Modellgröße.
  2. Nutze ein kleines Modell für Vorschläge beim Tippen und ein größeres für den Chat.
  3. Prüf mit "ollama list", ob die Namen in der Konfiguration genau stimmen.
  4. Vergleiche zwei Modelle an Aufgaben, die in deinem Alltag wirklich vorkommen.

Häufige Fragen

Welche lokale KI ist die beste zum Programmieren?

Eine feste Bestenliste geben wir nicht. Mit 24 GB Grafikspeicher ist Qwen3-Coder mit 30 Milliarden Parametern ein guter Startpunkt, mit 16 GB Qwen2.5-Coder mit 14 Milliarden⁠35. Probier zwei Modelle an deinen eigenen Aufgaben aus.

Kann ich lokale Modelle mit GitHub Copilot nutzen?

Im Chat von VS Code ja, über die Ollama-Erweiterung und ohne Copilot-Abo⁠2. Die Vorschläge beim Tippen kommen aber weiter von Copilot⁠2.

Wie viel Grafikspeicher brauche ich für ein Code-Modell?

Die Modelldatei plus einige Gigabyte für den Kontext. Qwen3-Coder braucht 19 GB, Qwen2.5-Coder mit 7 Milliarden Parametern 4,7 GB⁠35.

Läuft das auch ohne Internet?

Ja, sobald die Modelle geladen sind. Lokale Modelle im Chat von VS Code arbeiten laut Microsoft ohne Internetverbindung⁠2.

Quellen

Stand:

  1. Continue: Using Ollama with Continue, abgerufen am 22.11.2026. zurück
  2. Visual Studio Code: AI language models in VS Code, abgerufen am 22.11.2026. zurück
  3. Ollama: qwen3-coder, abgerufen am 22.11.2026. zurück
  4. Qwen auf Hugging Face: Model card Qwen3-Coder-30B-A3B-Instruct, abgerufen am 22.11.2026. zurück
  5. Ollama: qwen2.5-coder, abgerufen am 22.11.2026. zurück
  6. Ollama: devstral-small-2, abgerufen am 22.11.2026. zurück
  7. Eigene Messung: Probemessung Llama 3.2 3B Q4_K_M mit Ollama 0.40.0 auf RTX 4090 und RTX 5060 Ti, Treiber 621.35, drei Läufe, Median; Testrechner Ryzen 9 7950X3D, 128 GB Arbeitsspeicher, Stand 22.11.2026, abgerufen am 22.11.2026. zurück

Weiterlesen

Bilder: KI-generiert

Aus dem Lexikon

Bilder: KI-generiert. Grafiken: KI-Blog