Crea tu primer bot de Telegram que responde con IA usando Python y la API de OpenAI

¿Alguna vez has soñado con crear tu propio asistente virtual? En este tutorial, te llevaré paso a paso para construir un bot de Telegram que responde con inteligencia artificial usando Python y la API de OpenAI. No necesitas ser un experto en programación, solo ganas de aprender y crear algo increíble.

¿Qué necesitas antes de empezar?

Antes de sumergirnos en el código, asegúrate de tener estos elementos preparados:

Requisitos previos

• Python 3.8 o superior instalado en tu computadora
• Una cuenta de Telegram (obvio, ¿verdad?)
• Una cuenta de OpenAI para acceder a la API
• Un editor de código como Visual Studio Code o PyCharm
• Conocimientos básicos de Python (no te preocupes, lo explicaré todo)

Instalación de librerías

Primero, instala las librerías necesarias ejecutando estos comandos en tu terminal:

pip install python-telegram-bot openai python-dotenv

Paso 1: Creando tu bot en Telegram

El primer paso es crear tu bot en Telegram usando BotFather, el bot maestro que controla todos los demás bots.

Configuración con BotFather

1. Busca a BotFather en Telegram escribiendo @BotFather
2. Inicia una conversación haciendo clic en «Start»
3. Crea tu bot enviando el comando /newbot
4. Asigna un nombre para tu bot (por ejemplo, «Mi Bot IA»)
5. Elige un username único que termine en «bot» (ejemplo: mi_bot_ia_bot)

Una vez completado, BotFather te proporcionará un token único que se ve así:

123456789:ABCDefGhIJKlmNoPQRsTUVwxyZ

¡Importante! Guarda este token en un lugar seguro. Es como la llave maestra de tu bot.

Paso 2: Obteniendo tu clave API de OpenAI

Para que tu bot pueda «pensar» necesitas acceso a la API de OpenAI.

Configuración de OpenAI

1. Regístrate en platform.openai.com
2. Navega a la sección «API Keys»
3. Crea una nueva clave haciendo clic en «Create new secret key»
4. Copia y guarda tu clave API de forma segura

Tu clave API se verá similar a esto:

sk-proj-abc1234567890...

Paso 3: Configurando el entorno de desarrollo

Estructura del proyecto

Crea una carpeta para tu proyecto y organiza los archivos así:

mi_bot_telegram/
├── bot.py
├── .env
└── requirements.txt

Archivo .env

Crea un archivo .env para almacenar tus credenciales de forma segura:

TELEGRAM_BOT_TOKEN=tu_token_de_telegram_aquí
OPENAI_API_KEY=tu_clave_de_openai_aquí

Paso 4: Desarrollando tu bot

Ahora viene la parte emocionante: ¡programar tu bot!

Código principal (bot.py)

import logging
import os
from dotenv import load_dotenv
from telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, filters, ContextTypes
import openai

# Cargar variables de entorno
load_dotenv()

# Configurar logging
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)

# Configurar tokens
TELEGRAM_TOKEN = os.getenv('TELEGRAM_BOT_TOKEN')
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')

# Configurar OpenAI
openai.api_key = OPENAI_API_KEY

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Comando de inicio del bot"""
    await update.message.reply_text(
        "¡Hola! Soy tu asistente IA. Pregúntame lo que quieras y te responderé usando inteligencia artificial. 🤖"
    )

async def help_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Comando de ayuda"""
    help_text = """
    🤖 **Comandos disponibles:**
    
    /start - Iniciar conversación
    /help - Mostrar esta ayuda
    
    Simplemente escribe cualquier pregunta y te responderé usando IA.
    """
    await update.message.reply_text(help_text)

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Manejar mensajes de texto y responder con IA"""
    user_message = update.message.text
    user_name = update.effective_user.first_name
    
    try:
        # Preparar el prompt para OpenAI
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=[
                {"role": "system", "content": "Eres un asistente útil y amigable en Telegram. Responde de manera clara y concisa."},
                {"role": "user", "content": user_message}
            ],
            max_tokens=500,
            temperature=0.7
        )
        
        ai_response = response.choices[0].message.content
        
        # Responder al usuario
        await update.message.reply_text(f"🤖 {ai_response}")
        
    except Exception as e:
        logging.error(f"Error al procesar mensaje: {e}")
        await update.message.reply_text(
            "Lo siento, hubo un error al procesar tu mensaje. Inténtalo de nuevo."
        )

async def error_handler(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Manejo de errores"""
    logging.warning(f'Update {update} caused error {context.error}')

def main():
    """Función principal"""
    # Crear la aplicación
    application = ApplicationBuilder().token(TELEGRAM_TOKEN).build()
    
    # Agregar manejadores
    application.add_handler(CommandHandler("start", start))
    application.add_handler(CommandHandler("help", help_command))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    
    # Agregar manejador de errores
    application.add_error_handler(error_handler)
    
    # Iniciar el bot
    print("🚀 Bot iniciado. Presiona Ctrl+C para detenerlo.")
    application.run_polling()

if __name__ == '__main__':
    main()

Paso 5: Funcionalidades avanzadas

Añadiendo memoria conversacional

Para que tu bot recuerde conversaciones anteriores:

# Diccionario para almacenar historial de conversaciones
conversation_history = {}

async def handle_message_with_memory(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Manejar mensajes con memoria conversacional"""
    user_id = update.effective_user.id
    user_message = update.message.text
    
    # Inicializar historial si no existe
    if user_id not in conversation_history:
        conversation_history[user_id] = []
    
    # Agregar mensaje del usuario al historial
    conversation_history[user_id].append({"role": "user", "content": user_message})
    
    try:
        # Preparar mensajes para OpenAI
        messages = [
            {"role": "system", "content": "Eres un asistente útil y amigable en Telegram."}
        ] + conversation_history[user_id]
        
        response = openai.ChatCompletion.create(
            model="gpt-3.5-turbo",
            messages=messages,
            max_tokens=500,
            temperature=0.7
        )
        
        ai_response = response.choices[0].message.content
        
        # Agregar respuesta de IA al historial
        conversation_history[user_id].append({"role": "assistant", "content": ai_response})
        
        # Limitar historial para no exceder límites de tokens
        if len(conversation_history[user_id]) > 20:
            conversation_history[user_id] = conversation_history[user_id][-20:]
        
        await update.message.reply_text(f"🤖 {ai_response}")
        
    except Exception as e:
        logging.error(f"Error: {e}")
        await update.message.reply_text("Hubo un error. Inténtalo de nuevo.")

Comando para limpiar conversación

async def clear_conversation(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Limpiar historial de conversación"""
    user_id = update.effective_user.id
    
    if user_id in conversation_history:
        conversation_history[user_id] = []
    
    await update.message.reply_text("🧹 Conversación limpiada. ¡Empecemos de nuevo!")

Paso 6: Ejecutando tu bot

Ejecutar localmente

1. Abre tu terminal en la carpeta del proyecto
2. Ejecuta el bot con: python bot.py
3. Prueba tu bot enviándole mensajes en Telegram

Solución de problemas comunes

Error de token inválido:

• Verifica que tu token de Telegram sea correcto
• Asegúrate de que no haya espacios adicionales

Error de API de OpenAI:

• Confirma que tu clave API sea válida
• Verifica que tengas créditos disponibles en tu cuenta

Bot no responde:

• Revisa los logs en la consola
• Verifica tu conexión a internet

Paso 7: Despliegue en producción

Para mantener tu bot funcionando 24/7, considera estas opciones:

Opciones de hosting

1. Heroku – Fácil de usar, plan gratuito limitado
2. Railway – Moderno y sencillo
3. DigitalOcean – Más control, requiere configuración
4. AWS/Google Cloud – Escalable, más complejo

Configuración con webhooks

Para producción, es mejor usar webhooks en lugar de polling:

import uvicorn
from fastapi import FastAPI, Request
from telegram.ext import Application

app = FastAPI()

async def setup_bot():
    """Configurar bot para webhooks"""
    application = Application.builder().token(TELEGRAM_TOKEN).build()
    
    # Agregar handlers aquí
    application.add_handler(CommandHandler("start", start))
    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    
    return application

@app.post("/webhook")
async def webhook(request: Request):
    """Endpoint para recibir updates de Telegram"""
    application = await setup_bot()
    
    json_data = await request.json()
    update = Update.de_json(json_data, application.bot)
    
    await application.process_update(update)
    
    return {"status": "ok"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

Optimizaciones y mejores prácticas

Manejo de costos

• Limita las respuestas: Usa max_tokens para controlar el costo
• Implementa rate limiting: Evita spam costoso
• Monitorea el uso: Revisa regularmente tu facturación de OpenAI

Seguridad

• Nunca hardcodees tokens o claves en el código
• Usa variables de entorno para credenciales sensibles
• Valida las entradas del usuario para evitar inyecciones
• Implementa logging para detectar problemas

Rendimiento

• Usa async/await para operaciones no bloqueantes
• Implementa timeouts para evitar cuelgues
• Caché respuestas comunes para reducir costos
• Optimiza prompts para obtener mejores respuestas

Conclusión

¡Felicidades! Has creado tu primer bot de Telegram con inteligencia artificial. Este proyecto te ha mostrado cómo integrar múltiples tecnologías modernas para crear una experiencia de usuario impresionante.

Próximos pasos

Ahora que tienes tu bot funcionando, puedes expandirlo con:

• Comandos especializados para diferentes tipos de consultas
• Integración con bases de datos para almacenar preferencias de usuario
• Soporte para imágenes usando DALL-E
• Análisis de sentimientos para respuestas más empáticas
• Integración con APIs externas para información en tiempo real

Recursos adicionales

• Documentación oficial de python-telegram-bot
• Guía de OpenAI API
• Mejores prácticas para bots de Telegram

El mundo de la IA y los chatbots está en constante evolución. Con este proyecto como base, tienes las herramientas para crear experiencias cada vez más sofisticadas y útiles para tus usuarios. ¡Que comience tu aventura en el desarrollo de bots inteligentes!