Programar Bots IRC: Frameworks para Python, Node.js, Go y Rust

En este tutorial rápido te mostraré cómo crear un bot IRC sencillo en diferentes lenguajes y con distintos frameworks.

¿Por qué Python?

Python es actualmente uno de los lenguajes más populares y ofrece innumerables librerías para procesamiento de texto. Trabajo profesionalmente con frameworks Python como FastAPI y me encanta integrar estos sistemas.

¿Por qué Node.js?

Node.js es moderno y se ejecuta del lado del servidor. Su integración funciona perfectamente con numerosos frameworks JavaScript. Si programas asiduamente, difícilmente evitarás Node.js.

¿Por qué Go?

Go es ideal para bots IRC gracias a sus características de concurrencia integradas (Goroutines) y su sencilla programación de red. Los binarios compilados son pequeños y rápidos, perfectos para bots que deben ejecutarse 24/7.

¿Por qué Rust?

Cualquier proyecto que se presente siempre se considera una oportunidad para implementarlo en Rust. Por eso aquí también te presento una implementación rápida que demuestra la simplicidad del lenguaje. Rust ofrece memory safety sin garbage collector, ideal para bots de larga duración.

Principios fundamentales de un bot IRC

Para construir un andamiaje adecuado o encontrar el inicio y el desarrollo, conviene anotar e interiorizar las tareas principales de un bot IRC. En lugar de diagramas UML o estructogramas, trabajaremos con una simple lista de tareas.

Todo bot IRC hace esto en esencia:

• Establecer conexión TCP al servidor IRC
• Establecer el nickname
• Autenticación opcional (NickServ / SASL)
• Unirse a canales
• Leer mensajes (eventos)
• Responder a PRIVMSG
• Enviar respuestas si es necesario

Por supuesto, en la práctica puedes extender estas tareas y funciones sin límite. Aquí veremos también un sistema de plugins y métodos async.

Hay muchos tutoriales que explican todo desde cero, pero en este tutorial rápido partimos de conocimientos básicos e iniciamos directamente con instalaciones y requisitos necesarios.

Python – irc (entrada más sencilla)

Instalación

pip install irc

Bot mínimo

import irc.bot

class MyBot(irc.bot.SingleServerIRCBot):
    def __init__(self):
        server = [("irc.IRC-Mania.de", 6667)]
        nickname = "MyPyBot"
        irc.bot.SingleServerIRCBot.__init__(self, server, nickname, nickname)

    def on_welcome(self, connection, event):
        connection.join("#ircmania")

    def on_pubmsg(self, connection, event):
        msg = event.arguments[0]
        if msg == "!ping":
            connection.privmsg(event.target, "pong")

if __name__ == "__main__":
    MyBot().start()

¿Qué sucede aquí?

• on_welcome → unirse al canal
• on_pubmsg → mensajes en el canal
• lógica de strings sencilla para comandos

El concepto debería quedar claro aquí. Ahora puedes explorar frameworks. Python ofrece numerosos frameworks adecuados para esto.

Python – irc3 (moderno y modular)

irc3 es un framework IRC moderno basado en plugins para Python. Proporciona manejadores de comandos integrados, lógica de reconexión automática y una arquitectura de plugins limpia. Perfecto para bots más grandes con muchas funcionalidades.

Instalación

pip install irc3

Bot

import irc3
from irc3.plugins.command import command

@irc3.plugin
class Plugin:
    def __init__(self, bot):
        self.bot = bot

    @command
    def ping(self, mask, target, args):
        """!ping command"""
        self.bot.privmsg(target, "pong")

config = dict(
    nick='MyIrc3Bot',
    autojoins=['#ircmania'],
    host='irc.IRC-Mania.de',
    port=6667,
    includes=['irc3.plugins.core', __name__],
)

irc3.IrcBot(**config).run()

Ventaja: plugins y comandos listos para usar

Python – pydle (async y moderno)

pydle es un framework IRC moderno basado en async. Su principal ventaja frente a irc3 es la compatibilidad nativa con async/await, ideal para bots con muchas operaciones de entrada/salida. pydle es más ligero y flexible, aunque tiene menos funcionalidades integradas que irc3.

Instalación

pip install pydle

Bot

import pydle

class MyBot(pydle.Client):
    async def on_connect(self):
        await self.join('#ircmania')

    async def on_message(self, target, source, message):
        if message == "!ping":
            await self.message(target, "pong")

client = MyBot("MyPydleBot")
client.run("irc.IRC-Mania.de", tls=False)

Node.js – irc-framework

Node.js es perfecto para bots IRC gracias a su arquitectura orientada a eventos. Su modelo non-blocking I/O se adapta perfectamente al sistema de mensajes de IRC. irc-framework es la librería más popular, con excelentes características de reconexión y un sistema de plugins.

Instalación

npm install irc-framework

Bot

const IRC = require('irc-framework');

const bot = new IRC.Client();

bot.connect({
    host: 'irc.IRC-Mania.de',
    port: 6667,
    nick: 'MyNodeBot'
});

bot.on('registered', () => {
    bot.join('#ircmania');
});

bot.on('message', (event) => {
    if (event.message === '!ping') {
        bot.say(event.target, 'pong');
    }
});

Go – go-ircevent

Instalación

go get github.com/thoj/go-ircevent

Bot

package main

import (
    "github.com/thoj/go-ircevent"
    "fmt"
)

func main() {
    bot := irc.IRC("MyGoBot", "MyGoBot")
    
    bot.AddCallback("001", func(e irc.Event) {
        bot.Join("#ircmania")
    })
    
    bot.AddCallback("PRIVMSG", func(e irc.Event) {
        if e.Message() == "!ping" {
            bot.Privmsg(e.Arguments[0], "pong")
        }
    })
    
    err := bot.Connect("irc.IRC-Mania.de:6667")
    if err != nil {
        fmt.Println(err)
        return
    }

    bot.Loop()
}

Rust – irc crate

Rust es una buena opción para bots IRC porque ofrece memory safety sin garbage collector. Esto significa que los bots desarrollados en Rust son duraderos y estables.

Instalación

cargo add irc

Bot

use irc::client::prelude::*;

fn main() {
    let config = Config {
        nickname: Some("MyRustBot".to_owned()),
        server: Some("irc.IRC-Mania.de".to_owned()),
        channels: vec!["#ircmania".to_owned()],
        ..Default::default()
    };

    let mut client = Client::from_config(config).unwrap();
    client.identify().unwrap();

    for message in client.stream().unwrap() {
        if let Ok(message) = message {
            if let Command::PRIVMSG(_, ref msg) = message.command {
                if msg == "!ping" {
                    let _ = client.send_privmsg("#ircmania", "pong");
                }
            }
        }
    }
}

Integrar bots IRC en frameworks web de Python

Puedes integrar bots IRC excelentemente en frameworks web modernos de Python. Esto abre nuevas posibilidades para aplicaciones web con integración de chat.

Resumen: Frameworks web de Python para bots IRC

Integración con FastAPI (perfecto…rápido)

from fastapi import FastAPI, WebSocket
import asyncio
import threading
from irc.bot import SingleServerIRCBot

app = FastAPI()

class IRCBot(SingleServerIRCBot):
    def __init__(self):
        server = [("irc.IRC-Mania.de", 6667)]
        nickname = "FastAPIBot"
        super().__init__(server, nickname, nickname)
        self.messages = []

    def on_pubmsg(self, connection, event):
        msg = event.arguments[0]
        self.messages.append({
            "channel": event.target,
            "user": event.source.split("!")[0],
            "message": msg,
            "timestamp": asyncio.get_event_loop().time()
        })

irc_bot = IRCBot()
threading.Thread(target=irc_bot.start, daemon=True).start()

@app.get("/messages")
async def get_messages():
    return {"messages": irc_bot.messages[-20:]}

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        await websocket.send_json({"messages": irc_bot.messages[-5:]})
        await asyncio.sleep(1)

Integración con Streamlit (muy bien)

import streamlit as st
import threading
from irc.bot import SingleServerIRCBot

class StreamlitIRCBot(SingleServerIRCBot):
    def __init__(self):
        super().__init__([("irc.IRC-Mania.de", 6667)], "StreamlitBot", "StreamlitBot")
        if 'messages' not in st.session_state:
            st.session_state.messages = []

    def on_pubmsg(self, connection, event):
        st.session_state.messages.append({
            "channel": event.target,
            "user": event.source.split("!")[0],
            "message": event.arguments[0],
            "time": time.strftime("%H:%M:%S")
        })

if 'irc_bot' not in st.session_state:
    st.session_state.irc_bot = StreamlitIRCBot()
    threading.Thread(target=st.session_state.irc_bot.start, daemon=True).start()

st.title("IRC Bot Dashboard")
for msg in reversed(st.session_state.messages[-10:]):
    st.chat_message(msg["user"]).write(f"**{msg['channel']}**: {msg['message']}")

Integración con Django (bien)

# views.py
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from irc.bot import SingleServerIRCBot
import threading

class DjangoIRCBot(SingleServerIRCBot):
    def __init__(self):
        super().__init__([("irc.IRC-Mania.de", 6667)], "DjangoBot", "DjangoBot")

django_bot = DjangoIRCBot()
threading.Thread(target=django_bot.start, daemon=True).start()

@csrf_exempt
def send_message(request):
    if request.method == 'POST':
        channel = request.POST.get('channel')
        message = request.POST.get('message')
        django_bot.connection.privmsg(channel, message)
        return JsonResponse({'status': 'sent'})

Ventajas de integrar un framework

• Interfaz web: controla el bot desde el navegador en lugar de usar la terminal
• Endpoints API: otras aplicaciones pueden comunicarse con el bot
• Persistencia de datos: almacena historiales de chat en bases de datos
• Monitoreo: paneles en tiempo real para ver la actividad del bot
• Múltiples usuarios: varios usuarios pueden controlar el bot simultáneamente
• Características en tiempo real: integración WebSocket para actualizaciones en vivo

Espero que estas breves introducciones te inspiren a volver a explorar los bots IRC y el Internet Relay Chat. Esta página está diseñada precisamente para eso. Aquí encontrarás numerosos tutoriales detallados para principiantes, tanto en este sitio como en IRC-Mania.de.

Lo que todos los bots tienen en común

Al final, todos los lenguajes de programación siguen la misma receta, aunque no siempre con el mismo ingrediente:

Features típicos de bots IRC (siguiente nivel)

Si quieres profundizar, estos son los clásicos:

🔹 Lógica de reconexión Importante: IRC pierde conexiones constantemente.

Comenzamos con funciones simples. Si quieres construir algo más complejo, vale la pena establecer un esquema funcional básico. No necesitas diagramas de clases ni diagramas de casos de uso, pero una dirección general es conveniente.

Te mostraré una arquitectura de bot IRC lista para producción, además de cómo separar correctamente múltiples canales y async/threads sin que el bot colapse después de dos días o pierda mensajes.

Arquitectura de bot IRC lista para producción

Objetivo

┌─────────────────┐
│  IRC Client     │ ← Conexión al servidor
└─────────┬───────┘
│
┌─────────▼───────┐
│ Event Dispatcher│ ← Enrutamiento de eventos
└───────┬─┬───────┘
│ │
┌───────▼─▼───────┐
│ Plugin System   │ ← Funcionalidades
└─────────────────┘
│
┌────────▼─┐  ┌────▼────────┐
│ Plugin A │  │ Plugin B    │  ← Funcionalidades
└──────────┘  └─────────────┘

Estructura

bot/
 ├── core.py        (cliente IRC)
 ├── dispatcher.py  (enrutamiento de eventos)
 ├── plugins/
 │     ├── ping.py
 │     ├── logger.py
 │     └── admin.py
 └── main.py

Core del bot (async + reconexión)

import pydle
import asyncio

class CoreBot(pydle.Client):
    def __init__(self, nickname, channels):
        super().__init__(nickname)
        self.channels = channels
        self.plugins = []
        self.reconnect_delay = 5

    async def on_connect(self):
        for channel in self.channels:
            await self.join(channel)

    async def on_disconnect(self, expected):
        while True:
            try:
                await self.reconnect()
                break
            except:
                await asyncio.sleep(self.reconnect_delay)

    async def on_message(self, target, source, message):
        for plugin in self.plugins:
            await plugin.handle_message(self, target, source, message)

    def register_plugin(self, plugin):
        self.plugins.append(plugin)

Sistema de Plugins

class PingPlugin:
    async def handle_message(self, bot, target, source, message):
        if message == "!ping":
            await bot.message(target, "pong")

Ejecutor Principal

from core import CoreBot
from plugins.ping import PingPlugin

bot = CoreBot("MyBot", ["#dev", "#test"])
bot.register_plugin(PingPlugin())

bot.run("irc.libera.chat", tls=False)

Comportamiento Multi-Canal

Esto sucede automáticamente:

• El bot se une a #dev y #test
• El bot responde independientemente del canal

Arquitectura con Threads (si NO usas async)

Alternativa clásica, por ejemplo con la librería irc de Python:

Problema:

El loop de IRC se bloquea y ralentiza los plugins

Solución: Worker Threads IRC Thread ───► Event Queue ───► Worker Threads Patrón de ejemplo:

from queue import Queue
import threading

event_queue = Queue()

def worker():
    while True:
        event = event_queue.get()
        handle_event(event)

threading.Thread(target=worker, daemon=True).start()

Callback del IRC:

def on_message(msg):
    event_queue.put(msg)

Ventaja:

• El IRC se mantiene rápido
• Las tareas CPU-heavy NO bloquean nada

Características de Producción (esenciales en bots reales)

1. Reconexión Automática

async def on_disconnect(self, expected):
    while True:
        try:
            await self.reconnect()
            break
        except:
            await asyncio.sleep(5)

2. Rate Limiting (Protección contra Flood)

El servidor IRC te expulsará si envías demasiado rápido.

import time

last_send = 0

def safe_send(bot, target, msg):
    global last_send
    if time.time() - last_send < 1:
        time.sleep(1)
    bot.message(target, msg)
    last_send = time.time()

3. SASL / NickServ Auth

CAP REQ :sasl
AUTHENTICATE PLAIN

Necesario para:

• Nicks reservados
• Redes IRC como Libera

4. Sistema de Logging

async def on_message(self, target, source, message):
    print(f"[{target}] {source}: {message}")

Mejor enfoque:

• SQLite / PostgreSQL
• Elasticsearch para bots grandes

5. Hot Reload de Plugins (avanzado)

import importlib

def reload_plugin(module):
    importlib.reload(module)

Permite:

• Actualizar el bot sin desconectar

Arquitectura de Producción (vista final)

IRC Server
│
Async IRC Client
│
┌───────────▼───────────┐
│ Event Dispatcher       │
└───────┬───────┬───────┘
│       │
Plugin System   Logger
│
Thread Pool (optional heavy tasks)

Un bot de IRC real no es un script, sino:

Sistema asincrónico orientado a eventos + Arquitectura de plugins + Capa de resilencia