Menghubungkan AI dengan Telegram Bot

Integrasi AI ke dalam Telegram Bot memungkinkan interaksi real‑time yang cerdas, mulai dari menjawab pertanyaan hingga menghasilkan konten kreatif. Tutorial ini menjelaskan arsitektur dasar, persiapan lingkungan, dan implementasi kode Python yang siap diproduksi.

Pendahuluan

Masalah yang diselesaikan:
- Respons otomatis yang kontekstual: Bot tidak hanya mengirimkan teks statis, melainkan menghasilkan jawaban berbasis model bahasa besar.
- Skalabilitas: Menggunakan webhook sehingga bot dapat melayani ribuan pengguna tanpa polling terus‑menerus.
- Keamanan: Menyimpan kredensial secara aman dan membatasi akses API.

Arsitektur Ringkas

User (Telegram) --> BotFather (Token) --> Telegram API
                               |
                               v
                     Webhook (HTTPS) --> Flask (Python)
                               |
                               v
               AI Provider (ChatGPT/Claude/Gemini) API

Prasyarat & Persiapan

Instalasi Awal

# Buat folder proyek
mkdir telegram-ai-bot && cd telegram-ai-bot

# Virtual environment
python3 -m venv venv
source venv/bin/activate

# Install dependencies
pip install flask python-telegram-bot==20.0 requests python-dotenv

Buat file .env untuk menyimpan token secara aman:

# .env
BOT_TOKEN=123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11
AI_PROVIDER=chatgpt   # atau claude / gemini
OPENAI_API_KEY=sk-...
CLAUDE_API_KEY=...
GEMINI_API_KEY=...
WEBHOOK_URL=https://yourdomain.com/webhook

Catatan: Jangan pernah commit file .env ke repositori publik.

Langkah Demi Langkah

Step 1 – Daftarkan Webhook di Telegram

curl -F "url=${WEBHOOK_URL}" https://api.telegram.org/bot${BOT_TOKEN}/setWebhook

Jika berhasil, Telegram akan mengembalikan:

{"ok":true,"result":true,"description":"Webhook was set"}

Step 2 – Buat Server Flask

app.py

import os
import logging
from flask import Flask, request, abort
from telegram import Update, Bot
from telegram.ext import Dispatcher, CommandHandler, MessageHandler, filters
import requests
from dotenv import load_dotenv

load_dotenv()
logging.basicConfig(level=logging.INFO)

app = Flask(__name__)

BOT_TOKEN = os.getenv("BOT_TOKEN")
AI_PROVIDER = os.getenv("AI_PROVIDER")
bot = Bot(token=BOT_TOKEN)
dispatcher = Dispatcher(bot=bot, update_queue=None, workers=4, use_context=True)

def call_ai(prompt: str) -> str:
    """Panggil model AI yang dipilih."""
    if AI_PROVIDER == "chatgpt":
        api_key = os.getenv("OPENAI_API_KEY")
        headers = {"Authorization": f"Bearer {api_key}"}
        json_data = {
            "model": "gpt-4o-mini",
            "messages": [{"role": "user", "content": prompt}],
            "max_tokens": 500,
        }
        resp = requests.post(
            "https://api.openai.com/v1/chat/completions",
            headers=headers,
            json=json_data,
            timeout=15,
        )
        resp.raise_for_status()
        return resp.json()["choices"][0]["message"]["content"]

    elif AI_PROVIDER == "claude":
        api_key = os.getenv("CLAUDE_API_KEY")
        headers = {"x-api-key": api_key, "Content-Type": "application/json"}
        json_data = {"model": "claude-3-5-sonnet-20240620", "max_tokens": 500, "messages": [{"role": "user", "content": prompt}]}
        resp = requests.post("https://api.anthropic.com/v1/messages", headers=headers, json=json_data, timeout=15)
        resp.raise_for_status()
        return resp.json()["content"][0]["text"]

    elif AI_PROVIDER == "gemini":
        api_key = os.getenv("GEMINI_API_KEY")
        url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent?key={api_key}"
        json_data = {"contents": [{"role": "user", "parts": [{"text": prompt}]}]}
        resp = requests.post(url, json=json_data, timeout=15)
        resp.raise_for_status()
        return resp.json()["candidates"][0]["content"]["parts"][0]["text"]

    else:
        return "AI provider tidak dikenali."

def start(update: Update, context):
    update.message.reply_text("🤖 Bot AI siap! Kirim pesan apa saja.")

def handle_message(update: Update, context):
    user_msg = update.message.text
    try:
        ai_reply = call_ai(user_msg)
        update.message.reply_text(ai_reply)
    except Exception as e:
        logging.exception("Error calling AI")
        update.message.reply_text("⚠️ Gagal memproses permintaan. Coba lagi nanti.")

# Register handlers
dispatcher.add_handler(CommandHandler("start", start))
dispatcher.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_message))

@app.route("/webhook", methods=["POST"])
def webhook():
    if request.method == "POST":
        update = Update.de_json(request.get_json(force=True), bot)
        dispatcher.process_update(update)
        return "OK", 200
    else:
        abort(400)

if __name__ == "__main__":
    # Untuk development lokal, gunakan ngrok atau Flask built‑in server
    app.run(host="0.0.0.0", port=8443)

Step 3 – Deploy ke Server HTTPS

a. Menggunakan Docker (opsional)

Dockerfile

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
ENV PYTHONUNBUFFERED=1
CMD ["gunicorn", "-b", "0.0.0.0:8443", "app:app"]

requirements.txt

Flask
python-telegram-bot==20.0
requests
python-dotenv
gunicorn

Build & push:

docker build -t yourrepo/telegram-ai-bot:latest .
docker push yourrepo/telegram-ai-bot:latest

Deploy ke VPS (contoh dengan docker run):

docker run -d --restart unless-stopped \
  -p 443:8443 \
  -e BOT_TOKEN=$BOT_TOKEN \
  -e AI_PROVIDER=$AI_PROVIDER \
  -e OPENAI_API_KEY=$OPENAI_API_KEY \
  -e CLAUDE_API_KEY=$CLAUDE_API_KEY \
  -e GEMINI_API_KEY=$GEMINI_API_KEY \
  -e WEBHOOK_URL=$WEBHOOK_URL \
  yourrepo/telegram-ai-bot:latest

Pastikan port 443 terbuka dan sertifikat SSL terpasang (mis. menggunakan Caddy atau Nginx sebagai reverse proxy).

b. Verifikasi Webhook

curl https://api.telegram.org/bot${BOT_TOKEN}/getWebhookInfo

Output yang diharapkan:

{
  "ok": true,
  "result": {
    "url": "https://yourdomain.com/webhook",
    "has_custom_certificate": false,
    "pending_update_count": 0,
    ...
  }
}

Tips Optimasi & Keamanan

1. Environment Variables – Simpan semua kredensial di .env atau secret manager (AWS Secrets Manager, GCP Secret Manager). Hindari hard‑code.
2. Rate Limiting – Tambahkan middleware Flask untuk membatasi 1 request per detik per user agar tidak melebihi kuota AI.
3. Validasi Input – Bersihkan teks masuk (mis. menghapus markup) untuk mengurangi risiko prompt injection.
4. Logging Terstruktur – Gunakan logging dengan level INFO untuk audit, ERROR untuk kegagalan API.
5. Cache Respons – Untuk pertanyaan berulang, simpan hasil di Redis (TTL 5‑10 menit) untuk mengurangi biaya AI.
6. HTTPS Only – Telegram menolak webhook non‑SSL. Gunakan sertifikat yang valid (Let's Encrypt gratis).
7. Monitoring – Integrasikan dengan Prometheus atau Grafana untuk metrik latency, error rate, dan usage token.

Troubleshooting Error Umum

Kesimpulan

Dengan mengikuti langkah di atas, Anda dapat:

• Membuat Telegram Bot yang responsif dan cerdas menggunakan model AI terkemuka (ChatGPT Plus, Claude Pro, Gemini Advanced).
• Menyebarkan bot secara aman di lingkungan produksi dengan webhook HTTPS.
• Mengoptimalkan biaya dan performa lewat caching, rate limiting, dan monitoring.

Integrasi AI‑Telegram membuka peluang automasi layanan pelanggan, asisten pribadi, atau generator konten langsung di platform yang sudah dikenal luas. Selamat bereksperimen!