Synthia — Building an AI Telegram agent with Python and Claude. Part 1: FastAPI Telegram integration

Step-by-step guide from zero to a Claude-powered AI Agent

Welcome! This will be a series of articles, where we’ll build a general-purpose Telegram AI agent in Python, using Claude. The agent will be able to perform various tasks, such as publishing a research doc on a given topic, checking your calendar for today, or answering questions about the health of running services.

This will be a series of articles:

• Part 1 (this one): FastAPI Telegram integration
• Part 2: Adding the Claude agent
• Part 3: Adding skills and memories

For the curious, here’s the stack and technologies we’ll use:

• Python
• FastAPI
• mem0
• MCPs (playwright, mem0)

All code is available on GitHub. The code snippets below may be incomplete — I’ll only include the deltas as we progress. For the complete code, refer to the repository. Let’s kick this off, shall we?

Prerequisites

• Python 3.13
• uv (up to you, if you’d like to manage dependencies differently)
• Telegram account

Let’s do it

FastAPI app

Let’s initialize an empty project. We’ll call it Synthia.

uv init

Initialized project `synthia`

and add a few libraries we’ll need:

uv add "fastapi[standard]" python-telegram-bot python-dotenv loguru

Resolved 42 packages in 1.32s
Prepared 10 packages in 591ms
Installed 40 packages in 51ms
....

Also, some dev tools:

uv add ruff ty pytest-testmon pre-commit --group dev

Let’s make a dummy FastAPI application in synthia/main.py:

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
async def root():
    return {"status": "OK"}

and add a Makefile to simplify starting it:

dev:
 uv run uvicorn synthia.main:app --host 0.0.0.0 --port 8001 --reload

start:
 uv run uvicorn synthia.main:app --host 0.0.0.0 --port 8001

test:
 uv run pytest tests/ --testmon

lint:
 uv run ruff check . --fix --unsafe-fixes

check: format type lint

format:
 uv run ruff format .

type:
 uv run ty check .

Let’s also add some reasonable defaults in pyproject.toml

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[tool.hatch.build.targets.wheel]
packages = ["synthia"]

[tool.ruff]
target-version = "py313"
line-length = 120

Now, run make dev in one terminal and test the connection to the server:

curl http://localhost:8001

{"status":"OK"}

Let’s be good citizens, and also add a test in tests/test_e2e.py .

import pytest
from fastapi.testclient import TestClient

from synthia.main import app


def test_smoke():
    client = TestClient(app)
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"status": "OK"}

Sweet, we’re done with the FastAPI part. Let’s set up Telegram integration.

Telegram integration

Setting up a Telegram bot is explained in detail in the official docs, but since it’s really easy, I’ll include the steps here.

First, we need to get our own Telegram bot token. Open a chat with BotFather, enter /newbot, and provide a name and a username.

You’ll get an API token in return. Let’s put it in a .envfile and add it to .gitignore to prevent committing.

echo "TELEGRAM_BOT_TOKEN=<YOUR_BOT_TOKEN>" > .env
echo "\n.env" >> .gitignore

Now we need the ID of the Telegram Chat with the bot, so we can talk to it. Search for your bot in the app and start a chat with it. Now, you can get the chat ID via the Telegram API.

curl https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates

{
  "ok": true,
  "result": [
    {
      "update_id": 269387972,
      "message": {
        "message_id": 1,
        ...
        "chat": {
          "id": <CHAT_ID>
          ....
        },
        ...
      }
    }
}

Add the chat ID to .env as TELEGRAM_CHAT_ID . Now, we’re ready to have Syntia talk to Telegram. Let’s add telegram.py , a client for all Telegram interactions:

from telegram import Bot
from loguru import logger

class Telegram:
    def __init__(self, token: str, chat_id: str):
        self.chat_id = chat_id
        self.bot = Bot(token=token)

    async def start(self):
        try:
            await self.send_message(message="Synthia connected 👋")
        except Exception as _e:
            logger.error(f"Telegram application failed to start: {_e}")

    async def send_message(self, message: str):
        await self.bot.send_message(chat_id=self.chat_id, text=message)

and wire it up in main.py

async def lifespan(app: FastAPI):
    telegram = Telegram(token=os.environ["TELEGRAM_BOT_TOKEN"], chat_id=os.environ["TELEGRAM_CHAT_ID"])
    await telegram.start()
    yield

app = FastAPI(title="Synthia", lifespan=lifespan)

load_dotenv()

When the application restarts, you should see this in your Telegram chat:

Let’s now add a message handler that will allow Synthia to receive messages. We’ll also implement a poor man’s authentication (⚠️ this is not production grade!), allowing Synthia to receive only our message. For now, just responding with the same message.

class Telegram:
    def __init__(self, token: str, chat_id: str):
        ...
        self.application = Application.builder().token(token).build()
        self.application.add_handler(MessageHandler(callback=self._on_message, filters=filters.TEXT))

    async def start(self):
        try:
            await self.application.initialize()
            await self.application.start()
            await self.application.updater.start_polling()
            await self.send_message(message="Synthia connected 👋")
        except Exception as _e:
            logger.error(f"Telegram application failed to start: {_e}")

    async def send_message(self, message: str):
        await self.bot.send_message(chat_id=self.chat_id, text=message)

    async def _on_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        if update.message.from_user.id != int(self.chat_id):
            return
        message = update.message.text
        await self.send_message(message=f"Right back at you: {message}")

Summary

This is it for Part 1. We now have a working Telegram Bot with two-way communication. All code for this part is available on GitHub, under ‘part-1’ tag. In Part 2, we’ll add Claude integration 🤖

Building an AI Telegram agent. Part 1: FastAPI Telegram integration was originally published in Dan On Coding on Medium, where people are continuing the conversation by highlighting and responding to this story.