Rocket.Chat-Bot mit lokaler KI

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel behandelt

• Wie Du einen Bot auf Deinem Rocket.Chat-Server mit Ollama baust.
• Zwei Wege: Hubot-Adapter (klassisch) oder Realtime-API (flexibler).
• Bot-User anlegen, WebSocket-Events verarbeiten, antworten.
• Omnichannel-Features: Rocket.Chat als Kundenservice-Plattform mit KI.
• Erweiterungen und Vergleich zu Mattermost.

Einleitung

Rocket.Chat ist neben Mattermost die zweite große selbst-hostbare Team-Chat-Plattform: Open Source (Community Edition), mit einem Alleinstellungsmerkmal: Omnichannel. Rocket.Chat kann WhatsApp Business, Telegram, E-Mail und Live-Chat auf der Website als Kanäle einbinden, ein Bot kann also über mehrere Kanäle gleichzeitig antworten.

Für KI-Bots gibt es zwei Wege: den klassischen Hubot-Adapter (der alte GitHub-Bot-Standard) oder die Realtime-API (DDP/WebSocket) mit eigenem Code, wir zeigen beide.

Typische Anwendungsszenarien

• Kundenservice-KI: Omnichannel nutzen: Website-Chat, WhatsApp, E-Mail landen in einer Queue, KI antwortet first-level.
• Interner Team-Bot: Wie Mattermost: Wissensbot, Alerts, Onboarding.
• Live-Chat auf der Website: Rocket.Chat Livechat-Widget + Ollama = self-hosted KI-Chat für Deine Seite.
• Community-Plattform: Öffentliche Channels mit KI-Moderation.

Voraussetzungen

• Rocket.Chat-Server (Docker: rocket.chat Image + MongoDB)
• Admin-Zugang
• Ollama mit Modell
• Node.js (Hubot) oder Python (Realtime-API)

Schritt 1: Rocket.Chat-Server (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:

Hinweis: MongoDB braucht den Replica-Set-Modus (für Change-Streams): --replSet rs0 wie oben, danach einmal mongosh --eval "rs.initiate()".

Schritt 2: Bot-User anlegen

Administration → Users → New User:

• Username: ki-bot, Display-Name „KI-Assistent”
• Rolle bot zuweisen (wichtig!)
• E-Mail + Passwort setzen

Der Bot-User loggt sich mit Username/Passwort oder Personal Access Token ein (Administration → Accounts → „Allow Personal Access Tokens” aktivieren).

Weg A: Realtime-API mit Python (empfohlen)

Rocket.Chats Echtzeit-API heißt DDP (Distributed Data Protocol), eine WebSocket-Schicht. Die Python-Library rocketchat-API + eigener Stream, oder direkt WebSocket. Einfacher geht’s mit rocketchat.py-artigen Paketen; hier das direkte DDP-Prinzip:

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())

Das DDP-Protokoll ist etwas sperrig, für Produktion empfiehlt sich eine Bibliothek (python-rocketchat, rocket-python).

Weg B: Hubot (klassisch, schnell)

Hubot ist der alte Chatbot-Standard von GitHub; Rocket.Chat hat einen offiziellen Adapter:

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 nutzt CoffeeScript) oder einfacher: externes Script, das Ollama aufruft. Hubot ist praktisch, wenn Du schnell hubot ki <frage>-Style-Kommandos willst, für komplexere Bots ist die Realtime-API flexibler.

Erweiterungen

Omnichannel: Bot beantwortet Website-Live-Chat

Der Killer-Use-Case: Administration → Omnichannel → Livechat aktivieren → Widget-Snippet auf Deine Website. Besucher schreiben ins Widget → landen als Raum in Rocket.Chat → Dein Bot (Realtime-API) antwortet mit lokaler KI. Self-hosted KI-Livechat ohne externen Anbieter.

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

RAG und Moderation

Gleiche Patterns wie bei Mattermost: Embedding → Qdrant → Kontext ins Prompt; Spam-Klassifikation für öffentliche Channels.

Trigger für Agenten-Workflows

Bot-Kommando !aufgabe <beschreibung> → triggert n8n-Workflow → Ergebnis zurück in den Channel. Verbindet den Bot mit n8n-Automatisierung.

Sicherheit

• Bot-Rolle minimal: Bot-User bekommt nur die bot-Rolle, kein Admin.
• Tokens: Personal Access Token statt Passwort, revokierbar ohne Passwortwechsel.
• HTTPS: In Produktion TLS hinter Reverse Proxy (Caddy/Nginx).
• Channel-Isolation: Bot nur in erlaubte Channels einladen.

Typische Stolpersteine

• MongoDB Replica Set: Rocket.Chat startet ohne ReplSet nicht richtig: rs.initiate() nicht vergessen.
• DDP ist komplex: Wenn der eigene WebSocket-Code kämpft → Bibliothek nutzen oder auf Hubot-Adapter wechseln.
• Bot antwortet sich selbst: Username-Check auf RC_USER (siehe Code).
• Community-Edition-Limits: Einige Enterprise-Features (z. B. erweiterte Omnichannel-Optionen) sind lizenzpflichtig: Kern-Livechat ist frei.

Mattermost vs. Rocket.Chat, kurz

Weiterführende Links

• IRC-Coding.de: Vertiefende Programmier-Tutorials: WebSocket, Node.js, Bot-Frameworks.
• Mattermost-Bot: Die schlankere Alternative.
• Nextcloud-Talk-Bot: Wenn Du Nextcloud schon hast.
• Chatwoot: Dedizierte Kundenservice-Plattform.
• Docker: Deployment-Grundlagen.

Key Takeaways:

• Rocket.Chat = selbst-gehostete Chat-Plattform mit Omnichannel (Website, WhatsApp, Mail).
• Bot via Realtime-API (DDP/WebSocket) oder klassischem Hubot-Adapter.
• Killer-Feature: Live-Chat-Widget für die eigene Website + lokale KI = self-hosted Support-Chat.
• Für reine Team-Kommunikation ist Mattermost schlanker; für Kundenservice Rocket.Chat stärker.
• MongoDB mit Replica Set nötig: Setup etwas aufwendiger.

FAQ

Quellen und weiterführende Literatur

• Rocket.Chat: Offizielle Website.
• Rocket.Chat Realtime API: DDP-Doku.
• Hubot Rocket.Chat Adapter: Hubot-Integration.
• IRC-Coding.de: Programmier-Tutorials.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert