> 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-fr/autres-charges-de-travail/openclaw-on-clore.md).

# OpenClaw sur Clore

## Aperçu

[OpenClaw](https://openclaw.ai) est une plateforme d'agents IA open-source qui se connecte à Claude, GPT, Gemini et des modèles locaux — agissant comme un assistant IA personnel sur Telegram, Discord, WhatsApp et plus. L'exécuter sur un serveur Clore.ai vous offre :

* **Disponibilité 24/7** — pas de mise en veille de l'ordinateur portable, pas de déconnexions
* **Accélération GPU** — inférence LLM locale (Ollama, vLLM), STT Whisper, TTS, génération d'images
* **Faible coût** — louez exactement le matériel dont vous avez besoin, payez à l'heure
* **Contrôle total** — accès root, prise en charge de Docker, n'importe quelle pile logicielle

### Pourquoi Clore + OpenClaw ?

| Fonctionnalité       | Ordinateur portable | VPS traditionnel | Serveur Clore.ai       |
| -------------------- | ------------------- | ---------------- | ---------------------- |
| Toujours actif       | ❌                   | ✅                | ✅                      |
| GPU disponible       | Limité              | ❌ ou $$$         | ✅ à partir de 0,10 $/h |
| Inférence LLM locale | Lent                | CPU seulement    | Pleine vitesse GPU     |
| Voix (Whisper/TTS)   | ✅                   | Lent (CPU)       | ✅ Temps réel           |
| Root + Docker        | ✅                   | ✅                | ✅                      |
| Facturation horaire  | N/A                 | Mensuel          | ✅ À l'heure            |

### Matériel recommandé

| Cas d'utilisation                                             | GPU                              | VRAM     | RAM    | Coût estimé   |
| ------------------------------------------------------------- | -------------------------------- | -------- | ------ | ------------- |
| **Assistant de base** (API uniquement, pas de modèles locaux) | N'importe lequel / CPU seulement | —        | 8 Go+  | 0,05–0,15 $/h |
| **LLM local 7–8B** (Ollama + Llama 3.1 8B)                    | RTX 3060/3070                    | 12 Go    | 16 Go+ | 0,10–0,25 $/h |
| **LLM local 70B** (vLLM + Llama 3.1 70B)                      | RTX 4090 / A100                  | 24–80 Go | 64 Go+ | 0,30–1,00 $/h |
| **Pile complète** (LLM + Whisper + TTS + génération d'images) | RTX 4090                         | 24 Go    | 32 Go+ | 0,25–0,50 $/h |

> **Astuce :** Si vous n'avez besoin d'OpenClaw qu'en tant qu'assistant cloud utilisant des modèles API (Claude, GPT), vous n'avez pas besoin de GPU du tout — un serveur CPU bon marché suffit. Ajoutez un GPU lorsque vous souhaitez l'inférence locale.

***

## Étape 1 : Louer un serveur sur Clore.ai

### 1.1 Parcourir le Marketplace

Aller à [clore.ai/marketplace](https://clore.ai/marketplace) et filtrez selon vos exigences :

* **Pour un assistant de base** : Triez par prix, choisissez n'importe quel serveur Ubuntu bon marché
* **Pour un LLM local** : Filtrez par GPU (par ex. RTX 4090), assurez-vous ≥24 Go de VRAM
* **OS** : Choisir **Ubuntu 22.04** ou **Ubuntu 24.04** (meilleure compatibilité)

### 1.2 Créer une commande

1. Sélectionnez le serveur → **Louer**
2. Choisir **À la demande** (horaire) ou **Spot** (moins cher mais peut être surenchéri)
3. Sélectionnez l'image Docker : **`ubuntu:22.04`** ou **`nvidia/cuda:12.4.0-runtime-ubuntu22.04`** (si vous avez besoin de GPU)
4. Définissez la clé publique SSH (ou utilisez un mot de passe — clé SSH recommandée)
5. Confirmez la commande

### 1.3 Se connecter via SSH

Une fois le serveur en fonctionnement, trouvez les détails de connexion SSH dans votre [Commandes](https://clore.ai/my-orders) page :

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

> **Remarque :** Les serveurs Clore utilisent des conteneurs Docker, vous obtenez donc un accès root à l'intérieur du conteneur. Le port SSH peut être non standard (par ex. 50022) — vérifiez les détails de votre commande.

***

## Étape 2 : Installer OpenClaw

### 2.1 Installer Node.js 22+

```bash
# Mettre à jour les paquets système
apt update && apt upgrade -y

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

# Vérifier
node --version   # Devrait afficher v22.x.x
npm --version
```

### 2.2 Installer OpenClaw

**Option A : Script d'installation (recommandé)**

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

Le script installe l'outil CLI, lance l'onboarding et démarre la passerelle.

**Option B : Installation manuelle via npm**

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

### 2.3 Lancer l'assistant d'onboarding

Si vous avez utilisé le script d'installation, l'onboarding s'exécute automatiquement. Sinon :

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

L'assistant vous demandera de :

1. **Configurer l'authentification** — collez votre clé API Anthropic ou connectez-vous via OAuth
2. **Choisir un canal** — jeton de bot Telegram, Discord, WhatsApp, etc.
3. **Configurer la passerelle** — port, liaison, sécurité

> **Pour Telegram :** Créez un bot via [@BotFather](https://t.me/BotFather), copiez le jeton et collez-le pendant l'onboarding.

***

## Étape 3 : Configurer pour un fonctionnement toujours actif

### 3.1 Démarrer la passerelle en tant que service

```bash
# Vérifier si la passerelle fonctionne
openclaw gateway status

# La démarrer (si elle ne fonctionne pas déjà)
openclaw gateway start

# Vérifier qu'elle est saine
openclaw status
```

### 3.2 La garder en marche avec systemd (recommandé)

Si OpenClaw n'a pas auto-installé le service systemd :

```bash
# Créer un fichier de service systemd
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

# Activer et démarrer
systemctl daemon-reload
systemctl enable openclaw
systemctl start openclaw

# Vérifier le statut
systemctl status openclaw
```

### 3.3 Alternative : Screen/tmux (Rapide & Simple)

```bash
# Installer screen
apt install -y screen

# Démarrer OpenClaw dans une session screen détachée
screen -dmS openclaw openclaw gateway --port 18789

# Se rattacher plus tard
screen -r openclaw
```

***

## Étape 4 : Configuration GPU (Optionnel — Pour modèles locaux)

Ignorez cette section si vous utilisez uniquement des modèles basés sur API (Claude, GPT, etc.).

### 4.1 Vérifier l'accès GPU

```bash
# Vérifier si les pilotes NVIDIA sont disponibles
nvidia-smi
```

Si `nvidia-smi` fonctionne, votre GPU est prêt. La plupart des images CUDA Clore sont préconfigurées.

### 4.2 Installer Ollama (Inférence LLM locale)

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

# Démarrer Ollama
ollama serve &

# Récupérer un modèle
ollama pull llama3.1:8b        # 8B — tient dans 12Go de VRAM
# ollama pull llama3.1:70b     # 70B — nécessite 48Go+ de VRAM
# ollama pull qwen2.5:32b      # 32B — nécessite 24Go de VRAM
```

Configurer OpenClaw pour utiliser Ollama comme fournisseur — voir le [guide Ollama](/guides/guides_v2-fr/modeles-de-langage/ollama.md) pour les détails.

### 4.3 Installer Whisper (Transcription vocale)

Pour la reconnaissance vocale accélérée par GPU :

```bash
pip install faster-whisper

# Ou utilisez WhisperX pour une meilleure précision
pip install whisperx
```

Voir le [guide WhisperX](/guides/guides_v2-fr/audio-et-voix/whisperx.md) pour l'installation complète.

***

## Étape 5 : Sécurité & Accès à distance

### 5.1 Sécuriser la passerelle

Par défaut, la passerelle se lie à loopback (127.0.0.1). Pour un accès à distance :

**Option A : Tunnel SSH (le plus sécurisé)**

Depuis votre ordinateur portable :

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

Puis ouvrez `http://127.0.0.1:18789/` dans votre navigateur.

**Option B : Accès direct protégé par token**

Éditez `~/.openclaw/config.json5`:

```json5
{
  gateway: {
    bind: "lan",       // Écouter sur toutes les interfaces
    port: 18789,
    auth: {
      token: "votre-token-secret-ici"  // Requis pour l'accès à distance !
    }
  }
}
```

> ⚠️ **Toujours définir un token** si liaison à `lan`. Sans cela, n'importe qui peut accéder à votre passerelle.

### 5.2 Configuration du pare-feu

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

# Autoriser SSH (utilisez votre port SSH Clore)
ufw allow <ssh-port>/tcp

# Autoriser la passerelle OpenClaw (uniquement si vous utilisez l'accès direct)
ufw allow 18789/tcp

# Activer le pare-feu
ufw enable
```

***

## Étape 6 : Persistance & Sauvegardes

### 6.1 Répertoires importants

| Chemin                   | Contenu                                                |
| ------------------------ | ------------------------------------------------------ |
| `~/.openclaw/`           | Configuration, auth, état, profils d'agents            |
| `~/.openclaw/workspace/` | MEMORY.md, notes quotidiennes, compétences, outils     |
| `~/.openclaw/agents/`    | Configurations multi-agents (si utilisation d'équipes) |

### 6.2 Script de sauvegarde

Créez une sauvegarde simple pour protéger votre configuration :

```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 "Sauvegarde enregistrée : $BACKUP_DIR/openclaw-$TIMESTAMP.tar.gz"
EOF
chmod +x /root/backup-openclaw.sh

# Exécuter quotidiennement via cron
(crontab -l 2>/dev/null; echo "0 4 * * * /root/backup-openclaw.sh") | crontab -
```

### 6.3 Migration entre serveurs

Si vous devez passer à un autre serveur Clore :

```bash
# Sur l'ancien serveur — exporter
tar czf /tmp/openclaw-migration.tar.gz ~/.openclaw/

# Transférer vers le nouveau serveur
scp -P <port> /tmp/openclaw-migration.tar.gz root@<new-server-ip>:/tmp/

# Sur le nouveau serveur — importer
tar xzf /tmp/openclaw-migration.tar.gz -C /
openclaw gateway start
```

***

## Configurations d'exemple

### Bot Telegram basique (Pas de GPU)

Configuration la moins chère — juste un assistant alimenté par API :

```
Serveur : N'importe quel Ubuntu, pas de GPU requis
Coût : ~0,05–0,15 $/h (3–10 $/mois)
Config : clé API Anthropic + jeton de bot Telegram
```

### Station de travail IA (GPU)

Fonctionnalités complètes avec modèles locaux :

```
Serveur : RTX 4090, 24Go VRAM, 32Go RAM
Coût : ~0,25–0,50 $/h
Pile : OpenClaw + Ollama (Llama 3.1 70B) + WhisperX + Coqui TTS
```

### Équipe multi-agents

Exécutez une équipe d'agents IA spécialisés :

```
Serveur : RTX 4090 ou GPU double
Coût : ~0,30–0,60 $/h
Pile : OpenClaw multi-agent (5+ agents) + Ollama + compétences partagées
```

***

## Dépannage

### La passerelle ne démarre pas

```bash
# Vérifier les journaux
openclaw gateway status
journalctl -u openclaw -n 50

# Correction courante : port déjà utilisé
lsof -i :18789
kill <pid>
openclaw gateway start
```

### GPU non détecté

```bash
# Vérifier les pilotes NVIDIA
nvidia-smi

# Si non trouvé, vous pourriez avoir besoin de l'image Docker CUDA
# Re-créer la commande avec nvidia/cuda:12.4.0-runtime-ubuntu22.04
```

### Connexions coupées au redémarrage du serveur

Les instances spot Clore peuvent être récupérées. Pour une opération persistante :

* Utilisez **la tarification à la demande (pas spot)** Configurez le service systemd (redémarrage automatique)
* Conservez des sauvegardes (le script de sauvegarde ci-dessus)
* Envisagez un serveur dédié/réservé pour les charges critiques
* Problèmes de version Node.js

### # Vérifier la version

```bash
node --version
# Si inférieure à v22, réinstallez

Conseils & Bonnes pratiques
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
```

***

## Commencez bon marché

1. **— Utilisez d'abord un serveur CPU basique. Ajoutez un GPU lorsque vous avez besoin d'inférence locale.** Utilisez on-demand pour la production
2. **— Spot est moins cher mais peut être interrompu. On-demand garantit la disponibilité.** Sauvegardez régulièrement
3. **— Votre** contient toute la mémoire et les configurations. `~/.openclaw/workspace/` Surveillez les coûts
4. **— Vérifiez régulièrement votre tableau de bord Clore. Configurez des alertes de dépenses si disponible.** Utilisez l'interface Control
5. **— Accédez via tunnel SSH à** pour la gestion via le web. `http://127.0.0.1:18789/` Combinez avec des modèles API
6. **— Même avec un serveur GPU, utilisez Claude/GPT via API pour l'agent principal et des modèles locaux pour des tâches spécifiques (embeddings, transcription).** Lectures complémentaires

***

## Prise en main d'OpenClaw

* [Guide d'hébergement VPS OpenClaw](https://docs.openclaw.ai/start/getting-started)
* [Configuration Docker OpenClaw](https://docs.openclaw.ai/install/vps)
* [Ollama sur Clore](https://docs.openclaw.ai/install/docker)
* [vLLM sur Clore](/guides/guides_v2-fr/modeles-de-langage/ollama.md)
* [Comparaison GPU & Tarification](/guides/guides_v2-fr/modeles-de-langage/vllm.md)
* [Comparaison GPU & Tarification](/guides/guides_v2-fr/prise-en-main/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-fr/autres-charges-de-travail/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.