Faut-il savoir coder pour créer un bot Telegram avec l’IA ?

Très peu. Un agent de code peut écrire tout le bot ; votre rôle est de donner des prompts clairs, d’essayer le bot depuis votre propre compte et de lire les commandes que l’agent exécute. Un usage de base du terminal et savoir ce qu’est un fichier .env suffisent.

Où obtenir le token d’un bot Telegram ?

Dans le processus officiel de création de bots de Telegram : vous créez un nouveau bot dans Telegram, lui donnez un nom et un nom d’utilisateur, et un token s’affiche à la fin. Gardez ce token uniquement dans votre fichier .env.

Un bot Telegram doit-il utiliser le polling ou un webhook ?

Le polling est plus simple pour le développement et les petits bots, car il n’exige aucune adresse HTTPS publique. Les webhooks sont plus efficaces pour les bots très sollicités et sont obligatoires sur les plateformes serverless.

Comment ajouter des réponses IA (LLM) à un bot Telegram ?

Le bot envoie le message reçu à une API de LLM et renvoie la réponse. Gardez la clé d’API dans .env, et utilisez une limite quotidienne par utilisateur et un historique de conversation court pour maîtriser les coûts.

Puis-je déplacer le même bot vers Discord ?

En grande partie, oui. Si la gestion des commandes et des messages vit dans un module qui ne sait rien de la plateforme, le côté Discord n’est qu’une fine couche écrite avec discord.py ou discord.js.

Créer un bot Telegram avec l’IA : guide pas à pas

Pour créer un bot Telegram avec l’IA, demandez à un agent de code (Claude Code, Codex ou équivalent) d’écrire un bot avec python-telegram-bot, mettez le token dans un fichier .env et lancez-le d’abord sur votre machine en polling. Ensuite, vous ajoutez des commandes, un état stocké, des réponses propulsées par un LLM et, pour finir, vous le faites tourner 24 h/24 sur un serveur.

Ce guide suit Telegram de bout en bout, puis montre comment adapter le même bot pour Discord. Chaque étape s’accompagne d’un prompt à coller dans l’agent.

Ce que nous construisons

Le bot d’exemple va :

Répondre à /start et /help.
Enregistrer des notes avec /note <text> et les lister avec /notes (état stocké).
Répondre aux messages simples avec un LLM, avec une limite quotidienne par utilisateur.
Optionnellement, ne parler qu’aux utilisateurs que vous autorisez.
Tourner en continu sur un serveur avec systemd ou Docker.

C’est un bon premier projet de vibe coding : petit, avec un résultat visible tout de suite sur votre téléphone, et réellement utile.

Choisir la stack : Python ou TypeScript ?

Deux bonnes options :

Python + python-telegram-bot : mature, bien documenté et asynchrone. Le choix naturel si votre code d’IA, de données ou d’automatisation est en Python.
TypeScript + grammY : moderne, typé et léger, à l’aise avec les webhooks sur les plateformes serverless. Choisissez-le si vous vivez déjà dans Node.js.

J’utilise Python ici ; remplacez le nom de la bibliothèque dans les prompts et les mêmes étapes valent pour grammY.

Mise en place :

mkdir telegram-bot && cd telegram-bot
git init
python3 -m venv .venv && source .venv/bin/activate
pip install python-telegram-bot python-dotenv anthropic
printf ".env\n.venv/\n*.db\n" >> .gitignore

J’utilise le SDK Anthropic comme exemple de LLM ; avec un autre fournisseur, changez le paquet, l’idée reste la même.

Étape 1 : obtenir un token et le mettre dans .env

Obtenez votre token via le processus officiel de création de bots de Telegram : vous créez un nouveau bot dans Telegram, choisissez un nom affiché et un nom d’utilisateur unique se terminant par « bot », et un long token vous est remis à la fin. Ce token est le mot de passe du bot ; quiconque le possède peut envoyer des messages en son nom.

Le fichier .env :

TELEGRAM_TOKEN=your-token
LLM_API_KEY=your-api-key
LLM_MODEL=the-model-you-use
ALLOWED_USER_IDS=123456789
DAILY_LLM_LIMIT=30

Ne collez ni le token ni la clé d’API dans le chat avec l’agent. Il n’a pas besoin des valeurs, seulement de savoir qu’elles viennent de .env. Si le token fuite un jour, révoquez-le dans le même processus officiel et obtenez-en un nouveau.

Étape 2 : le premier prompt

Ouvrez l’agent dans le dossier du projet et demandez le bot le plus simple qui fonctionne :

Set up a simple Telegram bot with python-telegram-bot (async, ApplicationBuilder).
- Read the token from .env with python-dotenv. Never open or print .env.
- Layout: bot.py (startup and handler registration), handlers.py (commands),
  storage.py (SQLite later), config.py.
- Add /start and /help; /help lists all commands.
- Reply politely to unknown commands.
- Use polling. Use Python logging; never log the token.
- Add an error handler: log the error and send the user a short apology.
When done, tell me how to run it.

Lancez-le :

python bot.py

Trouvez votre bot dans Telegram et envoyez /start. S’il répond, la première boucle est bouclée. Sinon, collez l’erreur du terminal telle quelle à l’agent ; c’est généralement une variable d’environnement qui n’a pas été lue.

Étape 3 : commandes et état stocké

La plupart des bots doivent se souvenir de choses : réglages utilisateur, notes, compteurs d’usage. Tout ce qui est gardé en mémoire disparaît au redémarrage du bot. Pour un petit bot, SQLite suffit largement, sans serveur de base de données à faire tourner.

Add SQLite to storage.py (data/bot.db).
- notes table: id, user_id, text, created_at.
- usage table: user_id, date, llm_count.
- /note <text> saves a note, /notes lists the user's last 10 notes,
  /delete <id> deletes a note only if it belongs to that user.
- All SQL must be parameterized (no string concatenation).
- Write pytest tests for the storage functions and run them.

Le « seulement si elle appartient à cet utilisateur » compte. Les agents sautent souvent ce genre de contrôle d’autorisation, et soudain n’importe qui tapant /delete 5 peut supprimer la note de quelqu’un d’autre.

python-telegram-bot propose aussi ses propres options de persistance comme PicklePersistence, utiles pour l’état des conversations (les formulaires en plusieurs étapes, par exemple). Pour les données utilisateur, je trouve SQLite plus transparent.

Étape 4 : des réponses intelligentes avec un LLM

Voici la partie qui en fait un bot IA : envoyer les messages simples à un LLM et renvoyer la réponse.

# llm.py
import os
from anthropic import AsyncAnthropic

client = AsyncAnthropic(api_key=os.getenv("LLM_API_KEY"))

async def reply(history: list[dict]) -> str:
    resp = await client.messages.create(
        model=os.getenv("LLM_MODEL"),
        max_tokens=500,
        system="You are a helpful Telegram assistant who answers briefly.",
        messages=history[-10:],  # only the last 10 messages
    )
    return resp.content[0].text

Un prompt pour l’agent :

Send plain text messages to reply() in llm.py.
- Keep the last 10 messages per user in memory (alternating user/assistant).
- /reset clears the conversation history.
- Enforce DAILY_LLM_LIMIT per user per day (usage table); when it's reached,
  send a clear message.
- If ALLOWED_USER_IDS is not empty, only answer those users.
- Send the "typing..." action while the LLM call runs.
- Split replies longer than Telegram's message length limit.
- On API errors, send the user a short message and log the error.

Pourquoi ces limites ? Un bot LLM public que quelqu’un découvre et inonde de messages fera gonfler votre facture. Une limite quotidienne, une liste blanche et un historique court sont les trois moyens les plus simples de maîtriser le coût. Plus l’historique est long, plus vous envoyez de tokens à chaque requête.

Étape 5 : polling ou webhook ?

Un bot peut recevoir les messages de Telegram de deux façons :

Polling (long polling) : le bot demande en boucle à Telegram « du nouveau ? ». Aucune configuration : pas d’adresse HTTPS, de domaine ni de port ouvert. Idéal pour le développement et pour les bots petits à moyens sur un seul serveur.
Webhook : Telegram pousse chaque nouvelle mise à jour vers une adresse HTTPS que vous fournissez. Rien n’attend dans le vide, et sur les plateformes serverless (fonctions exécutées à chaque requête) c’est la seule option. En contrepartie, il faut un endpoint HTTPS valide, et vous devez vérifier que les requêtes viennent bien de Telegram avec un chemin secret ou un token secret.

Ma règle : commencez par le polling et passez à un webhook quand vous en avez réellement besoin. Vous ne pouvez pas utiliser les deux en même temps pour le même token ; le polling ne fonctionne pas tant qu’un webhook est défini.

Étape 6 : le faire tourner 24 h/24 sur un serveur

Quand votre portable s’éteint, le bot se tait. Un petit VPS Linux suffit, et avec le polling vous n’avez même pas besoin d’un domaine.

systemd

# /etc/systemd/system/telegram-bot.service
[Unit]
Description=Telegram bot
After=network-online.target

[Service]
User=bot
WorkingDirectory=/home/bot/telegram-bot
EnvironmentFile=/home/bot/telegram-bot/.env
ExecStart=/home/bot/telegram-bot/.venv/bin/python bot.py
Restart=on-failure
RestartSec=10

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now telegram-bot
journalctl -u telegram-bot -f

Docker

Demandez à l’agent d’écrire un Dockerfile et un docker-compose.yml avec restart: unless-stopped, env_file: .env et un volume pour data/. Oubliez le volume et votre base SQLite est effacée à chaque recréation du conteneur.

Ne lancez pas le même bot en polling à deux endroits (par exemple votre portable et le serveur) ; Telegram le refuse avec une erreur de conflit. Utilisez un bot de test séparé, avec son propre token, pour le développement.

Étape 7 : l’adapter à Discord

Les bots Discord sont proches dans leur principe, avec quelques différences importantes :

Token et application : vous créez une application dans le portail développeur de Discord, y ajoutez un bot et y prenez le token. Vous ajoutez le bot à votre serveur avec un lien d’invitation qui demande le moins de permissions possible.
Intents : pour lire le contenu des messages, vous devez activer l’intent de contenu des messages à la fois dans le portail et dans le code. Si votre bot ne voit pas les messages, c’est presque toujours la raison.
Modèle de connexion : les bots Discord gardent une connexion WebSocket persistante avec la gateway, le bot doit donc être un processus de longue durée ; il ne fonctionnera pas comme fonction serverless.
Commandes : les commandes slash sont la méthode moderne, et elles doivent être enregistrées auprès de Discord.
Bibliothèques : discord.py pour Python, discord.js pour Node.js.

L’approche la plus propre consiste à séparer la logique du bot de la plateforme. Un prompt :

Separate the bot logic from the platform:
- core/ holds platform-independent functions: handle_note, list_notes,
  ask_llm. They take user_id and text and return text.
- Rewrite telegram_bot.py so its handlers call core/.
- discord_bot.py: /note, /notes and /ask slash commands with discord.py,
  all calling core/. DISCORD_TOKEN comes from .env.
- Add a platform column in storage so Discord and Telegram user ids don't mix.
- Keep existing tests passing; extend the tests for core.

Les deux bots partagent désormais la même base de données et la même logique LLM, et chacun ne s’occupe que des détails de sa propre plateforme.

Erreurs courantes : ce que l’IA a tendance à rater

Écrire pour une ancienne API. python-telegram-bot est passé à l’asynchrone avec la version 20, et les agents mélangent parfois d’anciens exemples synchrones. En cas d’erreurs, demandez à l’agent de vérifier la version installée (pip show python-telegram-bot) et de corriger le code d’après la documentation de cette version.
Coder le token en dur. L’agent peut vouloir mettre le token dans bot.py « juste pour tester vite ». Refusez.
Contrôles d’autorisation manquants. Les commandes d’administration finissent ouvertes à tous, ou les utilisateurs accèdent aux données les uns des autres.
Code bloquant. Un time.sleep ou un appel HTTP synchrone dans un handler asynchrone fige tout le bot.
Erreurs avalées. Sans gestionnaire d’erreurs, le bot cesse de répondre en silence.
État en mémoire. Tout est réinitialisé au redémarrage.
Ne pas découper les longs messages. Quand le LLM écrit une longue réponse, Telegram rejette le message.

Sécurité

Les tokens et clés d’API ne vivent que dans .env, et .env est dans .gitignore.
Ne collez jamais de clés dans un chat, une capture d’écran ou un rapport de bug.
Lisez les commandes que l’agent veut exécuter avant de les approuver, surtout celles qui lisent .env ou envoient des données à l’extérieur.
Quand vous transmettez le texte d’un utilisateur à un LLM, partez du principe qu’il peut tenter de contourner vos instructions (injection de prompt). Ne donnez pas au bot de capacités dangereuses comme exécuter des commandes ou supprimer des fichiers.
Informez vos utilisateurs que vous stockez leurs données et les envoyez à un fournisseur de LLM.
N’exécutez pas le bot en root sur le serveur ; faites un chmod 600 sur le fichier d’environnement.

Le faire avec AgentVera

Ce projet se découpe naturellement en deux tâches parallèles : un agent écrit le côté Telegram, un autre le côté Discord. Dans AgentVera, vous pouvez exécuter Claude Code dans un worktree et Codex dans un autre, dans la même grille. Après chaque tour, la revue de code automatique fait examiner par un second modèle les points faciles à manquer, comme les contrôles d’autorisation. Vous relisez les changements dans le panneau Git avant de fusionner et suivez la consommation de tokens des agents pendant que vous construisez la fonction LLM. Au moment du serveur, SSH et SFTP transfère les fichiers, et le gestionnaire Docker affiche en local les logs du conteneur.

Rien de tout cela n’est obligatoire ; un terminal et git suffisent aussi à terminer ce bot. Si vous cherchez une mission pour votre bot, les alertes Telegram de créer un bot de trading crypto avec l’IA en sont un bon exemple.

Pour conclure

Créer un bot Telegram avec l’IA est l’une des façons les plus agréables de se lancer dans le vibe coding. Obtenez le token via le processus officiel et gardez-le dans .env, demandez à l’agent d’écrire d’abord le bot le plus simple, puis ajoutez couche par couche les commandes, l’état SQLite et les réponses LLM. Commencez par le polling, faites-le tourner sur un serveur avec systemd ou Docker, et séparez la logique de la plateforme pour que Discord soit une étape facile. Lisez vous-même les contrôles d’autorisation que l’agent écrit et les commandes qu’il exécute ; l’agent peut s’occuper du reste.