Continue.dev KI-Coding

Versorge Continue.dev mit Clore.ai-GPUs — führe CodeLlama 34B, DeepSeek Coder und Qwen2.5-Coder lokal auf günstigen GPU-Mieten für private KI-Coding-Unterstützung aus.

Continue.dev ist ein Open-Source-KI-Coding-Assistent für VS Code und JetBrains mit über 25.000 GitHub-Stars. Die Erweiterung läuft auf Ihrem lokalen Rechner (oder in Ihrer IDE), verbindet sich aber für die Inferenz mit einem Backend-Modellserver. Wenn Sie Continue.dev auf eine leistungsstarke GPU ausrichten, die von Clore.ai gemietet wurde, erhalten Sie:

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

Dieser Leitfaden konzentriert sich auf die Einrichtung 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 die CLORE.AI-Marktplatz.

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

Überblick

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

Schwierigkeit

Einfach (Erweiterung installieren) / Mittel (selbst gehostetes Backend)

GPU erforderlich?

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

Hauptfunktionen

Autovervollständigung, Chat, Bearbeitungsmodus, Kontext der Codebasis (RAG), benutzerdefinierte Slash-Befehle

Empfohlene Modelle für das Coden

Modell

VRAM

Stärke

Hinweise

codellama:7b

~6 GB

Schnelle Autovervollständigung

Guter Ausgangspunkt

codellama:13b

~10 GB

Ausgewogen

Beste Qualität/Geschwindigkeit für Autovervollständigung

codellama:34b

~22 GB

Beste CodeLlama-Qualität

Benötigt RTX 3090 / A100

deepseek-coder:6.7b

~5 GB

Spezialist für Python/JS

Hervorragend für Webentwicklung

deepseek-coder:33b

~22 GB

Open Source der Spitzenklasse

Konkurrenz für GPT-4 beim Coden

qwen2.5-coder:7b

~6 GB

Mehrsprachiger Code

Stark bei über 40 Sprachen

qwen2.5-coder:32b

~22 GB

Auf dem neuesten Stand der Technik

Bestes Open-Coding-Modell 2024

starcoder2:15b

~12 GB

Spezialist für Code-Vervollständigung

Unterstützung für FIM (Fill-in-the-Middle)

Anforderungen

Clore.ai-Serveranforderungen

Stufe

GPU

VRAM

RAM

Festplatte

Preis

Modelle

Budget

RTX 3060

12 GB

16 GB

40 GB

0,03–0,07 $/Std.

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

Empfohlen

RTX 3090

24 GB

32 GB

80 GB

ca. 0,07–0,21 $/h

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

Leistung

RTX 4090

24 GB

32 GB

80 GB

ca. 0,14–0,42 $/h

Dieselben Modelle wie oben, schnellere Inferenz

Leistung

A100 40GB

40 GB

64 GB

120 GB

Bare Metal

Mehrere 34B-Modelle gleichzeitig

Maximum

A100 80GB

80 GB

200 GB

Bare Metal

70B-Modelle (CodeLlama 70B)

Lokale Anforderungen (Ihr Rechner)

VS Code oder jede JetBrains-IDE
Continue.dev-Erweiterung installiert
Stabile Internetverbindung zu Ihrem Clore.ai-Server
Keine lokale GPU erforderlich — die gesamte Inferenz läuft auf Clore.ai

Schnellstart

Teil 1: Das Clore.ai-Backend einrichten

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

Ollama ist das einfachste Backend für Continue.dev — einfache Einrichtung, hervorragende Modellverwaltung, mit OpenAI kompatible API.

# 1. Per SSH auf Ihren Clore.ai-Server verbinden
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. Prüfen, ob Ollama läuft
curl http://localhost:11434/

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

# Für 24 GB 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 Autovervollständigungsmodell herunterladen (separat vom Chatmodell)
docker exec ollama ollama pull starcoder2:3b   # Sehr schnell, großartig für FIM-Autovervollständigung

# 6. Prüfen, ob die Modelle verfügbar sind
docker exec ollama ollama list

# 7. Inferenz testen
docker exec ollama ollama run qwen2.5-coder:32b "Schreibe eine Python-Funktion für die binäre Suche in einer sortierten Liste"

Um Ollama extern zugänglich zu machen (damit sich Ihre lokale IDE 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

# Test von Ihrem LOKALEN Rechner aus:
curl http://<clore-server-ip>:11434/api/tags

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

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

vLLM bietet schnellere Inferenz und Unterstützung für mehrere Benutzer. Ideal, wenn mehrere Entwickler einen Clore.ai-Server gemeinsam nutzen.

# vLLM mit OpenAI-kompatibler API starten
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 3090s):
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": "Schreibe ein Hallo-Welt-Programm in Rust"}],
    "max_tokens": 200
  }'

Option C — TabbyML-Backend (Spezialist für FIM-Autovervollständigung)

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

# Schnelle TabbyML-Einrichtung für Continue.dev-Autovervollständigung
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

# Prüfen
curl http://localhost:8080/v1/health

Teil 2: Continue.dev-Erweiterung installieren

VS Code:

Öffnen Sie das Erweiterungs-Panel (Strg+Umschalt+X / Cmd+Umschalt+X)
Suchen "Continue" — installieren Sie die offizielle Erweiterung von Continue (continuedev)
Klicken Sie auf das Continue-Symbol in der Seitenleiste (oder Strg+Umschalt+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 für die Nutzung von Clore.ai konfigurieren

Bearbeiten Sie ~/.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 (Autovervollständigung)",
    "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 das vLLM-Backend statt Ollama:

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

Für TabbyML-Backend (nur Autovervollständigung):

{
  "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)

Statt Ports öffentlich freizugeben, verwenden Sie einen SSH-Tunnel von Ihrem lokalen Rechner aus:

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

# Tunnel am Laufen 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

# Persistenten Tunnel ausführen, der sich 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>

# Für automatischen Start beim Booten zu systemd hinzufügen (Linux)
cat > ~/.config/systemd/user/clore-tunnel.service << 'EOF'
[Unit]
Beschreibung=SSH-Tunnel zum 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 gleichzeitig ein großes Chatmodell und ein kleines Autovervollständigungsmodell ausführen:

# Auf dem Clore.ai-Server:

# Die Modelle herunterladen
docker exec ollama ollama pull qwen2.5-coder:32b      # Chat (22 GB)
docker exec ollama ollama pull starcoder2:3b           # Autovervollständigung (2 GB)
docker exec ollama ollama pull nomic-embed-text        # Embeddings (0,5 GB)

# Ollama übernimmt das Modellwechseln 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

Indexierung der Codebasis (RAG für Ihr Repo)

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

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

# In config.json (lokal) sind Embeddings bereits oben konfiguriert.
# Continue.dev indexiert Ihren geöffneten Arbeitsbereich automatisch.
# Manuelles Neuindizieren auslösen: Strg+Umschalt+P → "Continue: Index Codebase"

GPU-Beschleunigung

Inferenzleistung überwachen

# Auf Ihrem Clore.ai-Server — die GPU während der Codierungssitzungen 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 Leistung nach GPU

GPU

Modell

Kontext

Tokens/s (ca.)

RTX 3060 12 GB

CodeLlama 7B

~40–60 t/s

RTX 3060 12 GB

DeepSeek-Coder 6.7B

~45–65 t/s

RTX 3090 24 GB

Qwen2.5-Coder 32B (Q4)

16K

~15–25 t/s

RTX 3090 24 GB

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 Autovervollständigung (Fill-in-the-Middle), starcoder2:3b oder codellama:7b erreicht 50–100 t/s — schnell genug, um sich in der 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: 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 & bewährte Praktiken

Verschiedene Modelle für verschiedene Aufgaben verwenden

Konfigurieren Sie Continue.dev mit spezialisierten Modellen je Aufgabentyp — die UI ermöglicht es Ihnen, Modelle mitten im Gespräch 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, geringe Latenz"
    },
    {
      "title": "Autovervollständigung — StarCoder2 3B",
      "provider": "ollama",
      "model": "starcoder2:3b",
      "apiBase": "http://localhost:11434",
      "contextLength": 4096,
      "description": "Inline-Ghost-Text-Vorschläge"
    }
  ]
}

Kostenvergleich

Lösung

Monatliche Kosten (Nutzung 8 Std./Tag)

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

ca. 24 $/Monat

✅ Dein Server

CodeLlama 13B

RTX 3090 auf Clore.ai

ca. 48 $/Monat

✅ Dein Server

Qwen2.5-Coder 32B

RTX 4090 auf Clore.ai

ca. 84 $/Monat

✅ Dein Server

Qwen2.5-Coder 32B

A100 80GB auf Clore.ai

ca. 264 $/Monat

✅ Dein Server

CodeLlama 70B

Für ein Team von 3+ Entwicklern, das sich eine Clore.ai RTX 3090 teilt (insgesamt ca. 48 $/Monat), liegen die Kosten pro Nutzer unter Copilot und bieten gleichzeitig ein größeres, privates Modell.

Herunterfahren, wenn nicht programmiert wird

Clore.ai berechnet stundenweise. 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 "SSH-Tunnel wird geschlossen..."
pkill -f "ssh.*clore-coding"
echo "Tunnel geschlossen. Denk daran, deine Clore.ai-Bestellung zu stoppen, um die Abrechnung zu beenden!"

Verwende benutzerdefinierte Continue.dev-Befehle

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

{
  "customCommands": [
    {
      "name": "review",
      "prompt": "Überprüfe diesen Code auf Fehler, Sicherheitsprobleme und Leistungsprobleme. Sei konkret und umsetzbar.",
      "description": "Code-Review"
    },
    {
      "name": "test",
      "prompt": "Schreibe umfassende Unit-Tests für diesen Code. Berücksichtige Grenzfälle. Verwende dieselbe Sprache/dasselbe Framework wie der Code.",
      "description": "Tests generieren"
    },
    {
      "name": "docstring",
      "prompt": "Füge diesem Code klare, umfassende Docstrings/Kommentare gemäß den Best Practices für die Sprache hinzu.",
      "description": "Dokumentation hinzufügen"
    },
    {
      "name": "optimize",
      "prompt": "Optimiere diesen Code hinsichtlich der Leistung. Erkläre, was du geändert hast und warum.",
      "description": "Code optimieren"
    }
  ]
}

Fehlerbehebung

Problem

Wahrscheinliche Ursache

Lösung

Continue.dev zeigt "Verbindung abgelehnt"

Ollama nicht erreichbar

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

Autovervollständigung wird nicht ausgelöst

Tab-Autovervollständigungsmodell nicht festgelegt

Fügen Sie tabAutocompleteModel in config.json; in den Continue-Einstellungen aktivieren

Sehr langsame Antworten (>30 s bis zum ersten Token)

Modell wird von der Festplatte geladen

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

Fehler "Modell nicht gefunden"

Modell nicht heruntergeladen

Ausführen docker exec ollama ollama pull <model-name> auf dem Clore.ai-Server

Hohe Latenz zwischen den Tokens

Netzwerklatenz oder Modell zu groß

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

Codebasis-Kontext funktioniert nicht

Einbettungsmodell fehlt

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

SSH-Tunnel bricht häufig ab

Instabile Verbindung

Verwende autossh für dauerhafte Wiederverbindung; füge ServerAliveInterval 30

Kontextfenster überschritten

Lange Dateien/Unterhaltungen

Reduziere contextLength in config.json; verwende ein Modell mit längerem Kontext

JetBrains-Plugin wird nicht geladen

Inkompatibilität der IDE-Version

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ügen Sie --gpu-memory-utilization 0.85; verwende ein kleineres Modell oder eine quantisierte Version

Debug-Befehle

# Auf deinem LOKALEN Rechner — Konnektivität testen
curl http://localhost:11434/api/tags          # wenn du einen SSH-Tunnel verwendest
curl http://<clore-ip>:11434/api/tags        # wenn 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

# Prüfe die Syntax von config.json auf deinem lokalen Rechner
python3 -c "
import json, sys
try:
    config = json.load(open(sys.argv[1]))
    print('✅ Die Konfiguration 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 Doku für alle IDE-Integrationen und Konfigurationsoptionen
Continue.dev-GitHub — Quellcode, Issues, Modellkompatibilität
Continue.dev-Konfigurationsreferenz — vollständiges config.json Schema
Ollama auf Clore.ai — ausführliche Ollama-Einrichtungsanleitung (empfohlenes Backend)
vLLM auf Clore.ai — leistungsstarkes alternatives Backend für Teams
TabbyML — spezialisiertes Autovervollständigungs-Backend mit FIM-Optimierung
GPU-Vergleichsleitfaden — wähle die richtige GPU für deine Coding-Workload
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 — GPU-Server mieten

VorherigeHaystack-KI-Framework

NächsteOpen Interpreter

Zuletzt aktualisiert vor 1 Monat

War das hilfreich?