Bot de Slack con OpenAI: menciones, DMs y memoria

Visión General

Enchufa un LLM a Slack y podrá responder preguntas, resumir hilos y ejecutar comandos justo donde tu equipo ya conversa. Esta receta conecta el Socket Mode de Slack Bolt (sin necesidad de una URL pública) con la API de chat completions de OpenAI, con memoria de conversación por usuario, respuestas en hilo y mensajes directos. Para un chatbot general sin Slack, consulta Chatbot con OpenAI.

Cuándo Usarlo

• Quieres un asistente dentro de Slack que ya conozca el contexto de tu equipo.
• Las mismas preguntas se repiten en los canales públicos y quieres responderlas de forma automática.
• Prefieres probar una interfaz conversacional en el chat antes de invertir en una UI.
• No lo apuntes a todos los mensajes de canales con mucho tráfico: sin filtrado ni límites por usuario, la factura de OpenAI te sorprenderá.

Requisitos Previos

• Una app de Slack con Bot Token y Socket Mode habilitado (obtendrás tokens xoxb- y xapp-).
• Una API key de OpenAI.
• Node.js 18+ o Python 3.10+.

Solución

Node.js

npm install @slack/bolt openai dotenv

# .env
SLACK_BOT_TOKEN=xoxb-your-bot-token
SLACK_SIGNING_SECRET=your-signing-secret
SLACK_APP_TOKEN=xapp-your-app-token
OPENAI_API_KEY=sk-your-openai-key

// app.js
import { App } from '@slack/bolt';
import OpenAI from 'openai';
import dotenv from 'dotenv';

dotenv.config();

const slack = new App({
  token: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET,
  appToken: process.env.SLACK_APP_TOKEN,
  socketMode: true,
});

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

// Almacén de conversaciones en memoria (usa Redis en producción)
const conversations = new Map();

function getHistory(userId) {
  if (!conversations.has(userId)) {
    conversations.set(userId, [{ role: 'system', content: 'Eres un asistente útil en un workspace de Slack.' }]);
  }
  return conversations.get(userId);
}

async function getGPTResponse(messages) {
  const response = await openai.chat.completions.create({
    model: 'gpt-4o-mini',
    messages,
    max_tokens: 500,
  });
  return response.choices[0].message.content;
}

// Responde a menciones en canales
slack.event('app_mention', async ({ event, say }) => {
  const text = event.text.replace(/<@[^>]+>/, '').trim();
  if (!text) return; // mención sin pregunta

  const history = getHistory(event.user);
  history.push({ role: 'user', content: text });
  const reply = await getGPTResponse(history);
  history.push({ role: 'assistant', content: reply });

  // Conserva el prompt de sistema más los últimos 10 mensajes
  if (history.length > 11) {
    conversations.set(event.user, [history[0], ...history.slice(-10)]);
  }

  await say({ text: reply, thread_ts: event.ts });
});

// Responde a mensajes directos — ignora bots, tráfico que no es DM y texto vacío
slack.message(async ({ message, say }) => {
  if (message.bot_id || message.subtype || message.channel_type !== 'im' || !message.text?.trim()) {
    return;
  }

  const history = getHistory(message.user);
  history.push({ role: 'user', content: message.text });
  const reply = await getGPTResponse(history);
  history.push({ role: 'assistant', content: reply });

  await say(reply);
});

(async () => {
  await slack.start();
  console.log('Bot de Slack en ejecución');
})();

node app.js

Python

pip install slack-bolt openai python-dotenv

# bot.py
import os
from slack_bolt import App
from slack_bolt.adapter.socket_mode import SocketModeHandler
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

app = App(token=os.environ["SLACK_BOT_TOKEN"])
openai_client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

conversations = {}

def get_history(user_id):
    if user_id not in conversations:
        conversations[user_id] = [
            {"role": "system", "content": "Eres un asistente útil en un workspace de Slack."}
        ]
    return conversations[user_id]

def get_gpt_response(messages):
    response = openai_client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
        max_tokens=500,
    )
    return response.choices[0].message.content

@app.event("app_mention")
def handle_mention(event, say):
    import re
    text = re.sub(r"<@[^>]+>", "", event["text"]).strip()
    if not text:
        return  # mención sin pregunta
    history = get_history(event["user"])
    history.append({"role": "user", "content": text})
    reply = get_gpt_response(history)
    history.append({"role": "assistant", "content": reply})
    if len(history) > 11:
        conversations[event["user"]] = [history[0]] + history[-10:]
    say(text=reply, thread_ts=event["ts"])

@app.message("")
def handle_dm(message, say):
    # Ignora bots, tráfico que no es DM y texto vacío
    if message.get("bot_id") or message.get("subtype") or message.get("channel_type") != "im":
        return
    if not message.get("text", "").strip():
        return
    history = get_history(message["user"])
    history.append({"role": "user", "content": message["text"]})
    reply = get_gpt_response(history)
    history.append({"role": "assistant", "content": reply})
    say(reply)

if __name__ == "__main__":
    handler = SocketModeHandler(app, os.environ["SLACK_APP_TOKEN"])
    handler.start()

Cómo Funciona

1. Socket Mode: el bot abre una conexión WebSocket hacia Slack, así que funciona detrás de un firewall sin endpoint público. Bolt confirma los eventos por ti, y eso importa porque Slack reintenta todo lo que no se confirma en ~3 segundos.
2. Memoria de conversación: cada usuario tiene una ventana móvil (prompt de sistema + últimos 10 mensajes). Un Map/dict vive y muere con el proceso — usa Redis para algo serio.
3. Hilos: las respuestas en canal pasan thread_ts, así quedan pegadas al mensaje que las disparó en lugar de inundar el canal.
4. Mensajes directos: los DMs tienen su propio handler con guardas de bot_id, subtype y texto vacío para que el bot no entre en bucle respondiéndose a sí mismo.

Variantes

Variante	Cuándo elegirla
Node.js + Socket Mode	Opción por defecto; corre en cualquier sitio sin URL pública
Python + SocketModeHandler	El mismo flujo para equipos Python (slack-bolt + openai)
Endpoint HTTP de eventos	Cuando ya expones una URL pública y prefieres request/response en vez de un socket persistente
Resumidor de hilos	Escucha eventos de hilo y ofrece resúmenes TL;DR bajo demanda
Entrada de imágenes	Reenvía imágenes subidas a un modelo con visión (p. ej. gpt-4o)

Lo que funciona

1. Cambia el almacén en memoria por Redis en despliegues multi-instancia — un reinicio borra todas las conversaciones si no. Consulta Rate Limiting de APIs con Redis para patrones de Redis.
2. Trunca por tokens, no por mensajes. Diez mensajes largos pueden reventar la ventana de contexto; cuenta tokens con tiktoken en lugar de un “últimos 10” fijo.
3. Pon un tope de gasto por usuario. Un solo usuario insistiendo puede quemar todo el presupuesto de OpenAI — impón una cuota diaria de requests o tokens por user ID.
4. Reintenta las llamadas a OpenAI con backoff. Los rate limits y los errores de red transitorios son normales; envuelve la llamada como en Retry con Backoff Exponencial.
5. Registra cada interacción: quién preguntó, dónde, cuándo y cuántos tokens gastó. La necesitas para auditar costes y depurar respuestas raras.
6. Expón un endpoint /health cuando el bot corra como servicio, para que el monitoreo distinga “bot caído” de “Slack caído”.
7. Filtra antes de gastar. Revisa bot_id, subtype y texto vacío antes de llamar a OpenAI — filtrar después de la llamada igualmente cuesta tokens.

Errores Comunes

1. Confirmar tarde — Slack reintenta cualquier evento no confirmado en ~3 segundos, así que acabas respondiendo el mismo mensaje dos veces. Bolt confirma por ti; en un endpoint propio, confirma primero y procesa en async.
2. Subir archivos .env o tokens a git — las claves van en variables de entorno o en un gestor de secretos, nunca en código.
3. No filtrar los mensajes del propio bot — revisa message.bot_id y sáltalo, o el bot se responde a sí mismo para siempre.
4. Ignorar el contexto del hilo — una pregunta de seguimiento dentro de un hilo necesita los mensajes anteriores; recupéralos con la API conversations.replies de Slack.
5. Llamar a la API sin max_tokens — una respuesta sin tope puede gastar el presupuesto en una sola llamada.
6. Responder a texto vacío o menciones sin pregunta — valida message.text antes de gastar tokens.
7. Olvidar el rate limit de Slack (~1 mensaje por segundo por canal) — encola o agrupa las respuestas en canales concurridos.

Checklist de Producción

• API keys en variables de entorno, no en código
• El bot filtra bot_id, subtypes y mensajes vacíos
• Historial persistido en Redis o Postgres (no en memoria)
• Límites por usuario (máx. requests o tokens por día)
• Llamadas a OpenAI con timeout y retry con backoff
• Uso de tokens registrado por request para controlar el gasto
• Errores mostrados al usuario amigables (sin errores crudos de la API)
• Respuestas en canal publicadas en hilos
• Endpoint /health expuesto para monitoreo
• Logs estructurados con correlation IDs para depurar

Ver También

• Slack API — Socket Mode — entrega de eventos sin URL pública.
• Slack API — conversations.replies — recupera el historial del hilo para dar contexto.
• Referencia de la API de OpenAI — parámetros de chat completions y el campo usage.
• Repositorio companion — app.js, bot.py y .env.example ejecutables.