Bot Discord para resumir hilos con IA

Automatiza el resumen de conversaciones largas en Discord. Es útil para comunidades técnicas, equipos de trabajo o servidores de clientes donde los hilos acumulan contexto que luego nadie quiere leer entero.

El bot escucha el comando /resumir, recupera los últimos mensajes del hilo y usa Claude API para generar un resumen estructurado.

Guía de Implementación Paso a Paso

Crea una aplicación en Discord Developer Portal, activa el modo Bot y copia el TOKEN.
Crea una API key en Anthropic Console.
Inicializa el proyecto e instala dependencias.

BASH

mkdir discord-summary-bot && cd discord-summary-bot
npm init -y
npm install discord.js @anthropic-ai/sdk dotenv
npm install -D typescript ts-node @types/node
npx tsc --init

Crea un archivo .env en la raíz.

ENV

DISCORD_TOKEN=tu_token_aqui
ANTHROPIC_API_KEY=tu_api_key_aqui

Pega el código en src/index.ts.
Ejecuta el bot con npx ts-node src/index.ts.
Invita el bot a tu servidor con permisos de lectura, envío de mensajes e historial.

TYPESCRIPT

// src/index.ts
// Bot Discord que resume hilos usando Claude API
// Comando: /resumir [numero_de_mensajes]

import { Client, GatewayIntentBits, ThreadChannel, Message } from 'discord.js';
import Anthropic from '@anthropic-ai/sdk';
import * as dotenv from 'dotenv';

dotenv.config();

const client = new Client({
  intents: [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.MessageContent,
    GatewayIntentBits.GuildMessageTyping,
  ],
});

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

async function fetchThreadMessages(
  thread: ThreadChannel,
  limit: number = 50
): Promise<string> {
  const messages = await thread.messages.fetch({ limit });
  const sorted = [...messages.values()].reverse();

  return sorted
    .filter((msg: Message) => !msg.author.bot)
    .map((msg: Message) => `[${msg.author.username}]: ${msg.content}`)
    .join('\n');
}

async function generateSummary(conversation: string): Promise<string> {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1024,
    messages: [
      {
        role: 'user',
        content: `Analiza la siguiente conversación de Discord y genera un resumen claro y estructurado en español.

El resumen debe incluir:
1. **Tema principal**: ¿De qué trata la conversación?
2. **Puntos clave**: Los 3-5 puntos más importantes discutidos
3. **Decisiones tomadas**: Si se tomó alguna decisión o conclusión
4. **Próximos pasos**: Si se mencionaron acciones o tareas pendientes

Conversación:
${conversation}

Formato de salida: usa markdown con negritas y listas. Máximo 300 palabras.`,
      },
    ],
  });

  const content = response.content[0];
  return content.type === 'text' ? content.text : 'No se pudo generar el resumen.';
}

client.on('messageCreate', async (message: Message) => {
  if (message.author.bot) return;
  if (!message.content.startsWith('/resumir')) return;

  if (!message.channel.isThread()) {
    await message.reply('Este comando solo funciona dentro de hilos (threads).');
    return;
  }

  const thread = message.channel as ThreadChannel;
  const args = message.content.split(' ');
  const limit = parseInt(args[1]) || 50;

  await thread.sendTyping();

  try {
    const conversation = await fetchThreadMessages(thread, Math.min(limit, 100));

    if (!conversation.trim()) {
      await message.reply('No encontré mensajes para resumir en este hilo.');
      return;
    }

    const summary = await generateSummary(conversation);

    await message.reply({
      content: `## Resumen del hilo (últimos ${limit} mensajes)\n\n${summary}`,
    });
  } catch (error) {
    console.error('Error al generar resumen:', error);
    await message.reply('Ocurrió un error al generar el resumen. Intenta de nuevo.');
  }
});

client.once('ready', () => {
  console.log(`Bot conectado como ${client.user?.tag}`);
  console.log('Usa /resumir [n] dentro de un hilo para activarlo');
});

client.login(process.env.DISCORD_TOKEN);

Prompt para Codex

TEXT

Crea un bot de Discord en TypeScript que use la Claude API para resumir hilos de conversación.

Requisitos técnicos:
- Usa discord.js v14 con GatewayIntentBits: Guilds, GuildMessages, MessageContent
- Usa @anthropic-ai/sdk con el modelo claude-sonnet-4-20250514
- El comando se activa con /resumir [numero_opcional] dentro de un Thread/Hilo
- Recupera los últimos N mensajes (default: 50, max: 100) filtrando bots
- Envía cada mensaje con formato [username]: contenido
- El prompt a Claude debe pedir: tema principal, puntos clave, decisiones y próximos pasos
- Responde con markdown usando negritas y emojis
- Maneja errores con try/catch y mensajes descriptivos al usuario
- Usa dotenv para DISCORD_TOKEN y ANTHROPIC_API_KEY
- TypeScript estricto con tipos correctos de discord.js

Salida: el archivo completo src/index.ts listo para ejecutar con ts-node.