1Tu token será algo como:
27123456789:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw

1telegram-ai-bot/
2├── bot.py
3├── config.py
4├── requirements.txt
5└── .env

1aiogram==3.4.1
2openai==1.12.0
3anthropic==0.18.0
4python-dotenv==1.0.1

1TELEGRAM_TOKEN=tu-token-de-botfather
2OPENAI_API_KEY=sk-...
3ANTHROPIC_API_KEY=sk-ant-...

1import os
2from dotenv import load_dotenv
3 
4load_dotenv()
5 
6TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN")
7OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
8ANTHROPIC_API_KEY = os.getenv("ANTHROPIC_API_KEY")

1import asyncio
2from aiogram import Bot, Dispatcher, types
3from aiogram.filters import Command
4from openai import AsyncOpenAI
5from config import TELEGRAM_TOKEN, OPENAI_API_KEY
6 
7# Inicializar
8bot = Bot(token=TELEGRAM_TOKEN)
9dp = Dispatcher()
10openai_client = AsyncOpenAI(api_key=OPENAI_API_KEY)
11 
12# Almacenar historial de conversaciones
13conversations = {}
14 
15@dp.message(Command("start"))
16async def start_handler(message: types.Message):
17    await message.answer(
18        "¡Hola! Soy un bot con IA. "
19        "Escríbeme cualquier pregunta y te responderé."
20    )
21 
22@dp.message(Command("clear"))
23async def clear_handler(message: types.Message):
24    user_id = message.from_user.id
25    conversations[user_id] = []
26    await message.answer("Historial borrado.")
27 
28@dp.message()
29async def message_handler(message: types.Message):
30    user_id = message.from_user.id
31    user_message = message.text
32 
33    # Inicializar historial si no existe
34    if user_id not in conversations:
35        conversations[user_id] = []
36 
37    # Añadir mensaje del usuario
38    conversations[user_id].append({
39        "role": "user",
40        "content": user_message
41    })
42 
43    # Mantener solo últimos 10 mensajes
44    conversations[user_id] = conversations[user_id][-10:]
45 
46    # Mostrar "escribiendo..."
47    await bot.send_chat_action(message.chat.id, "typing")
48 
49    try:
50        # Llamar a OpenAI
51        response = await openai_client.chat.completions.create(
52            model="gpt-4o-mini",
53            messages=[
54                {"role": "system", "content": "Eres un asistente útil y amigable. Responde en español de forma concisa."},
55                *conversations[user_id]
56            ],
57            max_tokens=1000
58        )
59 
60        assistant_message = response.choices[0].message.content
61 
62        # Guardar respuesta en historial
63        conversations[user_id].append({
64            "role": "assistant",
65            "content": assistant_message
66        })
67 
68        await message.answer(assistant_message)
69 
70    except Exception as e:
71        await message.answer(f"Error: {str(e)}")
72 
73async def main():
74    print("Bot iniciado...")
75    await dp.start_polling(bot)
76 
77if __name__ == "__main__":
78    asyncio.run(main())

1import asyncio
2from aiogram import Bot, Dispatcher, types
3from aiogram.filters import Command
4import anthropic
5from config import TELEGRAM_TOKEN, ANTHROPIC_API_KEY
6 
7bot = Bot(token=TELEGRAM_TOKEN)
8dp = Dispatcher()
9claude_client = anthropic.AsyncAnthropic(api_key=ANTHROPIC_API_KEY)
10 
11conversations = {}
12 
13@dp.message()
14async def message_handler(message: types.Message):
15    user_id = message.from_user.id
16    user_message = message.text
17 
18    if user_id not in conversations:
19        conversations[user_id] = []
20 
21    conversations[user_id].append({
22        "role": "user",
23        "content": user_message
24    })
25 
26    conversations[user_id] = conversations[user_id][-10:]
27 
28    await bot.send_chat_action(message.chat.id, "typing")
29 
30    try:
31        response = await claude_client.messages.create(
32            model="claude-3-5-sonnet-20241022",
33            max_tokens=1000,
34            system="Eres un asistente útil. Responde en español de forma concisa.",
35            messages=conversations[user_id]
36        )
37 
38        assistant_message = response.content[0].text
39 
40        conversations[user_id].append({
41            "role": "assistant",
42            "content": assistant_message
43        })
44 
45        await message.answer(assistant_message)
46 
47    except Exception as e:
48        await message.answer(f"Error: {str(e)}")
49 
50async def main():
51    print("Bot con Claude iniciado...")
52    await dp.start_polling(bot)
53 
54if __name__ == "__main__":
55    asyncio.run(main())

1@dp.message(Command("resumen"))
2async def resumen_handler(message: types.Message):
3    """Resumir un texto largo"""
4    text = message.text.replace("/resumen", "").strip()
5 
6    if not text:
7        await message.answer("Uso: /resumen [texto a resumir]")
8        return
9 
10    response = await openai_client.chat.completions.create(
11        model="gpt-4o-mini",
12        messages=[
13            {"role": "system", "content": "Resume el siguiente texto en 3 puntos clave."},
14            {"role": "user", "content": text}
15        ]
16    )
17 
18    await message.answer(response.choices[0].message.content)
19 
20@dp.message(Command("traducir"))
21async def traducir_handler(message: types.Message):
22    """Traducir texto al inglés"""
23    text = message.text.replace("/traducir", "").strip()
24 
25    response = await openai_client.chat.completions.create(
26        model="gpt-4o-mini",
27        messages=[
28            {"role": "system", "content": "Traduce el siguiente texto al inglés."},
29            {"role": "user", "content": text}
30        ]
31    )
32 
33    await message.answer(response.choices[0].message.content)

1@dp.message(types.ContentType.PHOTO)
2async def photo_handler(message: types.Message):
3    """Analizar imágenes con GPT-4 Vision"""
4    photo = message.photo[-1]  # Mayor resolución
5    file = await bot.get_file(photo.file_id)
6    file_url = f"https://api.telegram.org/file/bot{TELEGRAM_TOKEN}/{file.file_path}"
7 
8    response = await openai_client.chat.completions.create(
9        model="gpt-4o",
10        messages=[
11            {
12                "role": "user",
13                "content": [
14                    {"type": "text", "text": "Describe esta imagen en español."},
15                    {"type": "image_url", "image_url": {"url": file_url}}
16                ]
17            }
18        ]
19    )
20 
21    await message.answer(response.choices[0].message.content)

1# Instalar Railway CLI
2npm install -g @railway/cli
3 
4# Login y deploy
5railway login
6railway init
7railway up

1FROM python:3.11-slim
2 
3WORKDIR /app
4COPY requirements.txt .
5RUN pip install -r requirements.txt
6 
7COPY . .
8CMD ["python", "bot.py"]

1docker build -t telegram-bot .
2docker run -d --env-file .env telegram-bot

1# En el servidor
2git clone tu-repo
3cd telegram-ai-bot
4pip install -r requirements.txt
5nohup python bot.py &

1from collections import defaultdict
2import time
3 
4user_last_message = defaultdict(float)
5RATE_LIMIT = 5  # segundos entre mensajes
6 
7@dp.message()
8async def message_handler(message: types.Message):
9    user_id = message.from_user.id
10    now = time.time()
11 
12    if now - user_last_message[user_id] < RATE_LIMIT:
13        await message.answer("Espera unos segundos antes de enviar otro mensaje.")
14        return
15 
16    user_last_message[user_id] = now
17    # ... resto del código