DEV Community: Mukul Saini

Building a Golang Telegram Bot for Personal AI Assistance

Mukul Saini — Thu, 26 Dec 2024 12:51:31 +0000

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 ?

Building a Golang Telegram Bot for Personal AI Assistance | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 26, 2024 ・
Medium

demo

Conclusion
With this bot, we leverage Golang's concurrency and efficient libraries to build a scalable and interactive AI assistant. The integration with Telegram API ensures a seamless real-time experience for users. Start building yours today and explore the power of AI-driven conversations!

Singleton Design Pattern in Java

Mukul Saini — Fri, 20 Dec 2024 16:04:49 +0000

The Singleton design pattern is one of the most widely recognized and used patterns in software engineering. It originated from the concept of ensuring that a class has only one instance, an idea inspired by real-world scenarios like government systems requiring a single registry or resource manager. The pattern was first formally described in the seminal book "Design Patterns: Elements of Reusable Object-Oriented Software" by the Gang of Four (Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides), laying the foundation for its widespread adoption in modern software development. It ensures that a class has only one instance while providing a global access point to that instance. This pattern is particularly useful for managing shared resources, such as database connections, logging mechanisms, and configuration settings.

Why Singleton?
The Singleton pattern is used in scenarios where:

Single Instance Requirement: A class must have exactly one instance, such as a configuration manager or logger.
Global Access: The instance needs to be globally accessible.
Resource Management: Shared resources like file systems, thread pools, or database connections benefit from controlled and centralized access.

Implementing Singleton in Java
There are several ways to implement the Singleton pattern in Java, each with its pros and cons. Below are some common approaches:

1. Eager Initialization
In this approach, the instance is created at the time of class loading. While simple and straightforward, it’s not ideal for cases where the instance might not be used, leading to wasted resources. For example, consider a Singleton managing a database connection pool in an application that may not always require database access during its lifecycle. Eager initialization would allocate resources unnecessarily in such scenarios, causing inefficiencies.

class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    private EagerSingleton() {}

    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

2. Lazy Initialization
Here, the instance is created only when it’s requested for the first time. This is efficient if the Singleton instance is not always needed. However, without thread safety, issues can arise when multiple threads access the getInstance method simultaneously, potentially leading to multiple instances being created, thus violating the Singleton principle.

class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {}

    public static LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

3. Thread-Safe Singleton
To make the Lazy Initialization thread-safe, we use the synchronized keyword. This ensures that only one thread can access the initialization code at a time, though it can introduce performance bottlenecks.

class ThreadSafeSingleton {
    private static ThreadSafeSingleton instance;

    private ThreadSafeSingleton() {}

    public static synchronized ThreadSafeSingleton getInstance() {
        if (instance == null) {
            instance = new ThreadSafeSingleton();
        }
        return instance;
    }
}

4. Bill Pugh Singleton
This approach uses a static inner helper class to leverage the Java class loading mechanism for thread-safe lazy initialization without synchronization overhead.

class BillPughSingleton {
    private BillPughSingleton() {}

    private static class SingletonHelper {
        private static final BillPughSingleton INSTANCE = new BillPughSingleton();
    }

    public static BillPughSingleton getInstance() {
        return SingletonHelper.INSTANCE;
    }
}

Challenges with Singleton

Serialization
Serialization can create new instances of a Singleton during deserialization. When a Singleton object is serialized and then deserialized, the default behavior of Java can result in the creation of a new instance, violating the Singleton principle. To prevent this, override the readResolve() method. This method ensures that during deserialization, the existing Singleton instance is returned instead of creating a new one.

class SerializedSingleton implements java.io.Serializable {
    private static final SerializedSingleton INSTANCE = new SerializedSingleton();

    private SerializedSingleton() {}

    public static SerializedSingleton getInstance() {
        return INSTANCE;
    }

    protected Object readResolve() {
        return INSTANCE;
    }
}

Cloning
Cloning can also break the Singleton pattern by creating a new instance. Override the clone() method to prevent this.

class CloneSafeSingleton implements Cloneable {
    private static final CloneSafeSingleton INSTANCE = new CloneSafeSingleton();

    private CloneSafeSingleton() {}

    public static CloneSafeSingleton getInstance() {
        return INSTANCE;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        throw new CloneNotSupportedException("Singleton, cannot be cloned");
    }
}

Reflection
Reflection can bypass private constructors and create new instances by directly invoking the constructor, even if it's private. This can lead to the creation of multiple instances, breaking the Singleton pattern. To address this risk, include a check in the constructor to see if an instance already exists, and throw an exception if it does. This effectively prevents reflection from compromising the Singleton by enforcing the one-instance constraint at the constructor level.

class ReflectionSafeSingleton {
    private static final ReflectionSafeSingleton INSTANCE = new ReflectionSafeSingleton();

    private ReflectionSafeSingleton() {
        if (INSTANCE != null) {
            throw new IllegalStateException("Instance already exists");
        }
    }

    public static ReflectionSafeSingleton getInstance() {
        return INSTANCE;
    }
}

😀🚀✨Real-World Examples

Database Connection Manager

To implement a Singleton for managing MySQL database connections, follow these steps:

Create the Singleton Class:
Define a DatabaseConnectionManager class with a private constructor to restrict instantiation.
Include a Static Instance:
Add a static variable to hold the single instance of the class.
Implement Thread-Safe Initialization:
Use the Bill Pugh Singleton or double-checked locking for thread safety.
Manage Database Connection Logic:
Include methods to initialize, fetch, and close the MySQL database connection.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class DatabaseConnectionManager {

    private static DatabaseConnectionManager instance;
    private Connection connection;
    private static final String URL = "jdbc:mysql://localhost:3306/yourDatabase";
    private static final String USER = "yourUsername";
    private static final String PASSWORD = "yourPassword";

    private DatabaseConnectionManager() {
        try {
            connection = DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (SQLException e) {
            e.printStackTrace();
            throw new RuntimeException("Failed to create the database connection.");
        }
    }

    public static DatabaseConnectionManager getInstance() {
        if (instance == null) {
            synchronized (DatabaseConnectionManager.class) {
                if (instance == null) {
                    instance = new DatabaseConnectionManager();
                }
            }
        }
        return instance;
    }

    public Connection getConnection() {
        return connection;
    }

    public void closeConnection() {
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

Usage Example:

public class Main {
    public static void main(String[] args) {
        DatabaseConnectionManager dbManager = DatabaseConnectionManager.getInstance();
        Connection connection = dbManager.getConnection();

        try {
            // Perform database operations
            System.out.println("Database connected successfully.");
        } finally {
            dbManager.closeConnection();
        }
    }
}

Logger
A Singleton Logger class ensures that all parts of the application write logs to the same instance.

class Logger {
    private static Logger instance;

    private Logger() {}

    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }

    public void log(String message) {
        System.out.println("Log: " + message);
    }
}

Conclusion
The Singleton design pattern is a powerful tool for managing shared resources and ensuring controlled access to a single instance of a class. However, careful consideration must be given to serialization, cloning, reflection, and multi-threaded environments to maintain the integrity of the Singleton. By understanding and implementing the various approaches, you can effectively use the Singleton pattern in your Java applications.

Getting Started with Golang: A Beginner’s Guide

Mukul Saini — Mon, 16 Dec 2024 18:50:54 +0000

Golang, or simply Go, is an open-source programming language developed by Google. Known for its simplicity, efficiency, and strong concurrency model, Go has become a popular choice for developers building scalable and high-performance applications. If you're new to Go, this guide will help you get started.

Why Learn Golang?
Before diving into the installation and setup, let’s understand why Go is worth learning:

Simplicity: Go's syntax is clean and easy to understand, making it beginner-friendly.

Performance: Compiled to machine code, Go applications are fast and efficient.

Concurrency: Goroutines and channels make concurrent programming seamless.

Community and Ecosystem: A vibrant community and a growing number of libraries.

Widely Used: Go is used in big projects like Docker, Kubernetes, and Terraform.

Check Out the Full Hello World example here

Getting Started with Golang: A Beginner’s Guide | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 16, 2024 ・
Medium

Mastering End-to-End Transactional Functionality in Spring Boot with Examples

Mukul Saini — Sat, 14 Dec 2024 19:25:02 +0000

Transactional management is a critical component of any robust application. It ensures the atomicity, consistency, isolation, and durability (ACID) of operations within a system. Java Spring Framework simplifies transactional management with its robust @Transactional annotation and other utilities. In this blog, we’ll cover an end-to-end overview of Spring’s transactional functionality with a practical example.

What Is a Transaction?
A transaction is a series of operations that are performed as a single logical unit. In simple terms, if one operation fails, the entire sequence is rolled back, leaving the system in its previous stable state.

Why Transaction Management Is Important

Ensures data consistency in databases.
Prevents partial updates during failures.
Supports recovery from errors while maintaining system integrity.

How Transactions Work in Spring
Spring uses the PlatformTransactionManager to coordinate transactions with the underlying persistence provider (e.g., JPA, JDBC). Spring offers annotations like @Transactional to manage transactions declaratively, meaning you don’t need to write boilerplate code for transaction management.

Transactional Settings in Spring
Key properties of the @Transactional annotation:

Propagation: Defines how transactions relate to each other.

REQUIRED (default): Joins an existing transaction or creates a new one if none exists.
REQUIRES_NEW: Creates a new transaction, suspending the existing one.

Isolation: Sets the level of isolation between transactions.

Examples: READ_COMMITTED, SERIALIZABLE.

Timeout: The maximum time (in seconds) a transaction can run.
Rollback Rules: Specifies conditions under which a rollback is triggered (e.g., specific exceptions).

Check Out the Full Example

Mastering End-to-End Transactional Functionality in Spring Boot ♨👾 | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 14, 2024 ・
Medium

Understanding == in Java: Why 1 == 1 is True but 128 == 128 Might Be False

Mukul Saini — Thu, 12 Dec 2024 09:05:50 +0000

If you’re learning Java, you’ve likely used the== operator countless times. It’s straightforward when dealing with numbers, right? Well, not always. A common point of confusion arises when 1 == 1evaluates to true, but surprisingly, 128 == 128 might evaluate to false. What’s going on? Is Java broken? Absolutely not! The key lies in understanding primitive types, object references, and autoboxing in Java. Let’s unravel this mystery step by step.

The Basics: Primitive vs Object Comparison
In Java, the == operator behaves differently depending on whether you are comparing primitives or objects:

For primitives(e.g., int, char, double):
The == operator compares the actual values. If the values are the same, the result is true.

int x = 1;
int y = 1;
System.out.println(x == y); // true

For objects (e.g., Integer, String, or custom classes):
The == operator checks whether the two objects point to the same memory location (i.e., reference equality).

Integer x = new Integer(128);
Integer y = new Integer(128);
System.out.println(x == y); // false (different memory locations)

What About Autoboxing?
Java introduced autoboxing in Java 5 to make working with primitives and their wrapper classes (like int and Integer) more seamless. It allows you to write code like this.

Integer a = 1; // Autoboxes the int 1 to an Integer object
int b = a;     // Unboxes the Integer back to a primitive int

While this is convenient, it can lead to subtle bugs when combined with ==. Why? Because objects and primitives behave differently with ==.

The Integer Cache
Java optimizes memory usage by caching Integer objects for values between -128 and 127. This means if you create two Integer objects within this range, they will point to the same memory location. Let’s see this in action.

Integer x = 127;
Integer y = 127;
System.out.println(x == y); // true (same cached object)

Integer a = 128;
Integer b = 128;
System.out.println(a == b); // false (different objects)

When comparing x and y (both 127), Java reuses the same cached object. For a and b (both 128), Java creates two distinct Integer objects outside the cached range. Hence, a == b evaluates to false.

Why Does This Happen?
The caching behavior is defined in the Integer class.

private static class IntegerCache {
   static final Integer[] cache = new Integer[-(-128) + 127 + 1];
   ...
}

By default, Java caches Integer values in the range -128 to 127 to save memory. For numbers outside this range, new objects are created.

How to Avoid This Confusion
If you want to compare the values of two Integer objects (or other wrapper classes), you should use the .equals() method, or explicitly unbox them into primitives.

Using .equals()

Integer a = 128;
Integer b = 128;
System.out.println(a.equals(b)); // true

Unboxing to Primitives

Integer a = 128;
Integer b = 128;
System.out.println(a.intValue() == b.intValue()); // true

Working with Primitives Directly

int a = 128;
int b = 128;
System.out.println(a == b); // true

Key Takeaways

Primitive Comparison: == compares the actual values.

int x = 1, y = 1;
System.out.println(x == y); // true

Object Comparison: == compares memory references, not values.

Integer x = 128, y = 128;
System.out.println(x == y); // false

Integer Cache: Java caches Integer objects for values between -128 and 127.

Integer x

DEV Community: Mukul Saini

Building a Golang Telegram Bot for Personal AI Assistance

Overview

System Design

Building a Golang Telegram Bot for Personal AI Assistance | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 26, 2024 ・
Medium

Singleton Design Pattern in Java

Getting Started with Golang: A Beginner’s Guide

Getting Started with Golang: A Beginner’s Guide | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 16, 2024 ・
Medium

Mastering End-to-End Transactional Functionality in Spring Boot with Examples

Mastering End-to-End Transactional Functionality in Spring Boot ♨👾 | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 14, 2024 ・
Medium

Understanding == in Java: Why 1 == 1 is True but 128 == 128 Might Be False

DEV Community: Mukul Saini

Building a Golang Telegram Bot for Personal AI Assistance

Overview

System Design

Building a Golang Telegram Bot for Personal AI Assistance | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 26, 2024 ・ Medium

Singleton Design Pattern in Java

Getting Started with Golang: A Beginner’s Guide

Getting Started with Golang: A Beginner’s Guide | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 16, 2024 ・ Medium

Mastering End-to-End Transactional Functionality in Spring Boot with Examples

Mastering End-to-End Transactional Functionality in Spring Boot ♨👾 | by Mukul Saini | Dec, 2024 | Medium

Mukul Saini ・ Dec 14, 2024 ・ Medium

Understanding == in Java: Why 1 == 1 is True but 128 == 128 Might Be False

Mukul Saini ・ Dec 26, 2024 ・
Medium

Mukul Saini ・ Dec 16, 2024 ・
Medium

Mukul Saini ・ Dec 14, 2024 ・
Medium