Matrix-Bot mit Ollama

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Matrix-Bot mit Ollama behandelt

• Wie Du einen Matrix-Bot mit Ollama als KI-Backend baust.
• Wie Du den Bot in Matrix-Räume integrierst.
• Wie RAG und Tool-Integration in Matrix funktionieren.
• Praxisbeispiele für Support-Bot, Moderation und Automatisierung.
• Best Practices für E2EE, Sicherheit und Datenschutz.

Einleitung: Matrix-Bot mit Ollama verständlich erklärt

Matrix ist ein dezentrales Chat-Protokoll: Self-Hosted, verschlüsselt, ohne zentrale Firma. Ein Matrix-Bot mit Ollama beantwortet Fragen in Deinen Matrix-Räumen mit lokaler KI: keine Daten an Dritte, keine API-Kosten, volle Kontrolle.

Dieser Artikel richtet sich an Anwender, die einen Matrix-Bot mit lokaler KI bauen wollen. Grundlagen findest Du in Matrix-Bots und Ollama.

Warum brauche ich einen Matrix-Bot mit Ollama?

Discord-Bots laufen auf Discord-Servern: Deine Daten liegen bei Discord. Matrix ist Self-Hosted: Dein Server, Deine Daten. Ein Matrix-Bot mit Ollama ist die konsequenteste Privacy-Lösung: Dezentrales Protokoll + lokale KI = niemand sieht Deine Daten.

Matrix-Bot mit Ollama kurz erklärt

Du erstellst einen Matrix-Bot (matrix-nio oder matrix-js-sdk), der in Räumen auf Nachrichten reagiert. Bei Nachrichten ruft der Bot Ollama auf und postet die Antwort. Mit E2EE bleiben sogar die Nachrichten verschlüsselt.

Der Kerngedanke lautet: Dezentrales Protokoll + lokale KI = maximale Kontrolle.

Für wen ist dieser Artikel gedacht?

• Matrix-Nutzer, die einen KI-Bot wollen.
• Privacy-Bewusste, die Discord meiden.
• Self-Hoster, die ihren eigenen Matrix-Server betreiben.
• Entwicklerinnen und Entwickler, die Matrix-Bots bauen.

Vorkenntnisse in Python und Ollama sind hilfreich.

Wichtige Begriffe

• Matrix - Dezentrales Chat-Protokoll. Wann nützlich: das Protokoll.
• Synapse - Matrix-Homeserver. Wann nützlich: die Server-Software.
• Element - Matrix-Client. Wann nützlich: das Frontend.
• matrix-nio - Python-Bibliothek. Wann nützlich: für den Bot.
• Ollama - Lokaler Modellserver. Wann nützlich: das KI-Backend.
• E2EE - End-to-End-Verschlüsselung. Wann nützlich: für private Nachrichten.
• RAG - Wissensdatenbank. Wann nützlich: für FAQ.

Setup: Matrix-Bot erstellen

1. Bot-Account auf Deinem Homeserver

# Auf dem Synapse-Server: Bot-Benutzer erstellen
register_new_matrix_user -c /etc/matrix-synapse/homeserver.yaml \
  -u ki-bot -p "sicheres-passwort" --no-admin

2. Bot mit matrix-nio

# bot.py
import asyncio
import aiohttp
from nio import AsyncClient, RoomMessageText

OLLAMA_URL = "http://ollama:11434"
HOMESERVER = "https://matrix.deine-domain.de"
BOT_USER = "@ki-bot:deine-domain.de"
BOT_PASSWORD = "sicheres-passwort"

async def call_ollama(prompt, system=None):
    """Ollama aufrufen"""
    messages = []
    if system:
        messages.append({"role": "system", "content": system})
    messages.append({"role": "user", "content": prompt})

    async with aiohttp.ClientSession() as session:
        async with session.post(
            f"{OLLAMA_URL}/api/chat",
            json={
                "model": "llama3.1",
                "messages": messages,
                "stream": False
            },
            timeout=aiohttp.ClientTimeout(total=60)
        ) as response:
            data = await response.json()
            return data["message"]["content"]

async def main():
    client = AsyncClient(HOMESERVER, BOT_USER)

    # Login
    response = await client.login(BOT_PASSWORD)
    print(f"Bot eingeloggt: {response.user_id}")

    # Auto-Join auf Einladungen
    client.add_event_callback(on_invite, InviteEvent)

    async def on_message(room, event):
        """Bei neuer Nachricht"""
        if event.sender == BOT_USER:
            return

        # Auf Erwähnungen oder Commands reagieren
        if f"{BOT_USER}" in event.body or event.body.startswith("!"):
            async with client.typing(room.room_id):
                # Frage extrahieren
                question = event.body.replace(f"@{BOT_USER.split(':')[0][1:]}", "").strip()
                if question.startswith("!"):
                    question = question[1:].strip()

                # Ollama aufrufen
                answer = await call_ollama(
                    question,
                    system="Du bist ein hilfreicher Assistent in einem Matrix-Chat. Antworte kurz und hilfreich."
                )

                # Antwort senden
                await client.room_send(
                    room_id=room.room_id,
                    message_type="m.room.message",
                    content={
                        "msgtype": "m.text",
                        "body": answer
                    }
                )

    client.add_event_callback(on_message, RoomMessageText)

    # Sync loop
    await client.sync_forever(timeout=30000)

asyncio.run(main())

3. Bot in Raum einladen

# In Element (Matrix-Client):
1. Raum erstellen oder öffnen
2. /invite @ki-bot:deine-domain.de
3. Bot akzeptiert automatisch (on_invite callback)

Praxisbeispiel 1: FAQ-Bot mit RAG

import chromadb

class MatrixFAQBot:
    def __init__(self):
        self.chroma = chromadb.HttpClient(host="chromadb", port=8000)
        self.collection = self.chroma.get_collection("faq")

    async def answer(self, question):
        """Frage mit RAG beantworten"""
        results = self.collection.query(
            query_texts=[question],
            n_results=3
        )

        context = "\n".join(results["documents"][0])

        answer = await call_ollama(
            f"Kontext:\n{context}\n\nFrage: {question}",
            system="Beantworte die Frage basierend auf dem Kontext. Gib Quellen an."
        )

        return {
            "answer": answer,
            "sources": [m["source"] for m in results["metadatas"][0]]
        }

# Im on_message:
if event.body.startswith("!faq"):
    question = event.body[4:].strip()
    result = await faq_bot.answer(question)
    await client.room_send(
        room_id=room.room_id,
        message_type="m.room.message",
        content={
            "msgtype": "m.text",
            "body": f"{result['answer']}\n\nQuellen: {', '.join(result['sources'])}"
        }
    )

Praxisbeispiel 2: Moderation

async def moderate_message(room, event, client):
    """Nachricht moderieren"""
    analysis = await call_ollama(
        f"Analysiere:\n{event.body}\n\n"
        "Kategorien: ok, spam, toxisch, nsfw\n"
        "Antworte: KATEGORIE|BEGRÜNDUNG",
        system="Du bist ein Moderations-Assistent."
    )

    category, reason = analysis.split("|", 1)

    if category != "ok":
        # Nachricht löschen (Bot braucht Moderator-Rechte)
        await client.room_redact(
            room_id=room.room_id,
            event_id=event.event_id,
            reason=reason
        )
        # Warnung senden
        await client.room_send(
            room_id=room.room_id,
            message_type="m.room.message",
            content={
                "msgtype": "m.text",
                "body": f"⚠️ Nachricht entfernt: {reason}"
            }
        )

Praxisbeispiel 3: Workflow-Trigger

if event.body.startswith("!workflow"):
    parts = event.body.split()
    workflow_name = parts[1] if len(parts) > 1 else "default"
    params = " ".join(parts[2:]) if len(parts) > 2 else ""

    # n8n Webhook aufrufen
    async with aiohttp.ClientSession() as session:
        async with session.post(
            f"http://n8n:5678/webhook/{workflow_name}",
            json={"params": params, "user": event.sender}
        ) as r:
            result = await r.text()

    await client.room_send(
        room_id=room.room_id,
        message_type="m.room.message",
        content={
            "msgtype": "m.text",
            "body": f"Workflow {workflow_name}: {result}"
        }
    )

E2EE berücksichtigen

Matrix-Räume können Ende-zu-Ende-verschlüsselt sein. Der Bot kann nur unverschlüsselte Nachrichten lesen, es sei denn, er hat die Schlüssel.

# E2EE-Bot mit matrix-nio
from nio import AsyncClient, MatrixRoom, RoomMessageText
from nio.crypto import OlmMachine

# Für E2EE braucht der Bot:
# 1. Device-Keys
# 2. Vertrauensstellung mit anderen Devices
# 3. Entschlüsselung der Nachrichten

# Das ist komplex. Für den Anfang:
# - Bot nur in unverschlüsselten Räumen nutzen
# - Oder: E2EE-Bibliothek wie pantalaimon nutzen

Sicherheitshinweise

• Bot-Passwort: Starkes Passwort, sicher gespeichert. Siehe Secrets.
• Berechtigungen: Bot sollte nur lesen und schreiben, keine Admin-Rechte.
• E2EE: In verschlüsselten Räumen kann der Bot nur mit Schlüsseln lesen.
• Prompt Injection: Nutzer können Injections senden. Siehe Prompt Injection.
• Federation: Matrix ist föderiert: Nachrichten können an andere Server gehen.

Typische Stolpersteine

• E2EE-Komplexität: Verschlüsselte Räume erfordern Key-Management. Für den Anfang unverschlüsselte Räume nutzen.
• Token vs. Passwort: Access Token ist besser als Passwort. Nach Login speichern.
• Rate-Limiting: Matrix-Server haben Limits. Implementiere Throttling.
• Zu lange Antworten: Matrix hat ein Limit (~65KB pro Nachricht). Bei langen Antworten aufteilen.
• Federation: Der Bot sieht nur Räume, in denen er ist. Remote-Räume über Federation sind anders.

Weiterführende Links

• Matrix-Bots - Matrix-Bot Grundlagen.
• Ollama - Modellserver.
• matrix-nio - Python-Bibliothek.
• Synapse - Matrix-Server.
• Lokales RAG - Wissensdatenbank.
• Prompt Injection - Sicherheit.

Key Takeaways:

• Matrix + Ollama: Dezentraler Chat mit lokaler KI.
• matrix-nio für Python-Bots, matrix-js-sdk für JavaScript.
• Bot reagiert auf Erwähnungen und Commands.
• RAG für FAQ, Moderation für Sicherheit, Workflows für Automatisierung.
• E2EE ist komplex, für den Anfang unverschlüsselte Räume.

FAQ

Quellen und weiterführende Literatur

• Matrix - Dezentrales Protokoll.
• matrix-nio - Python-Bibliothek.
• Synapse - Homeserver.
• Ollama - Lokaler Modellserver.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert