Mukul Saini

Posted on Dec 26

Building a Golang Telegram Bot for Personal AI Assistance

#go #tutorial #ai #openai

Creating a Telegram bot that integrates with an AI assistant is an exciting project that combines real-time messaging, AI processing, and Golang's powerful concurrency model. In this blog, I'll guide you through the architecture, features, and implementation of a Telegram bot using Golang, with a complete system design to boot!

Overview

This project builds a personal AI assistant accessible via two interfaces:

Telegram Bot: A real-time conversational interface.
Console Chat: A terminal-based chatbot for direct interaction.

Key Features:

AI model switching based on user input.
Persistent chat history across sessions.
Interactive bot responses with live editing.
Retry mechanism for robust API handling.

System Design

Architecture
The system comprises the following components:

Bot Interface: Handles incoming messages, processes user input, and sends responses.
Assistant Utilities: Contains AI model integration logic.
History Management: Manages conversation history for persistence.
Error Handling: Ensures graceful error recovery.

Flow Diagram

[User] <---> [Telegram API] <---> [Bot API Handler] <---> [AI Processing Logic]
                                  ^                      |
                                  |                      v
                            [History Management]  [Error Handler]

Components

Telegram Bot API: Utilized for real-time messaging and updates.
Golang’s Concurrency: To handle multiple user conversations seamlessly.
History Module: Saves chat history in local files for reloadable sessions.
Assistant Utilities: Processes user input and integrates AI logic.

Key Code Walkthrough

Main Application Entry The main() function provides users with two modes: Telegram Bot and Console Chat. This ensures the assistant is accessible both online and offline.

func main() {
    fmt.Println("Choose mode: [1] Telegram Bot, [2] Console Chat")
    var choice int
    fmt.Scan(&choice)
    switch choice {
        case 1:
            deploy.TelegramBot()
        case 2:
            runConsoleChat()
        default:
            fmt.Println("Invalid choice.")
    }
}

Telegram Bot Initialization The bot uses go-telegram-bot-api for interacting with Telegram.

func NewTelegramBot() {
    token := os.Getenv("TELEGRAM_BOT_TOKEN")
    bot, err := NewBot(token)
    if err != nil {
        log.Fatal("Failed to start bot:", err)
    }
    bot.Start(context.Background())
}

Handling User Messages

This method manages user interactions, including history loading and AI response handling.

func handleTelegramMessageNew(ctx context.Context, b *tgbotapi.BotAPI, client *Client, update tgbotapi.Update) {
    userMessage := update.Message.Text
    response, err := assistantutils.ProcessUserMessage(userMessage, client.ModelType, client.History, "", nil, true)
    if err != nil {
        log.Println("Error processing message:", err)
        b.Send(tgbotapi.NewMessage(update.Message.Chat.ID, "An error occurred. Please try again."))
    }
    b.Send(tgbotapi.NewMessage(update.Message.Chat.ID, response))
}

Persistent History Management Chat history is managed through file-based persistence for continuity between sessions.

func selectSession(files []string) string {
    if len(files) == 0 {
        return history.GenerateFileName("conversation")
    }
}

AI Processing Logic The bot integrates with an AI assistant, handling retries and partial responses.

func processUserMessageWithRetry(ctx context.Context, userMessage, modelType string, hist *history.History, identifier string, sendChunk func(chunk string, isFinal bool)) (string, error) {
    for i := 0; i < 3; i++ {
        response, err := assistantutils.ProcessUserMessage(userMessage, modelType, hist, identifier, sendChunk, true)
        if err == nil {
            return response, nil
        }
        time.Sleep(time.Second * (i + 1))
    }
    return "", fmt.Errorf("failed to process message after retries")
}

Want a demo ?