# OpenClaw auf Clore

## Überblick

[OpenClaw](https://openclaw.ai) ist eine Open-Source-AI-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 Laptop-Schlaf, keine Verbindungsabbrüche
* **GPU-Beschleunigung** — lokale LLM-Inferenz (Ollama, vLLM), Whisper STT, TTS, Bildgenerierung
* **Geringe Kosten** — mieten Sie genau die Hardware, die Sie brauchen, Zahlung pro Stunde
* **Volle Kontrolle** — Root-Zugriff, Docker-Unterstützung, beliebiger Software-Stack

### Warum Clore + OpenClaw?

| Funktion              | Laptop   | Traditioneller VPS | Clore.ai Server           |
| --------------------- | -------- | ------------------ | ------------------------- |
| Immer eingeschaltet   | ❌        | ✅                  | ✅                         |
| 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     | N/A      | Monatlich          | ✅ Pro Stunde              |

### Empfohlene Hardware

| Anwendungsfall                                                  | GPU                | VRAM     | RAM    | Gesch. Kosten     |
| --------------------------------------------------------------- | ------------------ | -------- | ------ | ----------------- |
| **Basis-Assistent** (Nur API, keine lokalen Modelle)            | Beliebig / Nur CPU | —        | 8 GB+  | $0.05–0.15/Stunde |
| **Lokales 7–8B LLM** (Ollama + Llama 3.1 8B)                    | RTX 3060/3070      | 12 GB    | 16 GB+ | $0.10–0.25/Stunde |
| **Lokales 70B LLM** (vLLM + Llama 3.1 70B)                      | RTX 4090 / A100    | 24–80 GB | 64 GB+ | $0.30–1.00/Stunde |
| **Vollständiger Stack** (LLM + Whisper + TTS + Bildgenerierung) | RTX 4090           | 24 GB    | 32 GB+ | $0.25–0.50/Stunde |

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

***

## Schritt 1: Mieten Sie einen Server auf Clore.ai

### 1.1 Durchsuchen Sie den Marktplatz

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

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

### 1.2 Erstellen Sie eine Bestellung

1. Wählen Sie den Server → **Mieten**
2. Wählen **On-Demand** (stündlich) oder **Spot** (günstiger, kann aber überboten werden)
3. Wählen Sie das Docker-Image aus: **`ubuntu:22.04`** oder **`nvidia/cuda:12.4.0-runtime-ubuntu22.04`** (falls Sie eine GPU benötigen)
4. Setzen Sie den SSH-Public-Key (oder verwenden Sie ein Passwort — SSH-Schlüssel empfohlen)
5. Bestätigen Sie die Bestellung

### 1.3 Verbinden Sie sich per SSH

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

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

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

***

## Schritt 2: Installieren Sie OpenClaw

### 2.1 Installieren Sie Node.js 22+

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

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

### 2.2 Installieren Sie OpenClaw

**Option A: Installationsskript (empfohlen)**

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

Das Skript installiert das 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 Führen Sie den Onboarding-Assistenten aus

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

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

Der Assistent wird Sie bitten:

1. **Authentifizierung einrichten** — fügen Sie Ihren Anthropic-API-Schlüssel ein oder verbinden Sie sich über OAuth
2. **Wählen Sie einen Kanal** — Telegram-Bot-Token, Discord, WhatsApp usw.
3. **Konfigurieren Sie das Gateway** — Port, Bindung, Sicherheit

> **Für Telegram:** Erstellen Sie einen Bot über [@BotFather](https://t.me/BotFather), kopieren Sie das Token und fügen Sie es während des Onboardings ein.

***

## Schritt 3: Konfiguration für den Always-On-Betrieb

### 3.1 Starten Sie das Gateway als Dienst

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

# Starten (falls noch nicht gestartet)
openclaw gateway start

# Überprüfen Sie, ob es gesund ist
openclaw status
```

### 3.2 Lassen Sie es mit systemd laufen (empfohlen)

Falls OpenClaw den systemd-Dienst nicht automatisch installiert hat:

```bash
# Erstellen Sie eine systemd-Dienstdatei
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
# Installieren Sie screen
apt install -y screen

# Starten Sie OpenClaw in einer detached screen-Session
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 (Claude, GPT usw.) verwenden.

### 4.1 GPU-Zugriff überprüfen

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

Wenn `nvidia-smi` funktioniert, ist Ihre GPU bereit. Die meisten Clore CUDA-Images sind vorkonfiguriert.

### 4.2 Installieren Sie Ollama (lokale LLM-Inferenz)

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

# Ollama starten
ollama serve &

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

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

### 4.3 Installieren Sie Whisper (Spracherkennung)

Für GPU-beschleunigte Speech-to-Text:

```bash
pip install faster-whisper

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

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

***

## Schritt 5: Sicherheit & Fernzugriff

### 5.1 Sichern Sie das Gateway

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

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

Von Ihrem Laptop:

```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: Token-geschützter Direktzugriff**

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

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

> ⚠️ **Setzen Sie immer ein Token** wenn Sie an `lan`binden.

### Ohne dieses kann jeder auf Ihr Gateway zugreifen.

```bash
5.2 Firewall-Einrichtung
# Installieren Sie UFW

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, Auth, Zustand, Agentenprofile` | \~/.openclaw/workspace/ |
| `MEMORY.md, tägliche Notizen, Skills, Tools`   | \~/.openclaw/agents/    |

### Multi-Agenten-Konfigurationen (bei Nutzung von Teams)

6.2 Backup-Skript

```bash
Erstellen Sie ein einfaches Backup, um Ihre Konfiguration zu sichern:
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/
EOF
echo "Backup gespeichert: $BACKUP_DIR/openclaw-$TIMESTAMP.tar.gz"

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 Migration zwischen Servern

```bash
Wenn Sie zu einem anderen Clore-Server wechseln müssen:
# 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
openclaw gateway start
```

***

## tar xzf /tmp/openclaw-migration.tar.gz -C /

### Beispielkonfigurationen

Basis Telegram-Bot (keine GPU)

```
Günstigste Konfiguration — nur ein API-basierter Assistent:
Server: Beliebiges Ubuntu, keine GPU benötigt
Kosten: ~ $0.05–0.15/Stunde ($3–10/Monat)
```

### Konfiguration: Anthropic-API-Schlüssel + Telegram-Bot-Token

AI-Arbeitsstation (GPU)

```
Voll ausgestattet mit lokalen Modellen:
Server: RTX 4090, 24GB VRAM, 32GB RAM
Kosten: ~ $0.25–0.50/Stunde
```

### Stack: OpenClaw + Ollama (Llama 3.1 70B) + WhisperX + Coqui TTS

Multi-Agenten-Team

```
Betreiben Sie ein Team spezialisierter AI-Agenten:
Server: RTX 4090 oder Dual-GPU
Kosten: ~ $0.30–0.60/Stunde
```

***

## Stack: OpenClaw Multi-Agent (5+ Agenten) + Ollama + geteilte Skills

### Fehlerbehebung

```bash
Gateway startet nicht
openclaw gateway status
# Logs prüfen

journalctl -u openclaw -n 50
# Häufige Ursache: Port bereits in Gebrauch
lsof -i :18789
openclaw gateway start
```

### kill \<pid>

```bash
GPU wird nicht erkannt
nvidia-smi

# NVIDIA-Treiber prüfen
# Falls nicht gefunden, benötigen Sie möglicherweise das CUDA-Docker-Image
```

### # Bestellung mit nvidia/cuda:12.4.0-runtime-ubuntu22.04 neu erstellen

Verbindung bricht bei Server-Neustart ab

* Clore-Spot-Instanzen können zurückgefordert werden. Für persistente Operation: **Verwenden Sie** On-Demand
* Preise (nicht Spot)
* Richten Sie den systemd-Dienst ein (automatischer Neustart)
* Bewahren Sie Backups auf (das obenstehende Backup-Skript)

### Erwägen Sie einen dedizierten/reservierten Server für kritische Workloads

```bash
Node.js Versionsprobleme
# Version prüfen

node --version
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
```

***

## # Falls unter v22, neu installieren

1. **Tipps & Best Practices** Günstig starten
2. **— Verwenden Sie zunächst einen einfachen CPU-Server. Fügen Sie eine GPU hinzu, wenn Sie lokale Inferenz benötigen.** Verwenden Sie On-Demand für Produktion
3. **— Spot ist günstiger, kann aber unterbrochen werden. On-Demand garantiert Betriebszeit.** Regelmäßig sichern `Konfiguration, Auth, Zustand, Agentenprofile` — Ihr
4. **enthält alle Erinnerungen und Konfigurationen.** Kosten überwachen
5. **— Prüfen Sie regelmäßig Ihr Clore-Dashboard. Legen Sie Ausgabenwarnungen fest, falls verfügbar.** Verwenden Sie die Control-UI `http://127.0.0.1:18789/` — Zugriff über SSH-Tunnel unter
6. **für webbasierte Verwaltung.** Mit API-Modellen kombinieren

***

## — Selbst mit einem GPU-Server sollten Sie Claude/GPT per API für den Hauptagenten verwenden und lokale Modelle für spezielle Aufgaben (Embeddings, Transkription).

* [Weiterführende Lektüre](https://docs.openclaw.ai/start/getting-started)
* [OpenClaw Erste Schritte](https://docs.openclaw.ai/install/vps)
* [OpenClaw VPS-Hosting-Anleitung](https://docs.openclaw.ai/install/docker)
* [OpenClaw Docker-Einrichtung](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama)
* [Ollama auf Clore](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm)
* [vLLM auf Clore](https://docs.clore.ai/guides/guides_v2-de/erste-schritte/gpu-comparison)