Telegram-Bot mit KI bauen: Schritt-für-Schritt-Anleitung

Um einen Telegram-Bot mit KI zu bauen, lässt du einen Coding-Agenten (Claude Code, Codex oder ähnlich) einen Bot mit python-telegram-bot schreiben, legst den Token in eine .env-Datei und startest ihn zunächst per Polling auf deinem eigenen Rechner. Danach ergänzt du Befehle, gespeicherten Zustand und LLM-Antworten und lässt ihn schließlich rund um die Uhr auf einem Server laufen.

Diese Anleitung folgt Telegram von Anfang bis Ende und zeigt dann, wie du denselben Bot für Discord anpasst. Zu jedem Schritt gibt es einen Prompt, den du in den Agenten einfügen kannst.

Was wir bauen

Der Beispiel-Bot soll:

• /start und /help beantworten.
• Notizen mit /note <text> speichern und mit /notes auflisten (gespeicherter Zustand).
• Auf normale Nachrichten mit einem LLM antworten, mit Tageslimit pro Nutzer.
• Optional nur mit Nutzern sprechen, die du zulässt.
• Dauerhaft auf einem Server mit systemd oder Docker laufen.

Das ist ein gutes erstes Vibe-Coding-Projekt: klein, du siehst das Ergebnis sofort auf dem Handy, und es ist tatsächlich nützlich.

Den Stack wählen: Python oder TypeScript?

Zwei gute Optionen:

• Python + python-telegram-bot: ausgereift, gut dokumentiert und asynchron. Die natürliche Wahl, wenn dein KI-, Daten- oder Automatisierungscode in Python liegt.
• TypeScript + grammY: modern, typisiert und leichtgewichtig, und mit Webhooks auf Serverless-Plattformen gut nutzbar. Nimm diesen Weg, wenn du ohnehin in Node.js zu Hause bist.

Ich nehme hier Python; tausch in den Prompts den Bibliotheksnamen aus, dann funktionieren dieselben Schritte mit grammY.

Einrichtung:

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

Als LLM-Beispiel nutze ich das Anthropic SDK; bei einem anderen Anbieter tauschst du das Paket aus, die Idee bleibt gleich.

Schritt 1: Token holen und in .env ablegen

Den Token bekommst du über den offiziellen Bot-Erstellungsablauf von Telegram: Du legst in Telegram einen neuen Bot an, wählst einen Anzeigenamen und einen eindeutigen Benutzernamen, der auf „bot“ endet, und bekommst am Ende einen langen Token. Dieser Token ist das Passwort des Bots; wer ihn hat, kann Nachrichten als dein Bot senden.

Die .env-Datei:

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

Füge Token oder API-Key nicht in den Chat mit dem Agenten ein. Er braucht die Werte nicht, nur die Information, dass sie aus .env kommen. Sollte der Token je durchsickern, widerrufe ihn im selben offiziellen Ablauf und hole dir einen neuen.

Schritt 2: der erste Prompt

Öffne den Agenten im Projektordner und bitte um den einfachsten funktionierenden Bot:

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.

Starte ihn:

python bot.py

Such deinen Bot in Telegram und sende /start. Antwortet er, ist die erste Runde geschafft. Wenn nicht, gib den Terminalfehler unverändert an den Agenten weiter; meist wurde eine Umgebungsvariable nicht gelesen.

Schritt 3: Befehle und gespeicherter Zustand

Die meisten Bots müssen sich Dinge merken: Nutzereinstellungen, Notizen, Nutzungszähler. Alles, was nur im Speicher liegt, verschwindet beim Neustart des Bots. Für einen kleinen Bot reicht SQLite völlig, ohne einen Datenbankserver zu betreiben.

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.

„Only if it belongs to that user“ ist wichtig. Agenten lassen solche Autorisierungsprüfungen oft aus, und plötzlich kann jeder, der /delete 5 tippt, die Notiz eines anderen löschen.

python-telegram-bot bringt außerdem eigene Persistenz-Optionen wie PicklePersistence mit, die bei Gesprächszuständen helfen (zum Beispiel mehrstufige Formulare). Für Nutzerdaten finde ich SQLite transparenter.

Schritt 4: schlaue Antworten mit einem LLM

Jetzt der Teil, der aus dem Bot einen KI-Bot macht: normale Nachrichten an ein LLM schicken und die Antwort zurückschreiben.

# 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

Ein Prompt für den Agenten:

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.

Warum die Limits? Ein öffentlicher LLM-Bot, den jemand entdeckt und mit Nachrichten flutet, treibt deine Rechnung hoch. Tageslimit, Allowlist und kurzer Verlauf sind die drei einfachsten Wege, die Kosten im Griff zu behalten. Je länger der Verlauf, desto mehr Tokens schickst du mit jeder Anfrage mit.

Schritt 5: Polling oder Webhook?

Ein Bot kann Nachrichten auf zwei Arten von Telegram empfangen:

• Polling (Long Polling): Der Bot fragt Telegram laufend „gibt es etwas Neues?“. Kein Setup: keine HTTPS-Adresse, keine Domain, kein offener Port. Ideal für die Entwicklung und für kleine bis mittlere Bots auf einem einzelnen Server.
• Webhook: Telegram schickt jedes neue Update an eine HTTPS-Adresse, die du angibst. Nichts wartet im Leerlauf, und auf Serverless-Plattformen (Funktionen, die pro Anfrage laufen) ist es die einzige Option. Dafür brauchst du einen gültigen HTTPS-Endpunkt und solltest per geheimem Pfad oder Secret Token prüfen, dass Anfragen wirklich von Telegram kommen.

Meine Regel: mit Polling anfangen und erst auf einen Webhook wechseln, wenn du ihn wirklich brauchst. Beides gleichzeitig für denselben Token geht nicht; Polling funktioniert nicht, solange ein Webhook gesetzt ist.

Schritt 6: rund um die Uhr auf einem Server

Wenn dein Laptop herunterfährt, wird der Bot stumm. Ein kleiner Linux-VPS reicht, und mit Polling brauchst du nicht einmal eine Domain.

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

Lass den Agenten ein Dockerfile und eine docker-compose.yml mit restart: unless-stopped, env_file: .env und einem Volume für data/ schreiben. Vergisst du das Volume, wird deine SQLite-Datenbank bei jeder Neuerstellung des Containers gelöscht.

Betreibe denselben Bot nicht mit Polling an zwei Orten (etwa auf dem Laptop und dem Server); Telegram lehnt das mit einem Konfliktfehler ab. Nutze für die Entwicklung einen separaten Test-Bot mit eigenem Token.

Schritt 7: Anpassung an Discord

Discord-Bots sind konzeptionell ähnlich, mit ein paar wichtigen Unterschieden:

• Token und Application: Du legst im Developer-Portal von Discord eine Application an, fügst ihr einen Bot hinzu und nimmst den Token von dort. Den Bot fügst du mit einem Einladungslink zu deinem Server hinzu, der nur die minimal nötigen Berechtigungen anfordert.
• Intents: Um Nachrichteninhalte zu lesen, musst du den Message-Content-Intent im Portal und im Code aktivieren. Sieht dein Bot keine Nachrichten, liegt es fast immer daran.
• Verbindungsmodell: Discord-Bots halten eine dauerhafte WebSocket-Verbindung zum Gateway, der Bot muss also ein lang laufender Prozess sein; als Serverless-Funktion funktioniert er nicht.
• Befehle: Slash-Commands sind der moderne Weg, und sie müssen bei Discord registriert werden.
• Bibliotheken: discord.py für Python, discord.js für Node.js.

Am saubersten trennst du die Logik des Bots von der Plattform. Ein 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.

Beide Bots teilen sich nun dieselbe Datenbank und LLM-Logik, und jeder kümmert sich nur um die Eigenheiten seiner Plattform.

Häufige Fehler: wo die KI danebenliegt

• Gegen eine alte API schreiben. python-telegram-bot ist in Version 20 auf async umgestiegen, und Agenten mischen manchmal alte synchrone Beispiele ein. Bei Fehlern lass den Agenten die installierte Version prüfen (pip show python-telegram-bot) und den Code anhand der Doku dieser Version korrigieren.
• Den Token fest im Code verdrahten. Der Agent will den Token vielleicht „nur zum schnellen Testen“ in bot.py schreiben. Sag nein.
• Fehlende Autorisierungsprüfungen. Admin-Befehle stehen allen offen, oder Nutzer kommen an die Daten anderer.
• Blockierender Code. time.sleep oder ein synchroner HTTP-Aufruf in einem async-Handler friert den ganzen Bot ein.
• Verschluckte Fehler. Ohne Error-Handler hört der Bot einfach still auf zu antworten.
• Zustand im Speicher. Bei jedem Neustart ist alles weg.
• Lange Nachrichten nicht aufteilen. Schreibt das LLM eine lange Antwort, lehnt Telegram die Nachricht ab.

Sicherheit

• Tokens und API-Keys liegen nur in .env, und .env steht in .gitignore.
• Füge Keys nie in einen Chat, einen Screenshot oder einen Bugreport ein.
• Lies die Befehle, die der Agent ausführen will, bevor du sie freigibst, besonders alles, was .env liest oder Daten nach außen sendet.
• Wenn du Nutzertext an ein LLM weiterreichst, geh davon aus, dass er versuchen könnte, deine Anweisungen zu überschreiben (Prompt Injection). Gib dem Bot keine gefährlichen Fähigkeiten wie Befehle ausführen oder Dateien löschen.
• Sag deinen Nutzern, dass du ihre Daten speicherst und an einen LLM-Anbieter sendest.
• Betreibe den Bot auf dem Server nicht als root; setze chmod 600 auf die Env-Datei.

Mit AgentVera umsetzen

Dieses Projekt teilt sich natürlich in zwei parallele Aufgaben: Ein Agent schreibt die Telegram-Seite, ein anderer die Discord-Seite. In AgentVera kannst du Claude Code in einem Worktree und Codex in einem anderen laufen lassen, im selben Raster. Nach jedem Turn lässt das automatische Code-Review ein zweites Modell auf leicht übersehene Stellen wie Autorisierungsprüfungen schauen. Du prüfst die Änderungen im Git-Panel vor dem Merge und siehst die Token-Nutzung der Agenten, während du die LLM-Funktion baust. Wenn der Server dran ist, überträgt SSH und SFTP die Dateien, und der Docker-Manager zeigt die Logs des Containers lokal an.

Nichts davon ist Pflicht; mit Terminal und Git wird dieser Bot auch fertig. Wenn du eine Aufgabe für deinen Bot suchst, sind die Telegram-Alerts in Krypto-Trading-Bot mit KI bauen ein gutes Beispiel.

Fazit

Einen Telegram-Bot mit KI zu bauen ist einer der angenehmsten Einstiege ins Vibe Coding. Hol den Token über den offiziellen Ablauf und halte ihn in .env, lass den Agenten zuerst den einfachsten Bot schreiben und ergänze dann Schicht für Schicht Befehle, SQLite-Zustand und LLM-Antworten. Starte mit Polling, betreibe ihn mit systemd oder Docker auf einem Server und halte die Logik getrennt von der Plattform, damit Discord ein leichter Schritt wird. Lies die Autorisierungsprüfungen des Agenten und die Befehle, die er ausführt, selbst; den Rest kann der Agent übernehmen.