---
title: "Bot Telegram Inteligente com IA: Guia Completo 2026"
url: "https://openclaw.ia.br/blog/bot-telegram-inteligente-ia-guia/"
markdown_url: "https://openclaw.ia.br/blog/bot-telegram-inteligente-ia-guia.MD"
description: "Aprenda a criar um bot Telegram com inteligência artificial usando Python, OpenClaw ou n8n. Tutorial passo a passo com código e exemplos práticos."
date: "2026-01-31"
author: "OpenClaw Brasil"
---

# Bot Telegram Inteligente com IA: Guia Completo 2026

Aprenda a criar um bot Telegram com inteligência artificial usando Python, OpenClaw ou n8n. Tutorial passo a passo com código e exemplos práticos.


O Telegram é a plataforma ideal para bots de IA: API gratuita, sem limites de mensagens, suporte a rich media e grupos de até 200.000 membros. Este guia mostra como criar seu bot inteligente.

## Por Que Telegram para Bots de IA?

| Recurso | Telegram | WhatsApp |
|---------|----------|----------|
| API | Gratuita | Paga |
| Limites | Praticamente sem | Por conversa |
| Aprovação | Instantânea | Processo longo |
| Grupos | 200.000 membros | 1.024 membros |
| Bots inline | Sim | Não |
| Markdown | Completo | Limitado |
| Arquivos | Até 2GB | Limitado |

## Opções para Criar Seu Bot

### 1. OpenClaw (Recomendado)

A forma mais rápida de ter um assistente inteligente no Telegram.

**Vantagens:**
- Configuração em minutos
- Claude, GPT-4 ou modelos locais
- Memória persistente
- Ferramentas integradas (web, arquivos, etc.)

**Configuração:**

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

**Obtendo o token:**
1. Abra @BotFather no Telegram
2. Envie `/newbot`
3. Escolha nome e username
4. Copie o token

**Obtendo seu ID:**
1. Abra @userinfobot
2. Envie qualquer mensagem
3. Copie o ID retornado

### 2. Python + python-telegram-bot

Para quem quer controle total do código.

**Instalação:**
```bash
pip install python-telegram-bot openai
```

**Bot básico com GPT-4:**
```python
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()
```

**Executando:**
```bash
export TELEGRAM_TOKEN="seu_token"
export OPENAI_API_KEY="sua_chave"
python bot.py
```

### 3. Python + LangChain

Para recursos avançados como RAG e memória persistente.

```python
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)
```

### 4. n8n (No-Code)

Para automações visuais sem programar.

**Fluxo básico:**
1. **Telegram Trigger** - Recebe mensagens
2. **OpenAI** - Processa com IA
3. **Telegram** - Envia resposta

**Configuração no n8n:**
```json
{
  "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 }}"
      }
    }
  ]
}
```

## Recursos Avançados

### Processamento de Imagens

```python
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)
```

### Transcrição de Áudio

```python
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}"
    )
```

### Botões Inline

```python
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!")
```

## Deploy

### Railway (Recomendado)

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

# Login e deploy
railway login
railway init
railway up
```

**railway.json:**
```json
{
  "build": {
    "builder": "NIXPACKS"
  },
  "deploy": {
    "startCommand": "python bot.py"
  }
}
```

### Docker

```dockerfile
FROM python:3.11-slim

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

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

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

### VPS (DigitalOcean, Linode)

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

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

```ini
[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
```

## Custos

| Componente | Custo |
|------------|-------|
| API Telegram | Grátis |
| GPT-4 Turbo | ~$10/1M tokens input |
| Claude Sonnet | ~$3/1M tokens input |
| Whisper | $0.006/minuto |
| Railway | $5/mês (básico) |
| VPS | $5-10/mês |

Estimativa para uso moderado (100 msgs/dia): **$5-15/mês**

## Segurança

### Boas Práticas

1. **Restrinja usuários**
   ```python
   ALLOWED_USERS = [123456789, 987654321]
   
   async def check_user(update: Update, context: ContextTypes.DEFAULT_TYPE):
       if update.effective_user.id not in ALLOWED_USERS:
           await update.message.reply_text("Acesso negado.")
           return False
       return True
   ```

2. **Rate limiting**
   ```python
   from collections import defaultdict
   from datetime import datetime, timedelta
   
   user_requests = defaultdict(list)
   
   def rate_limit(user_id, max_requests=10, window=60):
       now = datetime.now()
       user_requests[user_id] = [
           t for t in user_requests[user_id]
           if now - t < timedelta(seconds=window)
       ]
       if len(user_requests[user_id]) >= max_requests:
           return False
       user_requests[user_id].append(now)
       return True
   ```

3. **Não exponha tokens em código**
   ```python
   # Use variáveis de ambiente
   import os
   TOKEN = os.getenv("TELEGRAM_TOKEN")
   ```

## Próximos Passos

1. **Iniciantes:** Use OpenClaw para começar em minutos
2. **Desenvolvedores:** Clone o template Python e customize
3. **No-code:** Configure n8n com template Telegram

## Recursos

- [Documentação python-telegram-bot](https://python-telegram-bot.org/)
- [API do Telegram](https://core.telegram.org/bots/api)
- [LangChain docs](https://python.langchain.com/)
- [OpenClaw - Canal Telegram](/guias/telegram/)

---

*Quer o caminho mais rápido? O [OpenClaw](/instalacao/) configura um bot Telegram inteligente em minutos, com Claude ou GPT-4, memória e ferramentas integradas.*

---

## Artigos Relacionados

- [Tutorial: Conectar OpenClaw ao Telegram](/como-usar/telegram/)
- [Como Conectar WhatsApp ao OpenClaw](/blog/como-conectar-whatsapp-openclaw/)
- [12 Automações OpenClaw que Funcionam de Verdade](/blog/12-casos-de-uso-que-funcionam/)
- [20 Casos de Uso Reais do OpenClaw](/blog/20-casos-uso-reais-openclaw/)