Build Your Own AI Chatbot with OpenAI and Telegram Using Pyrogram in Python

 

Creating an AI chatbot by integrating OpenAI's language models with Telegram using the Pyrogram library in Python can significantly enhance user interaction. Here is a comprehensive guide to building this chatbot:

Introduction

Artificial Intelligence has become an essential part of our daily lives, with chatbots playing a crucial role in customer support, virtual assistance, and more. This guide aims to help you create a Telegram chatbot that uses OpenAI's GPT-3.5 language model to provide human-like responses.

Step 1: Setting Up Your Environment

Create a Virtual Environment

To begin, create a virtual environment to manage your project dependencies. This ensures that the libraries you install are isolated from other projects.

python -m venv chatbot_env

source chatbot_env/bin/activate   On Windows use chatbot_env\Scripts\activate

Install Required Libraries

Install the necessary Python libraries:

pip install pyrogram openai

Step 2: Creating a Telegram Bot

1. Use BotFather on Telegram: Search for `BotFather` on Telegram and follow the instructions to create a new bot. Once done, you will receive an API token, which is essential for configuring your bot.
2. Obtain API Token: This token is used to authenticate your bot with the Telegram API.

Step 3: Initializing Pyrogram

Pyrogram is a Python library for interacting with the Telegram API. Here’s how to set it up:

from pyrogram import Client

app = Client("my_bot", bot_token="YOUR_TELEGRAM_BOT_API_TOKEN")

@app.on_message()

async def handle_message(client, message):

    user_input = message.text

    response = get_openai_response(user_input)

    await message.reply_text(response)

def get_openai_response(user_input):

     Placeholder for OpenAI API interaction

    pass

app.run()

Replace "YOUR_TELEGRAM_BOT_API_TOKEN" with the token from BotFather. The handle_message function processes incoming messages and generates responses using OpenAI’s API.

Step 4: Integrating OpenAI API

To generate intelligent responses, integrate the OpenAI API. First, obtain an API key from OpenAI by signing up on their website.

import openai

openai.api_key = "YOUR_OPENAI_API_KEY"

def get_openai_response(user_input):

    response = openai.Completion.create(

        engine="text-davinci-003",

        prompt=user_input,

        max_tokens=150

    )

    return response.choices[0].text.strip()

Replace "YOUR_OPENAI_API_KEY" with your actual key. The get_openai_response function sends user inputs to OpenAI and returns the generated response.

Step 5: Testing Your Bot

Run your script to start the bot:

python your_bot_script.py

Test the bot by sending messages to it on Telegram. Fine-tune your code based on the responses to improve interaction quality.

Detailed Steps with Code Structure

Step 1: Setup Your Project Structure

Create a project directory and set up the following structure:

├── bot.py

├── config.py

├── env

├── handlers

│   └── message_handler.py

└── requirements.txt

Step 2: Configuring Your Project

config.py

Store your API tokens and keys here.

class Config:

    API_ID = "YOUR_TELEGRAM_API_ID"

    API_HASH = "YOUR_TELEGRAM_API_HASH"

    BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"

    OPENAI_API_KEY = "YOUR_OPENAI_API_KEY"

bot.py

Initialize Pyrogram and the OpenAI API.

import pyrogram

from config import Config

from handlers.message_handler import MessageHandler

app = pyrogram.Client(

    session_name="my_bot",

    api_id=Config.API_ID,

    api_hash=Config.API_HASH,

    bot_token=Config.BOT_TOKEN

)

openai.api_key = Config.OPENAI_API_KEY

message_handler = MessageHandler(openai.api_key)

app.add_handler(pyrogram.handlers.MessageHandler(message_handler.handle, pyrogram.filters.private))

app.run()

handlers/message_handler.py

Handle incoming messages and generate responses using OpenAI.

import openai

class MessageHandler:

    def __init__(self, openai_api_key):

        self.openai_api_key = openai_api_key

    async def handle(self, client, message):

        if message.from_user.is_bot:

            return

        response = self.generate_response(message.text)

        await client.send_message(message.chat.id, response)

    def generate_response(self, input_text):

        openai.api_key = self.openai_api_key

        completions = openai.Completion.create(

            engine="davinci",

            prompt=input_text,

            max_tokens=60,

            n=1,

            stop=None,

            temperature=0.7

        )

        return completions.choices[0].text.strip()

Step 3: Running and Testing Your Bot

Start your bot by running bot.py. Test it on Telegram and refine your code based on user interactions.

Conclusion

By following these steps, you can create a robust AI chatbot that integrates OpenAI’s language models with Telegram using the Pyrogram library in Python. This guide provides a detailed approach to building and refining your chatbot, ensuring a smooth development process.