> 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

## Ü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](/guides/guides_v2-de/sprachmodelle/ollama.md) 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](/guides/guides_v2-de/audio-and-sprache/whisperx.md) 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](/guides/guides_v2-de/sprachmodelle/ollama.md)
* [Ollama auf Clore](/guides/guides_v2-de/sprachmodelle/vllm.md)
* [vLLM auf Clore](/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:

```
GET https://docs.clore.ai/guides/guides_v2-de/andere-workloads/openclaw-on-clore.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.