# 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](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama) 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](https://docs.clore.ai/guides/guides_v2-es/audio-y-voz/whisperx) 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](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/ollama)
* [vLLM en Clore](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/vllm)
* [Comparación de GPU y precios](https://docs.clore.ai/guides/guides_v2-es/primeros-pasos/gpu-comparison)