IRC-Bot mit Ollama

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über IRC-Bot mit Ollama behandelt

• Wie Du einen IRC-Bot mit Ollama als KI-Backend baust.
• Wie Du den Bot in IRC-Channels integrierst.
• Wie Commands, Moderation und Automatisierung funktionieren.
• Praxisbeispiele für FAQ-Bot, Channel-Support und Logging.
• Best Practices für Netzwerk-Etikette, Sicherheit und Rate-Limiting.

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

IRC ist der klassische Chat, einfach, schnell, seit 1988. Ein IRC-Bot mit Ollama bringt moderne KI in den klassischen Chat: Der Bot sitzt in einem Channel, beantwortet Fragen, führt Commands aus und moderiert. Alles mit lokalem KI-Modell.

Dieser Artikel richtet sich an Anwender, die IRC mit KI erweitern wollen. Grundlagen findest Du in IRC-Bots und Ollama. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.

Warum brauche ich einen IRC-Bot mit Ollama?

IRC ist minimalistisch: Text rein, Text raus. Ein KI-Bot kann in IRC-Channels Fragen beantworten, Kommandos ausführen und moderieren. Im Gegensatz zu Discord oder Matrix ist IRC simpel, ein Bot ist in 50 Zeilen Python geschrieben.

IRC-Bot mit Ollama kurz erklärt

Der Bot verbindet sich mit einem IRC-Server, joint einen Channel und lauscht auf Nachrichten. Bei Nachrichten mit ! oder Erwähnung ruft er Ollama auf und postet die Antwort zurück.

Der Kerngedanke lautet: IRC ist simpel: KI macht ihn intelligent.

Für wen ist dieser Artikel gedacht?

• IRC-Nutzer, die KI in ihren Channels wollen.
• Retro-Computing-Fans, die IRC mit moderner KI kombinieren.
• Entwicklerinnen und Entwickler, die einfache Bots bauen.
• Community-Admins, die IRC-Channels automatisieren.

Vorkenntnisse in Python und IRC sind hilfreich.

Wichtige Begriffe

• IRC - Internet Relay Chat. Wann nützlich: das Protokoll.
• Channel - Chatraum in IRC. Wann nützlich: wo der Bot ist.
• Nickname - Benutzername. Wann nützlich: der Bot-Name.
• irc / pydle - Python-Bibliotheken. Wann nützlich: für die Implementierung.
• Ollama - Lokaler Modellserver. Wann nützlich: das KI-Backend.
• PRIVMSG - Nachricht in IRC. Wann nützlich: wie der Bot kommuniziert.
• IRC-Bot Grundlagen - Bot-Basics. Wann nützlich: für Setup.

Setup: IRC-Bot erstellen

Bot mit pydle (Python)

# bot.py
import asyncio
import aiohttp
from pydle import Client

OLLAMA_URL = "http://ollama:11434"
IRC_SERVER = "irc.libera.chat"
IRC_PORT = 6697
IRC_CHANNEL = "#mein-channel"
BOT_NICK = "KI-Bot"

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"]

class KIBot(Client):
    async def on_connect(self):
        """Bei Verbindung"""
        await self.join(IRC_CHANNEL)
        print(f"Bot online in {IRC_CHANNEL}")

    async def on_message(self, target, source, message):
        """Bei neuer Nachricht"""
        # Eigene Nachrichten ignorieren
        if source == self.nickname:
            return

        # Auf Commands reagieren
        if message.startswith("!"):
            await self.handle_command(target, source, message)

        # Auf Erwähnungen reagieren
        elif self.nickname.lower() in message.lower():
            await self.handle_mention(target, source, message)

    async def handle_command(self, target, source, message):
        """Command verarbeiten"""
        parts = message[1:].split()
        command = parts[0].lower()
        args = " ".join(parts[1:])

        if command == "ask":
            # !ask Wie funktioniert X?
            answer = await call_ollama(
                args,
                system="Du bist ein hilfreicher IRC-Bot. Antworte kurz."
            )
            await self.message(target, f"{source}: {answer}")

        elif command == "summarize":
            # !summarize (nutzt letzte N Nachrichten)
            # Implementierung: Nachrichten-History sammeln
            await self.message(target, f"{source}: Summarizing...")

        elif command == "help":
            await self.message(target,
                "Commands: !ask <frage>, !summarize, !help"
            )

    async def handle_mention(self, target, source, message):
        """Erwähnung verarbeiten"""
        # Nickname entfernen
        question = message.replace(self.nickname, "").strip()

        answer = await call_ollama(
            question,
            system="Du bist ein hilfreicher IRC-Bot. Antworte kurz."
        )

        await self.message(target, f"{source}: {answer}")

# Bot starten
bot = KIBot(BOT_NICK, realname="KI Bot")
bot.run(IRC_SERVER, tls=True, tls_verify=False)

Bot starten

pip install pydle aiohttp

export OLLAMA_URL="http://localhost:11434"
python bot.py

Commands implementieren

COMMANDS = {
    "ask": "Frage an die KI",
    "summarize": "Letzte Nachrichten zusammenfassen",
    "translate": "Text übersetzen",
    "weather": "Wetter abfragen",
    "help": "Hilfe anzeigen"
}

async def handle_command(self, target, source, message):
    parts = message[1:].split()
    command = parts[0].lower()
    args = " ".join(parts[1:])

    if command == "ask":
        answer = await call_ollama(args, system="Kurz antworten.")
        await self.message(target, f"{source}: {answer}")

    elif command == "translate":
        answer = await call_ollama(
            f"Übersetze ins Deutsche: {args}",
            system="Übersetze nur."
        )
        await self.message(target, f"{source}: {answer}")

    elif command == "weather":
        # Wetter-API aufrufen
        weather = await get_weather(args)
        await self.message(target, f"{source}: {weather}")

    elif command == "help":
        cmds = ", ".join(f"!{k}" for k in COMMANDS)
        await self.message(target, f"Commands: {cmds}")

Praxisbeispiel 1: FAQ-Bot

import chromadb

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

    async def handle_command(self, target, source, message):
        if message.startswith("!faq"):
            question = message[4:].strip()

            # RAG: Ähnliche Dokumente suchen
            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 basierend auf Kontext. Kurz."
            )

            await self.message(target, f"{source}: {answer}")
        else:
            await super().handle_command(target, source, message)

Praxisbeispiel 2: Moderation

async def on_message(self, target, source, message):
    if source == self.nickname:
        return

    # KI prüft Nachricht
    analysis = await call_ollama(
        f"Analysiere: {message}\n"
        "Kategorien: ok, spam, toxisch\n"
        "Antworte: KATEGORIE",
        system="Du bist ein IRC-Moderator."
    )

    if "spam" in analysis.lower() or "toxisch" in analysis.lower():
        # Nachricht entfernen (Bot braucht Op-Rechte)
        await self.kick(target, source, "Regelverstoß")
        await self.message(target, f"⚠️ {source} wurde verwarnt")

Praxisbeispiel 3: Channel-Logging mit KI-Zusammenfassung

class LoggingBot(KIBot):
    def __init__(self):
        super().__init__(BOT_NICK)
        self.log = []

    async def on_message(self, target, source, message):
        # Loggen
        self.log.append({
            "time": asyncio.get_event_loop().time(),
            "user": source,
            "message": message
        })

        await super().on_message(target, source, message)

    async def daily_summary(self):
        """Tägliche Zusammenfassung"""
        log_text = "\n".join(
            f"{e['user']}: {e['message']}" for e in self.log[-500:]
        )

        summary = await call_ollama(
            f"Fasse die letzten IRC-Nachrichten zusammen:\n{log_text}",
            system="Erstelle eine kurze Zusammenfassung."
        )

        await self.message(IRC_CHANNEL, f"Tägliche Zusammenfassung:\n{summary}")
        self.log = []

Praxisbeispiel 4: n8n-Trigger

elif command == "workflow":
    # !workflow name param1 param2
    parts = args.split()
    wf_name = parts[0] if parts else "default"
    wf_params = " ".join(parts[1:])

    async with aiohttp.ClientSession() as session:
        async with session.post(
            f"http://n8n:5678/webhook/{wf_name}",
            json={"params": wf_params, "user": source}
        ) as r:
            result = await r.text()

    await self.message(target, f"{source}: {result}")

IRC-Netiquette

# Rate-Limiting: Nicht zu schnell senden
async def message(self, target, text):
    # IRC hat Rate-Limits
    await asyncio.sleep(1)  # 1 Sekunde zwischen Nachrichten
    await super().message(target, text)

# Lange Nachrichten aufteilen
async def send_long(self, target, text, max_len=400):
    for i in range(0, len(text), max_len):
        await self.message(target, text[i:i+max_len])

Sicherheitshinweise

• Bot-Passwort: Für registrierte Nicks ein Passwort setzen (NickServ).
• Op-Rechte minimal: Der Bot sollte nur nötige Rechte haben.
• Prompt Injection: Nutzer können Injections senden. Siehe Prompt Injection.
• Flooding: Nicht zu viele Nachrichten zu schnell senden. Server kicken Bots.
• Logging: Protokolliere Bot-Aktionen. Siehe Audit Logging.

Typische Stolpersteine

• Flooding: IRC-Server kicken Bots, die zu schnell senden. Rate-Limiting implementieren.
• Zu lange Nachrichten: IRC hat 512-Byte-Limit pro Zeile. Nachrichten aufteilen.
• Nick-Kollision: Der Bot-Nick muss frei sein. NickServ registrieren.
• SSL/TLS: Viele IRC-Server verlangen TLS. tls=True in pydle.
• Encoding: IRC ist Latin-1 oder UTF-8. Encoding-Probleme beachten.
• Ollama zu langsam: Große Modelle brauchen Zeit. Nutze kleine Modelle (8B) für Echtzeit.

Weiterführende Links

• IRC-Bot Grundlagen - Bot-Basics.
• Erweitertes IRC-Setup - Erweiterte Features.
• Ollama - Modellserver.
• pydle - Python IRC-Bibliothek.
• Prompt Injection - Sicherheit.

Key Takeaways:

• IRC + Ollama: Klassischer Chat mit moderner KI.
• pydle für Python-Bots, einfach und mächtig.
• Commands mit !, Erwähnungen für Chat.
• Rate-Limiting und Netiquette beachten.
• Lokale KI: keine Daten raus, keine API-Kosten.

FAQ

Quellen und weiterführende Literatur

• pydle - Python IRC-Bibliothek.
• IRC RFC - IRC-Protokoll.
• Libera.Chat - IRC-Netzwerk.
• Ollama - Lokaler Modellserver.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert