> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/continue-dev.md).

# 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](/guides/guides_v2-de/sprachmodelle/ollama.md) — ausführliche Ollama-Setup-Anleitung (empfohlenes Backend)
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — leistungsstarke alternative Backend-Lösung für Teams
* [TabbyML](https://tabby.tabbyml.com/) — spezialisiertes Autocomplete-Backend mit FIM-Optimierung
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — wähle die richtige GPU für deine Coding-Arbeitslast
* [Modellkompatibilität](/guides/guides_v2-de/erste-schritte/model-compatibility.md) — 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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/ki-plattformen-and-agenten/continue-dev.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.