--- id: "cloud.conectar-ao-seu-bot" titulo: "Conectar con tu bot" resumo: "Deja que tu bot (OpenClaw, Hermes, Grok Bot, dot de OpenAI, OpenBot, MausBot, nanobot y otros) controle Elyra, y haz que Elyra le avise cuando un agente termine." idioma: "es" tipo: "tutorial" categoria: "cloud" aplicavelDesde: "0.0.16" capabilities: [] estadoEditorial: "aprovado" nivelEvidencia: "artefato-distribuido" refFonte: "84e3f6465900b817684ac57323b97fb8bc17076a" revisaoFonte: "2026-10-18" revisor: "mantenedor (pediu a página dos bots, 2026-10-18)" rota: "/docs/es/cloud/conectar-ao-seu-bot/" fonte: "pt-br/cloud/conectar-ao-seu-bot.md" caminhoPublico: "docs/publica/es/cloud/conectar-ao-seu-bot.md" hashFonte: "sha256:3e9ff62b9c1746fee329c7517af16929bf6bf4e9906398a6bfdf9c90e139f75c" hashDestaPagina: "sha256:c78ae5b4187dff378c3e1c38f3f38017cf702436d14f001175f7c24aa94d8b02" traducaoAssistidaPorIA: true traducaoDesatualizada: false corpoRetido: false --- Un **bot** es un asistente que está siempre en pie y habla contigo por el chat, por el móvil o por un mensajero: OpenClaw, Hermes, Grok Bot, dot de OpenAI, OpenBot, MausBot, nanobot y otros. Esta página muestra cómo conectarlo a Elyra en dos direcciones: - **El bot controla Elyra**: abre tarjetas, envía tareas a los agentes, lee terminales y archivos. - **Elyra avisa al bot**: cuando un agente termina, Elyra llama a una dirección del bot, y él te lo cuenta. En cada sección hay un **prompt listo**. Cópialo, pégalo en tu bot y él hace la configuración por ti. Donde la configuración depende del bot, el prompt le pide que siga **su propia documentación**. ## Qué puede hacer el bot en Elyra Conectado, el bot usa las **mismas herramientas** del conector del Cloud, que actúan con tus permisos en el ordenador donde corre Elyra: - **`elyra`**: ejecuta la [CLI de Elyra](/docs/es/cloud/operar-pela-cli/): proyectos, workspaces, tarjetas del Canvas, terminales, agentes, el navegador integrado y las automatizaciones; - **`shell`**, **`read_file`**, **`write_file`**, **`edit_file`**, **`list_dir`** y **`search`**: comandos y archivos; - **`screenshot`** y **`browser_screenshot`**: muestran lo que Elyra o una página exhibe (en el Cloud, con un enlace a la imagen); - **`list_skills`** y **`read_skill`**: los manuales de las skills de Elyra. La tabla completa está en [Conectar agentes externos mediante MCP](/docs/es/cloud/conectar-agentes-mcp/#qué-puede-hacer-el-agente). > **Seguridad.** El bot actúa como tú, sin pedir confirmación en cada paso. Conecta solo bots en los que > confíes y revoca el acceso cuando ya no lo necesites (consulta [Seguridad](/docs/es/cloud/conectar-agentes-mcp/#seguridad)). ## Elige el camino | Dónde corre el bot | Camino | Necesita | |---|---|---| | **En el mismo ordenador** que Elyra | [`elyra mcp`](#bot-en-el-mismo-ordenador-elyra-mcp), por stdio | Elyra abierto | | **En otra máquina** (servidor, nube, móvil) | [MCP del Cloud con OAuth](#bot-en-otra-máquina-el-mcp-del-cloud) | Elyra Cloud activado | ## Bot en el mismo ordenador: `elyra mcp` `elyra mcp` es un servidor MCP por **stdio**: el bot lo inicia como un subproceso y habla con él por líneas de JSON. Reenvía cada petición al **Elyra abierto** en este ordenador, con las **mismas herramientas** del conector del Cloud. Sin túnel, sin Cloud y sin inicio de sesión. La configuración, en cualquier cliente MCP que acepte un servidor iniciado por un comando, es esta: ```json { "mcpServers": { "elyra": { "command": "elyra", "args": ["mcp"] } } } ``` El nombre de las claves y el archivo donde va cambian de un bot a otro: usa el formato que pida su documentación y mantén el **comando `elyra`** con el **argumento `mcp`**. Puntos de atención: - **Elyra tiene que estar abierto.** Con la app cerrada, cada petición vuelve con un error que dice que abras Elyra, y `elyra mcp` sigue en pie para la siguiente petición. - **El bot tiene que encontrar el ejecutable.** Si no encuentra `elyra`, pon la **ruta completa** en `command`. Para descubrirla, ejecuta `command -v elyra` (macOS y Linux) o `Get-Command elyra` (PowerShell). - **El bot y Elyra tienen que estar en el mismo ordenador y con el mismo usuario del sistema.** Un bot dentro de un contenedor o de un servidor no alcanza el Elyra de tu ordenador: para ese caso, usa el camino del Cloud. - Lo que `elyra mcp` escribe en la salida estándar es solo el protocolo MCP; avisos y errores van a `stderr`. **MausBot**: [MausBot](https://github.com/milind-soni/OpenMausBot) trabaja con el Claude Code y el Codex de tu ordenador. Registra `elyra mcp` en ellos, y MausBot pasa a controlar Elyra: ```bash claude mcp add --scope user elyra -- elyra mcp codex mcp add elyra -- elyra mcp ``` **Prompt para tu bot:** ```text Configura un servidor MCP llamado "elyra" con el comando `elyra mcp` (transporte stdio). Si el comando `elyra` no se encuentra, usa la ruta completa del ejecutable. Después lista las herramientas del servidor y llama a la herramienta `elyra` con los argumentos `workspace list` para confirmar que funcionó. Usa la documentación de tu propio MCP para saber dónde registrar el servidor; no inventes comandos. ``` ## Bot en otra máquina: el MCP del Cloud Cuando el bot no corre en tu ordenador, alcanza Elyra mediante el **conector del Cloud**: una dirección `https://-cloud.elyra.sh/mcp`, con inicio de sesión **OAuth**. Apruebas la conexión una vez y el acceso se renueva solo; sin clave fija que copiar. El paso a paso, la pantalla de consentimiento y la revocación están en [Conectar agentes externos mediante MCP](/docs/es/cloud/conectar-agentes-mcp/); no se repiten aquí. El conector responde con **JSON sobre HTTP (`POST`)**, sin SSE. Un bot que solo hable el transporte SSE antiguo no se conecta. Dónde registrar el servidor en cada bot: | Bot | Dónde registrar el servidor remoto | |---|---| | **Grok Bot** | **Setup → Plugins**, servidor **Remote HTTPS** con **OAuth** ([fuente](https://docs.x.ai/grok-bot/team-bots)) | | **dot, de OpenAI** | **Plugins → + → Add custom MCP server**, para uso personal, sin revisión ([fuente](https://developers.openai.com/plugins/quickstart)) | | **OpenClaw** | **Settings → MCP**, en el panel de control (Control UI), con transporte HTTP e inicio de sesión OAuth ([fuente](https://docs.openclaw.ai/tools/mcp)) | | **Hermes** | `hermes mcp add --url --auth oauth elyra` y después `hermes mcp test elyra` ([fuente](https://hermes-agent.nousresearch.com/docs/user-guide/features/mcp)) | | **nanobot** | **Apps → MCP → Connect**, con `auth` en `oauth` ([fuente](https://github.com/HKUDS/nanobot/blob/main/docs/configuration.md)) | Cada flujo termina en una página de tu Cloud, donde entras con la cuenta de Elyra y tocas **Permitir**. Si el bot corre en un servidor sin navegador, el inicio de sesión tiene que volver a la máquina del bot (por reenvío de puerto, por ejemplo); la documentación del bot explica cómo. **Prompt para tu bot:** ```text Añade el servidor MCP remoto https://-cloud.elyra.sh/mcp con autenticación OAuth y envíame el enlace de inicio de sesión para que yo lo autorice. Sigue la documentación de tu propio MCP para hacerlo; no inventes comandos. Cuando yo lo haya autorizado, lista las herramientas del servidor y llama a la herramienta `elyra` con los argumentos `workspace list` para confirmar. ``` ## Avisar al bot: la acción "Llamar a una URL" Para que el bot sepa que un agente **terminó** (o quedó esperándote, o falló el CI), Elyra hace una llamada HTTP a la dirección que el bot publica. Es la acción **Llamar a una URL** de las [automatizaciones](/docs/es/fluxos/automacoes-acoes/). ### Crearla en la pantalla 1. Abre **Automatizaciones** y usa **Crear automatización**. 2. En **cuando**, elige el evento, por ejemplo **un agente termine**. 3. En **haz esto**, elige **Llamar a una URL** y rellena: - **Método**: `GET`, `POST`, `PUT`, `PATCH` o `DELETE`; - **Dirección (URL)**: la dirección del bot, con la query si la hay; - **Cabeceras**: pares nombre/valor; - **Cuerpo**: solo en los métodos que llevan cuerpo. Por defecto es un JSON con el evento; - **Firmar con un secreto**: activa la firma (ver abajo). 4. **Crear automatización**. ### Variables del evento La URL y el cuerpo aceptan estas variables, escritas entre llaves dobles: | Variable | Qué trae | |---|---| | `{{trigger}}` | El evento que disparó, como `agent-finished`, `agent-waiting` o `card-message`; `manual` cuando ejecutas la automatización a mano; en los demás casos, el tipo del disparador | | `{{agent}}` | En un evento de Elyra que viene de una tarjeta (agente terminó, agente esperando, mensaje de tarjeta), el agente de esa tarjeta, cuando Elyra lo conoce; en los demás casos, el agente de la automatización | | `{{card}}` | En esos eventos, el título de la tarjeta que disparó; en los demás casos, el título de la ejecución | | `{{project}}` | El nombre del proyecto | | `{{time}}` | La hora, en ISO 8601 | | `{{summary}}` | Evento de GitHub, GitLab o webhook: evento, repositorio, título y dirección, lo que venga. Evento de Elyra con tarjeta: el evento y el título de la tarjeta (`agent-finished · Revisor del PR`). En los demás casos, vacío | En la URL los valores entran **codificados**; en el cuerpo entran **escapados para JSON**. El cuerpo por defecto es: ```json { "trigger": "{{trigger}}", "agent": "{{agent}}", "card": "{{card}}", "project": "{{project}}", "time": "{{time}}", "summary": "{{summary}}" } ``` Y el bot recibe, por ejemplo: ```json { "trigger": "agent-finished", "agent": "claude", "card": "Revisor del PR", "project": "mi-app", "time": "2026-10-18T14:03:00.000Z", "summary": "agent-finished · Revisor del PR" } ``` ### Firma Con **Firmar con un secreto** activado, cada llamada lleva la cabecera: ```text X-Elyra-Signature-256: sha256= ``` Es el mismo formato del [webhook de entrada](/docs/es/fluxos/automacoes-webhook/#llamar-al-webhook-genérico). El secreto lo genera Elyra y se guarda cifrado en el almacén del sistema, como el del webhook: 1. Guarda la automatización y abre su detalle. 2. En la sección **Firma de Llamar a una URL**, toca **Generar secreto** y **cópialo al instante**: se muestra una sola vez. Si lo pierdes, usa **Cambiar secreto**. 3. Entrega el secreto al bot. Quien recibe comprueba la firma sobre los **bytes exactos** del cuerpo. En Node.js: ```js import { createHmac, timingSafeEqual } from 'node:crypto' function firmaCoincide(cuerpoBruto, cabecera, secreto) { const esperado = createHmac('sha256', secreto).update(cuerpoBruto).digest() if (!/^sha256=[0-9a-f]{64}$/i.test(cabecera ?? '')) return false const recibido = Buffer.from(cabecera.slice(7), 'hex') return recibido.length === esperado.length && timingSafeEqual(recibido, esperado) } ``` Sin la firma activada, **Elyra no prueba quién llamó**: úsala solo en una dirección que controlas y que no acepta nada de desconocidos. ### Qué pasa en la llamada - **Plazo de 10 segundos** y **ningún reenvío**. Si el bot está caído, Elyra no guarda cola. - **La llamada sale de tu ordenador, y se aceptan direcciones locales (`localhost`) y de la red interna.** Así se avisa a un bot en la misma máquina, como el gateway de OpenClaw. Usa solo URLs en las que confíes. - **Solo una respuesta 2xx cuenta como éxito.** El historial de la ejecución muestra `HTTP 200 · 120 ms`. Cualquier otra respuesta, un error de conexión o el plazo agotado **hacen fallar la acción** y detienen la cadena, con el motivo en el historial; en la pantalla, el fallo también aparece en un aviso. - **Elyra no sigue redirecciones**: un `3xx` cuenta como fallo, para que el cuerpo firmado nunca se reenvíe a otra dirección. - **El secreto y las cabeceras no van a los logs**, y el resumen de la acción muestra solo el servidor, nunca la query. - Los **valores de las cabeceras se guardan con la automatización**. Prefiere la firma a un token fijo en una cabecera. ### Ejemplo: avisar a OpenBot [OpenBot](https://github.com/meetopenbot/openbot) ejecuta un servidor local en el puerto `4132` y recibe eventos en `POST /api/publish`. Una automatización **un agente termina → Llamar a una URL** con estos campos le envía el aviso directamente: - **Método**: `POST`; - **Dirección (URL)**: `http://localhost:4132/api/publish`; - **Encabezados**: `content-type` = `application/json`; - **Cuerpo**: ```json { "type": "agent:invoke", "data": { "role": "user", "content": "El agente {{agent}} terminó en la tarjeta {{card}} del proyecto {{project}}. Avísame." } } ``` ### Crearla por la línea de comandos El bot también puede crear la automatización, con la herramienta `elyra`, usando `--actions`. El secreto de firma, sin embargo, solo se genera **en la app**, en el detalle de la automatización: ```bash elyra automations create --name "Avisar al bot" \ --trigger-json '{"kind":"elyra-event","events":["agent-finished"]}' \ --actions '[{"kind":"http-call","method":"POST","url":"https://bot.ejemplo.com/elyra","headers":[],"body":"{\"card\":\"{{card}}\"}","sign":true}]' \ --trigger daily --prompt "Aviso de evento" --provider codex --repo ``` **Prompt para tu bot:** ```text Quiero que recibas avisos de Elyra. Publica una dirección HTTP POST (o dime cuál de tus direcciones debo usar) y, cuando llegue un aviso, comprueba la cabecera X-Elyra-Signature-256: vale "sha256=" más el HMAC-SHA256 en hexadecimal del cuerpo exacto, usando como clave el secreto que te voy a pasar. Si la firma no coincide, ignora el aviso. Si coincide, el cuerpo es un JSON con trigger, agent, card, project, time y summary: cuéntame en el chat qué pasó. Responde 200 a Elyra en menos de 10 segundos. Cuando la dirección exista, crea en Elyra, con la herramienta `elyra`, la automatización "un agente termine → Llamar a una URL" (método POST, esa dirección, firma activada) y avísame para que yo genere el secreto en el detalle de la automatización. ``` ## Skills en las carpetas de los bots Las **skills de Elyra** son manuales cortos que enseñan al agente a usar la CLI. Elyra las instala solo en las carpetas de skills de los asistentes que **ya están en tu ordenador**, y eso ahora incluye **OpenClaw**: | Bot | Carpeta | |---|---| | **OpenClaw** | `~/.openclaw/skills` (o `/skills`, si cambiaste la carpeta de estado) | | **Hermes** | la carpeta de skills de Hermes (`~/.hermes/skills`, `%LOCALAPPDATA%\hermes\skills` en Windows o `HERMES_HOME`) | | Otros asistentes | `~/.agents/skills` y las carpetas de Claude, Codex, Grok CLI, Cursor y demás | Las reglas son siempre las mismas: - **Elyra nunca crea la carpeta de un bot.** Sin OpenClaw instalado, no se escribe nada. - Cada skill instalada lleva el marcador `.elyra-managed.json`. **Lo que no es de Elyra no se toca**, y desinstalar Elyra elimina solo lo que tiene el marcador. - **MausBot**: usa las skills de las carpetas del Claude Code y del Codex, donde Elyra ya las instala. - **OpenBot**: recibe los avisos de Elyra por la acción **Llamar a una URL** ([ejemplo arriba](#ejemplo-avisar-a-openbot)). - La carpeta `~/.grok/skills` es la del **Grok CLI**, no la de Grok Bot; Grok Bot recibe Elyra por el conector. Un bot que no ve las skills puede necesitar recargar las suyas; consulta cómo en su documentación. **Prompt para tu bot:** ```text Lista las skills que tienes cargadas y dime si existe una llamada "elyra". Si existe, léela ahora y, antes de usar la herramienta `elyra`, sigue lo que ella indica. Si no existe, recarga tus skills siguiendo la documentación de tu propio bot y vuelve a comprobar; no inventes comandos. ``` ## Ejemplo de punta a punta El bot envía una tarea a un agente y recibe un aviso cuando termina. 1. **Conecta el bot** a Elyra mediante [`elyra mcp`](#bot-en-el-mismo-ordenador-elyra-mcp) o mediante el [Cloud](#bot-en-otra-máquina-el-mcp-del-cloud). 2. **Crea la automatización** "un agente termine → Llamar a una URL" apuntando a la dirección del bot, con firma, y entrégale el secreto (consulta [Avisar al bot](#avisar-al-bot-la-acción-llamar-a-una-url)). 3. **Pide en el chat del bot**: "pide a un agente que revise los cambios del proyecto X". 4. El bot usa la herramienta `elyra` para localizar el proyecto y abrir el agente, algo como: ```bash elyra workspace list --json elyra canvas create terminal --workspace 'id:' --agent --title 'Tarea del bot' --json elyra terminal wait --terminal '' --for tui-idle --json elyra terminal send --terminal '' --text-file --json ``` El `` viene de la respuesta del segundo comando. 5. El agente trabaja. Cuando termina, Elyra hace la llamada **Llamar a una URL**, el bot comprueba la firma y te cuenta en el chat que acabó. Para leer el resultado, el bot usa `elyra terminal read --terminal ''`. **Prompt para tu bot:** ```text Usa Elyra para esta tarea: abre un agente en el proyecto "" (lista los workspaces con `elyra workspace list --json` mediante la herramienta `elyra`, y lee antes la skill "elyra"), pídele que "" y vigílalo. Cuando Elyra me avise en tu dirección de que el agente terminó (comprueba la firma X-Elyra-Signature-256), lee el resultado de su terminal y cuéntame aquí, en el chat, qué se hizo. ``` ## Resolver problemas | Síntoma | Qué hacer | |---|---| | El bot recibe "abre la aplicación Elyra" | Elyra está cerrado. Abre la app; `elyra mcp` vuelve a funcionar en la siguiente petición. | | El bot no encuentra el comando `elyra` | Usa la ruta completa del ejecutable en `command`. | | El Cloud rechaza la conexión del bot | Consulta [Resolver problemas del Cloud](/docs/es/cloud/resolver-problemas/). | | La acción falló con "El servidor respondió 401" | El bot rechazó la llamada. Revisa la dirección y el secreto que usa para validar. | | La acción falló con "La firma está activada, pero el secreto no existe" | Abre el detalle de la automatización y toca **Generar secreto**. | | La acción falló con "La llamada tardó más de 10 s en responder" | El bot tardó demasiado. Responde `200` enseguida y procesa el aviso después. |