GitHub Copilot ersetzen: Ollama + Continue.dev

laptop_mac macOS Sonoma Intermediate schedule 8 min read

by Alex Rivera • May 14, 2024

Step 1 Die Kosten von Cloud-Autovervollständigung vs. lokaler KI

Jeder Tastendruck, den Sie in VS Code mit aktivem GitHub Copilot eingeben, wird an Microsofts Azure-gehostete OpenAI-Infrastruktur übertragen. Das ist keine Verschwörungstheorie — es ist die dokumentierte Produktarchitektur. Ihre proprietären Algorithmen, interne Geschäftslogik, unveröffentlichte Features und Architekturentscheidungen verlassen alle Ihren Rechner. Für einzelne Entwickler, die an Nebenprojekten arbeiten, ist dieser Kompromiss oft akzeptabel. Für Teams, die kommerziell sensible Software entwickeln, ist es ein materielles Sicherheits- und Compliance-Risiko.

Dann gibt es noch die finanzielle Dimension.

Die Preisrealität von GitHub Copilot

Für eine mittelgroße Entwicklungsorganisation mit 50 Entwicklern auf dem Business-Tier sprechen wir von $11.400 pro Jahr — auf unbegrenzte Zeit an einen externen Anbieter gezahlt, ohne Eigentumsrecht am zugrundeliegenden Modell oder Garantie auf Preisstabilität. Microsoft hat die Copilot-Preise seit dem Launch bereits nach oben korrigiert, und es gibt keinen strukturellen Grund, zu erwarten, dass sich dieser Trend umkehrt.

Was „Lokale KI" tatsächlich bedeutet

Das Ausführen eines lokalen Modells über Ollama verändert die Gleichung grundlegend. Die Rechenkosten sind Ihre bereits vorhandene Hardware. Das Datenschutzmodell ist absolut — keine Daten verlassen Ihren Rechner. Die Latenz ist oft geringer als bei cloudbasierten Vervollständigungen, da der Netzwerk-Roundtrip zu entfernten Inferenz-Servern entfällt.

Cloud Copilot flow:
Keypress → VS Code → HTTPS → Azure OpenAI → Inference → Response → VS Code

Local Ollama flow:
Keypress → VS Code → localhost:11434 → Inference → Response → VS Code

Der localhost-Inferenzpfad eliminiert eine ganze Kategorie von Fehlerquellen: API-Ausfälle, Rate-Limiting, Unternehmens-Proxy-Interferenzen und geografische Latenzschwankungen. Entwickler hinter strikten Unternehmens-Firewalls, die Copilot bisher gar nicht nutzen konnten, können nun ein vollständig leistungsfähiges Code-Modell betreiben, ohne den Netzwerkperimeter zu berühren.

Die versteckten Kosten der Cloud-Abhängigkeit

Über Lizenzgebühren hinaus führt Cloud-Autovervollständigung zu einer operativen Kopplung, die leicht unterschätzt wird:

• Vendor-Lock-in: Der Workflow Ihres Teams wird abhängig von einem Drittanbieterdienst mit einseitiger Kontrolle über Preisgestaltung, Verfügbarkeit und Nutzungsbedingungen.
• Compliance-Aufwand: Viele regulierte Branchen (Gesundheitswesen, Finanzen, Verteidigung) verlangen formelle Datenverarbeitungsvereinbarungen und Sicherheitsprüfungen für jedes Tool, das Code extern überträgt. Der Genehmigungsprozess für Copilot ist in diesen Umgebungen nicht trivial.
• Context-Window-Leckage: Cloud-Modelle erhalten nicht nur Ihre aktuelle Datei, sondern auch umgebende Kontextpuffer — benachbarte Dateien, kürzlich geöffnete Tabs und Repository-Metadaten je nach Konfiguration.
• Lücken im Audit-Trail: Wenn Code-Vorschläge aus einer externen Black Box stammen, wird die Zuordnung von IP-Herkunft in Rechtsstreitigkeiten oder Lizenzstreitigkeiten kompliziert.

Wo lokale Modelle heute wettbewerbsfähig sind

Moderne quantisierte Modelle wie Code Llama 13B und StarCoder2 7B, die auf Consumer-Hardware laufen, erreichen eine Vervollständigungsqualität, die für die häufigsten Autovervollständigungsszenarien genuine Konkurrenz zu Copilot darstellt: Boilerplate-Generierung, Funktionssignatur-Vervollständigung, Test-Scaffolding und gängige Algorithmus-Implementierungen. Die Lücke verengt sich weiter, wenn das Modell mit Code in Sprachen und Mustern arbeitet, auf die es spezifisch trainiert wurde.

Die Kalkulation ist eindeutig: null Grenzkosten, vollständige Datensouveränität und keine externen Abhängigkeiten versus eine wachsende SaaS-Rechnung und eine implizite Vereinbarung, Ihre Codebasis mit einem Cloud-Inferenz-Anbieter zu teilen. Für Teams, die ernsthaft an langfristiger Toolchain-Eigenverantwortung interessiert sind, ist der Local-First-Ansatz kein Kompromiss — er ist die architektonisch defensiblere Wahl.

Step 2 Voraussetzungen: VS Code und Ollama

Bevor wir in die Konfiguration eintauchen, müssen zwei grundlegende Komponenten verifiziert und gesichert sein. Das Überspringen einer ordnungsgemäßen Voraussetzungs-Validierung ist der bei weitem häufigste Grund, warum Entwickler stundenlang debuggen, was eigentlich ein unkompliziertes lokales KI-Setup sein sollte. Machen Sie diese richtig, und alles Nachfolgende wird mechanisch.

Visual Studio Code

Sie benötigen VS Code 1.80 oder neuer. Die Continue.dev-Extension ist auf moderne VS Code-APIs für Inline-Ghost-Text-Vervollständigungen angewiesen, und ältere Versionen werden stillschweigend scheitern oder ein degradiertes Verhalten produzieren.

Überprüfen Sie Ihre Version über die Kommandozeile:

code --version

Erwartete Ausgabe (Ihre kann neuer sein):

1.89.1
e170252f762678dec6ca2cc69aba1864a9a1f8ad
x64

Wenn Sie einen Fork wie VSCodium verwenden, ist Continue.dev vollständig kompatibel — stellen Sie nur sicher, dass Sie die Extension aus der Open VSX Registry und nicht aus dem Microsoft Marketplace beziehen, da VSCodium standardmäßig ohne Microsofts proprietären Extension-Host ausgeliefert wird.

Ollama

Ollama ist die lokale Modell-Laufzeitumgebung, die Model-Downloads, Quantisierungs-Management übernimmt und eine OpenAI-kompatible REST-API auf localhost:11434 bereitstellt. Diese Kompatibilitätsschicht ist genau der Grund, warum sich Continue.dev so sauber damit integriert — keine benutzerdefinierte Plugin-Architektur erforderlich.

Installation nach Plattform:

Starten Sie nach der Installation den Ollama-Daemon:

ollama serve

Unter macOS läuft Ollama nach der Installation automatisch als Menüleisten-Applikation. Unter Linux möchten Sie es möglicherweise als systemd-Dienst einrichten:

sudo systemctl enable ollama
sudo systemctl start ollama

Überprüfen Sie, ob die API aktiv ist:

curl http://localhost:11434/api/tags

Eine erfolgreiche Antwort gibt ein JSON-Objekt zurück, das Ihre lokal installierten Modelle auflistet. Eine leere Liste ist in diesem Stadium in Ordnung — Model-Downloads folgen in einem späteren Schritt.

{
  "models": []
}

Hardware-Überlegungen

Hier lassen Sie die meisten Anleitungen im Stich. Ihre Hardware bestimmt direkt, welche Modelle praktikabel sind und auf welchem Quantisierungsniveau.

Ollama lagert Layer automatisch auf Ihre GPU aus via Metal (Apple Silicon), CUDA (NVIDIA) oder ROCm (AMD). Keine manuelle Konfiguration erforderlich — Ollama erkennt Ihre Hardware und optimiert das Layer-Offloading transparent.

Kritischer Hinweis für Apple-Silicon-Nutzer: Unified Memory wird zwischen CPU und GPU geteilt. Ein MacBook Pro M3 mit 16 GB kann ein 13B-Modell komfortabel ausführen, da es keine diskrete VRAM-Obergrenze gibt. Dies ist eines der stärksten Argumente für Apple Silicon in lokalen KI-Workflows.

Bestätigung Ihrer Umgebung

Führen Sie diesen schnellen Plausibilitätscheck durch, bevor Sie fortfahren:

# Confirm VS Code version
code --version

# Confirm Ollama is running and responsive
curl -s http://localhost:11434/api/tags | python3 -m json.tool

# Confirm GPU acceleration (Ollama logs)
ollama run llama3.2:1b "say ok"

Beobachten Sie die Ollama-Terminal-Ausgabe während der Modell-Inferenz. Sie sollten Layer-Offload-Anzahlen sehen, die auf Ihre GPU verweisen. Wenn alles auf der CPU läuft, überprüfen Sie Ihre Treiber-Installation erneut, bevor Sie größere Code-Modelle herunterladen.

Mit beiden bestätigten Voraussetzungen sind Sie bereit, Continue.dev zu installieren und alles zu verbinden.

Step 3 Schritt 1: Installation der Continue.dev-Extension

Continue.dev ist der Grundpfeiler dieses gesamten Setups — ein Open-Source-KI-Code-Assistent, der als Drop-in-Ersatz für GitHub Copilot fungiert, aber mit einem entscheidenden architektonischen Unterschied: Er leitet Ihre Anfragen dorthin weiter, wo Sie es ihm sagen, einschließlich einer lokal laufenden Ollama-Instanz. Kein Telemetrie. Kein Cloud-Egress. Kein Abonnement.

Installation aus dem VS Code Marketplace

Der einfachste Installationsweg führt direkt im Editor über den VS Code Extension Marketplace:

1. Öffnen Sie VS Code
2. Drücken Sie Ctrl+Shift+X (Windows/Linux) oder Cmd+Shift+X (macOS), um das Extensions-Panel zu öffnen
3. Suchen Sie nach "Continue"
4. Lokalisieren Sie die von Continue veröffentlichte Extension (das Icon ist ein markantes lila Gradienten-Logo)
5. Klicken Sie auf Install

Alternativ installieren Sie es über die Kommandozeile mit der VS Code CLI:

code --install-extension Continue.continue

Oder wenn Sie VS Codium (den Telemetrie-freien Fork) verwenden, ist die Extension im Open VSX Registry verfügbar:

codium --install-extension Continue.continue

Hinweis: Continue.dev unterstützt auch JetBrains IDEs (IntelliJ, PyCharm, GoLand, etc.) über ein separates Plugin, aber dieser Leitfaden konzentriert sich ausschließlich auf die VS Code-Integration.

Überprüfung der Installation

Nach der Installation sollten Sie zwei sofortige Änderungen in Ihrer VS Code-Umgebung sehen:

Klicken Sie auf das Continue-Icon in der Activity Bar, um das Seitenpanel zu öffnen. Beim ersten Start präsentiert Continue einen Onboarding-Flow, der Sie auffordert, einen Anbieter zu verbinden. Sie können diesen überspringen oder schließen — wir verbinden Ollama manuell im nächsten Schritt durch direktes Bearbeiten von config.json, was uns weitaus mehr Kontrolle gibt als der GUI-Wizard.

Das Architekturverständnis der Extension

Bevor wir weitermachen, lohnt es sich zu verstehen, was Continue tatsächlich installiert und wie es kommuniziert:

VS Code Extension (Continue.dev)
        │
        ▼
  config.json  ──────────────────────────────────────────────────┐
        │                                                          │
        ▼                                                          ▼
  Chat Provider (LLM)                               Autocomplete Provider (LLM)
  e.g., Ollama → llama3                             e.g., Ollama → starcoder2
        │                                                          │
        └────────────────────────┬─────────────────────────────────┘
                                 │
                                 ▼
                    http://localhost:11434  (Ollama REST API)

Continue trennt Chat und Autovervollständigung in zwei unabhängig konfigurierbare Anbieter. Dies ist eine mächtige Unterscheidung — Sie können ein großes, instruktionsgesteuertes Modell wie llama3 oder deepseek-coder für konversationelle Anfragen betreiben, während Sie ein leichtgewichtiges Fill-in-the-Middle-Modell wie starcoder2:3b für latenzarme Inline-Vervollständigungen verwenden. Kein anderer gängiger Copilot-Ersatz bietet diese Granularität bei der Anbieter-Konfiguration.

Die config.json-Datei lokalisieren

Das gesamte Verhalten von Continue wird durch eine einzelne JSON-Datei gesteuert. Wissen Sie, wo sie sich befindet:

Sie können sie direkt aus VS Code über das Einstellungs-Zahnrad-Icon des Continue-Panels öffnen oder manuell im Terminal navigieren:

# macOS / Linux
cat ~/.continue/config.json

# Windows (PowerShell)
Get-Content "$env:USERPROFILE\.continue\config.json"

Mit der installierten Extension und der lokalisierten Konfigurationsdatei sind Sie bereit, Continue auf Ihre lokale Ollama-Instanz zu verweisen.

Step 4 Schritt 2: Konfiguration von config.json für Ollama

Sobald Continue.dev installiert ist, wird das gesamte Verhalten der Extension durch eine einzige Datei gesteuert: config.json. Hier verbinden Sie Continue mit Ihrer lokalen Ollama-Instanz, definieren, welche Modelle Chat versus Autovervollständigung übernehmen, und justieren Leistungsparameter. Diese Datei korrekt zu konfigurieren ist der Unterschied zwischen einem trägen, unzuverlässigen Setup und einem, das GitHub Copilot in der Reaktionsgeschwindigkeit rivaliert.

config.json lokalisieren

Continue speichert seine Konfiguration in Ihrem Home-Verzeichnis:

Sie können sie auch direkt aus VS Code über die Continue-Seitenleiste öffnen — klicken Sie auf das Zahnrad-Icon am unteren Ende des Continue-Panels, und es öffnet config.json im Editor.

Die minimale Ollama-Konfiguration

Nachfolgend ist eine produktionsreife Basis-config.json, die Continue mit einer lokal laufenden Ollama-Instanz für sowohl Chat als auch Tab-Autovervollständigung verbindet:

{
  "models": [
    {
      "title": "CodeLlama 13B (Chat)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (Autocomplete)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://localhost:11434"
  },
  "tabAutocompleteOptions": {
    "useCopyBuffer": false,
    "maxPromptTokens": 1024,
    "prefixPercentage": 0.85
  },
  "allowAnonymousTelemetry": false
}

Warum zwei separate Modelle? Chat-Modelle sind für Instruktions-Following und Multi-Turn-Dialog optimiert. Autovervollständigungs-Modelle — insbesondere jene, die mit Fill-in-the-Middle (FIM) trainiert wurden — sind spezifisch darauf abgestimmt, Code aus einem Prefix- und Suffix-Kontextfenster vorherzusagen. Beide zu vermischen verschlechtert beide Erfahrungen.

Aufschlüsselung jedes Feldes

models-Array — Dies definiert die im Continue-Chat-Panel verfügbaren Modelle. Sie können mehrere Einträge hinzufügen und zur Laufzeit zwischen ihnen wechseln. Jedes Objekt erfordert: - provider: auf "ollama" für lokale Inferenz setzen - model: den exakten Tag, wie er in ollama list erscheint - apiBase: Ollamas Standard-REST-Endpunkt; ändern Sie diesen nur, wenn Sie den Port umgemappt haben

tabAutocompleteModel — Ein dedizierter Eintrag für Inline-Autovervollständigung. Dieses Modell feuert bei jeder Tastenpause, daher gilt: kleiner und schneller ist hier besser. Ein 3B–7B-Parameter-Modell mit FIM-Unterstützung ist der Sweet Spot.

tabAutocompleteOptions — Feinkörnige Kontrolle über die Autovervollständigungs-Engine:

allowAnonymousTelemetry — Setzen Sie dies auf false. Sie betreiben lokale KI genau deshalb, um Ihren Code von Drittanbietern fernzuhalten; es gibt keinen Grund, Telemetrie an die Analyse-Pipeline von Continue zu senden.

Überprüfung der Verbindung

Nach dem Speichern von config.json bestätigen Sie, dass Ollama von Continue aus erreichbar ist, indem Sie die VS Code Command Palette (Cmd+Shift+P / Ctrl+Shift+P) öffnen und folgendes ausführen:

Continue: Open Debug Panel

Sie sollten einen grünen Status-Indikator und einen erfolgreichen Modell-Ping sehen. Wenn Sie einen connection refused-Fehler erhalten, überprüfen Sie, ob Ollama läuft mit:

ollama serve
# or check its status
curl http://localhost:11434/api/tags

Eine gültige JSON-Antwort, die Ihre heruntergeladenen Modelle auflistet, bestätigt, dass die API aktiv ist und Continue mit der Bereitstellung von Vervollständigungen fortfahren kann.

Step 5 Schritt 3: Code Llama oder StarCoder2 herunterladen

Mit installiertem Continue.dev und konfigurierter config.json ist die nächste kritische Entscheidung, welches Modell Sie tatsächlich auf Ihren Rechner herunterladen. Für lokale Code-Vervollständigung und Chat dominieren zwei Modelle die Diskussion: Code Llama (Meta) und StarCoder2 (BigCode/Hugging Face). Beide laufen ausgezeichnet über Ollama, haben aber bedeutsam unterschiedliche Stärken. Lassen Sie uns diese aufschlüsseln und dann die genauen Pull-Befehle durchgehen.

Modellvergleich auf einen Blick

Empfehlung: Wenn Sie 8 GB VRAM oder RAM verfügbar haben, beginnen Sie mit codellama:7b-code für eine ausgewogene Erfahrung. Wenn Sie sich rein auf Inline-Autovervollständigungs-Qualität und Mehrsprachenunterstützung konzentrieren, schlägt starcoder2:7b bei Fill-in-the-Middle (FIM)-Benchmarks häufig das Erstere.

Code Llama über Ollama beziehen

Ollama macht das Modell-Management trivial einfach. Öffnen Sie Ihr Terminal und führen Sie aus:

# Lightweight 7B instruct variant — best starting point
ollama pull codellama:7b-instruct

# 7B code-specialized variant — better raw completion, less chat
ollama pull codellama:7b-code

# If you have the hardware headroom (13B is noticeably sharper)
ollama pull codellama:13b-instruct

Die instruct-Variante versteht natürlichsprachliche Anweisungen und ist ideal für das Chat-Panel innerhalb von Continue.dev. Die code-Variante ist abgespeckt und rein für Vervollständigungs-Aufgaben optimiert — betrachten Sie sie als die „Autovervollständigungs-Engine"-Variante.

Nach dem Download überprüfen Sie, ob das Modell verfügbar ist:

ollama list

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

NAME                    ID              SIZE    MODIFIED
codellama:7b-instruct   8fdf8f752f6e    3.8 GB  2 minutes ago

StarCoder2 über Ollama beziehen

StarCoder2 wurde gezielt für Fill-in-the-Middle (FIM)-Aufgaben entwickelt — genau das, worauf IDE-Autovervollständigung angewiesen ist. Es wurde auf über 600 Programmiersprachen aus dem The Stack v2-Datensatz trainiert, was es außergewöhnlich breit aufgestellt macht.

# 3B — runs on nearly any modern machine, including CPU-only
ollama pull starcoder2:3b

# 7B — sweet spot for quality vs. resource usage
ollama pull starcoder2:7b

# 15B — requires ~10+ GB VRAM, but delivers near-Copilot quality
ollama pull starcoder2:15b

Testen Sie das Modell sofort in Ihrem Terminal, um zu bestätigen, dass es korrekt antwortet:

ollama run starcoder2:7b "Write a Python function to flatten a nested list."

Wenn Sie kohärente, syntaktisch korrekte Ausgabe erhalten, ist Ihr Modell bereit für Continue.dev.

Ein Hinweis zu Hardware-Einschränkungen

Lassen Sie sich von den größeren Parameteranzahlen nicht einschüchtern. Quantisierte Modelle (die Ollama standardmäßig herunterlädt — typischerweise Q4_K_M-Quantisierung) sind dramatisch kleiner als ihre theoretischen Größen. Ein 7B-Modell in Q4-Quantisierung läuft komfortabel auf:

• Apple-Silicon-Macs (M1/M2/M3) mit 16 GB Unified Memory — nahezu native GPU-Beschleunigung via Metal
• NVIDIA-GPUs mit 6–8 GB VRAM (RTX 3060, 4060, etc.)
• Nur-CPU-Rechnern mit 16+ GB RAM — langsamer, aber vollständig funktional für Chat; die Autovervollständigungs-Latenz wird spürbar sein

Wenn Sie CPU-gebunden sind, bevorzugen Sie dringend starcoder2:3b oder codellama:7b-code — ihr kleinerer Speicher-Footprint übersetzt sich direkt in schnellere Token-Generierung und eine reaktionsfähigere Autovervollständigungs-Erfahrung.

Sobald Ihr gewähltes Modell heruntergeladen und verifiziert ist, wird Continue.dev es automatisch über den Ollama-API-Endpunkt (http://localhost:11434) entdecken, den Sie in Schritt 2 konfiguriert haben — keine zusätzliche Verknüpfung erforderlich.

Step 6 Best Practices für lokale Autovervollständigung und Chat

Den Stack zum Laufen zu bringen ist nur die halbe Miete. Maximale Produktivität aus einem lokalen KI-Setup zu extrahieren erfordert bewusste Konfigurationsentscheidungen, disziplinierte Prompt-Gewohnheiten und ein klares Verständnis davon, wo lokale Modelle brillieren und wo sie Sie frustrieren werden.

Modellauswahl-Strategie

Nicht alle Modelle sind gleich, und das richtige Werkzeug hängt von der jeweiligen Aufgabe ab. Betreiben Sie separate Modelle für Autovervollständigung und Chat, anstatt ein einzelnes Modell zu zwingen, beides zu leisten.

Die Kernerkenntnis: Autovervollständigung ist latenzsensitiv, Chat ist qualitätssensitiv. Ein 3B-Modell, das in 150ms antwortet, fühlt sich bei Vervollständigungen magisch an. Dasselbe Modell, das auf eine komplexe Architektur-Frage eine oberflächliche Antwort gibt, fühlt sich defekt an.

Autovervollständigungs-Verhalten in config.json optimieren

Die Standard-Autovervollständigungs-Einstellungen in Continue.dev sind konservativ. Treiben Sie sie für eine bessere Erfahrung an:

```json { "tabAutocompleteModel": { "title": "StarC

Continue Reading

Performance

Mistral 7B vs Llama 3 on Apple Silicon

Tools

Best GUI clients for Local LLMs

Advanced

Quantization 101: Speed up your Inference