Crear un bot de Telegram con IA: guía paso a paso

Para crear un bot de Telegram con IA, pide a un agente de programación (Claude Code, Codex o similar) que escriba un bot con python-telegram-bot, pon el token en un archivo .env y ejecútalo primero en tu propia máquina con polling. A partir de ahí añades comandos, estado guardado, respuestas con LLM y, por último, lo dejas corriendo 24/7 en un servidor.

Esta guía sigue Telegram de principio a fin y después muestra cómo adaptar el mismo bot a Discord. Cada paso incluye un prompt que puedes pegar en el agente.

Qué vamos a construir

El bot de ejemplo hará lo siguiente:

• Responder a /start y /help.
• Guardar notas con /note <text> y listarlas con /notes (estado guardado).
• Responder con un LLM a los mensajes normales, con un límite diario por usuario.
• Opcionalmente, hablar solo con los usuarios que tú permitas.
• Ejecutarse de forma continua en un servidor con systemd o Docker.

Es un buen primer proyecto de vibe coding: pequeño, ves el resultado en el móvil enseguida y es realmente útil.

Elegir el stack: ¿Python o TypeScript?

Dos buenas opciones:

• Python + python-telegram-bot: madura, bien documentada y asíncrona. La elección natural si tu código de IA, datos o automatización está en Python.
• TypeScript + grammY: moderna, tipada y ligera, y cómoda con webhooks en plataformas serverless. Ve por aquí si ya vives en Node.js.

Aquí usaré Python; cambia el nombre de la librería en los prompts y los mismos pasos sirven para grammY.

Preparación:

mkdir telegram-bot && cd telegram-bot
git init
python3 -m venv .venv && source .venv/bin/activate
pip install python-telegram-bot python-dotenv anthropic
printf ".env\n.venv/\n*.db\n" >> .gitignore

Uso el SDK de Anthropic como ejemplo de LLM; con otro proveedor, cambia el paquete, la idea es la misma.

Paso 1: consigue un token y ponlo en .env

Obtén tu token en el flujo oficial de creación de bots de Telegram: creas un bot nuevo dentro de Telegram, eliges un nombre visible y un nombre de usuario único que termine en «bot», y al final te dan un token largo. Ese token es la contraseña del bot; quien lo tenga puede enviar mensajes como tu bot.

El archivo .env:

TELEGRAM_TOKEN=your-token
LLM_API_KEY=your-api-key
LLM_MODEL=the-model-you-use
ALLOWED_USER_IDS=123456789
DAILY_LLM_LIMIT=30

No pegues el token ni la clave de API en el chat con el agente. No necesita los valores, solo saber que vienen de .env. Si el token se filtra alguna vez, revócalo en el mismo flujo oficial y consigue uno nuevo.

Paso 2: el primer prompt

Abre el agente en la carpeta del proyecto y pide el bot más simple que funcione:

Set up a simple Telegram bot with python-telegram-bot (async, ApplicationBuilder).
- Read the token from .env with python-dotenv. Never open or print .env.
- Layout: bot.py (startup and handler registration), handlers.py (commands),
  storage.py (SQLite later), config.py.
- Add /start and /help; /help lists all commands.
- Reply politely to unknown commands.
- Use polling. Use Python logging; never log the token.
- Add an error handler: log the error and send the user a short apology.
When done, tell me how to run it.

Ejecútalo:

python bot.py

Busca tu bot en Telegram y envía /start. Si responde, el primer ciclo está hecho. Si no, pega el error de la terminal al agente tal cual; suele ser una variable de entorno que no se leyó.

Paso 3: comandos y estado guardado

La mayoría de los bots necesitan recordar cosas: ajustes de usuario, notas, contadores de uso. Todo lo que se guarda en memoria desaparece cuando el bot se reinicia. Para un bot pequeño SQLite es más que suficiente, sin ningún servidor de base de datos que mantener.

Add SQLite to storage.py (data/bot.db).
- notes table: id, user_id, text, created_at.
- usage table: user_id, date, llm_count.
- /note <text> saves a note, /notes lists the user's last 10 notes,
  /delete <id> deletes a note only if it belongs to that user.
- All SQL must be parameterized (no string concatenation).
- Write pytest tests for the storage functions and run them.

El «only if it belongs to that user» es importante. Los agentes suelen saltarse comprobaciones de autorización como esta, y de pronto cualquiera que escriba /delete 5 puede borrar la nota de otra persona.

python-telegram-bot también tiene sus propias opciones de persistencia, como PicklePersistence, que ayudan con el estado de las conversaciones (por ejemplo, formularios de varios pasos). Para los datos de usuario me parece que SQLite es más transparente.

Paso 4: respuestas inteligentes con un LLM

Ahora la parte que lo convierte en un bot de IA: enviar los mensajes normales a un LLM y escribir la respuesta de vuelta.

# llm.py
import os
from anthropic import AsyncAnthropic

client = AsyncAnthropic(api_key=os.getenv("LLM_API_KEY"))

async def reply(history: list[dict]) -> str:
    resp = await client.messages.create(
        model=os.getenv("LLM_MODEL"),
        max_tokens=500,
        system="You are a helpful Telegram assistant who answers briefly.",
        messages=history[-10:],  # only the last 10 messages
    )
    return resp.content[0].text

Un prompt para el agente:

Send plain text messages to reply() in llm.py.
- Keep the last 10 messages per user in memory (alternating user/assistant).
- /reset clears the conversation history.
- Enforce DAILY_LLM_LIMIT per user per day (usage table); when it's reached,
  send a clear message.
- If ALLOWED_USER_IDS is not empty, only answer those users.
- Send the "typing..." action while the LLM call runs.
- Split replies longer than Telegram's message length limit.
- On API errors, send the user a short message and log the error.

¿Por qué los límites? Un bot público con LLM que alguien descubre y satura de mensajes te inflará la factura. Un límite diario, una lista de permitidos y un historial corto son las tres formas más simples de mantener el coste bajo control. Cuanto más largo es el historial, más tokens envías con cada petición.

Paso 5: ¿polling o webhook?

Un bot puede recibir mensajes de Telegram de dos maneras:

• Polling (long polling): el bot le pregunta a Telegram una y otra vez «¿hay algo nuevo?». Cero configuración: sin dirección HTTPS, sin dominio, sin puerto abierto. Ideal para desarrollo y para bots pequeños o medianos en un solo servidor.
• Webhook: Telegram envía cada actualización nueva a una dirección HTTPS que tú le das. No hay nada esperando y, en plataformas serverless (funciones que se ejecutan por petición), es la única opción. A cambio necesitas un endpoint HTTPS válido y debes verificar que las peticiones vienen realmente de Telegram con una ruta secreta o un token secreto.

Mi regla: empieza con polling y pasa a un webhook cuando de verdad lo necesites. No puedes usar ambos a la vez con el mismo token; el polling no funciona mientras hay un webhook configurado.

Paso 6: ejecutarlo 24/7 en un servidor

Cuando tu portátil se apaga, el bot se queda en silencio. Basta con un VPS Linux pequeño y, con polling, ni siquiera necesitas un dominio.

systemd

# /etc/systemd/system/telegram-bot.service
[Unit]
Description=Telegram bot
After=network-online.target

[Service]
User=bot
WorkingDirectory=/home/bot/telegram-bot
EnvironmentFile=/home/bot/telegram-bot/.env
ExecStart=/home/bot/telegram-bot/.venv/bin/python bot.py
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now telegram-bot
journalctl -u telegram-bot -f

Docker

Pide al agente que escriba un Dockerfile y un docker-compose.yml con restart: unless-stopped, env_file: .env y un volumen para data/. Si olvidas el volumen, tu base de datos SQLite se borra cada vez que se recrea el contenedor.

No ejecutes el mismo bot con polling en dos sitios a la vez (por ejemplo, tu portátil y el servidor); Telegram lo rechaza con un error de conflicto. Usa un bot de pruebas aparte, con su propio token, para desarrollar.

Paso 7: adaptarlo a Discord

Los bots de Discord son parecidos en concepto, con algunas diferencias importantes:

• Token y aplicación: creas una aplicación en el portal de desarrolladores de Discord, le añades un bot y sacas el token de ahí. Añades el bot a tu servidor con un enlace de invitación que pida los mínimos permisos necesarios.
• Intents: para leer el contenido de los mensajes tienes que activar el message content intent tanto en el portal como en el código. Si tu bot no ve los mensajes, casi siempre es por esto.
• Modelo de conexión: los bots de Discord mantienen una conexión WebSocket persistente con el gateway, así que el bot tiene que ser un proceso de larga duración; no funcionará como una función serverless.
• Comandos: los comandos slash son la forma moderna y hay que registrarlos en Discord.
• Librerías: discord.py para Python, discord.js para Node.js.

Lo más limpio es separar la lógica del bot de la plataforma. Un prompt:

Separate the bot logic from the platform:
- core/ holds platform-independent functions: handle_note, list_notes,
  ask_llm. They take user_id and text and return text.
- Rewrite telegram_bot.py so its handlers call core/.
- discord_bot.py: /note, /notes and /ask slash commands with discord.py,
  all calling core/. DISCORD_TOKEN comes from .env.
- Add a platform column in storage so Discord and Telegram user ids don't mix.
- Keep existing tests passing; extend the tests for core.

Ahora ambos bots comparten la misma base de datos y la misma lógica de LLM, y cada uno solo se ocupa de los detalles de su plataforma.

Errores comunes: en qué suele fallar la IA

• Escribir contra una API antigua. python-telegram-bot pasó a ser asíncrona en la versión 20, y los agentes a veces mezclan ejemplos síncronos antiguos. Si te salen errores, pide al agente que compruebe la versión instalada (pip show python-telegram-bot) y corrija el código según la documentación de esa versión.
• Dejar el token en el código. El agente puede querer poner el token en bot.py «solo para probar rápido». Di que no.
• Faltan comprobaciones de autorización. Los comandos de administración quedan abiertos a todo el mundo, o los usuarios pueden acceder a los datos de otros.
• Código bloqueante. Un time.sleep o una llamada HTTP síncrona dentro de un handler asíncrono congela todo el bot.
• Errores tragados. Sin un manejador de errores, el bot deja de responder en silencio.
• Estado en memoria. Todo se reinicia al reiniciar.
• No dividir los mensajes largos. Cuando el LLM escribe una respuesta larga, Telegram rechaza el mensaje.

Seguridad

• Los tokens y las claves de API viven solo en .env, y .env está en .gitignore.
• Nunca pegues claves en un chat, una captura de pantalla o un informe de bug.
• Lee los comandos que el agente quiere ejecutar antes de aprobarlos, sobre todo cualquiera que lea .env o envíe datos al exterior.
• Cuando reenvías texto de usuarios a un LLM, da por hecho que puede intentar anular tus instrucciones (prompt injection). No des al bot capacidades peligrosas como ejecutar comandos o borrar archivos.
• Cuéntales a tus usuarios que guardas sus datos y los envías a un proveedor de LLM.
• No ejecutes el bot como root en el servidor; aplica chmod 600 al archivo de entorno.

Hacerlo con AgentVera

Este proyecto se divide de forma natural en dos trabajos paralelos: un agente escribe la parte de Telegram y otro la de Discord. En AgentVera puedes ejecutar Claude Code en un worktree y Codex en otro, en la misma cuadrícula. Después de cada turno, la revisión de código automática hace que un segundo modelo mire puntos fáciles de pasar por alto, como las comprobaciones de autorización. Revisas los cambios en el panel de Git antes de fusionar y ves el uso de tokens de los agentes mientras construyes la función de LLM. Cuando llega el momento del servidor, SSH y SFTP mueve los archivos y el gestor de Docker muestra los logs del contenedor en local.

Nada de esto es obligatorio; con una terminal y git también terminarás este bot. Si buscas algo que tu bot pueda hacer, las alertas de Telegram de crear un bot de trading de criptomonedas con IA son un buen ejemplo.

Para terminar

Crear un bot de Telegram con IA es una de las formas más divertidas de empezar con el vibe coding. Consigue el token por el flujo oficial y guárdalo en .env, pide al agente que escriba primero el bot más simple y luego añade capa a capa los comandos, el estado en SQLite y las respuestas con LLM. Empieza con polling, ejecútalo en un servidor con systemd o Docker y mantén la lógica separada de la plataforma para que pasar a Discord sea un paso fácil. Lee tú mismo las comprobaciones de autorización que escribe el agente y los comandos que ejecuta; el resto lo puede hacer el agente.