# Telegram

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

Aivara provides pre-built templates to create **AI-powered Telegram bots** for tasks like chat automation, content generation, and workflow execution. Using Aivara’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 Aivara and the Telegram Bot API library:

Copy

Copy

Copy

```
bashCopy code# Install Aivara
pip install aivara

# 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

Copy

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

# Your Telegram Bot Token
TELEGRAM_BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"

# Initialize Aivara 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 Aivara workflow.

***

**Step 5: Run the Bot**

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

Copy

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

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

Copy

```
pythonCopy codefrom aivara 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

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**

Aivara’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, Aivara makes it easy to deploy scalable bots on Telegram.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://aivara.gitbook.io/docs/templates/telegram.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.