Bot de IRC con Ollama

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 de IRC con Ollama como backend de IA.
• Cómo integrar el bot en canales de IRC.
• Cómo funcionan los comandos, la moderación y la automatización.
• Ejemplos prácticos para bot de FAQ, soporte de canal y registro.
• Mejores prácticas para etiqueta de red, seguridad y limitación de velocidad.

Introducción: Bot de IRC con Ollama explicado

IRC es el chat clásico, simple y rápido, desde 1988. Un bot de IRC con Ollama lleva IA moderna al chat clásico: el bot se sienta en un canal, responde preguntas, ejecuta comandos y modera. Todo con un modelo de IA local.

Este artículo va dirigido a usuarios que quieren extender IRC con IA. Encontrarás los conceptos básicos en Bots de IRC y Ollama. Para los fundamentos de programación en Python, consulta IRC-Coding.de.

¿Por qué necesito un bot de IRC con Ollama?

IRC es minimalista: texto dentro, texto fuera. Un bot de IA puede responder preguntas en canales de IRC, ejecutar comandos y moderar. A diferencia de Discord o Matrix, IRC es simple; puedes escribir un bot en 50 líneas de Python.

Bot de IRC con Ollama en pocas palabras

El bot se conecta a un servidor IRC, entra en un canal y escucha mensajes. Cuando recibe mensajes con ! o menciones, llama a Ollama y publica la respuesta.

La idea central es simple: IRC es minimalista, la IA lo hace inteligente.

¿Para quién es este artículo?

• Usuarios de IRC que quieren IA en sus canales.
• Aficionados a la informática retro que combinan IRC con IA moderna.
• Desarrolladores que construyen bots simples.
• Administradores de comunidades que automatizan canales de IRC.

Experiencia previa en Python e IRC es útil.

Términos importantes

• IRC - Internet Relay Chat. Cuándo es útil: el protocolo.
• Channel - Sala de chat en IRC. Cuándo es útil: dónde está el bot.
• Nickname - Nombre de usuario. Cuándo es útil: el nombre del bot.
• irc / pydle - Bibliotecas de Python. Cuándo es útil: para la implementación.
• Ollama - Servidor de modelos local. Cuándo es útil: el backend de IA.
• PRIVMSG - Mensaje en IRC. Cuándo es útil: cómo se comunica el bot.
• Fundamentos de bot de IRC - Conceptos básicos de bot. Cuándo es útil: para la configuración.

Configuración: Crear un bot de IRC

Bot con 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):
    """Llamar a Ollama"""
    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):
        """Al conectarse"""
        await self.join(IRC_CHANNEL)
        print(f"Bot online en {IRC_CHANNEL}")

    async def on_message(self, target, source, message):
        """En nuevo mensaje"""
        # Ignorar mensajes propios
        if source == self.nickname:
            return

        # Reaccionar a comandos
        if message.startswith("!"):
            await self.handle_command(target, source, message)

        # Reaccionar a menciones
        elif self.nickname.lower() in message.lower():
            await self.handle_mention(target, source, message)

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

        if command == "ask":
            # !ask ¿Cómo funciona X?
            answer = await call_ollama(
                args,
                system="Eres un bot de IRC útil. Responde brevemente."
            )
            await self.message(target, f"{source}: {answer}")

        elif command == "summarize":
            # !summarize (usa últimos N mensajes)
            # Implementación: reunir historial de mensajes
            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):
        """Procesar mención"""
        # Eliminar nickname
        question = message.replace(self.nickname, "").strip()

        answer = await call_ollama(
            question,
            system="Eres un bot de IRC útil. Responde brevemente."
        )

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

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

Iniciar el bot

pip install pydle aiohttp

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

Implementar comandos

COMMANDS = {
    "ask": "Pregunta a la IA",
    "summarize": "Resumir últimos mensajes",
    "translate": "Traducir texto",
    "weather": "Consultar clima",
    "help": "Mostrar ayuda"
}

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="Responde brevemente.")
        await self.message(target, f"{source}: {answer}")

    elif command == "translate":
        answer = await call_ollama(
            f"Traduce al alemán: {args}",
            system="Solo traduce."
        )
        await self.message(target, f"{source}: {answer}")

    elif command == "weather":
        # Llamar API de clima
        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}")

Ejemplo práctico 1: Bot de FAQ

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: Buscar documentos similares
            results = self.collection.query(
                query_texts=[question],
                n_results=3
            )
            context = "\n".join(results["documents"][0])

            answer = await call_ollama(
                f"Contexto:\n{context}\n\nPregunta: {question}",
                system="Responde basándote en el contexto. Brevemente."
            )

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

Ejemplo práctico 2: Moderación

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

Ejemplo práctico 3: Registro de canales con resumen basado en IA

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 = []

Ejemplo práctico 4: Activador n8n

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}")

Etiqueta de red IRC

# 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])

Notas de seguridad

• Contraseña del bot: Define una contraseña para nicks registrados (NickServ).
• Permisos mínimos: El bot debe tener solo los permisos necesarios.
• Inyección de prompts: Los usuarios pueden enviar inyecciones. Consulta Prompt Injection.
• Flooding: No envíes demasiados mensajes muy rápido. Los servidores expulsan bots.
• Logging: Registra las acciones del bot. Consulta Audit Logging.

Errores comunes

• Flooding: Los servidores IRC expulsan bots que envían demasiado rápido. Implementa rate-limiting.
• Mensajes muy largos: IRC tiene un límite de 512 bytes por línea. Divide los mensajes.
• Colisión de nick: El nick del bot debe estar disponible. Regístralo en NickServ.
• SSL/TLS: Muchos servidores IRC requieren TLS. Usa tls=True en pydle.
• Codificación: IRC usa Latin-1 o UTF-8. Ten cuidado con los problemas de codificación.
• Ollama lento: Los modelos grandes necesitan tiempo. Usa modelos pequeños (8B) para tiempo real.

Enlaces útiles

• Fundamentos de bots IRC - Lo básico sobre bots.
• Configuración avanzada de IRC - Funcionalidades avanzadas.
• Ollama - Servidor de modelos.
• pydle - Librería Python para IRC.
• Prompt Injection - Seguridad.

Puntos clave:

• IRC + Ollama: Chat clásico con IA moderna.
• pydle para bots en Python, simple y potente.
• Comandos con !, menciones para chat.
• Respeta el rate-limiting y la etiqueta de red.
• IA local: sin datos que salgan, sin costos de API.

Preguntas frecuentes

Fuentes y lecturas recomendadas

• pydle - Biblioteca Python para IRC.
• IRC RFC - Protocolo IRC.
• Libera.Chat - Red IRC.
• Ollama - Servidor de modelos local.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert