> 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

Déployez l’assistant IA OpenClaw sur un serveur GPU Clore.ai — toujours actif, accéléré par GPU, avec intégration Telegram/Discord, inférence locale de LLM et capacités vocales.

## Aperçu

[OpenClaw](https://openclaw.ai) est une plateforme d'agents IA open source qui se connecte à Claude, GPT, Gemini et aux modèles locaux — agissant comme un assistant IA personnel sur Telegram, Discord, WhatsApp, et plus encore. Le faire tourner sur un serveur Clore.ai vous donne :

* **Disponibilité 24h/24, 7j/7** — pas de veille de l'ordinateur portable, pas de déconnexions
* **Accélération GPU** — inférence LLM locale (Ollama, vLLM), transcription vocale 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 uniquement   | Vitesse GPU complète   |
| Voix (Whisper/TTS)   | ✅                   | Lent (CPU)       | ✅ en 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 basique** (API uniquement, pas de modèles locaux) | N'importe lequel / CPU uniquement | —        | 8 Go+  | 0,05–0,15 $/h                             |
| **LLM local 7–8B** (Ollama + Llama 3.1 8B)                    | RTX 3060/3070                     | 12 Go    | 16 Go+ | $0.03–0.07/hr                             |
| **LLM local 70B** (vLLM + Llama 3.1 70B)                      | RTX 4090 / A100                   | 24–80 Go | 64 Go+ | [bare metal](https://clore.ai/bare-metal) |
| **Pile complète** (LLM + Whisper + TTS + génération d'images) | RTX 4090                          | 24 Go    | 32 Go+ | 0,14–0,42 $/h                             |

> **Astuce :** Si vous n'avez besoin d'OpenClaw que comme assistant cloud utilisant des modèles API (Claude, GPT), vous n'avez pas besoin de GPU du tout — un serveur CPU bon marché fonctionne très bien. Ajoutez un GPU lorsque vous voulez une inférence locale.

***

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

### 1.1 Parcourez la place de marché

Accédez à [clore.ai/marketplace](https://clore.ai/marketplace) et filtrez selon vos besoins :

* **Pour un assistant basique** : triez par prix, choisissez n'importe quel serveur Ubuntu bon marché
* **Pour un LLM local** : filtrez par GPU (par ex. RTX 4090), assurez-vous d'avoir ≥24 Go de VRAM
* **Système d'exploitation** : choisissez **Ubuntu 22.04** ou **Ubuntu 24.04** (meilleure compatibilité)

### 1.2 Créez une commande

1. Sélectionnez le serveur → **Louer**
2. Choisissez **À la demande** (à l'heure) ou **Spot** (moins cher mais peut être surenchéri)
3. Sélectionnez l'image Docker : **`ubuntu:22.04`** ou **`nvidia/cuda:12.8.1-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 Connectez-vous via SSH

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

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

> **Remarque :** Les serveurs Clore utilisent des conteneurs Docker, vous obtenez donc l'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 : Installez OpenClaw

### 2.1 Installez 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   # Doit afficher v22.x.x
npm --version
```

### 2.2 Installez OpenClaw

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

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

Le script installe le CLI, lance la configuration initiale et démarre la passerelle.

**Option B : installation npm manuelle**

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

### 2.3 Lancez l'assistant de configuration

Si vous avez utilisé le script d'installation, la configuration initiale 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 la configuration initiale.

***

## Étape 3 : Configurez le fonctionnement permanent

### 3.1 Démarrez la passerelle comme service

```bash
# Vérifier si la passerelle est en cours d'exécution
openclaw gateway status

# La démarrer (si elle n'est pas déjà en cours d'exécution)
openclaw gateway start

# Vérifier son bon fonctionnement
openclaw status
```

### 3.2 La maintenir en cours d'exécution avec systemd (recommandé)

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

```bash
# Créer un fichier de service systemd
cat > /etc/systemd/system/openclaw.service << 'EOF'
[Unit]
Description=Passerelle OpenClaw
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 l'état
systemctl status openclaw
```

### 3.3 Alternative : Screen/tmux (rapide et 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

# Rattacher plus tard
screen -r openclaw
```

***

## Étape 4 : Configuration du GPU (optionnelle — pour les modèles locaux)

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

### 4.1 Vérifier l'accès au 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 Clore CUDA sont préconfigurées.

### 4.2 Installez Ollama (inférence LLM locale)

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

# Démarrer Ollama
ollama serve &

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

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

### 4.3 Installez Whisper (transcription vocale)

Pour une conversion parole-texte 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 la configuration complète.

***

## Étape 5 : Sécurité et accès à distance

### 5.1 Sécurisez la passerelle

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

**Option A : tunnel SSH (le plus sûr)**

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 jeton**

Modifier `~/.openclaw/config.json5`:

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

> ⚠️ **Définissez toujours un jeton** si vous liez à `lan`. Sans lui, 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 et sauvegardes

### 6.1 Répertoires importants

| Chemin                   | Contenu                                                    |
| ------------------------ | ---------------------------------------------------------- |
| `~/.openclaw/`           | Configuration, authentification, état, profils d'agents    |
| `~/.openclaw/workspace/` | MEMORY.md, notes quotidiennes, compétences, outils         |
| `~/.openclaw/agents/`    | Configurations multi-agents (si vous utilisez des é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 — export
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 — import
tar xzf /tmp/openclaw-migration.tar.gz -C /
openclaw gateway start
```

***

## Exemples de configurations

### Bot Telegram de base (sans GPU)

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

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

### Station de travail IA (GPU)

Toutes fonctionnalités avec modèles locaux :

```
Serveur : RTX 4090, 24 Go de VRAM, 32 Go de 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 double GPU
Coût : ~0,30–0,60 $/h
Pile : OpenClaw multi-agents (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

# Correctif courant : 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 aurez peut-être besoin de l'image Docker CUDA
# Recréer la commande avec nvidia/cuda:12.8.1-runtime-ubuntu22.04
```

### La connexion se coupe au redémarrage du serveur

Les instances spot Clore peuvent être récupérées. Pour un fonctionnement persistant :

* Utilisez **à la demande** tarification (pas spot)
* Mettre en place 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 de travail critiques

### Problèmes de version de Node.js

```bash
# Vérifier la version
node --version

# Si inférieur à v22, réinstallez
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
```

***

## Conseils et bonnes pratiques

1. **Commencez à bas coût** — utilisez d'abord un serveur CPU basique. Ajoutez un GPU lorsque vous avez besoin d'une inférence locale.
2. **Utilisez l'instance à la demande pour la production** — le spot est moins cher mais peut être interrompu. L'instance à la demande garantit la disponibilité.
3. **Sauvegardez régulièrement** — Votre `~/.openclaw/workspace/` contient toute la mémoire et les configurations.
4. **Surveillez les coûts** — Vérifiez régulièrement votre tableau de bord Clore. Définissez des alertes de dépenses si possible.
5. **Utilisez l'interface de contrôle** — Accédez via un tunnel SSH à `http://127.0.0.1:18789/` pour la gestion via le web.
6. **Combinez avec des modèles API** — 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).

***

## Pour aller plus loin

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