Continue.dev KI-Codierung

Betreiben Sie Continue.dev mit Clore.ai GPUs — führen Sie CodeLlama 34B, DeepSeek Coder und Qwen2.5-Coder lokal auf günstigen GPU-Mietgeräten für private KI-Coding-Unterstützung aus.

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

• Erstklassige Codierungsmodelle (34B+ Parameter), die nicht auf Ihren Laptop passen

• Volle Privatsphäre — Code verbleibt auf einer Infrastruktur, die Sie kontrollieren

• Flexible Kosten — zahlen Sie nur, während Sie coden (~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 Ihre lokale Continue.dev-Erweiterung sich verbindet.

Alle GPU-Server-Beispiele verwenden Server, die über CLORE.AI Marketplace.

Architektur: Ihre IDE (mit Continue.dev-Erweiterung) → Internet → Clore.ai GPU-Server (führt Ollama / vLLM / TabbyML aus) → lokale Modellausführung. Kein Code berührt jemals eine Drittanbieter-API.

Überblick

Eigenschaft	Details
Projekt	continuedev/continue
Lizenz	Apache 2.0
GitHub-Sterne	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 (Erweiterung installieren) / Mittel (selbstgehostetes Backend)
GPU erforderlich?	Auf dem Clore.ai-Server (ja); auf Ihrem Laptop (nein)
Hauptmerkmale	Autocomplete, Chat, Bearbeitungsmodus, Codebase-Kontext (RAG), benutzerdefinierte Slash-Befehle

Empfohlene Modelle zum Programmieren

Modell	VRAM	Stärke	Hinweise
codellama:7b	~6 GB	Schnelles Autocomplete	Guter Ausgangspunkt
codellama:13b	~10 GB	Ausgeglichen	Beste Qualität/Geschwindigkeit 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	Top-Qualität Open Source	Rivalisiert mit GPT-4 beim Code
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 Codiermodell 2024
starcoder2:15b	~12 GB	Spezialist für Codevervollständigung	FIM-Unterstützung (Fill-in-the-middle)

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/Stunde	CodeLlama 34B, DeepSeek 33B, Qwen2.5-Coder 32B
Leistung	RTX 4090	24 GB	32 GB	80 GB	~$0.35/Stunde	Gleiche Modelle wie oben, schnellere Inferenz
Leistung	A100 40GB	40 GB	64 GB	120 GB	~0,60 $/Std.	Mehrere 34B-Modelle gleichzeitig
Maximal	A100 80GB	80 GB	80 GB	200 GB	~$1.10/Stunde	70B-Modelle (CodeLlama 70B)

Lokale Anforderungen (Ihr Gerät)

• 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, ausgezeichnetes 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, dass Ollama läuft
curl http://localhost:11434/

# 4. Ziehen Sie Ihr Codiermodell (wählen Sie je nach VRAM)
# 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. Ziehen Sie ein schnelles Autocomplete-Modell (separat vom Chat-Modell)
docker exec ollama ollama pull starcoder2:3b   # Sehr schnell, ideal für FIM-Autocomplete

# 6. Überprüfen, dass 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 freizugeben (so dass Ihre lokale IDE sich verbinden kann):

# Ollama mit aktiviertem externen Zugriff neu starten
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 Ihrem LOKALEN Rechner:
curl http://<clore-server-ip>:11434/api/tags

Das öffentliche Freigeben von Port 11434 hat standardmäßig keine Authentifizierung. Für den Produktionseinsatz richten Sie stattdessen einen SSH-Tunnel ein (siehe Tipps & bewährte Methoden).

Option B — vLLM-Backend (Hoher Durchsatz / OpenAI-kompatibel)

vLLM bietet schnellere Inferenz und Mehrbenutzer-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

# Testen Sie die API
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-Geistertext-Vorschläge. Siehe die TabbyML-Anleitung 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

# Verifizieren
curl http://localhost:8080/v1/health

Teil 2: Continue.dev-Erweiterung installieren

VS Code:

1. Öffnen Sie das Erweiterungen-Panel (Ctrl+Shift+X / Cmd+Shift+X)

2. Suchen "Continue" — installieren Sie die offizielle Erweiterung von Continue (continuedev)

3. Klicken Sie auf das Continue-Symbol in der Seitenleiste (oder Ctrl+Shift+I)

JetBrains (IntelliJ, PyCharm, WebStorm, GoLand):

1. Datei → Einstellungen → Plugins → Marketplace

2. Suchen "Continue" und installieren Sie

3. 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": "Ausgewählten 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 Ihrem lokalen Rechner:

# 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 config.json localhost verwenden:
# "apiBase": "http://localhost:11434"

Persistenter Tunnel mit autossh

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

# Starten Sie einen persistierenden Tunnel, 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>

# Zum automatischen Start beim Booten in systemd hinzufügen (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 ausführen:

# Auf dem Clore.ai-Server:

# Ziehen Sie die Modelle
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 Modellwechsel automatisch
# Alle drei passen mit intelligenter Caching innerhalb von 24 GB VRAM

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

Codebase-Indizierung (RAG für Ihr Repo)

Continue.dev kann Ihre Codebasis für kontextbewusste Vorschläge indizieren. Ziehen Sie ein Embedding-Modell:

# Auf dem Clore.ai-Server — fügen Sie das Embedding-Modell zu Ollama hinzu
docker exec ollama ollama pull nomic-embed-text

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

GPU-Beschleunigung

Inference-Leistung überwachen

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

# Prüfen Sie Tokens pro Sekunde (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 Leistung nach GPU

GPU	Modell	Kontext	Tokens/Sek (ca.)
RTX 3060 12GB	CodeLlama 7B	8K	~40–60 t/s
RTX 3060 12GB	DeepSeek-Coder 6.7B	8K	~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 im IDE sofort anzufühlen.

Ollama für bessere Leistung 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: zwei Anfragen gleichzeitig bedienen
# OLLAMA_MAX_LOADED_MODELS=2: zwei Modelle im GPU-Speicher halten
# OLLAMA_FLASH_ATTENTION=1: Flash-Attention aktivieren (schneller, weniger Speicher)

Tipps & bewährte Methoden

Verschiedene Modelle für verschiedene Aufgaben verwenden

Konfigurieren Sie Continue.dev mit spezialisierten Modellen pro Aufgabentyp — die UI erlaubt, Modelle mitten in einer Konversation zu wechseln:

{
  "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, niedrige Latenz"
    },
    {
      "title": "Autocomplete — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "Inline-Geistertext-Vorschläge"
    }
  ]
}

Kostenvergleich

Lösung	Monatliche Kosten (8 Std./Tag Nutzung)	Privatsphäre	Modellqualität
GitHub Copilot	19 $/Nutzer/Monat	❌ Microsoft-Cloud	GPT-4o (geschlossen)
Cursor Pro	20 $/Nutzer/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 eine Clore.ai RTX 3090 (~48 $/Monat insgesamt) teilen, ist der Preis pro Nutzer besser als bei Copilot, während ein größeres, privates Modell bereitgestellt wird.

Herunterfahren, wenn nicht programmiert wird

Clore.ai berechnet stündlich. Verwenden Sie ein einfaches Skript, um den Server zu starten/stoppen:

# Speichern Sie 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. Denken Sie daran, Ihre Clore.ai-Bestellung zu stoppen, um die Abrechnung zu beenden!"

Verwenden Sie Continue.dev-Benutzerbefehle

Fügen Sie benutzerdefinierte Slash-Befehle zu config.json für gängige Codierungs-Workflows hinzu:

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

Fehlerbehebung

Problem	Wahrscheinliche Ursache	Lösung
Continue.dev zeigt "Connection refused"	Ollama nicht erreichbar	Überprüfen Sie, dass der SSH-Tunnel aktiv ist; verifizieren Sie curl http://localhost:11434/ funktioniert
Autocomplete löst nicht aus	Tab-Autocomplete-Modell nicht gesetzt	Hinzufügen tabAutocompleteModel in config.json; aktivieren Sie es in den Continue-Einstellungen
Sehr langsame Antworten (>30s erstes Token)	Modell lädt von der Festplatte	Die erste Anfrage lädt das Modell in den VRAM — nachfolgende Anfragen sind schnell
"Modell nicht gefunden" Fehler	Modell nicht gezogen	Ausführen docker exec ollama ollama pull <model-name> auf dem Clore.ai-Server
Hohe Latenz zwischen Tokens	Netzwerkverzögerung oder Modell zu groß	Verwenden Sie SSH-Tunnel; wechseln Sie zu einem kleineren Modell; prüfen Sie GPU-Auslastung des Servers
Codebase-Kontext funktioniert nicht	Embeddings-Modell fehlt	Ziehen Sie nomic-embed-text via Ollama; prüfen Sie embeddingsProvider in config.json
SSH-Tunnel bricht häufig ab	Unstabile Verbindung	Verwenden Sie autossh für persistente Wiederverbindung; fügen Sie hinzu ServerAliveInterval 30
Kontextfenster überschritten	Lange Dateien/Konversationen	Reduziere contextLength in config.json; verwenden Sie ein Modell mit längerem Kontext
JetBrains-Plugin wird nicht geladen	Inkompatible IDE-Version	Aktualisieren Sie die JetBrains-IDE auf die neueste Version; prüfen Sie die Kompatibilitätsmatrix des Continue.dev-Plugins
vLLM OOM beim Laden	Nicht genug VRAM	Hinzufügen --gpu-memory-utilization 0.85; verwenden Sie ein kleineres Modell oder eine quantisierte Version

Debug-Befehle

# Auf Ihrem LOKALEN Rechner — Konnektivität testen
curl http://localhost:11434/api/tags          # falls Sie SSH-Tunnel verwenden
curl http://<clore-ip>:11434/api/tags        # falls der Port direkt geöffnet ist

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

# 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 Konfigurationsvalidierung

# Validieren Sie die config.json-Syntax auf Ihrem lokalen Rechner
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, Probleme, Modellkompatibilität

• Continue.dev Konfigurationsreferenz — vollständig config.json schema

• Ollama auf Clore.ai — detaillierte Ollama-Einrichtungsanleitung (empfohlenes Backend)

• vLLM auf Clore.ai — leistungsstarkes alternatives Backend für Teams

• TabbyML auf Clore.ai — spezialisiertes Autovervollständigungs-Backend mit FIM-Optimierung

• GPU-Vergleichsanleitung — wähle die richtige GPU für deine Programmier-Workloads

• Modellkompatibilität — welche Modelle in welche VRAM-Größen passen

• Qwen2.5-Coder — derzeit das beste offene Code-Modell

• DeepSeek-Coder-V2 — starke Alternative mit langem Kontext

• CLORE.AI Marketplace — GPU-Server mieten