# Telegram

Quickly build and deploy AI-powered bots on Telegram using Polylith’s ready-to-use templates. Automate tasks, respond to messages, and integrate with AI models seamlessly.

Polylith provides pre-built templates to create **AI-powered Telegram bots** for tasks like chat automation, content generation, and workflow execution. Using Polylith’s modular Input, Processing, and Output blocks, you can integrate AI providers like **OpenAI**, **Claude**, or **Gemini** into Telegram in minutes.

***

**Step 1: Installation and Setup**

Install Polylith and the Telegram Bot API library:

Copy

Copy

```
bashCopy code# Install Polylith
pip install polylith

# Install Telegram API wrapper (python-telegram-bot)
pip install python-telegram-bot --upgrade

# Install AI provider SDKs (e.g., OpenAI)
pip install openai
```

***

**Step 2: Set Up Your Telegram Bot**

1. Open Telegram and search for the **BotFather**.
2. Send `/newbot` to create a new bot.
3. Copy the **bot token** provided by BotFather.
4. Save the bot token for use in your script.

***

**Step 3: Full Telegram AI Agent Code**

Here’s the **complete code** for a Telegram bot that listens to messages, processes them using OpenAI’s GPT-4, and replies to the chat:

Copy

Copy

```
pythonCopy codefrom telegram import Update
from telegram.ext import ApplicationBuilder, CommandHandler, MessageHandler, ContextTypes, filters
from polylith import InputBlock, ProcessingBlock, OutputBlock

# Your Telegram Bot Token
TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"

# Initialize Polylith Workflow
class TelegramAgent:
    def __init__(self):
        # Input Block: Accepts user messages
        self.input_block = InputBlock("telegram")

        # Processing Block: Sends user input to OpenAI GPT-4
        self.processing_block = ProcessingBlock("openai", model="gpt-4", api_key="YOUR_OPENAI_API_KEY")

        # Output Block: Sends the response back to the Telegram chat
        self.output_block = OutputBlock("telegram")

    async def process_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE):
        user_message = update.message.text
        print(f"User Message: {user_message}")

        # Input: Capture user message
        self.input_block.data = {"prompt": user_message}

        # Process: Use GPT-4 to generate response
        response = self.processing_block.process()

        # Output: Send response back to Telegram
        await update.message.reply_text(response)

# Bot Handlers
async def start_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text("Hello! I’m your AI-powered assistant. Send me a message to get started. 🚀")

def main():
    app = ApplicationBuilder().token(TELEGRAM_BOT_TOKEN).build()

    # Initialize Telegram Agent
    agent = TelegramAgent()

    # Command Handlers
    app.add_handler(CommandHandler("start", start_command))

    # Message Handlers: Process all text messages
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, agent.process_message))

    # Run the bot
    print("Telegram bot is running...")
    app.run_polling()

if __name__ == "__main__":
    main()
```

***

**Step 4: Explanation of Code**

1. **Input Block** Captures the user’s message from the Telegram chat.
2. **Processing Block** Sends the input to OpenAI’s GPT-4 (or any other AI provider) to generate a response.
3. **Output Block** Sends the AI-generated reply back to the user in the same chat.
4. **Handlers**
   * `/start` Command: Initializes the bot and provides instructions.
   * Message Handler: Processes all incoming messages and runs the Polylith workflow.

***

**Step 5: Run the Bot**

Save the code as `telegram_ai_agent.py` and run it:

Copy

Copy

```
bashCopy codepython telegram_ai_agent.py
```

In your Telegram chat, type `/start` or any message, and your AI agent will respond.

***

**Extending the Template**

Here’s how you can extend the Telegram bot for more advanced use cases:

1. **Command-Based Tasks** Add specific commands for functionality like `/summarize` or `/search`:

Copy

Copy

```
pythonCopy codeasync def summarize_command(update: Update, context: ContextTypes.DEFAULT_TYPE):
    text_to_summarize = " ".join(context.args)
    agent.input_block.data = {"prompt": f"Summarize this: {text_to_summarize}"}
    response = agent.processing_block.process()
    await update.message.reply_text(response)
```

1. **Contextual Agents** Store previous conversations in a vector store like Pinecone to provide contextual replies:

Copy

Copy

```
pythonCopy codefrom polylith import ProcessingBlock

vector_block = ProcessingBlock("pinecone", api_key="YOUR_PINECONE_API_KEY", index_name="chat_history")
self.processing_block >> vector_block
```

1. **Automated Notifications** Schedule messages or reminders for groups using custom logic:

Copy

Copy

```
pythonCopy codeawait context.bot.send_message(chat_id=update.effective_chat.id, text="This is a scheduled update!", schedule="daily 10:00 AM")
```

***

**Use Cases for Telegram Templates**

* **AI-Powered Assistants**: Build chatbots for customer support, FAQs, or productivity tools.
* **Content Summarization**: Allow users to summarize documents or articles by simply pasting the text.
* **Task Automation**: Automate group notifications, reminders, and updates.
* **Real-Time Q\&A**: Provide real-time answers to questions using advanced AI models.

***

**Conclusion**

Polylith’s Telegram templates offer a robust, modular foundation for building AI-powered bots. Whether you need to automate tasks, create interactive assistants, or integrate powerful AI workflows, Polylith makes it easy to deploy scalable bots on Telegram.
