Bot Telegram Inteligente com IA: Guia Completo 2026

# config.yaml
channels:
  telegram:
    enabled: true
    token: "BOT_TOKEN_DO_BOTFATHER"
    allowedUsers:
      - 123456789  # Seu Telegram ID

pip install python-telegram-bot openai

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

# Configuração
TELEGRAM_TOKEN = os.getenv("TELEGRAM_TOKEN")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")

client = OpenAI(api_key=OPENAI_API_KEY)

# Histórico de conversas (em memória)
conversations = {}

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Comando /start"""
    user_id = update.effective_user.id
    conversations[user_id] = []
    await update.message.reply_text(
        "Olá! Sou um assistente de IA. Como posso ajudar?"
    )

async def clear(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Comando /clear - limpa histórico"""
    user_id = update.effective_user.id
    conversations[user_id] = []
    await update.message.reply_text("Histórico limpo!")

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Processa mensagens de texto"""
    user_id = update.effective_user.id
    user_message = update.message.text
    
    # Inicializa histórico se necessário
    if user_id not in conversations:
        conversations[user_id] = []
    
    # Adiciona mensagem ao histórico
    conversations[user_id].append({
        "role": "user",
        "content": user_message
    })
    
    # Mantém apenas últimas 20 mensagens
    if len(conversations[user_id]) > 20:
        conversations[user_id] = conversations[user_id][-20:]
    
    # Envia "digitando..."
    await context.bot.send_chat_action(
        chat_id=update.effective_chat.id,
        action="typing"
    )
    
    # Chama a API do OpenAI
    try:
        response = client.chat.completions.create(
            model="gpt-4-turbo",
            messages=[
                {"role": "system", "content": "Você é um assistente útil e amigável."},
                *conversations[user_id]
            ],
            max_tokens=1000
        )
        
        assistant_message = response.choices[0].message.content
        
        # Salva resposta no histórico
        conversations[user_id].append({
            "role": "assistant",
            "content": assistant_message
        })
        
        await update.message.reply_text(assistant_message)
        
    except Exception as e:
        await update.message.reply_text(f"Erro: {str(e)}")

def main():
    """Inicia o bot"""
    app = Application.builder().token(TELEGRAM_TOKEN).build()
    
    # Handlers
    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("clear", clear))
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))
    
    # Inicia polling
    print("Bot iniciado!")
    app.run_polling(allowed_updates=Update.ALL_TYPES)

if __name__ == "__main__":
    main()

export TELEGRAM_TOKEN="seu_token"
export OPENAI_API_KEY="sua_chave"
python bot.py

from langchain_openai import ChatOpenAI
from langchain.memory import ConversationBufferWindowMemory
from langchain.chains import ConversationChain
from telegram import Update
from telegram.ext import Application, MessageHandler, filters, ContextTypes

# LLM e memória
llm = ChatOpenAI(model="gpt-4-turbo", temperature=0.7)
memories = {}

def get_chain(user_id):
    """Retorna chain com memória do usuário"""
    if user_id not in memories:
        memories[user_id] = ConversationBufferWindowMemory(k=10)
    
    return ConversationChain(
        llm=llm,
        memory=memories[user_id],
        verbose=False
    )

async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_id = update.effective_user.id
    chain = get_chain(user_id)
    
    response = chain.predict(input=update.message.text)
    await update.message.reply_text(response)

{
  "nodes": [
    {
      "type": "n8n-nodes-base.telegramTrigger",
      "position": [250, 300],
      "parameters": {
        "updates": ["message"]
      }
    },
    {
      "type": "@n8n/n8n-nodes-langchain.openAi",
      "position": [450, 300],
      "parameters": {
        "model": "gpt-4-turbo",
        "prompt": "={{ $json.message.text }}"
      }
    },
    {
      "type": "n8n-nodes-base.telegram",
      "position": [650, 300],
      "parameters": {
        "operation": "sendMessage",
        "chatId": "={{ $('Telegram Trigger').item.json.message.chat.id }}",
        "text": "={{ $json.text }}"
      }
    }
  ]
}

import base64
from openai import OpenAI

async def handle_photo(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Analisa imagens enviadas"""
    photo = update.message.photo[-1]  # Maior resolução
    file = await context.bot.get_file(photo.file_id)
    
    # Download da imagem
    image_data = await file.download_as_bytearray()
    base64_image = base64.b64encode(image_data).decode()
    
    # Análise com GPT-4 Vision
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "O que você vê nesta imagem?"},
                    {
                        "type": "image_url",
                        "image_url": {"url": f"data:image/jpeg;base64,{base64_image}"}
                    }
                ]
            }
        ]
    )
    
    await update.message.reply_text(response.choices[0].message.content)

async def handle_voice(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Transcreve áudios enviados"""
    voice = update.message.voice
    file = await context.bot.get_file(voice.file_id)
    
    # Download do áudio
    audio_path = f"/tmp/{voice.file_id}.ogg"
    await file.download_to_drive(audio_path)
    
    # Transcrição com Whisper
    with open(audio_path, "rb") as audio_file:
        transcript = client.audio.transcriptions.create(
            model="whisper-1",
            file=audio_file
        )
    
    # Responde sobre a transcrição
    response = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "system", "content": "Responda à mensagem de áudio transcrita."},
            {"role": "user", "content": transcript.text}
        ]
    )
    
    await update.message.reply_text(
        f"📝 Transcrição: {transcript.text}\n\n💬 Resposta: {response.choices[0].message.content}"
    )

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

async def menu(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Mostra menu com botões"""
    keyboard = [
        [
            InlineKeyboardButton("Ajuda", callback_data="help"),
            InlineKeyboardButton("Config", callback_data="config")
        ],
        [InlineKeyboardButton("Limpar histórico", callback_data="clear")]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)
    
    await update.message.reply_text(
        "Escolha uma opção:",
        reply_markup=reply_markup
    )

async def button_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    """Processa cliques em botões"""
    query = update.callback_query
    await query.answer()
    
    if query.data == "help":
        await query.edit_message_text("Envie qualquer mensagem para conversar!")
    elif query.data == "clear":
        conversations[update.effective_user.id] = []
        await query.edit_message_text("Histórico limpo!")

# Instale CLI do Railway
npm install -g @railway/cli

# Login e deploy
railway login
railway init
railway up

{
  "build": {
    "builder": "NIXPACKS"
  },
  "deploy": {
    "startCommand": "python bot.py"
  }
}

FROM python:3.11-slim

WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . .
CMD ["python", "bot.py"]

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

# No servidor
git clone seu-repo
cd telegram-bot
pip install -r requirements.txt

# Systemd service
sudo nano /etc/systemd/system/telegram-bot.service

[Unit]
Description=Telegram Bot
After=network.target

[Service]
User=ubuntu
WorkingDirectory=/home/ubuntu/telegram-bot
ExecStart=/usr/bin/python3 bot.py
Restart=always
EnvironmentFile=/home/ubuntu/telegram-bot/.env

[Install]
WantedBy=multi-user.target