# Telegram-Bot mit KI bauen: Schritt-für-Schritt-Anleitung URL: https://agentvera.dev/de/blog/build-telegram-bot-with-ai/ · Veröffentlicht: 2026-10-11 Telegram-Bot mit KI bauen: Token holen, Polling oder Webhook wählen, Zustand speichern, LLM-Antworten ergänzen, auf einem Server hosten und für Discord anpassen. **Kurz gesagt:** - Nimm python-telegram-bot oder grammY für TypeScript, halte den Bot-Token nur in .env und starte mit Polling, das keine HTTPS-Adresse braucht; Webhooks brauchen HTTPS und sind bei Serverless die einzige Option. - Speichere den Zustand in SQLite mit Besitzprüfungen und begrenze die LLM-Kosten mit einem Tageslimit pro Nutzer, einer Allowlist von Nutzer-IDs und kurzem Nachrichtenverlauf. - Betreibe den Bot rund um die Uhr auf einem VPS mit systemd oder Docker; ein Discord-Bot braucht eine dauerhafte Gateway-Verbindung, halte die Logik daher in einem plattformunabhängigen Kernmodul. 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 ` 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](/de/glossary/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: ```bash 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: ```bash 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: ```text 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: ```bash 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. ```text Add SQLite to storage.py (data/bot.db). - notes table: id, user_id, text, created_at. - usage table: user_id, date, llm_count. - /note saves a note, /notes lists the user's last 10 notes, /delete 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. ```python # 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: ```text 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](/de/glossary/token/) 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 ```ini # /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 ``` ```bash 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: ```text 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](/de/features/workspace/) 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](/de/features/code-review/) ein zweites Modell auf leicht übersehene Stellen wie Autorisierungsprüfungen schauen. Du prüfst die Änderungen im [Git-Panel](/de/features/git-and-github/) vor dem Merge und siehst die [Token-Nutzung](/de/features/token-savings/) der Agenten, während du die LLM-Funktion baust. Wenn der Server dran ist, überträgt [SSH und SFTP](/de/features/ssh-and-sftp/) die Dateien, und der [Docker-Manager](/de/features/docker/) 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](/de/blog/build-crypto-trading-bot-with-ai/) 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. ## Häufige Fragen **Muss ich programmieren können, um mit KI einen Telegram-Bot zu bauen?** Sehr wenig. Ein Coding-Agent kann den ganzen Bot schreiben; deine Aufgabe ist es, klare Prompts zu geben, den Bot mit deinem eigenen Konto auszuprobieren und die Befehle zu lesen, die der Agent ausführt. Grundkenntnisse im Terminal und zu .env-Dateien genügen. **Woher bekomme ich einen Telegram-Bot-Token?** Aus dem offiziellen Bot-Erstellungsablauf von Telegram: Du legst in Telegram einen neuen Bot an, vergibst Namen und Benutzernamen und bekommst am Ende einen Token angezeigt. Bewahre diesen Token nur in deiner .env-Datei auf. **Sollte ein Telegram-Bot Polling oder einen Webhook nutzen?** Polling ist für die Entwicklung und kleine Bots einfacher, weil keine öffentliche HTTPS-Adresse nötig ist. Webhooks sind bei viel genutzten Bots effizienter und auf Serverless-Plattformen Pflicht. **Wie baue ich KI-(LLM-)Antworten in einen Telegram-Bot ein?** Der Bot schickt die eingehende Nachricht an eine LLM-API und schreibt die Antwort zurück. Halte den API-Key in .env und nutze ein Tageslimit pro Nutzer und einen kurzen Gesprächsverlauf, um die Kosten im Griff zu behalten. **Kann ich denselben Bot auf Discord umziehen?** Den Großteil der Logik ja. Liegen Befehls- und Nachrichtenverarbeitung in einem Modul, das nichts von der Plattform weiß, ist die Discord-Seite nur eine dünne Schicht mit discord.py oder discord.js. --- **Über AgentVera.** AgentVera ist eine Desktop-App für macOS, Windows und Linux, entwickelt von Solviera Teknoloji. Sie führt 18 KI-Coding-Agenten (Claude Code, Codex, Gemini CLI, Copilot, Cursor, Antigravity, opencode, Hermes, Qwen Code, Kimi Code, Kiro, Amp, Droid, Goose, Vibe, Crush, Aider, Cline) nebeneinander aus, pro Projekt, in echten Terminals mit den eigenen CLI-Installationen und Logins des Nutzers. Der kostenlose Plan hat unbegrenzt viele Agenten. Download: https://agentvera.dev/de/download/ · Preise: https://agentvera.dev/de/pricing/