Mi Bot de Python: Configuración Rápida con la API de Telegram

Bien, amigos, Marcus Rivera aquí, de vuelta en ai7bot.com, y hoy vamos a adentrarnos de lleno en algo que ha estado resonando en mis propios círculos de desarrollo, especialmente cuando intento poner en marcha un bot rápidamente sin complicaciones. Estamos hablando de la a menudo subestimada, a veces pasada por alto, pero siempre presente, API de Bots de Telegram. En concreto, quiero hablar sobre cómo poner en marcha un bot simple, pero sorprendentemente poderoso, en minutos usando Python y la API de Bots de Telegram sin necesidad de un servidor web completo o un despliegue complejo.

Es cierto, lo sé. “Los bots de Telegram” pueden sonar un poco a 2018 para algunos de ustedes, pero escúchenme. Mientras que los bots de Discord reciben mucho amor (y con razón, he construido bastante), hay un punto ideal para Telegram cuando necesitas algo personal, rápido y altamente interactivo con un mínimo de sobrecarga. Piénsalo: un bot de monitoreo para tu servidor doméstico, una utilidad rápida para tu grupo familiar, o incluso un simple sistema de notificación para tu estrategia de trading. No siempre necesitas un contenedor Docker y Kubernetes para eso. A veces, un script de Python corriendo en un Raspberry Pi o incluso en un entorno de hosting compartido es todo lo que necesitas, y es ahí donde Telegram realmente brilla.

Mi propio viaje con esto se reavivó hace unos meses. Estaba tratando de construir un bot pequeño para un proyecto comunitario local: esencialmente, una forma sencilla para que los miembros soliciten una actualización sobre hitos específicos del proyecto. Comencé a mirar Discord, pero la carga de configurar intenciones, permisos y lidiar con interacciones de servidor potencialmente complejas se sentía excesiva para lo que era esencialmente un empuje de información unidireccional con una consulta simple. Recordé un viejo bot de Telegram que había construido hace años para rastrear pedidos de café (no preguntes), y pensé: “¿Por qué no?” La simplicidad de la API, especialmente su mecanismo de long-polling, hizo clic de nuevo conmigo. Significaba que no necesitaba exponer un servidor web a internet, lo cual es una gran victoria en términos de seguridad y despliegue para proyectos pequeños y personales.

Así que hoy, vamos a construir un bot de Telegram “Quick-Query”. Este bot esencialmente permitirá a los usuarios solicitar información predefinida, actuando como una súper simple FAQ o recuperador de datos. Usaremos Python y la biblioteca python-telegram-bot, que, en mi opinión, hace que interactuar con la API de Bots de Telegram sea un placer.

Por qué el Long-Polling de Telegram sigue siendo genial para Bots Pequeños

Seamos claros: Telegram ofrece dos formas principales de recibir actualizaciones de tu bot: Webhooks y Long Polling. Los webhooks son geniales cuando tienes un servidor público que puede recibir solicitudes HTTP POST de Telegram. Son eficientes porque Telegram te envía las actualizaciones conforme ocurren. Sin embargo, si no tienes una IP pública o no quieres lidiar con proxies inversos, certificados SSL y puertos expuestos, los webhooks se convierten en un dolor de cabeza.

Ahí entra el Long Polling. Con el long polling, tu script de bot hace una solicitud a los servidores de Telegram y esencialmente dice: “¿Hey, tienes nuevos mensajes para mí?” Telegram mantiene esa conexión abierta por un tiempo (hasta 60 segundos por defecto). Si llega un nuevo mensaje durante ese tiempo, Telegram lo envía de inmediato. Si no, la conexión eventualmente se agota, y tu script simplemente hace otra solicitud. Es como tocar repetidamente una puerta y esperar, pero la persona dentro es muy rápida para responder si te escucha. La belleza aquí es que tu script inicia la conexión, lo que significa que puede ejecutarse casi en cualquier lugar con acceso a internet: tu laptop, un VPS barato, incluso un Raspberry Pi escondido en tu armario. No necesitas redirigir puertos ni exponer nada a la internet salvaje.

Configuración de tu Bot de Telegram: Lo Básico

Antes de escribir cualquier código, necesitas un token de bot. Esta es la identidad de tu bot y su clave para interactuar con la API de Telegram.

1. Abre Telegram y busca @BotFather.
2. Inicia un chat con BotFather y envía el comando /newbot.
3. BotFather te pedirá un nombre para tu bot (ej. “AI7Bot Helper”).
4. Luego, te pedirá un nombre de usuario (debe terminar con “bot”, ej. “AI7BotHelper_bot”).
5. Una vez que proves esto, BotFather te dará un token de API HTTP. Se verá algo como 1234567890:ABCDEFGHIJKLMNPQRSTUVWXYZabcdefghij. ¡Mantén este token en secreto! Si alguien lo obtiene, puede controlar tu bot.

¡Eso es todo por el lado de Telegram! Sencillo, ¿verdad?

Codificando Nuestro Bot Quick-Query

Usaremos Python y la biblioteca python-telegram-bot. Primero, asegúrate de tenerla instalada:

pip install python-telegram-bot==20.X # Usa la última versión estable principal

Estoy usando la versión 20.x para este ejemplo, que tiene algunas agradables características modernas de asincronía. Si estás en una versión más antigua, puede que alguna sintaxis difiera ligeramente, así que recomiendo actualizar.

Paso 1: La Estructura Central y las Importaciones

Comencemos con el boilerplate básico para una aplicación de python-telegram-bot.

import asyncio
import logging
import os # Para variables de entorno

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

# Configuración del logging
logging.basicConfig(
 format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
 level=logging.INFO
)
logger = logging.getLogger(__name__)

# --- Configuración ---
# Es una buena práctica mantener el token de tu bot fuera del código.
# Usaremos una variable de entorno.
BOT_TOKEN = os.getenv("TELEGRAM_BOT_TOKEN")

if not BOT_TOKEN:
 logger.error("Variable de entorno TELEGRAM_BOT_TOKEN no está establecida. Saliendo.")
 exit(1)

# --- Definimos nuestros datos de consulta ---
# Aquí es donde vive el conocimiento de nuestro bot.
QUERY_DATA = {
 "hello": "¡Hola! Soy tu asistente Quick-Query de AI7Bot.",
 "status": "¡Todos los sistemas están en funcionamiento para AI7Bot.com!",
 "features": "Puedo contarte sobre 'hello', 'status' y 'features'. ¡Prueba preguntándome algo específico!",
 "marcus": "Marcus es el cerebro detrás de ai7bot.com, siempre experimentando con nuevas ideas de bots.",
 "date": f"La fecha de hoy es 2026-03-12. (Duro código para este ejemplo, ¡pero podría ser dinámico!)"
}

# --- Funciones Controladoras ---

async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Envía un mensaje de saludo cuando se emite el comando /start."""
 user = update.effective_user
 await update.message.reply_html(
 f"¡Hola, {user.mention_html()}! 👋 Soy tu Bot Quick-Query. "
 "Pregúntame sobre 'hello', 'status', 'features', 'marcus' o 'date'."
 )

async def query_handler(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Responde a las consultas de los usuarios basadas en los datos predefinidos."""
 user_message = update.message.text.lower().strip()
 logger.info(f"Consulta recibida de {update.effective_user.username}: {user_message}")

 response = QUERY_DATA.get(user_message, "Lo siento, no tengo información sobre eso. ¡Prueba 'features' para ver qué sé!")
 await update.message.reply_text(response)

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Envía un mensaje de ayuda cuando se emite el comando /help."""
 await update.message.reply_text(
 "¡Soy un simple Bot Quick-Query! "
 "Puedes preguntarme sobre temas predefinidos como 'hello', 'status', 'features', 'marcus' o 'date'.\n"
 "Simplemente escribe tu consulta directamente."
 )

async def echo_unknown(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 """Repite mensajes desconocidos y solicita ayuda."""
 await update.message.reply_text("No entendí eso. Prueba con '/help' para ver lo que puedo hacer.")

async def main() -> None:
 """Inicia el bot."""
 application = Application.builder().token(BOT_TOKEN).build()

 # Registrar controladores
 application.add_handler(CommandHandler("start", start_command))
 application.add_handler(CommandHandler("help", help_command))
 
 # Controlador de mensajes para nuestras consultas - coincidirá con cualquier mensaje de texto
 # que no sea un comando.
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, query_handler))

 # Captura todo para mensajes desconocidos (no comandos, no manejados por query_handler)
 application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, echo_unknown)) # Esto podría necesitar un cuidadoso orden
 # Por ahora, si query_handler no coincide, llegará aquí.
 # Un mejor enfoque para mensajes desconocidos en general podría ser poner esto DESPUÉS de query_handler
 # y asegurar que query_handler tenga un filtro más específico si es necesario.
 # Para este ejemplo simple, dejaremos que query_handler maneje todo el texto no comando y responda.

 logger.info("Bot iniciando en modo de long polling...")
 application.run_polling(allowed_updates=Update.ALL_TYPES) # Comienza a buscar actualizaciones

if __name__ == "__main__":
 asyncio.run(main())

Una nota rápida sobre el orden de MessageHandler: la biblioteca python-telegram-bot procesa los controladores en el orden en que se agregan. En nuestro ejemplo, query_handler está diseñado para atrapar cualquier mensaje de texto que no sea un comando. Si una consulta coincide, responde. Si no coincide con nuestros QUERY_DATA, todavía responde con un mensaje de “Lo siento, no tengo información…”. Por lo tanto, el controlador echo_unknown que atrapa `filters.TEXT & ~filters.COMMAND` puede no ser estrictamente necesario como un controlador separado si `query_handler` ya maneja todos esos casos con una respuesta de respaldo. Lo he dejado con un comentario para resaltar cómo podrías usarlo para una enrutación más compleja más adelante, pero para este ejemplo específico, el `query_handler` es bastante completo para mensajes de texto.

Paso 2: Ejecutando Tu Bot

Antes de ejecutarlo, necesitas establecer tu token de bot como una variable de entorno. En Linux/macOS:

export TELEGRAM_BOT_TOKEN="YOUR_BOT_TOKEN_HERE"
python your_bot_script.py

En Windows (Símbolo del sistema):

set TELEGRAM_BOT_TOKEN="YOUR_BOT_TOKEN_HERE"
python your_bot_script.py

Sustituye YOUR_BOT_TOKEN_HERE con el token real que obtuviste de BotFather. Después, simplemente ejecuta tu script en Python.

Abre Telegram, busca el nombre de usuario de tu bot y comienza una conversación. Intenta enviar /start, luego hello, status, o cualquiera de las palabras clave definidas en QUERY_DATA. ¡Verás que tu bot responde casi al instante!

Expandiendo tu Bot de Consultas Rápidas: Ideas Prácticas

Este marco simple es increíblemente flexible. Aquí hay algunas formas en que he utilizado o considerado utilizar este patrón exacto:

1. Monitor de Estado del Servidor

En lugar de codificar en duro "Todos los sistemas nominales...", podrías hacer que el bot realice una verificación rápida. Por ejemplo, si estás monitorizando un servidor local:

# Dentro de query_handler, si user_message == "server_status":
import subprocess

async def get_server_status():
 try:
 # Ejemplo: verifica si un servicio está en funcionamiento (p. ej., Nginx)
 result = subprocess.run(['systemctl', 'is-active', 'nginx'], capture_output=True, text=True, check=True)
 if "active" in result.stdout:
 return "¡Nginx está en funcionamiento! ✅"
 else:
 return "Nginx no está activo. ❌"
 except subprocess.CalledProcessError:
 return "No se pudo verificar el estado de Nginx. ¿Está disponible 'systemctl'?"
 except Exception as e:
 return f"Ocurrió un error: {e}"

# Luego, en tu query_handler:
if user_message == "server_status":
 response = await get_server_status()
 await update.message.reply_text(response)

Esto te permitiría consultar el estado real de un servicio directamente desde Telegram. ¡Imagina configurar esto en un Raspberry Pi en casa!

2. Bot de Recordatorios Simple

Puedes agregar un comando como /remind me to [task] in [X] minutes. Esto implicaría analizar el tiempo y la tarea, y luego utilizar asyncio.sleep de Python para esperar y enviar un mensaje de vuelta al ID de chat del usuario.

# (Ejemplo simplificado, manejo de errores y análisis adecuado necesario)
import re
import asyncio

async def remind_me_command(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
 args = context.args # Obtener argumentos después del comando
 if not args or len(args) < 4 or args[0] != "me" or args[1] != "to" or args[-2] != "in":
 await update.message.reply_text("Uso: /remind me to [task] in [X] minutes")
 return

 try:
 delay_minutes = int(args[-1])
 task_parts = args[2:-2]
 task = " ".join(task_parts)

 await update.message.reply_text(f"Está bien, te recordaré que '{task}' en {delay_minutes} minutos.")
 
 # Obtener el ID de chat para enviar el recordatorio más tarde
 chat_id = update.effective_chat.id 

 # Programar el recordatorio
 await asyncio.sleep(delay_minutes * 60) # Convertir minutos a segundos
 await context.bot.send_message(chat_id=chat_id, text=f"Recordatorio: {task}!")

 except ValueError:
 await update.message.reply_text("Por favor especifica un número válido de minutos.")
 except Exception as e:
 logger.error(f"Error en remind_me_command: {e}")
 await update.message.reply_text("Algo salió mal con tu recordatorio.")

# En main():
# application.add_handler(CommandHandler("remind", remind_me_command))

Esto utiliza context.bot.send_message, que permite a tu bot enviar un mensaje a un ID de chat específico, incluso si no es en respuesta a un mensaje inmediato del usuario.

Conclusiones Accionables para tu Próximo Proyecto de Bot

Si estás buscando construir algo rápido, personal, o simplemente no quieres la molestia de configurar un servidor, aquí está lo que recomiendo:

1. Aprovecha Long Polling por Simplicidad: Para herramientas internas, asistentes personales o bots de comunidades pequeñas, el long polling es una forma fantástica de evitar exponer puertos o lidiar con implementaciones complejas. Tu bot puede funcionar en casi cualquier dispositivo con acceso a Internet.
2. Comienza Pequeño con python-telegram-bot: Esta biblioteca está increíblemente bien documentada y hace que la interacción con la API de Telegram sea directa. No trates de construir todo de una vez; comienza con un solo comando o una consulta simple.
3. Usa Variables de Entorno para Tokens: Nunca codifiques en duro tu token de bot. Usar os.getenv() es una práctica estándar y segura.
4. Piense en Tu Caso de Uso: Los bots de Telegram son excelentes para interacciones rápidas, notificaciones y recuperación simple de datos. Si necesitas elementos de UI complejos, compartir medios enriquecidos o una integración profunda con otros servicios web que requieren puntos finales públicos constantes, entonces puede que los webhooks u otras plataformas sean más adecuadas. Pero para muchos bots de utilidad, Telegram es perfecto.
5. Mantén la Asincronía: La biblioteca python-telegram-bot está construida sobre asyncio. Familiarízate con async def y await, especialmente si tu bot necesita realizar operaciones que tardan tiempo (como hacer una solicitud web, consultar una base de datos, o, como en nuestro ejemplo de recordatorio, esperar por un retraso).

Ahí lo tienes. Una nueva perspectiva sobre cómo construir un bot de Telegram práctico que eluda los problemas de implementación y vaya directamente a ofrecer valor. Personalmente, he encontrado este enfoque invaluable para prototipar ideas y crear utilidades útiles sin quedarme atascado en la infraestructura. ¡Pruébalo y avísame qué tipo de bots de Consultas Rápidas terminas construyendo!

🕒 Published: March 25, 2026