> 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/andere-workloads/openclaw-on-clore.md).

# OpenClaw auf Clore

Stelle den OpenClaw-KI-Assistenten auf einem Clore.ai-GPU-Server bereit — dauerhaft aktiv, GPU-beschleunigt, mit Telegram-/Discord-Integration, lokaler LLM-Inferenz und Sprachfunktionen.

## Überblick

[OpenClaw](https://openclaw.ai) ist eine Open-Source-KI-Agentenplattform, die sich mit Claude, GPT, Gemini und lokalen Modellen verbindet — und als persönlicher KI-Assistent über Telegram, Discord, WhatsApp und mehr fungiert. Wenn Sie sie auf einem Clore.ai-Server betreiben, erhalten Sie:

* **24/7-Betriebszeit** — kein Schlafmodus des Laptops, keine Verbindungsabbrüche
* **GPU-Beschleunigung** — lokale LLM-Inferenz (Ollama, vLLM), Whisper-STT, TTS, Bildgenerierung
* **Geringe Kosten** — mieten Sie genau die Hardware, die Sie brauchen, und zahlen Sie pro Stunde
* **Volle Kontrolle** — Root-Zugriff, Docker-Unterstützung, beliebiger Software-Stack

### Warum Clore + OpenClaw?

| Funktion              | Laptop   | Traditioneller VPS | Clore.ai-Server           |
| --------------------- | -------- | ------------------ | ------------------------- |
| Dauerbetrieb          | ❌        | ✅                  | ✅                         |
| GPU verfügbar         | Begrenzt | ❌ oder $$$         | ✅ ab $0.10/Stunde         |
| Lokale LLM-Inferenz   | Langsam  | Nur CPU            | Volle GPU-Geschwindigkeit |
| Sprache (Whisper/TTS) | ✅        | Langsam (CPU)      | ✅ Echtzeit                |
| Root + Docker         | ✅        | ✅                  | ✅                         |
| Stundenabrechnung     | k. A.    | Monatlich          | ✅ Pro Stunde              |

### Empfohlene Hardware

| Anwendungsfall                                                  | GPU                | VRAM     | RAM    | Geschätzte Kosten                         |
| --------------------------------------------------------------- | ------------------ | -------- | ------ | ----------------------------------------- |
| **Einfacher Assistent** (nur API, keine lokalen Modelle)        | Beliebig / nur CPU | —        | 8 GB+  | $0.05–0.15/Stunde                         |
| **Lokales 7–8B-LMM** (Ollama + Llama 3.1 8B)                    | RTX 3060/3070      | 12 GB    | 16 GB+ | 0,03–0,07 $/Std.                          |
| **Lokales 70B-LMM** (vLLM + Llama 3.1 70B)                      | RTX 4090 / A100    | 24–80 GB | 64 GB+ | [Bare Metal](https://clore.ai/bare-metal) |
| **Vollständiger Stack** (LLM + Whisper + TTS + Bildgenerierung) | RTX 4090           | 24 GB    | 32 GB+ | ca. 0,14–0,42 $/h                         |

> **Tipp:** Wenn Sie OpenClaw nur als cloudbasierten Assistenten mit API-Modellen (Claude, GPT) benötigen, brauchen Sie überhaupt keine GPU — ein günstiger CPU-Server reicht völlig aus. Fügen Sie eine GPU hinzu, wenn Sie lokale Inferenz möchten.

***

## Schritt 1: Einen Server auf Clore.ai mieten

### 1.1 Den Marktplatz durchsuchen

Gehe zu [clore.ai/marketplace](https://clore.ai/marketplace) und nach Ihren Anforderungen filtern:

* **Für einfachen Assistenten**: Nach Preis sortieren, einen beliebigen günstigen Ubuntu-Server auswählen
* **Für lokales LLM**: Nach GPU filtern (z. B. RTX 4090), mindestens 24 GB VRAM sicherstellen
* **Betriebssystem**: Wählen Sie **Ubuntu 22.04** oder **Ubuntu 24.04** (beste Kompatibilität)

### 1.2 Eine Bestellung erstellen

1. Server auswählen → **Mieten**
2. Wähle **On-Demand** (stündlich) oder **Spot** (günstiger, kann aber überboten werden)
3. Das Docker-Image auswählen: **`ubuntu:22.04`** oder **`nvidia/cuda:12.8.1-runtime-ubuntu22.04`** (wenn Sie eine GPU benötigen)
4. Öffentlichen SSH-Schlüssel festlegen (oder Passwort verwenden — SSH-Schlüssel empfohlen)
5. Die Bestellung bestätigen

### 1.3 Per SSH verbinden

Sobald der Server läuft, finden Sie die SSH-Verbindungsdetails auf Ihrer [Bestellungen](https://clore.ai/my-orders) Seite:

```bash
ssh root@<server-ip> -p <port>
```

> **Hinweis:** Clore-Server verwenden Docker-Container, sodass Sie innerhalb des Containers Root-Zugriff erhalten. Der SSH-Port kann unüblich sein (z. B. 50022) — prüfen Sie die Bestelldetails.

***

## Schritt 2: OpenClaw installieren

### 2.1 Node.js 22+ installieren

```bash
# Systempakete aktualisieren
apt update && apt upgrade -y

# Node.js 22 über NodeSource installieren
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs

# Prüfen
node --version   # Sollte v22.x.x anzeigen
npm --version
```

### 2.2 OpenClaw installieren

**Option A: Installationsskript (empfohlen)**

```bash
curl -fsSL https://openclaw.ai/install.sh | bash
```

Das Skript installiert die CLI, führt das Onboarding aus und startet das Gateway.

**Option B: Manuelle npm-Installation**

```bash
npm install -g openclaw@latest
openclaw onboard --install-daemon
```

### 2.3 Den Onboarding-Assistenten ausführen

Wenn Sie das Installationsskript verwendet haben, läuft das Onboarding automatisch. Andernfalls:

```bash
openclaw onboard --install-daemon
```

Der Assistent wird Sie fragen, um:

1. **Die Authentifizierung einrichten** — Ihren Anthropic-API-Schlüssel einfügen oder per OAuth verbinden
2. **Einen Kanal auswählen** — Telegram-Bot-Token, Discord, WhatsApp usw.
3. **Das Gateway konfigurieren** — Port, Bindung, Sicherheit

> **Für Telegram:** Einen Bot erstellen über [@BotFather](https://t.me/BotFather), das Token kopieren und während des Onboardings einfügen.

***

## Schritt 3: Für den Dauerbetrieb konfigurieren

### 3.1 Das Gateway als Dienst starten

```bash
# Prüfen, ob das Gateway läuft
openclaw gateway status

# Starten (falls es noch nicht läuft)
openclaw gateway start

# Überprüfen, ob es fehlerfrei läuft
openclaw status
```

### 3.2 Mit systemd am Laufen halten (empfohlen)

Wenn OpenClaw den systemd-Dienst nicht automatisch installiert hat:

```bash
# Eine systemd-Dienstdatei erstellen
cat > /etc/systemd/system/openclaw.service << 'EOF'
[Unit]
Description=OpenClaw Gateway
After=network.target

[Service]
Type=simple
ExecStart=/usr/bin/openclaw gateway --port 18789
Restart=always
RestartSec=10
Environment=NODE_ENV=production
WorkingDirectory=/root

[Install]
WantedBy=multi-user.target
EOF

# Aktivieren und starten
systemctl daemon-reload
systemctl enable openclaw
systemctl start openclaw

# Status prüfen
systemctl status openclaw
```

### 3.3 Alternative: Screen/tmux (schnell & einfach)

```bash
# Screen installieren
apt install -y screen

# OpenClaw in einer abgetrennten Screen-Sitzung starten
screen -dmS openclaw openclaw gateway --port 18789

# Später wieder anhängen
screen -r openclaw
```

***

## Schritt 4: GPU-Einrichtung (optional — für lokale Modelle)

Überspringen Sie diesen Abschnitt, wenn Sie nur API-basierte Modelle verwenden (Claude, GPT usw.).

### 4.1 GPU-Zugriff prüfen

```bash
# Prüfen, ob NVIDIA-Treiber verfügbar sind
nvidia-smi
```

Falls `nvidia-smi` funktioniert, ist Ihre GPU bereit. Die meisten Clore-CUDA-Images sind vorab konfiguriert.

### 4.2 Ollama installieren (lokale LLM-Inferenz)

```bash
curl -fsSL https://ollama.com/install.sh | sh

# Ollama starten
ollama serve &

# Ein Modell abrufen
ollama pull llama3.1:8b        # 8B — passt in 12 GB VRAM
# ollama pull llama3.1:70b     # 70B — benötigt 48 GB+ VRAM
# ollama pull qwen2.5:32b      # 32B — benötigt 24 GB VRAM
```

Konfigurieren Sie OpenClaw so, dass Ollama als Anbieter verwendet wird — siehe die [Ollama-Anleitung](/guides/guides_v2-de/sprachmodelle/ollama.md) für Details.

### 4.3 Whisper installieren (Sprachtranskription)

Für GPU-beschleunigte Spracherkennung:

```bash
pip install faster-whisper

# Oder WhisperX für bessere Genauigkeit verwenden
pip install whisperx
```

Siehe die [WhisperX-Anleitung](/guides/guides_v2-de/audio-and-stimme/whisperx.md) für die vollständige Einrichtung.

***

## Schritt 5: Sicherheit & Fernzugriff

### 5.1 Das Gateway absichern

Standardmäßig bindet das Gateway an den Loopback (127.0.0.1). Für Fernzugriff:

**Option A: SSH-Tunnel (am sichersten)**

Von Ihrem Laptop aus:

```bash
ssh -N -L 18789:127.0.0.1:18789 root@<server-ip> -p <port>
```

Dann öffnen Sie `http://127.0.0.1:18789/` in Ihrem Browser.

**Option B: Direkter Zugriff mit Token-Schutz**

Bearbeiten Sie `~/.openclaw/config.json5`:

```json5
{
  gateway: {
    bind: "lan",       // Auf allen Schnittstellen lauschen
    port: 18789,
    auth: {
      token: "your-secret-token-here"  // Für Fernzugriff erforderlich!
    }
  }
}
```

> ⚠️ **Immer ein Token setzen** wenn Sie an `lan`binden. Ohne Token kann jeder auf Ihr Gateway zugreifen.

### 5.2 Firewall-Einrichtung

```bash
# UFW installieren
apt install -y ufw

# SSH erlauben (verwenden Sie Ihren Clore-SSH-Port)
ufw allow <ssh-port>/tcp

# OpenClaw-Gateway erlauben (nur bei direktem Zugriff)
ufw allow 18789/tcp

# Firewall aktivieren
ufw enable
```

***

## Schritt 6: Persistenz & Backups

### 6.1 Wichtige Verzeichnisse

| Pfad                     | Inhalt                                                      |
| ------------------------ | ----------------------------------------------------------- |
| `~/.openclaw/`           | Konfiguration, Authentifizierung, Zustand, Agentenprofile   |
| `~/.openclaw/workspace/` | MEMORY.md, tägliche Notizen, Fähigkeiten, Werkzeuge         |
| `~/.openclaw/agents/`    | Multi-Agenten-Konfigurationen (wenn Teams verwendet werden) |

### 6.2 Backup-Skript

Erstellen Sie ein einfaches Backup, um Ihre Konfiguration zu sichern:

```bash
cat > /root/backup-openclaw.sh << 'EOF'
#!/bin/bash
BACKUP_DIR="/root/openclaw-backups"
mkdir -p "$BACKUP_DIR"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
tar czf "$BACKUP_DIR/openclaw-$TIMESTAMP.tar.gz" \
  ~/.openclaw/config.json5 \
  ~/.openclaw/workspace/ \
  ~/.openclaw/agents/ \
  ~/.openclaw/identity/
echo "Backup gespeichert: $BACKUP_DIR/openclaw-$TIMESTAMP.tar.gz"
EOF
chmod +x /root/backup-openclaw.sh

# Täglich per Cron ausführen
(crontab -l 2>/dev/null; echo "0 4 * * * /root/backup-openclaw.sh") | crontab -
```

### 6.3 Zwischen Servern migrieren

Wenn Sie auf einen anderen Clore-Server wechseln müssen:

```bash
# Auf dem alten Server — exportieren
tar czf /tmp/openclaw-migration.tar.gz ~/.openclaw/

# Auf den neuen Server übertragen
scp -P <port> /tmp/openclaw-migration.tar.gz root@<new-server-ip>:/tmp/

# Auf dem neuen Server — importieren
tar xzf /tmp/openclaw-migration.tar.gz -C /
openclaw gateway start
```

***

## Beispielkonfigurationen

### Einfacher Telegram-Bot (ohne GPU)

Günstigste Einrichtung — nur ein KI-Assistent mit API:

```
Server: Beliebiges Ubuntu, keine GPU nötig
Kosten: ca. $0.05–0.15/Stunde ($3–10/Monat)
Konfiguration: Anthropic-API-Schlüssel + Telegram-Bot-Token
```

### KI-Workstation (GPU)

Voll ausgestattet mit lokalen Modellen:

```
Server: RTX 4090, 24 GB VRAM, 32 GB RAM
Kosten: ca. $0.25–0.50/Stunde
Stack: OpenClaw + Ollama (Llama 3.1 70B) + WhisperX + Coqui TTS
```

### Multi-Agenten-Team

Betreiben Sie ein Team spezialisierter KI-Agenten:

```
Server: RTX 4090 oder Dual-GPU
Kosten: ca. $0.30–0.60/Stunde
Stack: OpenClaw Multi-Agent (5+ Agenten) + Ollama + gemeinsame Skills
```

***

## Fehlerbehebung

### Gateway startet nicht

```bash
# Protokolle prüfen
openclaw gateway status
journalctl -u openclaw -n 50

# Häufige Lösung: Port wird bereits verwendet
lsof -i :18789
kill <pid>
openclaw gateway start
```

### GPU nicht erkannt

```bash
# NVIDIA-Treiber prüfen
nvidia-smi

# Falls nicht gefunden, benötigen Sie möglicherweise das CUDA-Docker-Image
# Bestellung neu erstellen mit nvidia/cuda:12.8.1-runtime-ubuntu22.04
```

### Verbindung bricht bei Server-Neustart ab

Clore-Spot-Instanzen können zurückgefordert werden. Für den dauerhaften Betrieb:

* Verwende **On-Demand** Preisgestaltung (nicht Spot)
* Den systemd-Dienst einrichten (automatischer Neustart)
* Backups behalten (das Backup-Skript oben)
* Für kritische Workloads einen dedizierten/reservierten Server in Betracht ziehen

### Node.js-Versionsprobleme

```bash
# Version prüfen
node --version

# Falls unter v22, neu installieren
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
```

***

## Tipps & bewährte Praktiken

1. **Günstig starten** — Verwenden Sie zuerst einen einfachen CPU-Server. Fügen Sie eine GPU hinzu, wenn Sie lokale Inferenz benötigen.
2. **Für Produktion On-Demand verwenden** — Spot ist günstiger, kann aber unterbrochen werden. On-Demand garantiert Betriebszeit.
3. **Regelmäßig sichern** — Ihr `~/.openclaw/workspace/` enthält den gesamten Speicher und alle Konfigurationen.
4. **Kosten überwachen** — Prüfen Sie regelmäßig Ihr Clore-Dashboard. Legen Sie falls verfügbar Ausgabenalarme fest.
5. **Die Control-UI verwenden** — Zugriff per SSH-Tunnel unter `http://127.0.0.1:18789/` für webbasierte Verwaltung.
6. **Mit API-Modellen kombinieren** — Auch mit einem GPU-Server können Sie Claude/GPT per API für den Hauptagenten verwenden und lokale Modelle für spezielle Aufgaben (Embeddings, Transkription).

***

## Weiterführende Lektüre

* [OpenClaw Erste Schritte](https://docs.openclaw.ai/start/getting-started)
* [OpenClaw VPS-Hosting-Anleitung](https://docs.openclaw.ai/install/vps)
* [OpenClaw-Docker-Setup](https://docs.openclaw.ai/install/docker)
* [Ollama auf Clore](/guides/guides_v2-de/sprachmodelle/ollama.md)
* [vLLM auf Clore](/guides/guides_v2-de/sprachmodelle/vllm.md)
* [GPU-Vergleich & Preise](/guides/guides_v2-de/erste-schritte/gpu-comparison.md)


---

# 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/andere-workloads/openclaw-on-clore.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.
