> 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

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.

{% hint style="success" %}
Alle GPU-Server-Beispiele verwenden Server, die über die [CLORE.AI-Marktplatz](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 zu einer Drittanbieter-API.
{% endhint %}

## Überblick

| 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                                           |
| **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](https://clore.ai/bare-metal) | Mehrere 34B-Modelle gleichzeitig                |
| **Maximum**   | A100 80GB | 80 GB | 80 GB | 200 GB     | [Bare Metal](https://clore.ai/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.

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

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

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

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

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

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

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

Bearbeiten Sie `~/.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 (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:

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

```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)

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

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

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

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

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

```bash
# 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             | 8K      | \~40–60 t/s    |
| RTX 3060 12 GB | DeepSeek-Coder 6.7B      | 8K      | \~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

```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 & 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:

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

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

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

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

```bash
# 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](https://docs.continue.dev/) — offizielle Doku für alle IDE-Integrationen und Konfigurationsoptionen
* [Continue.dev-GitHub](https://github.com/continuedev/continue) — Quellcode, Issues, Modellkompatibilität
* [Continue.dev-Konfigurationsreferenz](https://docs.continue.dev/reference) — vollständiges `config.json` Schema
* [Ollama auf Clore.ai](/guides/guides_v2-de/sprachmodelle/ollama.md) — ausführliche Ollama-Einrichtungsanleitung (empfohlenes Backend)
* [vLLM auf Clore.ai](/guides/guides_v2-de/sprachmodelle/vllm.md) — leistungsstarkes alternatives Backend für Teams
* [TabbyML](https://tabby.tabbyml.com/) — spezialisiertes Autovervollständigungs-Backend mit FIM-Optimierung
* [GPU-Vergleichsleitfaden](/guides/guides_v2-de/erste-schritte/gpu-comparison.md) — wähle die richtige GPU für deine Coding-Workload
* [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](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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.