---
title: "Guía de Configuración de CoPaw: Asistente de IA Multicanal que Puedes Autoalojar"
description: "Guía paso a paso para instalar CoPaw en un VPS o localmente. Cubre la instalación con pip, Docker, proveedores de modelos, canales como DingTalk, Discord y Telegram, habilidades, memoria y tareas programadas."
date: 2026-03-05
categories: ["AI"]
tags: ["ai-tools","self-hosted","vps"]
---
import YouTubeEmbed from "@components/widgets/YouTubeEmbed.astro";
import Button from "@components/widgets/Button.astro";
import Notice from "@components/widgets/Notice.astro";
import ListCheck from "@components/widgets/ListCheck.astro";
import Accordion from "@components/widgets/Accordion.astro";
import Tabs from "@components/widgets/Tabs.astro";
import Tab from "@components/widgets/Tab.astro";
CoPaw es un asistente de IA personal de código abierto del equipo AgentScope de Alibaba. Se ejecuta en tu propia máquina o servidor y se conecta a DingTalk, Feishu, QQ, Discord, Telegram e iMessage. Lo he estado configurando junto a mis instancias de [OpenClaw](/es/guia-configuracion-openclaw/) y [nanobot](/es/guia-configuracion-nanobot/). Lo que llamó mi atención fue la consola web integrada para la configuración y el hecho de que incluye tres backends de modelos locales de fábrica.
Instalar CoPaw mediante pip, script de una línea o Docker
Configurar proveedores de LLM en la nube (DashScope, OpenAI, Azure OpenAI)
Ejecutar modelos locales con llama.cpp, MLX y Ollama
Habilidades integradas, habilidades personalizadas e importación desde hubs
Sistema de memoria con búsqueda híbrida semántica + texto completo
Tareas programadas y check-ins por heartbeat
Si estás comparando opciones de asistentes de IA autoalojados, nuestro resumen de [alternativas a OpenClaw](/es/alternativas-openclaw/) cubre varios proyectos incluyendo nanobot, NanoClaw, PicoClaw y más. Para una opción más ligera basada en Go, consulta la [guía de configuración de PicoClaw](/es/guia-configuracion-picoclaw/).
## Qué hace realmente CoPaw
CoPaw significa "Co Personal Agent Workstation." El equipo AgentScope lo construyó sobre [AgentScope](https://github.com/agentscope-ai/agentscope) y [ReMe](https://github.com/agentscope-ai/ReMe) para la gestión de memoria. La propuesta: un asistente que se conecta a tus aplicaciones de mensajería y ejecuta tareas según un horario sin que tengas que pedirlo.
La arquitectura:
```
Tú (DingTalk / Feishu / QQ / Discord / Telegram / iMessage)
↓
CoPaw Server (ejecutándose en tu máquina o VPS)
↓
LLM Provider (DashScope, OpenAI, Azure, Ollama, llama.cpp, MLX)
↓
Skills (cron, PDF, Word/Excel/PPT, news, file reader, browser, custom)
```
Los mensajes llegan desde la aplicación de chat que uses, CoPaw los enruta al LLM que hayas elegido, y el modelo puede usar habilidades integradas para manejar archivos, ejecutar trabajos programados, navegar por la web o trabajar con documentos. Hay una consola web en `http://127.0.0.1:8088/` donde configuras todo en lugar de editar archivos de configuración a mano.
### Cómo se compara con OpenClaw y nanobot
| Característica | CoPaw | OpenClaw | nanobot |
|---|---|---|---|
| **Lenguaje** | Python | TypeScript | Python |
| **Creado por** | AgentScope (Alibaba) | Community | HKUDS |
| **Instalación** | pip / one-liner / Docker | curl one-liner | pip |
| **Consola web** | Sí (integrada en :8088) | No (dashboards de terceros) | No |
| **Canales** | DingTalk, Feishu, QQ, Discord, Telegram, iMessage | Telegram, WhatsApp, Slack, Discord | Telegram, Discord, WhatsApp, Slack, Feishu, DingTalk, Email, QQ |
| **Modelos locales** | llama.cpp, MLX, Ollama | Ollama | vLLM |
| **Memoria** | Basada en archivos + búsqueda híbrida vector/BM25 | Basada en archivos + búsqueda semántica | Basada en archivos |
| **Habilidades** | Integradas + importables desde hubs | Habilidades de la comunidad | Integradas |
| **Tareas programadas** | Cron + heartbeat | Cron | Cron |
| **Licencia** | Apache 2.0 | MIT | MIT |
Donde CoPaw destaca: la consola web integrada significa que no necesitas dashboards de terceros, y el soporte para DingTalk/Feishu/QQ es de primera clase en lugar de añadido a posteriori. Si esas son tus aplicaciones de chat diarias, CoPaw te ahorra muchos dolores de cabeza de configuración.
## Instalación
CoPaw te ofrece cinco formas de empezar. Cubriré las tres más prácticas.
El enfoque más limpio si ya tienes Python:
```bash
pip install copaw
copaw init --defaults
copaw app
```
Abre `http://127.0.0.1:8088/` y verás la Consola. Eso es todo para una configuración básica.
Para una configuración interactiva donde eliges tu proveedor de LLM y canales desde el principio:
```bash
copaw init
```
Esto te guía a través del intervalo de heartbeat, canal de destino, horas activas y configuración opcional de habilidades.
No necesitas Python. El instalador maneja todo usando [uv](https://docs.astral.sh/uv/).
**macOS / Linux:**
```bash
curl -fsSL https://copaw.agentscope.io/install.sh | bash
```
**Windows (PowerShell):**
```powershell
irm https://copaw.agentscope.io/install.ps1 | iex
```
Abre una nueva terminal después de instalar, luego:
```bash
copaw init --defaults
copaw app
```
Para instalar con soporte de modelos locales:
```bash
# llama.cpp (multiplataforma)
curl -fsSL https://copaw.agentscope.io/install.sh | bash -s -- --extras llamacpp
# MLX (solo Apple Silicon)
curl -fsSL https://copaw.agentscope.io/install.sh | bash -s -- --extras mlx
# Ollama
curl -fsSL https://copaw.agentscope.io/install.sh | bash -s -- --extras ollama
```
Las imágenes están en Docker Hub (`agentscope/copaw`). Etiquetas: `latest` (estable), `pre` (pre-release).
```bash
docker pull agentscope/copaw:latest
docker run -p 127.0.0.1:8088:8088 -v copaw-data:/app/working agentscope/copaw:latest
```
La configuración, la memoria y las habilidades se almacenan en el volumen `copaw-data`. Para pasar claves de API:
```bash
docker run -p 127.0.0.1:8088:8088 \
-e DASHSCOPE_API_KEY=your_key_here \
-v copaw-data:/app/working \
agentscope/copaw:latest
```
Si necesitas que CoPaw en Docker alcance Ollama en el host:
```bash
docker run -p 127.0.0.1:8088:8088 \
--add-host=host.docker.internal:host-gateway \
-v copaw-data:/app/working agentscope/copaw:latest
```
Luego en la configuración de CoPaw, cambia la URL Base de Ollama a `http://host.docker.internal:11434/v1`.
### Instalar en un VPS de Hetzner
Si quieres que CoPaw funcione 24/7 en un servidor, un VPS económico hace el trabajo. Yo uso un [Hetzner CX22](https://www.bitdoze.com/hetzner-cloud-review/) (2 vCPU, 4 GB de RAM) por €3,99/mes.
[Obtén €20 de crédito](https://go.bitdoze.com/hetzner), [Hostinger VPS](https://go.bitdoze.com/hostinger-vps) cuando te registres a través de nuestro enlace de referido. Eso cubre aproximadamente 5 meses ejecutando CoPaw.
Conéctate por SSH a tu servidor y ejecuta:
```bash
ssh root@YOUR_SERVER_IP
apt update && apt upgrade -y
curl -fsSL https://copaw.agentscope.io/install.sh | bash
```
Abre una nueva sesión de shell, luego:
```bash
copaw init --defaults
copaw app
```
Para mantenerlo en ejecución después de cerrar la sesión SSH, usa un gestor de procesos como systemd o ejecútalo en una sesión de tmux/screen.
### Desinstalar
```bash
copaw uninstall # conserva la configuración y los datos
copaw uninstall --purge # elimina todo
```
## Configuración de Modelos
Antes de que CoPaw pueda hacer algo útil, necesitas configurar un LLM. Abre la Consola en `http://127.0.0.1:8088/` y ve a **Settings → Models**.
### Proveedores en la nube
CoPaw funciona con DashScope, ModelScope, OpenAI, Azure OpenAI y Aliyun Coding Plan. Para cualquiera de ellos:
1. Ve a **Settings → Models** en la Consola
2. Encuentra la tarjeta del proveedor y haz clic en **Settings**
3. Introduce tu clave de API y haz clic en **Save**
4. El estado de la tarjeta cambia a **Available**
5. En la sección **LLM Configuration** de la parte superior, selecciona el proveedor y el modelo, luego haz clic en **Save**
También puedes establecer las claves de API como variables de entorno. Para DashScope:
```bash
export DASHSCOPE_API_KEY=your_key_here
```
O ponlo en un archivo `.env` en el directorio de trabajo (por defecto `~/.copaw/`).
### Usar OpenAI o Azure OpenAI
Estos funcionan a través del sistema de proveedores personalizados:
1. Haz clic en **Add provider** en la página de Models
2. Introduce un Provider ID (p. ej. `openai`) y un nombre para mostrar
3. Haz clic en **Settings**, introduce la URL Base (`https://api.openai.com/v1` para OpenAI) y la clave de API
4. Haz clic en **Models**, añade el ID del modelo (p. ej. `gpt-4o`)
5. Selecciónalo en el desplegable de LLM Configuration
### Modelos locales
CoPaw admite tres backends de modelos locales. No se necesitan claves de API.
| Backend | Ideal para | Comando de instalación |
|---|---|---|
| **llama.cpp** | Multiplataforma (macOS, Linux, Windows) | `pip install 'copaw[llamacpp]'` |
| **MLX** | Macs con Apple Silicon (M1–M4) | `pip install 'copaw[mlx]'` |
| **Ollama** | Cualquiera que ya use Ollama | `pip install 'copaw[ollama]'` |
Para descargar y usar un modelo local desde la línea de comandos:
```bash
copaw models download Qwen/Qwen3-4B-GGUF
copaw models # selecciona el modelo descargado
copaw app # inicia el servidor
```
También puedes descargar y gestionar modelos desde la interfaz de la Consola en **Settings → Models**. Haz clic en **Models** en la tarjeta de llama.cpp o MLX, luego en **Download model** e introduce el ID del repositorio de Hugging Face.
Para Ollama, asegúrate de que el daemon de Ollama esté en ejecución primero y luego descarga modelos a través de Ollama como de costumbre:
```bash
ollama pull qwen3:4b
```
CoPaw se sincroniza con los modelos que tenga disponibles Ollama.
Si eres nuevo en la ejecución de modelos locales, nuestra [guía de instalación de Ollama con Docker](https://www.bitdoze.com/ollama-docker-install/) cubre los conceptos básicos.
### Comparativa de costes
| Proveedor | Modelo de ejemplo | Coste mensual típico |
|---|---|---|
| DashScope | Qwen 3.5 Plus | $5–20 |
| OpenAI | GPT-4o | $20–70 |
| Azure OpenAI | GPT-4o | $20–70 |
| Local (llama.cpp) | Qwen3 4B | $0 (solo cómputo) |
| Local (Ollama) | Qwen3 4B | $0 (solo cómputo) |
Los modelos de DashScope son más baratos que OpenAI con una calidad comparable. Si quieres evitar las facturas de API por completo, llama.cpp u Ollama con un modelo local no te cuesta nada más allá de la electricidad.
## Configuración de Canales
Los canales son la forma en que te comunicas con CoPaw desde tus aplicaciones de mensajería. Puedes configurarlos a través de la Consola (**Control → Channels**) o editando directamente `config.json`.
### Discord
1. Crea una aplicación de Discord en [discord.com/developers](https://discord.com/developers/applications)
2. Ve a la pestaña **Bot**, haz clic en **Reset Token** y copia el token del bot
3. En **Privileged Gateway Intents**, activa **Message Content Intent**
4. Genera una URL de invitación OAuth2 con el alcance `bot` y los permisos `Send Messages` + `Read Message History`
5. Invita el bot a tu servidor
6. En la Consola de CoPaw, ve a **Control → Channels**, haz clic en **Discord**, actívalo y pega el token
En `config.json`, tiene este aspecto:
```json
{
"channels": {
"discord": {
"enabled": true,
"token": "YOUR_DISCORD_BOT_TOKEN"
}
}
}
```
### Telegram
1. Abre Telegram, busca **@BotFather**, envía `/newbot`
2. Elige un nombre y nombre de usuario, copia el token
3. En la Consola, activa Telegram y pega el token
```json
{
"channels": {
"telegram": {
"enabled": true,
"token": "YOUR_TELEGRAM_BOT_TOKEN"
}
}
}
```
### DingTalk
La configuración de DingTalk implica crear una aplicación personalizada en la consola de desarrolladores de DingTalk. CoPaw tiene una habilidad integrada llamada `dingtalk_channel_connect` que te guía en la búsqueda de credenciales, la configuración de Client ID/Secret y los pasos manuales. Activa el canal DingTalk en la Consola y sigue las indicaciones guiadas.
### Feishu (Lark)
Misma idea que DingTalk. Crea una aplicación en la Plataforma Abierta de Feishu, obtén el App ID y el App Secret, e introdúcelos en la Consola. CoPaw también admite proxy SOCKS para Feishu si estás detrás de un firewall corporativo.
### iMessage (solo macOS)
Si estás ejecutando CoPaw en un Mac, iMessage funciona como canal. Este es uno de los pocos asistentes autoalojados que admite iMessage de forma nativa.
### Varios canales a la vez
CoPaw puede conectarse a varios canales simultáneamente. Los mensajes van al canal en el que hablaste por última vez, o puedes dirigir mensajes programados a canales específicos.
## Habilidades
Las habilidades son la forma en que CoPaw hace más que simplemente chatear. Varias vienen integradas y puedes escribir las tuyas propias o importarlas desde hubs de la comunidad.
### Habilidades integradas
| Habilidad | Qué hace |
|---|---|
| **cron** | Trabajos programados — crear, listar, pausar, reanudar, eliminar |
| **file_reader** | Leer y resumir archivos de texto (.txt, .md, .json, .csv, .py, etc.) |
| **pdf** | Leer, extraer, combinar, dividir, rotar, añadir marca de agua, OCR en PDFs |
| **docx** | Crear, leer y editar documentos Word |
| **xlsx** | Leer, editar y crear hojas de cálculo |
| **pptx** | Crear, leer y editar archivos PowerPoint |
| **news** | Obtener y resumir las últimas noticias de fuentes configuradas |
| **browser_visible** | Lanzar un navegador con interfaz para demostraciones o escenarios con CAPTCHA |
### Gestionar habilidades en la Consola
Ve a **Agent → Skills** en la Consola para ver todas las habilidades cargadas, activarlas o desactivarlas, crear habilidades personalizadas o editar las existentes.
### Importar habilidades desde hubs
CoPaw puede importar habilidades desde estas fuentes:
- `https://skills.sh/`
- `https://clawhub.ai/`
- `https://skillsmp.com/`
- Repositorios de GitHub (cualquier repositorio con un archivo `SKILL.md`)
En la Consola, ve a **Agent → Skills**, haz clic en **Import Skills**, pega la URL y confirma.
### Crear habilidades personalizadas
Coloca una carpeta con un archivo `SKILL.md` en `~/.copaw/customized_skills/`:
```
~/.copaw/
customized_skills/
my_research_skill/
SKILL.md
```
El archivo `SKILL.md` es Markdown simple que describe lo que hace la habilidad:
```markdown
---
name: my_research_skill
description: Research a topic and summarize findings
---
# Research Skill
When asked to research something:
1. Search the web for current information
2. Summarize key findings in bullet points
3. List sources
```
CoPaw detecta las nuevas habilidades al reiniciar. Las habilidades personalizadas tienen prioridad sobre las integradas cuando los nombres coinciden.
## Sistema de Memoria
El sistema de memoria de CoPaw usa [ReMe](https://github.com/agentscope-ai/ReMe) y almacena todo en archivos Markdown simples. Tiene dos partes: la gestión de contexto que comprime conversaciones largas antes de alcanzar los límites de tokens, y la memoria a largo plazo que escribe hechos en archivos y los indexa para que CoPaw pueda encontrarlos más tarde.
### Estructura de archivos de memoria
```
~/.copaw/
MEMORY.md # Hechos persistentes, preferencias, decisiones
memory/
2026-03-05.md # Registro diario de hoy
2026-03-04.md # Registro de ayer
...
```
`MEMORY.md` contiene información persistente — cosas como "Prefiero Python 3.12" o "Mi equipo usa Slack para los standups." Los registros diarios capturan lo que ocurrió en cada conversación, y el sistema resume automáticamente las conversaciones cuando se vuelven demasiado largas.
### Búsqueda híbrida
CoPaw usa búsqueda semántica vectorial y búsqueda de texto completo BM25 juntas. Los pesos de fusión por defecto son 70% vectorial, 30% BM25.
| Tipo de búsqueda | Buena en | Débil en |
|---|---|---|
| **Semántica vectorial** | Encontrar conceptos relacionados con diferente redacción | Coincidencia exacta de tokens (nombres de funciones, códigos de error) |
| **BM25 texto completo** | Coincidencias exactas en términos específicos | Sinónimos y paráfrasis |
| **Híbrida (ambas)** | Mejor recuperación general | Requiere configuración de API de embedding |
Para habilitar la búsqueda vectorial, configura el servicio de embedding:
```bash
export EMBEDDING_API_KEY=your_key
export EMBEDDING_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
export EMBEDDING_MODEL_NAME=text-embedding-v4
```
Sin una clave de API de embedding, CoPaw recurre únicamente a la búsqueda de texto completo BM25.
### Hacer que las cosas persistan
Dile a CoPaw directamente:
> "Recuerda: siempre despliego en staging antes que en producción."
Esto se escribe en `MEMORY.md`. También puedes editar los archivos de memoria directamente:
```bash
nano ~/.copaw/MEMORY.md
```
## Tareas Programadas y Heartbeat
CoPaw puede ejecutar cosas según un horario de dos formas: trabajos cron para comandos específicos y heartbeat para check-ins periódicos.
### Trabajos cron
Crea tareas programadas a través de la CLI o la Consola:
```bash
# Crear un trabajo que se ejecute a las 9am cada día
copaw cron create --type agent --name "morning-digest" --cron "0 9 * * *" --message "Summarize my pending tasks and calendar for today"
# Listar todos los trabajos
copaw cron list
# Comprobar el estado de un trabajo
copaw cron state
```
También puedes gestionar trabajos cron desde la Consola en **Control → Cron Jobs**.
### Heartbeat
Heartbeat es la versión de CoPaw de un check-in programado. Escribes un bloque de preguntas en un archivo Markdown, y CoPaw las recorre según un temporizador y envía las respuestas a tu último canal usado. Configúralo durante `copaw init` o edita `HEARTBEAT.md` en el directorio de trabajo.
Ejemplo de `HEARTBEAT.md`:
```markdown
Check the following and report back:
- Any new emails from clients?
- What meetings do I have today?
- Summarize overnight GitHub notifications
```
Establece el intervalo y el destino en `config.json`:
```json
{
"heartbeat": {
"enabled": true,
"interval": "2h",
"active_hours": "08:00-22:00"
}
}
```
## Referencia de CLI
| Comando | Descripción |
|---|---|
| `copaw init` | Asistente de configuración interactivo |
| `copaw init --defaults` | Configuración rápida con valores predeterminados |
| `copaw app` | Iniciar el servidor |
| `copaw models` | Gestionar modelos locales |
| `copaw models download ` | Descargar un modelo desde Hugging Face |
| `copaw cron list` | Listar trabajos programados |
| `copaw cron create` | Crear un nuevo trabajo programado |
| `copaw uninstall` | Eliminar CoPaw (conserva los datos) |
| `copaw uninstall --purge` | Eliminar CoPaw y todos los datos |
## Solución de Problemas
### CoPaw no responde
Comprueba que el servidor esté en ejecución y el modelo esté configurado:
1. Abre `http://127.0.0.1:8088/` — si no carga, el servidor no está en ejecución
2. Ve a **Settings → Models** y verifica que un proveedor esté **Available** y haya un modelo seleccionado
3. Revisa la salida del terminal en busca de mensajes de error
### Problemas con la clave de API
Si ves errores de autenticación:
- Vuelve a verificar la clave de API en **Settings → Models**
- Para DashScope, verifica la clave en [dashscope.console.aliyun.com](https://dashscope.console.aliyun.com/)
- Intenta establecer la clave como variable de entorno: `export DASHSCOPE_API_KEY=xxx`
### Docker no puede alcanzar Ollama
Dentro de un contenedor Docker, `localhost` apunta al contenedor, no al host. Usa `--add-host=host.docker.internal:host-gateway` y establece la URL Base de Ollama a `http://host.docker.internal:11434/v1`.
En Linux, también puedes usar `--network=host`:
```bash
docker run --network=host -v copaw-data:/app/working agentscope/copaw:latest
```
### El canal no recibe mensajes
- Verifica que el canal esté habilitado en **Control → Channels**
- Comprueba que los tokens y las credenciales sean correctos
- Para Discord, asegúrate de que **Message Content Intent** esté habilitado en el portal de desarrolladores
- Reinicia CoPaw después de cambiar la configuración del canal
**¿Necesito saber Python para usar CoPaw?**
No. El instalador de una línea y las opciones de Docker no requieren ningún conocimiento de Python. La interfaz de la Consola maneja la mayor parte de la configuración. Solo necesitas conocimientos de Python si quieres crear habilidades personalizadas o instalar desde el código fuente.
**¿Con qué proveedor en la nube debería empezar?**
DashScope es la opción predeterminada y más económica. Si ya tienes una clave de API de OpenAI, añádela como proveedor personalizado. Para ejecutar sin ningún coste de API, usa llama.cpp u Ollama con un modelo local.
**¿Puedo ejecutar CoPaw en una Raspberry Pi?**
Técnicamente sí si tienes una Pi 4/5 con 4 GB+ de RAM, pero el rendimiento será limitado. Un VPS económico a €3,99/mes te da una experiencia mejor.
**¿CoPaw funciona en Windows?**
Sí. Usa el instalador de PowerShell (`irm https://copaw.agentscope.io/install.ps1 | iex`) o Docker. La instalación con pip también funciona si tienes Python 3.10+.
**¿Pueden varias personas usar una misma instancia de CoPaw?**
CoPaw responde en el canal donde hablaste por última vez. Varios usuarios pueden interactuar a través de canales de grupo en DingTalk, Feishu o Discord. Para conversaciones separadas, cada persona debe usar un canal o sesión diferente.
**¿Cómo se compara CoPaw con OpenClaw?**
OpenClaw tiene un soporte más amplio para aplicaciones de mensajería occidentales (WhatsApp, Slack). CoPaw tiene mejor soporte para aplicaciones chinas (DingTalk, Feishu, QQ), una consola web integrada y más opciones de modelos locales. Ambos son de código abierto y autoalojados. Consulta nuestra [guía de configuración de OpenClaw](/es/guia-configuracion-openclaw/) para la comparación completa.
**¿Son privados mis datos?**
Todos los datos permanecen en tu máquina. Las únicas llamadas externas van a tu proveedor de LLM configurado. Si ejecutas modelos locales, nada sale de tu servidor en absoluto.
CoPaw vale la pena probarlo si quieres un asistente autoalojado con una interfaz web adecuada en lugar de editar archivos JSON a ciegas. Los tres backends de modelos locales significan que puedes ejecutarlo sin ningún coste de API, y si DingTalk o Feishu es donde vive tu equipo, es la opción más pulida que he encontrado para esas plataformas.
Para otras opciones de asistentes autoalojados, consulta nuestro resumen de [alternativas a OpenClaw](/es/alternativas-openclaw/). Si quieres algo que compile a un único binario y funcione en una placa de $10, la [guía de configuración de PicoClaw](/es/guia-configuracion-picoclaw/) lo cubre. Para un asistente auto-mejorante con modo de voz y búsqueda de sesiones, ve la [guía de configuración de Hermes Agent](/es/guia-configuracion-hermes-agent/). Y para ejecutar modelos locales detrás de cualquiera de estos asistentes, nuestra [guía de Ollama con Docker](https://www.bitdoze.com/ollama-docker-install/) tiene los detalles de configuración.