Continue.dev AI Coding

Continue.dev mit Clore.ai‑GPUs betreiben — CodeLlama 34B, DeepSeek Coder und Qwen2.5‑Coder lokal auf günstigen GPU‑Mieten für private AI‑Coding‑Unterstützung ausführen.

Continue.dev ist ein Open-Source-AI-Coding-Assistent für VS Code und JetBrains mit über 25.000 GitHub-Sternen. Das Erweiterung läuft auf Ihrem lokalen Rechner (oder in Ihrer IDE), verbindet sich jedoch für Inferenz mit einem Backend-Modelserver. Wenn Sie Continue.dev auf eine leistungsstarke GPU zeigen, die Sie von Clore.ai mieten, erhalten Sie:

Erstklassige Coding-Modelle (34B+ Parameter), die nicht auf Ihren Laptop passen
Volle Privatsphäre — Code bleibt auf Infrastruktur, die Sie kontrollieren
Flexible Kosten — zahlen Sie nur während Sie programmieren (~0,20–0,50$/Std. vs. 19$/Monat für Copilot)
OpenAI-kompatible API — Continue.dev verbindet sich nahtlos mit Ollama, vLLM oder TabbyML

Diese Anleitung konzentriert sich auf das Einrichten des Clore.ai GPU-Backends (Ollama oder vLLM), mit dem sich Ihre lokale Continue.dev-Erweiterung verbindet.

Alle GPU-Server-Beispiele verwenden Server, die über den CLORE.AI-Marktplatz gemietet werden.

Architektur: Ihre IDE (mit Continue.dev-Erweiterung) → Internet → Clore.ai GPU-Server (mit Ollama / vLLM / TabbyML) → lokale Modellinferenz. Kein Code gelangt jemals an eine Drittanbieter-API.

Übersicht

Eigenschaft

Details

Projekt

continuedev/continue

Lizenz

Apache 2.0

GitHub-Stars

25K+

IDE-Unterstützung

VS Code, JetBrains (IntelliJ, PyCharm, WebStorm, GoLand usw.)

Konfigurationsdatei

~/.continue/config.json

Backend-Optionen

Ollama, vLLM, TabbyML, LM Studio, llama.cpp, OpenAI-kompatible APIs

Schwierigkeitsgrad

Einfach (Erweiterungsinstallation) / Mittel (self-hosted Backend)

GPU erforderlich?

Auf dem Clore.ai-Server (ja); auf Ihrem Laptop (nein)

Hauptfunktionen

Autocomplete, Chat, Edit-Modus, Codebase-Kontext (RAG), benutzerdefinierte Slash-Befehle

Empfohlene Modelle zum Programmieren

Modell

VRAM

Stärke

Anmerkungen

codellama:7b

~6 GB

Schnelles Autocomplete

Guter Ausgangspunkt

codellama:13b

~10 GB

Ausgewogen

Bestes Qualität/Geschwindigkeit-Verhältnis für Autocomplete

codellama:34b

~22 GB

Beste CodeLlama-Qualität

Benötigt RTX 3090 / A100

deepseek-coder:6.7b

~5 GB

Python/JS-Spezialist

Ausgezeichnet für Web-Entwicklung

deepseek-coder:33b

~22 GB

Erstklassig Open Source

Gleicht GPT-4 beim Code aus

qwen2.5-coder:7b

~6 GB

Mehrsprachiger Code

Stark in über 40 Sprachen

qwen2.5-coder:32b

~22 GB

State-of-the-art

Bestes offenes Coding-Modell 2024

starcoder2:15b

~12 GB

Spezialist für Codevervollständigung

FIM (fill-in-the-middle)-Unterstützung

Anforderungen

Clore.ai Serveranforderungen

Tier

GPU

VRAM

RAM

Festplatte

Preis

Modelle

Budget

RTX 3060

12 GB

16 GB

40 GB

~0,10$/Std.

CodeLlama 7B, DeepSeek 6.7B, Qwen2.5-Coder 7B

Empfohlen

RTX 3090

24 GB

32 GB

80 GB

~0,20$/Std.

CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B

Performance

RTX 4090

24 GB

32 GB

80 GB

~0,35$/Std.

Gleiche Modelle wie oben, schnellere Inferenz

Power

A100 40GB

40 GB

64 GB

120 GB

~0,60$/Std.

Mehrere 34B-Modelle gleichzeitig

Maximum

A100 80GB

80 GB

200 GB

~1,10$/Std.

70B-Modelle (CodeLlama 70B)

Lokale Anforderungen (Ihr Rechner)

VS Code oder eine beliebige JetBrains-IDE
Continue.dev-Erweiterung installiert
Stabile Internetverbindung zu Ihrem Clore.ai-Server
Keine lokale GPU erforderlich — alle Inferenzvorgänge erfolgen auf Clore.ai

Schnellstart

Teil 1: Einrichten des Clore.ai-Backends

Option A — Ollama-Backend (für die meisten Nutzer empfohlen)

Ollama ist das einfachste Backend für Continue.dev — einfache Einrichtung, exzellentes Modellmanagement, OpenAI-kompatible API.

# 1. SSH auf Ihren Clore.ai-Server
ssh root@<clore-server-ip> -p <port>

# 2. Ollama mit GPU-Unterstützung starten
docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  --restart unless-stopped \
  ollama/ollama

# 3. Überprüfen, ob Ollama läuft
curl http://localhost:11434/

# 4. Ihr Coding-Modell herunterladen (je nach VRAM auswählen)
# Für 12GB VRAM (RTX 3060):
docker exec ollama ollama pull codellama:13b

# Für 24GB VRAM (RTX 3090 / RTX 4090):
docker exec ollama ollama pull qwen2.5-coder:32b
# oder:
docker exec ollama ollama pull deepseek-coder:33b

# 5. Ein schnelles Autocomplete-Modell herunterladen (separat zum Chat-Modell)
docker exec ollama ollama pull starcoder2:3b   # Sehr schnell, großartig für FIM-Autocomplete

# 6. Überprüfen, ob Modelle verfügbar sind
docker exec ollama ollama list

# 7. Inferenz testen
docker exec ollama ollama run qwen2.5-coder:32b "Write a Python function to binary search a sorted list"

Um Ollama extern verfügbar zu machen (damit Ihre lokale IDE sich verbinden kann):

# Ollama neu starten mit externer Zugriffsfreigabe
docker stop ollama && docker rm ollama

docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \
  --restart unless-stopped \
  ollama/ollama

# Testen von Ihrer LOKALEN Maschine:
curl http://<clore-server-ip>:11434/api/tags

Das öffentliche Freigeben des Ports 11434 hat standardmäßig keine Authentifizierung. Für den Produktionseinsatz richten Sie stattdessen einen SSH-Tunnel ein (siehe Tipps & Best Practices).

Option B — vLLM-Backend (High-Throughput / OpenAI-kompatibel)

vLLM bietet schnellere Inferenz und Multi-User-Unterstützung. Ideal, wenn mehrere Entwickler einen Clore.ai-Server teilen.

# Starten Sie vLLM mit OpenAI-kompatibler API
docker run -d \
  --name vllm \
  --gpus all \
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \
  -e HF_TOKEN="your-huggingface-token" \
  --restart unless-stopped \
  vllm/vllm-openai:latest \
  --model Qwen/Qwen2.5-Coder-32B-Instruct \
  --dtype auto \
  --max-model-len 32768 \
  --tensor-parallel-size 1 \
  --gpu-memory-utilization 0.90 \
  --served-model-name qwen2.5-coder-32b

# Für Multi-GPU (z. B. zwei RTX 3090):
docker run -d \
  --name vllm \
  --gpus all \
  -p 8000:8000 \
  -v /workspace/hf-models:/root/.cache/huggingface \
  -e HF_TOKEN="your-huggingface-token" \
  vllm/vllm-openai:latest \
  --model deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct \
  --tensor-parallel-size 2 \
  --dtype auto \
  --max-model-len 65536 \
  --served-model-name deepseek-coder-v2

# API testen
curl http://localhost:8000/v1/models
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen2.5-coder-32b",
    "messages": [{"role": "user", "content": "Write a hello world in Rust"}],
    "max_tokens": 200
  }'

Option C — TabbyML-Backend (FIM-Autocomplete-Spezialist)

TabbyML bietet überlegene Fill-in-the-Middle (FIM) Autocomplete — die Inline-Ghost-Text-Vorschläge. Siehe die TabbyML-Dokumentation für vollständige Einrichtungsdetails.

# Schnelle TabbyML-Einrichtung für Continue.dev-Autocomplete
docker run -d \
  --name tabby \
  --gpus all \
  -p 8080:8080 \
  -v /workspace/tabby-data:/data \
  --restart unless-stopped \
  tabbyml/tabby serve \
  --model StarCoder2-7B \
  --chat-model Mistral-7B \
  --device cuda

# Überprüfen
curl http://localhost:8080/v1/health

Teil 2: Continue.dev-Erweiterung installieren

VS Code:

Öffnen Sie das Erweiterungsfeld (Ctrl+Shift+X / Cmd+Shift+X)
Suchen "Continue" — installieren Sie die offizielle Erweiterung von Continue (continuedev)
Klicken Sie auf das Continue-Symbol in der Seitenleiste (oder Ctrl+Shift+I)

JetBrains (IntelliJ, PyCharm, WebStorm, GoLand):

Datei → Einstellungen → Plugins → Marketplace
Suchen "Continue" und installieren Sie
Starten Sie die IDE neu; das Continue-Panel erscheint in der rechten Seitenleiste

Teil 3: Continue.dev konfigurieren, um Clore.ai zu verwenden

Bearbeiten ~/.continue/config.json auf Ihrem lokalen Rechner:

{
  "models": [
    {
      "title": "Clore.ai — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 32768,
      "completionOptions": {
        "temperature": 0.1,
        "topP": 0.95,
        "maxTokens": 4096
      }
    },
    {
      "title": "Clore.ai — CodeLlama 13B (schnell)",
      "provider": "ollama",
      "model": "codellama:13b",
      "apiBase": "http://<clore-server-ip>:11434",
      "contextLength": 16384
    }
  ],
  "tabAutocompleteModel": {
    "title": "StarCoder2 3B (autocomplete)",
    "provider": "ollama",
    "model": "starcoder2:3b",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "embeddingsProvider": {
    "provider": "ollama",
    "model": "nomic-embed-text",
    "apiBase": "http://<clore-server-ip>:11434"
  },
  "contextProviders": [
    { "name": "code" },
    { "name": "docs" },
    { "name": "diff" },
    { "name": "terminal" },
    { "name": "problems" },
    { "name": "folder" },
    { "name": "codebase" }
  ],
  "slashCommands": [
    { "name": "edit", "description": "Markierten Code bearbeiten" },
    { "name": "comment", "description": "Kommentare zum Code hinzufügen" },
    { "name": "share", "description": "Konversation als Markdown exportieren" },
    { "name": "cmd", "description": "Terminalbefehl generieren" },
    { "name": "commit", "description": "Git-Commit-Nachricht generieren" }
  ]
}

Für vLLM-Backend anstelle von Ollama:

{
  "models": [
    {
      "title": "Clore.ai — DeepSeek Coder 33B (vLLM)",
      "provider": "openai",
      "model": "deepseek-coder-v2",
      "apiBase": "http://<clore-server-ip>:8000/v1",
      "apiKey": "not-required",
      "contextLength": 65536,
      "completionOptions": {
        "temperature": 0.0,
        "maxTokens": 8192
      }
    }
  ]
}

Für TabbyML-Backend (nur Autocomplete):

{
  "tabAutocompleteModel": {
    "title": "Clore.ai — TabbyML StarCoder2",
    "provider": "openai",
    "model": "StarCoder2-7B",
    "apiBase": "http://<clore-server-ip>:8080/v1",
    "apiKey": "auth-token-if-set"
  }
}

Konfiguration

SSH-Tunnel-Einrichtung (sicherer Fernzugriff)

Anstatt Ports öffentlich freizugeben, verwenden Sie einen SSH-Tunnel von Ihrer lokalen Maschine:

# SSH-Tunnel öffnen: lokaler Port 11434 → Clore.ai-Server-Port 11434
ssh -N -L 11434:localhost:11434 root@<clore-server-ip> -p <clore-ssh-port>

# Tunnel aktiv halten (zu ~/.ssh/config hinzufügen):
Host clore-coding
  HostName <clore-server-ip>
  Port <clore-ssh-port>
  User root
  LocalForward 11434 localhost:11434
  LocalForward 8000 localhost:8000
  ServerAliveInterval 60
  ServerAliveCountMax 3

# Verbinden mit:
ssh -N clore-coding

# Dann in der config.json localhost verwenden:
# "apiBase": "http://localhost:11434"

Persistenter Tunnel mit autossh

# Installieren Sie autossh auf Ihrer lokalen Maschine (Linux/macOS)
sudo apt install autossh   # Ubuntu/Debian
brew install autossh       # macOS

# Persistenten Tunnel ausführen, der automatisch neu verbindet
autossh -M 0 -N \
  -o "ServerAliveInterval 30" \
  -o "ServerAliveCountMax 3" \
  -L 11434:localhost:11434 \
  root@<clore-server-ip> -p <clore-ssh-port>

# In systemd hinzufügen für automatischen Start beim Booten (Linux)
cat > ~/.config/systemd/user/clore-tunnel.service << 'EOF'
[Unit]
Description=SSH tunnel to Clore.ai coding server
After=network.target

[Service]
ExecStart=autossh -M 0 -N \
  -o StrictHostKeyChecking=accept-new \
  -o ServerAliveInterval=30 \
  -o ServerAliveCountMax=3 \
  -L 11434:localhost:11434 \
  root@CLORE_IP -p CLORE_PORT
Restart=always
RestartSec=10

[Install]
WantedBy=default.target
EOF

systemctl --user enable clore-tunnel
systemctl --user start clore-tunnel

Mehrere Modelle für verschiedene Aufgaben laden

Für eine RTX 3090 (24 GB) können Sie ein großes Chat-Modell und ein kleines Autocomplete-Modell gleichzeitig betreiben:

# Auf dem Clore.ai-Server:

# Modelle herunterladen
docker exec ollama ollama pull qwen2.5-coder:32b      # Chat (22 GB)
docker exec ollama ollama pull starcoder2:3b           # Autocomplete (2 GB)
docker exec ollama ollama pull nomic-embed-text        # Embeddings (0.5 GB)

# Ollama verwaltet das Modell-Swapping automatisch
# Alle drei passen mit intelligentem Caching in 24 GB VRAM

# VRAM-Nutzung überwachen
nvidia-smi --query-gpu=memory.used,memory.free --format=csv -l 5

Codebase-Indexierung (RAG für Ihr Repo)

Continue.dev kann Ihre Codebasis für kontextbezogene Vorschläge indexieren. Laden Sie ein Embedding-Modell herunter:

# Auf Clore.ai-Server — Embedding-Modell zu Ollama hinzufügen
docker exec ollama ollama pull nomic-embed-text

# In der config.json (lokal) sind Embeddings bereits oben konfiguriert.
# Continue.dev wird Ihren offenen Arbeitsbereich automatisch indexieren.
# Manuelles Re-Index auslösen: Ctrl+Shift+P → "Continue: Index Codebase"

GPU-Beschleunigung

Inference-Performance überwachen

# Auf Ihrem Clore.ai-Server — GPU während der Coding-Sitzungen beobachten
watch -n 1 nvidia-smi

# Tokens pro Sekunde prüfen (Ollama-Logs)
docker logs ollama --tail 20 -f

# Detaillierte GPU-Statistiken
nvidia-smi dmon -s u -d 2

# Speicheraufteilung
nvidia-smi --query-gpu=name,memory.used,memory.free,utilization.gpu \
  --format=csv,noheader -l 5

Erwartete Performance nach GPU

GPU

Modell

Kontext

Tokens/Sek. (ca.)

RTX 3060 12GB

CodeLlama 7B

~40–60 t/s

RTX 3060 12GB

DeepSeek-Coder 6.7B

~45–65 t/s

RTX 3090 24GB

Qwen2.5-Coder 32B (Q4)

16K

~15–25 t/s

RTX 3090 24GB

DeepSeek-Coder 33B (Q4)

16K

~15–22 t/s

RTX 4090 24GB

Qwen2.5-Coder 32B (Q4)

16K

~25–40 t/s

A100 40GB

Qwen2.5-Coder 32B (FP16)

32K

~35–50 t/s

A100 80GB

CodeLlama 70B (Q4)

32K

~20–30 t/s

Für Autocomplete (fill-in-the-middle), starcoder2:3b oder codellama:7b erzielen 50–100 t/s — schnell genug, um sich in der IDE sofort anzufühlen.

Ollama für bessere Performance optimieren

# Auf dem Clore.ai-Server — Ollama-Einstellungen optimieren
docker stop ollama && docker rm ollama

docker run -d \
  --name ollama \
  --gpus all \
  -p 11434:11434 \
  -v /workspace/ollama:/root/.ollama \
  -e OLLAMA_HOST=0.0.0.0 \
  -e OLLAMA_NUM_PARALLEL=2 \
  -e OLLAMA_MAX_LOADED_MODELS=2 \
  -e OLLAMA_FLASH_ATTENTION=1 \
  --restart unless-stopped \
  ollama/ollama

# OLLAMA_NUM_PARALLEL=2: 2 Anfragen gleichzeitig bedienen
# OLLAMA_MAX_LOADED_MODELS=2: 2 Modelle im GPU-Speicher halten
# OLLAMA_FLASH_ATTENTION=1: Flash-Attention aktivieren (schneller, weniger Speicher)

Tipps & Best Practices

Verschiedene Modelle für unterschiedliche Aufgaben verwenden

Konfigurieren Sie Continue.dev mit spezialisierten Modellen pro Aufgabentyp — die UI ermöglicht das Wechseln von Modellen mitten im Gespräch:

{
  "models": [
    {
      "title": "Chat — Qwen2.5-Coder 32B",
      "provider": "ollama",
      "model": "qwen2.5-coder:32b",
      "apiBase": "http://localhost:11434",
      "contextLength": 32768,
      "description": "Am besten für komplexe Fragen, Code-Reviews, Architekturentscheidungen"
    },
    {
      "title": "Schnell — CodeLlama 7B",
      "provider": "ollama",
      "model": "codellama:7b",
      "apiBase": "http://localhost:11434",
      "contextLength": 8192,
      "description": "Schnelle Antworten, einfache Vervollständigungen, geringe Latenz"
    },
    {
      "title": "Autocomplete — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "Inline-Ghost-Text-Vorschläge"
    }
  ]
}

Kostenvergleich

Lösung

Monatliche Kosten (8 Std./Tag Nutzung)

Privatsphäre

Modellqualität

GitHub Copilot

19$/Benutzer/Monat

❌ Microsoft-Cloud

GPT-4o (geschlossen)

Cursor Pro

20$/Benutzer/Monat

❌ Cursor-Cloud

Claude 3.5 (geschlossen)

RTX 3060 auf Clore.ai

~24$/Monat

✅ Ihr Server

CodeLlama 13B

RTX 3090 auf Clore.ai

~48 $/Monat

✅ Ihr Server

Qwen2.5-Coder 32B

RTX 4090 auf Clore.ai

~84 $/Monat

✅ Ihr Server

Qwen2.5-Coder 32B

A100 80GB auf Clore.ai

~264 $/Monat

✅ Ihr Server

CodeLlama 70B

Für ein Team von 3+ Entwicklern, die sich eine Clore.ai RTX 3090 (~48 $/Monat insgesamt) teilen, ist der Preis pro Nutzer günstiger als Copilot und bietet gleichzeitig ein größeres, privates Modell.

Beim Nicht-Codieren Herunterfahren

Clore.ai berechnet nach Stunden. Verwende ein einfaches Skript, um den Server zu starten/stoppen:

# Speichere diese als lokale Skripte

# start-coding-server.sh
#!/bin/bash
echo "Öffne SSH-Tunnel zu Clore.ai..."
ssh -N -f -L 11434:localhost:11434 clore-coding
echo "Tunnel offen. Continue.dev ist bereit."

# stop-coding-server.sh
#!/bin/bash
echo "Schließe SSH-Tunnel..."
pkill -f "ssh.*clore-coding"
echo "Tunnel geschlossen. Denk daran, deine Clore.ai-Bestellung zu stoppen, um die Abrechnung zu beenden!"

Continue.dev benutzerdefinierte Befehle verwenden

Füge benutzerdefinierte Slash-Befehle zu config.json für gängige Coding-Workflows hinzu:

{
  "customCommands": [
    {
      "name": "review",
      "prompt": "Überprüfe diesen Code auf Fehler, Sicherheitsprobleme und Performance-Probleme. Sei spezifisch und umsetzbar.",
      "description": "Code-Review"
    },
    {
      "name": "test",
      "prompt": "Schreibe umfassende Unit-Tests für diesen Code. Schließe Randfälle ein. Verwende dieselbe Sprache/Framework wie der Code.",
      "description": "Tests generieren"
    },
    {
      "name": "docstring",
      "prompt": "Füge diesem Code klare, umfassende Docstrings/Kommentare hinzu, die den Best Practices der jeweiligen Sprache folgen.",
      "description": "Dokumentation hinzufügen"
    },
    {
      "name": "optimize",
      "prompt": "Optimiere diesen Code für Performance. Erkläre, was du geändert hast und warum.",
      "description": "Code optimieren"
    }
  ]
}

Fehlerbehebung

Problem

Wahrscheinliche Ursache

Lösung

Continue.dev zeigt "Connection refused" an

Ollama nicht erreichbar

Prüfe, ob der SSH-Tunnel aktiv ist; verifiziere curl http://localhost:11434/ funktioniert

Autocomplete löst nicht aus

Tab-Autocomplete-Modell nicht gesetzt

Füge tabAutocompleteModel zur config.json hinzu; aktiviere es in den Continue-Einstellungen

Sehr langsame Antworten (>30s erstes Token)

Modell wird von der Festplatte geladen

Die erste Anfrage lädt das Modell in den VRAM — nachfolgende Anfragen sind schnell

"Model not found" Fehler

Modell nicht heruntergeladen

Führe docker exec ollama ollama pull <model-name> auf dem Clore.ai-Server aus

Hohe Latenz zwischen Tokens

Netzwerkverzögerung oder Modell zu groß

Verwende SSH-Tunnel; wechsle zu kleinem Modell; prüfe GPU-Auslastung des Servers

Codebase-Kontext funktioniert nicht

Embeddings-Modell fehlt

Ziehe nomic-embed-text über Ollama; prüfe embeddingsProvider in der config.json

SSH-Tunnel bricht häufig ab

Instabile Verbindung

Verwende autossh für persistente Wiederverbindungen; füge hinzu ServerAliveInterval 30

Kontextfenster überschritten

Lange Dateien/Unterhaltungen

Reduziere contextLength in der config.json; verwende ein Modell mit größerem Kontext

JetBrains-Plugin wird nicht geladen

IDE-Versionsinkompatibilität

Aktualisiere die JetBrains-IDE auf die neueste Version; prüfe die Kompatibilitätsmatrix des Continue.dev-Plugins

vLLM OOM beim Laden

Nicht genug VRAM

Füge --gpu-memory-utilization 0.85; verwende ein kleineres Modell oder eine quantisierte Version

Debug-Befehle

# Auf deinem LOKALEN Rechner — Verbindung testen
curl http://localhost:11434/api/tags          # wenn du einen SSH-Tunnel verwendest
curl http://<clore-ip>:11434/api/tags        # wenn der Port direkt offen ist

# Auf dem CLORE.AI-Server — prüfe Ollama
docker logs ollama --tail 30 -f
docker exec ollama ollama list
docker exec ollama ollama ps                  # aktuell geladene Modelle anzeigen

# Modell-Antwortzeit testen
time curl http://localhost:11434/api/generate \
  -d '{"model": "codellama:7b", "prompt": "def hello():", "stream": false}'

# GPU-Speicher prüfen
nvidia-smi --query-gpu=memory.used,memory.free --format=csv

# vLLM-Logs prüfen
docker logs vllm --tail 50 -f

# Ollama neu starten, ohne Modelle zu verlieren
docker restart ollama

Continue.dev Konfig-Validierung

# Syntax von config.json auf deinem lokalen Rechner validieren
python3 -c "
import json, sys
try:
    config = json.load(open(sys.argv[1]))
    print('✅ Config ist gültiges JSON')
    print(f'Modelle: {[m[\"title\"] for m in config.get(\"models\", [])]}')
except Exception as e:
    print(f'❌ Fehler: {e}')
" ~/.continue/config.json

Weiterführende Lektüre

Continue.dev Dokumentation — offizielle Dokumentation für alle IDE-Integrationen und Konfigurationsoptionen
Continue.dev GitHub — Quellcode, Issues, Modellkompatibilität
Continue.dev Konfig-Referenz — vollständiges config.json Schema
Ollama auf Clore.ai — ausführliche Ollama-Setup-Anleitung (empfohlenes Backend)
vLLM auf Clore.ai — leistungsstarke alternative Backend-Lösung für Teams
TabbyML — spezialisiertes Autocomplete-Backend mit FIM-Optimierung
GPU-Vergleichsleitfaden — wähle die richtige GPU für deine Coding-Arbeitslast
Modellkompatibilität — welche Modelle in welche VRAM-Größen passen
Qwen2.5-Coder — aktuell das beste offene Coding-Modell
DeepSeek-Coder-V2 — starke Alternative mit langem Kontext
CLORE.AI-Marktplatz gemietet werden — GPU-Server mieten

VorherigeHaystack AI Framework NächsteOpen Interpreter

Zuletzt aktualisiert vor 5 Tagen

War das hilfreich?

hashtagÜbersicht

hashtagEmpfohlene Modelle zum Programmieren

hashtagAnforderungen

hashtagClore.ai Serveranforderungen

hashtagLokale Anforderungen (Ihr Rechner)

hashtagSchnellstart

hashtagTeil 1: Einrichten des Clore.ai-Backends

hashtagOption A — Ollama-Backend (für die meisten Nutzer empfohlen)

hashtagOption B — vLLM-Backend (High-Throughput / OpenAI-kompatibel)

hashtagOption C — TabbyML-Backend (FIM-Autocomplete-Spezialist)

hashtagTeil 2: Continue.dev-Erweiterung installieren

hashtagTeil 3: Continue.dev konfigurieren, um Clore.ai zu verwenden

hashtagKonfiguration

hashtagSSH-Tunnel-Einrichtung (sicherer Fernzugriff)

hashtagPersistenter Tunnel mit autossh

hashtagMehrere Modelle für verschiedene Aufgaben laden

hashtagCodebase-Indexierung (RAG für Ihr Repo)

hashtagGPU-Beschleunigung

hashtagInference-Performance überwachen

hashtagErwartete Performance nach GPU

hashtagOllama für bessere Performance optimieren

hashtagTipps & Best Practices

hashtagVerschiedene Modelle für unterschiedliche Aufgaben verwenden

hashtagKostenvergleich

hashtagBeim Nicht-Codieren Herunterfahren

hashtagContinue.dev benutzerdefinierte Befehle verwenden

hashtagFehlerbehebung

hashtagDebug-Befehle

hashtagContinue.dev Konfig-Validierung

hashtagWeiterführende Lektüre

Übersicht

Empfohlene Modelle zum Programmieren

Anforderungen

Clore.ai Serveranforderungen

Lokale Anforderungen (Ihr Rechner)

Schnellstart

Teil 1: Einrichten des Clore.ai-Backends

Option A — Ollama-Backend (für die meisten Nutzer empfohlen)

Option B — vLLM-Backend (High-Throughput / OpenAI-kompatibel)

Option C — TabbyML-Backend (FIM-Autocomplete-Spezialist)

Teil 2: Continue.dev-Erweiterung installieren

Teil 3: Continue.dev konfigurieren, um Clore.ai zu verwenden

Konfiguration

SSH-Tunnel-Einrichtung (sicherer Fernzugriff)

Persistenter Tunnel mit autossh

Mehrere Modelle für verschiedene Aufgaben laden

Codebase-Indexierung (RAG für Ihr Repo)

GPU-Beschleunigung

Inference-Performance überwachen

Erwartete Performance nach GPU

Ollama für bessere Performance optimieren

Tipps & Best Practices

Verschiedene Modelle für unterschiedliche Aufgaben verwenden

Kostenvergleich

Beim Nicht-Codieren Herunterfahren

Continue.dev benutzerdefinierte Befehle verwenden

Fehlerbehebung

Debug-Befehle

Continue.dev Konfig-Validierung

Weiterführende Lektüre