Bot de Rocket.Chat con IA local

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo

• Cómo construir un bot en tu servidor Rocket.Chat con Ollama.
• Dos enfoques: adaptador Hubot (clásico) o API Realtime (más flexible).
• Crear usuario bot, procesar eventos WebSocket, responder mensajes.
• Características Omnichannel: Rocket.Chat como plataforma de atención al cliente con IA.
• Extensiones y comparación con Mattermost.

Introducción

Junto con Mattermost, Rocket.Chat es la segunda gran plataforma de chat para equipos autohospedada: código abierto (Community Edition), con una característica diferenciadora: Omnichannel. Rocket.Chat puede integrar WhatsApp Business, Telegram, correo electrónico y chat en vivo del sitio web como canales; un bot puede responder simultáneamente a través de múltiples canales.

Para bots con IA hay dos caminos: el clásico adaptador Hubot (el antiguo estándar de bots de GitHub) o la API Realtime (DDP/WebSocket) con código personalizado; te mostramos ambos.

Casos de uso típicos

• IA para atención al cliente: Aprovechar Omnichannel: chat del sitio web, WhatsApp, correo electrónico llegan a una cola, la IA responde en primera línea.
• Bot interno para el equipo: Como en Mattermost: bot de conocimiento, alertas, incorporación.
• Chat en vivo en el sitio web: Widget Livechat de Rocket.Chat + Ollama = chat de IA autohospedado para tu página.
• Plataforma comunitaria: Canales públicos con moderación impulsada por IA.

Requisitos previos

• Servidor Rocket.Chat (Docker: imagen rocket.chat + MongoDB)
• Acceso de administrador
• Ollama con modelo
• Node.js (Hubot) o Python (API Realtime)

Paso 1: Servidor Rocket.Chat (Docker)

services:
  rocketchat:
    image: rocket.chat:latest
    environment:
      MONGO_URL: mongodb://mongodb:27017/rocketchat?replicaSet=rs0
      MONGO_OPLOG_URL: mongodb://mongodb:27017/local?replicaSet=rs0
      ROOT_URL: https://chat.deine-domain.de
      PORT: 3000
      DEPLOY_METHOD: docker
    depends_on: [mongodb]
    ports: ["3000:3000"]
    restart: always

  mongodb:
    image: mongo:7
    command: mongod --replSet rs0 --oplogSize 128
    volumes: [mongo_data:/data/db]
    restart: always

volumes:
  mongo_data:

Nota: MongoDB requiere modo Replica Set (para Change Streams): --replSet rs0 como se muestra arriba, luego ejecuta una vez mongosh --eval "rs.initiate()".

Paso 2: Crear usuario bot

Administración → Usuarios → Nuevo usuario:

• Nombre de usuario: ki-bot, Nombre visible “Asistente de IA”
• Asignar rol bot (importante)
• Establecer correo electrónico + contraseña

El usuario bot inicia sesión con nombre de usuario/contraseña o con un token de acceso personal (Administración → Cuentas → activar “Permitir tokens de acceso personal”).

Opción A: API Realtime con Python (recomendado)

La API en tiempo real de Rocket.Chat se llama DDP (Distributed Data Protocol), una capa WebSocket. La biblioteca Python rocketchat-API + stream propio, o WebSocket directo. Es más simple con paquetes tipo rocketchat.py; aquí el principio DDP directo:

import asyncio
import json
import os
import websockets
import ollama
from dotenv import load_dotenv

load_dotenv()
RC_URL = os.environ["RC_URL"]              # wss://chat.deine-domain.de/websocket
RC_USER = os.environ["RC_USER"]
RC_PASS = os.environ["RC_PASS"]
MODEL = os.environ.get("OLLAMA_MODEL", "llama3.1:8b")
ollama_client = ollama.Client(host=os.environ["OLLAMA_URL"])

seq = 0
def msg(method, params, msg_id=None):
    global seq
    seq += 1
    return json.dumps({
        "msg": "method", "method": method, "params": params,
        "id": msg_id or str(seq)
    })

async def main():
    async with websockets.connect(RC_URL) as ws:
        # 1. Connect
        await ws.send(json.dumps({"msg": "connect",
            "version": "1", "support": ["1"]}))
        await ws.recv()

        # 2. Login (Passwort)
        await ws.send(msg("login", [{
            "user": {"username": RC_USER},
            "password": {"digest": sha256(RC_PASS), "algorithm": "sha-256"}
        }], "login"))
        login_resp = json.loads(await ws.recv())
        auth_token = login_resp["result"]["token"]

        # 3. Auf neue Nachrichten subscriben (stream-room-messages)
        await ws.send(json.dumps({
            "msg": "sub", "id": "sub1", "name": "stream-room-messages",
            "params": ["__my_messages__", False]
        }))

        async for raw in ws:
            evt = json.loads(raw)
            if evt.get("msg") == "changed":
                for arg in evt["fields"]["args"]:
                    m = arg if isinstance(arg, dict) else arg[0]
                    if m.get("u", {}).get("username") == RC_USER:
                        continue
                    text = m.get("msg", "")
                    if text.startswith("!ki"):
                        prompt = text[3:].strip()
                        resp = ollama_client.chat(model=MODEL, messages=[
                            {"role": "system", "content": "Kurz antworten, Deutsch."},
                            {"role": "user", "content": prompt}])
                        await ws.send(msg("sendMessage", [{
                            "rid": m["rid"],
                            "msg": resp["message"]["content"][:16000],
                        }]))

from hashlib import sha256
def sha256(s): return sha256(s.encode()).hexdigest()

asyncio.run(main())

El protocolo DDP es algo verboso; para producción se recomienda una biblioteca (python-rocketchat, rocket-python).

Opción B: Hubot (clásico, rápido)

Hubot es el antiguo estándar de chatbots de GitHub; Rocket.Chat tiene un adaptador oficial:

npm install -g yo generator-hubot
mkdir ki-bot && cd ki-bot
yo hubot --adapter rocketchat

.env:

ROCKETCHAT_URL=http://localhost:3000
ROCKETCHAT_USER=ki-bot
ROCKETCHAT_PASSWORD=bot-passwort
ROCKETCHAT_ROOM=general
LISTEN_ON_ALL_PUBLIC=true
RESPOND_TO_DM=true

scripts/ki.coffee (Hubot usa CoffeeScript) o más simple: script externo que llama a Ollama. Hubot es práctico si quieres comandos al estilo hubot ki <pregunta> rápidamente; para bots más complejos la API Realtime es más flexible.

Extensiones

Omnichannel: Bot responde chat en vivo del sitio web

El caso de uso clave: Administración → Omnichannel → Activar Livechat → Fragmento del widget en tu sitio web. Los visitantes escriben en el widget → llegan como sala en Rocket.Chat → Tu bot (API Realtime) responde con IA local. Chat de IA autohospedado sin proveedor externo.

// Widget Livechat en el sitio web
<script>
(function(w,d,s,u){ /* Rocket.Chat Livechat-Snippet */
})(window, document, 'script', 'https://chat.deine-domain.de/livechat');
</script>

RAG y moderación

Los mismos patrones que en Mattermost: embedding → Qdrant → contexto en el prompt; clasificación de spam para canales públicos.

Disparadores para flujos de agentes

Comando bot !aufgabe <descripción> → dispara flujo n8n → resultado vuelve al canal. Conecta el bot con automatización n8n.

Seguridad

• Rol bot mínimo: El usuario bot obtiene solo el rol bot, sin permisos de administrador.
• Tokens: Token de acceso personal en lugar de contraseña, revocable sin cambiar contraseña.
• HTTPS: En producción TLS detrás de proxy inverso (Caddy/Nginx).
• Aislamiento de canales: Invita el bot solo a canales permitidos.

Problemas frecuentes

• MongoDB Replica Set: Rocket.Chat no arranca correctamente sin ReplSet: no olvides ejecutar rs.initiate().
• DDP es complejo: Si tu código WebSocket personalizado tiene dificultades → usa una librería o cambia a un adaptador Hubot.
• El bot se responde a sí mismo: verifica el nombre de usuario contra RC_USER (ver código).
• Límites de Community Edition: algunas funciones empresariales (por ejemplo, opciones avanzadas de Omnichannel) requieren licencia; el chat en vivo básico es gratuito.

Mattermost vs. Rocket.Chat, comparación rápida

Enlaces de referencia

• IRC-Coding.de: tutoriales de programación en profundidad: WebSocket, Node.js, frameworks de bots.
• Mattermost-Bot: la alternativa más ligera.
• Nextcloud-Talk-Bot: si ya usas Nextcloud.
• Chatwoot: plataforma dedicada de atención al cliente.
• Docker: conceptos básicos de implementación.

Puntos clave:

• Rocket.Chat = plataforma de chat autohospedada con Omnichannel (web, WhatsApp, correo).
• Bot mediante Realtime API (DDP/WebSocket) o adaptador Hubot clásico.
• Característica destacada: widget de chat en vivo para tu sitio web + IA local = chat de soporte autohospedado.
• Para comunicación pura entre equipos, Mattermost es más ligero; para atención al cliente, Rocket.Chat es más potente.
• MongoDB con Replica Set requerido: la configuración es algo más compleja.

FAQ

Fuentes y lecturas adicionales

• Rocket.Chat: sitio web oficial.
• Rocket.Chat Realtime API: documentación de DDP.
• Hubot Rocket.Chat Adapter: integración de Hubot.
• IRC-Coding.de: tutoriales de programación.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert