# Continue.dev KI-Coding

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.

{% hint style="success" %}
Alle GPU-Server-Beispiele verwenden Server, die über den [CLORE.AI-Marktplatz gemietet werden](https://clore.ai/marketplace).
{% endhint %}

{% hint style="info" %}
**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.
{% endhint %}

## Übersicht

| Eigenschaft             | Details                                                                                  |
| ----------------------- | ---------------------------------------------------------------------------------------- |
| **Projekt**             | [continuedev/continue](https://github.com/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 | 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.

```bash
# 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):

```bash
# 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
```

{% hint style="warning" %}
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](#tips--best-practices)).
{% endhint %}

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

```bash
# 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](https://tabby.tabbyml.com/) für vollständige Einrichtungsdetails.

```bash
# 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:**

1. Öffnen Sie das Erweiterungsfeld (`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**:

```json
{
  "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:

```json
{
  "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):

```json
{
  "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:

```bash
# 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

```bash
# 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:

```bash
# 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:

```bash
# 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

```bash
# 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             | 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 in der IDE sofort anzufühlen.

### Ollama für bessere Performance optimieren

```bash
# 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:

```json
{
  "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:

```bash
# 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:

```json
{
  "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

```bash
# 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

```bash
# 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](https://docs.continue.dev/) — offizielle Dokumentation für alle IDE-Integrationen und Konfigurationsoptionen
* [Continue.dev GitHub](https://github.com/continuedev/continue) — Quellcode, Issues, Modellkompatibilität
* [Continue.dev Konfig-Referenz](https://docs.continue.dev/reference) — vollständiges `config.json` Schema
* [Ollama auf Clore.ai](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) — ausführliche Ollama-Setup-Anleitung (empfohlenes Backend)
* [vLLM auf Clore.ai](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) — leistungsstarke alternative Backend-Lösung für Teams
* [TabbyML](https://tabby.tabbyml.com/) — spezialisiertes Autocomplete-Backend mit FIM-Optimierung
* [GPU-Vergleichsleitfaden](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison) — wähle die richtige GPU für deine Coding-Arbeitslast
* [Modellkompatibilität](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/model-compatibility) — welche Modelle in welche VRAM-Größen passen
* [Qwen2.5-Coder](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) — aktuell das beste offene Coding-Modell
* [DeepSeek-Coder-V2](https://huggingface.co/deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct) — starke Alternative mit langem Kontext
* [CLORE.AI-Marktplatz gemietet werden](https://clore.ai/marketplace) — GPU-Server mieten