# OpenClaw en Clore

## Resumen

[OpenClaw](https://openclaw.ai) es una plataforma de agentes de IA de código abierto que se conecta a Claude, GPT, Gemini y modelos locales — actuando como un asistente personal de IA en Telegram, Discord, WhatsApp y más. Ejecutarlo en un servidor de Clore.ai te ofrece:

* **Disponibilidad 24/7** — sin suspensión del portátil, sin desconexiones
* **Aceleración por GPU** — inferencia local de LLM (Ollama, vLLM), Whisper STT, TTS, generación de imágenes
* **Bajo costo** — alquila exactamente el hardware que necesitas, paga por hora
* **Control total** — acceso root, soporte Docker, cualquier stack de software

### ¿Por qué Clore + OpenClaw?

| Característica       | Portátil | VPS tradicional | Servidor Clore.ai         |
| -------------------- | -------- | --------------- | ------------------------- |
| Siempre activo       | ❌        | ✅               | ✅                         |
| GPU disponible       | Limitada | ❌ o $$$         | ✅ desde $0.10/h           |
| Inferencia LLM local | Lenta    | Solo CPU        | Velocidad completa de GPU |
| Voz (Whisper/TTS)    | ✅        | Lento (CPU)     | ✅ En tiempo real          |
| Root + Docker        | ✅        | ✅               | ✅                         |
| Facturación por hora | N/D      | Mensual         | ✅ Por hora                |

### Hardware recomendado

| Caso de uso                                                       | GPU                   | VRAM     | RAM    | Costo estimado |
| ----------------------------------------------------------------- | --------------------- | -------- | ------ | -------------- |
| **Asistente básico** (Solo API, sin modelos locales)              | Cualquiera / Solo CPU | —        | 8 GB+  | $0.05–0.15/h   |
| **LLM local 7–8B** (Ollama + Llama 3.1 8B)                        | RTX 3060/3070         | 12 GB    | 16 GB+ | $0.10–0.25/h   |
| **LLM local 70B** (vLLM + Llama 3.1 70B)                          | RTX 4090 / A100       | 24–80 GB | 64 GB+ | $0.30–1.00/h   |
| **Stack completo** (LLM + Whisper + TTS + generación de imágenes) | RTX 4090              | 24 GB    | 32 GB+ | $0.25–0.50/h   |

> **Consejo:** Si solo necesitas OpenClaw como asistente en la nube usando modelos por API (Claude, GPT), no necesitas GPU en absoluto — un servidor económico con CPU funciona bien. Añade una GPU cuando quieras inferencia local.

***

## Paso 1: Alquila un servidor en Clore.ai

### 1.1 Explora el Marketplace

Ve a [clore.ai/marketplace](https://clore.ai/marketplace) y filtra según tus requisitos:

* **Para asistente básico**: Ordena por precio, elige cualquier servidor Ubuntu barato
* **Para LLM local**: Filtra por GPU (p. ej., RTX 4090), asegúrate de ≥24 GB de VRAM
* **SO**: Elige **Ubuntu 22.04** o **Ubuntu 24.04** (mejor compatibilidad)

### 1.2 Crea una orden

1. Selecciona el servidor → **Alquilar**
2. Elige **Bajo demanda** (por hora) o **Spot** (más barato pero puede ser superado)
3. Selecciona la imagen Docker: **`ubuntu:22.04`** o **`nvidia/cuda:12.4.0-runtime-ubuntu22.04`** (si necesitas GPU)
4. Configura la clave pública SSH (o usa contraseña — se recomienda clave SSH)
5. Confirma la orden

### 1.3 Conéctate vía SSH

Una vez que el servidor esté en funcionamiento, encuentra los detalles de conexión SSH en tu [Órdenes](https://clore.ai/my-orders) página:

```bash
ssh root@<ip-del-servidor> -p <puerto>
```

> **Nota:** Los servidores Clore usan contenedores Docker, por lo que obtienes acceso root dentro del contenedor. El puerto SSH puede ser no estándar (p. ej., 50022) — revisa los detalles de tu orden.

***

## Paso 2: Instala OpenClaw

### 2.1 Instala Node.js 22+

```bash
# Actualizar paquetes del sistema
apt update && apt upgrade -y

# Instalar Node.js 22 vía NodeSource
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs

# Verificar
node --version   # Debe mostrar v22.x.x
npm --version
```

### 2.2 Instalar OpenClaw

**Opción A: Script instalador (recomendado)**

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

El script instala la CLI, ejecuta la configuración inicial y arranca el gateway.

**Opción B: Instalación manual con npm**

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

### 2.3 Ejecuta el asistente de configuración

Si usaste el script instalador, la configuración inicial se ejecuta automáticamente. De lo contrario:

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

El asistente te hará estas preguntas:

1. **Configurar la autenticación** — pega tu clave de API de Anthropic o conéctate vía OAuth
2. **Elegir un canal** — token de bot de Telegram, Discord, WhatsApp, etc.
3. **Configurar el gateway** — puerto, enlace, seguridad

> **Para Telegram:** Crea un bot mediante [@BotFather](https://t.me/BotFather), copia el token y pégalo durante la configuración inicial.

***

## Paso 3: Configurar para operación siempre activa

### 3.1 Iniciar el Gateway como servicio

```bash
# Verificar si el gateway está corriendo
openclaw gateway status

# Iniciarlo (si no está ya en ejecución)
openclaw gateway start

# Verificar que esté sano
openclaw status
```

### 3.2 Mantenerlo en ejecución con systemd (recomendado)

Si OpenClaw no instaló automáticamente el servicio systemd:

```bash
# Crear un archivo de servicio 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

# Habilitar e iniciar
systemctl daemon-reload
systemctl enable openclaw
systemctl start openclaw

# Comprobar estado
systemctl status openclaw
```

### 3.3 Alternativa: Screen/tmux (rápido y simple)

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

# Iniciar OpenClaw en una sesión screen desconectada
screen -dmS openclaw openclaw gateway --port 18789

# Volver a adjuntar más tarde
screen -r openclaw
```

***

## Paso 4: Configuración de GPU (opcional — para modelos locales)

Omite esta sección si solo usas modelos basados en API (Claude, GPT, etc.).

### 4.1 Verificar acceso a la GPU

```bash
# Comprobar si los controladores NVIDIA están disponibles
nvidia-smi
```

Si `nvidia-smi` funciona, tu GPU está lista. La mayoría de las imágenes CUDA de Clore vienen preconfiguradas.

### 4.2 Instalar Ollama (inferencia LLM local)

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

# Iniciar Ollama
ollama serve &

# Descargar un modelo
ollama pull llama3.1:8b        # 8B — entra en 12GB de VRAM
# ollama pull llama3.1:70b     # 70B — necesita 48GB+ de VRAM
# ollama pull qwen2.5:32b      # 32B — necesita 24GB de VRAM
```

Configura OpenClaw para usar Ollama como proveedor — consulta la [guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) para más detalles.

### 4.3 Instalar Whisper (transcripción de voz)

Para reconocimiento de voz acelerado por GPU:

```bash
pip install faster-whisper

# O usa WhisperX para mejor precisión
pip install whisperx
```

Consulta la [guía de WhisperX](/guides/guides_v2-es/audio-y-voz/whisperx.md) para la configuración completa.

***

## Paso 5: Seguridad y acceso remoto

### 5.1 Asegurar el Gateway

Por defecto, el gateway enlaza al loopback (127.0.0.1). Para acceso remoto:

**Opción A: túnel SSH (más seguro)**

Desde tu portátil:

```bash
ssh -N -L 18789:127.0.0.1:18789 root@<ip-del-servidor> -p <puerto>
```

Luego abre `http://127.0.0.1:18789/` en tu navegador.

**Opción B: acceso directo protegido por token**

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

```json5
{
  gateway: {
    bind: "lan",       // Escuchar en todas las interfaces
    port: 18789,
    auth: {
      token: "tu-token-secreto-aqui"  // ¡Requerido para acceso remoto!
    }
  }
}
```

> ⚠️ **Siempre configura un token** si enlazas a `lan`. Sin él, cualquiera puede acceder a tu gateway.

### 5.2 Configuración del firewall

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

# Permitir SSH (usa tu puerto SSH de Clore)
ufw allow <ssh-port>/tcp

# Permitir gateway OpenClaw (solo si usas acceso directo)
ufw allow 18789/tcp

# Habilitar firewall
ufw enable
```

***

## Paso 6: Persistencia y copias de seguridad

### 6.1 Directorios importantes

| Ruta                     | Contenido                                                 |
| ------------------------ | --------------------------------------------------------- |
| `~/.openclaw/`           | Configuración, autenticación, estado, perfiles de agentes |
| `~/.openclaw/workspace/` | MEMORY.md, notas diarias, habilidades, herramientas       |
| `~/.openclaw/agents/`    | Configuraciones multi-agente (si usas equipos)            |

### 6.2 Script de copia de seguridad

Crea una copia de seguridad simple para mantener tu configuración segura:

```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 "Copia de seguridad guardada: $BACKUP_DIR/openclaw-$TIMESTAMP.tar.gz"
EOF
chmod +x /root/backup-openclaw.sh

# Ejecutar diariamente vía cron
(crontab -l 2>/dev/null; echo "0 4 * * * /root/backup-openclaw.sh") | crontab -
```

### 6.3 Migración entre servidores

Si necesitas cambiar a un servidor Clore diferente:

```bash
# En el servidor antiguo — exportar
tar czf /tmp/openclaw-migration.tar.gz ~/.openclaw/

# Transferir al servidor nuevo
scp -P <puerto> /tmp/openclaw-migration.tar.gz root@<ip-nuevo-servidor>:/tmp/

# En el servidor nuevo — importar
tar xzf /tmp/openclaw-migration.tar.gz -C /
openclaw gateway start
```

***

## Ejemplos de configuraciones

### Bot básico de Telegram (sin GPU)

Configuración más barata — solo un asistente impulsado por API:

```
Servidor: Cualquier Ubuntu, no se necesita GPU
Costo: ~$0.05–0.15/h ($3–10/mes)
Configuración: clave de API de Anthropic + token de bot de Telegram
```

### Estación de trabajo de IA (GPU)

Con todas las funciones y modelos locales:

```
Servidor: RTX 4090, 24GB VRAM, 32GB RAM
Costo: ~$0.25–0.50/h
Stack: OpenClaw + Ollama (Llama 3.1 70B) + WhisperX + Coqui TTS
```

### Equipo multi-agente

Ejecuta un equipo de agentes de IA especializados:

```
Servidor: RTX 4090 o GPU dual
Costo: ~$0.30–0.60/h
Stack: OpenClaw multi-agente (5+ agentes) + Ollama + habilidades compartidas
```

***

## Solución de problemas

### El gateway no se inicia

```bash
# Ver registros
openclaw gateway status
journalctl -u openclaw -n 50

# Solución común: puerto ya en uso
lsof -i :18789
kill <pid>
openclaw gateway start
```

### GPU no detectada

```bash
# Comprueba los controladores NVIDIA
nvidia-smi

# Si no se encuentran, puede que necesites la imagen Docker CUDA
# Re-crear la orden con nvidia/cuda:12.4.0-runtime-ubuntu22.04
```

### La conexión se corta al reiniciar el servidor

Las instancias spot de Clore pueden ser reclamadas. Para operación persistente:

* Usa **bajo demanda** precios (no spot)
* Configura el servicio systemd (reinicio automático)
* Mantén copias de seguridad (el script de backup arriba)
* Considera un servidor dedicado/reservado para cargas críticas

### Problemas con la versión de Node.js

```bash
# Verificar versión
node --version

# Si es inferior a v22, reinstala
curl -fsSL https://deb.nodesource.com/setup_22.x | bash -
apt install -y nodejs
```

***

## Consejos y buenas prácticas

1. **Empieza barato** — Usa primero un servidor básico con CPU. Añade GPU cuando necesites inferencia local.
2. **Usa bajo demanda para producción** — Spot es más barato pero puede ser interrumpido. Bajo demanda garantiza disponibilidad.
3. **Haz copias de seguridad regularmente** — Tu `~/.openclaw/workspace/` contiene toda la memoria y las configuraciones.
4. **Monitorea costos** — Revisa tu panel de Clore regularmente. Configura alertas de gasto si están disponibles.
5. **Usa la interfaz de Control** — Accede vía túnel SSH en `http://127.0.0.1:18789/` para gestión vía web.
6. **Combina con modelos por API** — Incluso con un servidor GPU, usa Claude/GPT vía API para el agente principal y modelos locales para tareas específicas (embeddings, transcripción).

***

## Lecturas adicionales

* [Inicio rápido de OpenClaw](https://docs.openclaw.ai/start/getting-started)
* [Guía de hosting VPS de OpenClaw](https://docs.openclaw.ai/install/vps)
* [Configuración Docker de OpenClaw](https://docs.openclaw.ai/install/docker)
* [Ollama en Clore](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md)
* [vLLM en Clore](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md)
* [Comparación de GPU y precios](/guides/guides_v2-es/primeros-pasos/gpu-comparison.md)


---

# Agent Instructions: 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-es/otras-cargas-de-trabajo/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.