DEV Community: BotticelliBots

Forward to BotticelliBots v.0.9

BotticelliBots — Sun, 30 Nov 2025 09:52:19 +0000

Several new main issues, currently we're working on:

Easiness of deployment — Docker: provide Dockerfiles, docker-compose examples, and documented deployment steps; aim for one-command startup.
Output BotId while starting a bot — log/display the BotId at startup for tracking and debugging.
Botticelli.Framework unit tests — create and run unit tests for the Botticelli.Framework components. Target coverage — minimum 30% unit test coverage for Botticelli.Framework.

Join us on GitHub: https://github.com/devgopher/botticelli

BotticelliBundle: Simplified Deployment of Chatbots using Docker

BotticelliBots — Sat, 25 Oct 2025 21:11:00 +0000

First of all, you should be aware about a Botticellibots project:

Creating a simple Telegram bot using BotticelliBots: a quick guide

BotticelliBots on Github

BotticelliBots v.0.8.1

BotticelliBundle is a Docker image specifically designed to streamline the deployment of a basic Botticelli bot. It offers a quick way to set up and customize your own bot configuration by leveraging the Botticelli framework. The use of Docker enables users to easily run and test their bots in a containerized environment, enhancing development efficiency.

Key Features

Docker Integration: BotticelliBundle simplifies the process of deploying chatbots by encapsulating all dependencies and configurations within a Docker container.
Sample Configuration: The repository includes a sample bot configuration to guide users in setting up their personalized bots.
Ease of Testing: Running the bot in a Docker container allows for isolated testing, reducing compatibility issues.

How to Deploy Your Bot

To deploy your bot using BotticelliBundle, follow these steps:

Clone the Repository: First, clone the BotticelliBundle repository to your local machine.
Modify the Dockerfile and appsettings.json: Adjust the Dockerfile and configuration settings.

Here’s an example Dockerfile setup:


dockerfile
   # Use .NET SDK 8 image for building
   FROM mcr.microsoft.com/dotnet/sdk:8.0-alpine AS build

   # Set the working directory
   WORKDIR /app

   # Clone the Botticelli repository and switch to the specified branch
   RUN git clone --single-branch --branch release/0.8 https://github.com/devgopher/botticelli.git .
   RUN git clone <your git repo> ./bot

   # Change to project directory
   WORKDIR /app/bot

   # Restore dependencies
   RUN dotnet restore

   # Build the project
   RUN dotnet build -c Release -o out

   # Use the ASP.NET Runtime image for running
   FROM mcr.microsoft.com/dotnet/aspnet:8.0-alpine
   WORKDIR /app
   COPY --from=build /app/bot/out .

   # Copy custom configuration file
   COPY appsettings.json .

   # Set the entry point for the application
   ENTRYPOINT ["dotnet", "<YourBot>.dll"]

Creating a Telegram Bot with BotticelliBots: A Quick Guide

BotticelliBots — Tue, 08 Apr 2025 17:24:19 +0000

BotticelliBots is an open-source .NET Core framework that streamlines the development of chatbots. In this guide, we’ll walk through creating a simple Telegram bot that displays the current UTC time, leveraging the framework's capabilities.

Prerequisites

Ensure you have .NET Core 8.0 or higher and either Visual Studio 2022 or Rider 2023.x. Download BotticelliBots v. 0.3 as a submodule in your project.

Step 1: Register Your Bot

Use the Telegram BotFather to create a new bot and obtain your bot token.

Step 2: Create a Web API Project

In Visual Studio, create a new .NET Core Web API project.

Step 3: Configure Your Bot

In Program.cs, add the necessary services:

builder.Services.AddTelegramBot(builder.Configuration, new BotOptionsBuilder<TelegramBotSettings>()
    .Set(s => s.Name = settings?.BotName));
builder.Services.AddHostedService<VeryBasicBotService>();
builder.Services.AddBotCommand<GetUtcCommand, GetUtcCommandProcessor<ReplyKeyboardMarkup>, PassValidator<GetUtcCommand>>();

Step 4: Implement Command Processor

Create a command processor to handle the /GetUtc command:

public class GetUtcCommandProcessor<TReplyMarkupBase> : CommandProcessor<GetUtcCommand>
{
    protected override async Task InnerProcess(Message message, string args, CancellationToken token)
    {
        var utcMessageRequest = new SendMessageRequest(Guid.NewGuid().ToString())
        {
            Message = new Message
            {
                Body = $"Current UTC Time is: {DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)}",
            }
        };
        await _bot.SendMessageAsync(utcMessageRequest, null, token);
    }
}

Step 5: Run Your Bot

Deploy your bot and ensure it’s operational. You can manage it through the admin pane, where you can register and configure your bot.

About admin pane and it's setup you can read here.

Sample Bots

For more examples and inspiration, check out the Telegram AI Sample on GitHub.

For further details, visit BotticelliBots or join the community on Telegram for support and updates!
Step 5: Run Your Bot

Deploy your bot and ensure it’s operational. You can manage it through the admin pane, where you can register and configure your bot.
Sample Bots

For more examples and inspiration, check out the Telegram AI Sample on GitHub.

For further details, visit BotticelliBots or join the community on Telegram for support and updates!

Making a Telegram bot with BotticelliBots

BotticelliBots — Wed, 10 Apr 2024 12:00:35 +0000

Let's imagine, that we need to create a .NET core - based chatbot, that shows us current time in UTC.

So, we need .NET Core 8.0 and very basic knowledge of C#.

Before you start

Please, check your .NET Core and Visual Studio version. You should have .NET Core 8 or higher and VS 2022 or Rider v. 2023.x (any edition). If no - check this and this. As a framework and chatbot-management system, we'll use BotticelliBots v. 0.3: see here. You may load it as a submodule with your git repository.

Docs

What do we want

We need to create a chat bot, that will show you a UTC time on command

And also we need to administrate this bot.

Let's register our Telegram bot
Please, check a Telegram BotFather bot and follow the instructions

Some basics for BotticelliBots
Botticelli is an open-source .NET Core framework for building your own universal bots integrated with databases, queue brokers, speech engines and AI engines (such as ChatGPT, DeepSeek and YaGPT).

In our case, we need several entities to use:

Commands - represents a messenger command (such as /test)
Command Processors. Each command needs it's own processor to encapsulate any business logic
IBot - interface, that represents main bot functions (such as sending message to a chat)
Message - general message representation, that consists of ChatId, Id and contents

Let's start

Let's open our Visual Studio/Rider and create a WebApi project for .Net Core.

First of all, we need to make some injections in Program.cs:

var builder = WebApplication.CreateBuilder(args);

var settings = builder.Configuration
    .GetSection(nameof(VeryBasicBotSettings))
    .Get<VeryBasicBotSettings>();

// Adds telegram bot injections
builder.Services.AddTelegramBot(builder.Configuration,
    new BotOptionsBuilder<TelegramBotSettings>()
        .Set(s => s.SecureStorageSettings = new SecureStorageSettings
        {
            ConnectionString = settings?.SecureStorageConnectionString
        })
        .Set(s => s.Name = settings?.BotName));

// Adds a hosted service, intended for keeping bot working during all
// the lifecycle of a bot
builder.Services.AddHostedService<VeryBasicBotService>();
// Adds a command processor, being used for proceeding a business logic for
// '/GetUtc' command and also adds some validation (in this case - pass validator, that tells OK to any command args)
builder.Services.AddBotCommand<GetUtcCommand, GetUtcCommandProcessor<ReplyKeyboardMarkup>, PassValidator<GetUtcCommand>>();

var app = builder.Build();
app.Services.RegisterBotCommand<GetUtcCommand, GetUtcCommandProcessor<ReplyKeyboardMarkup>, TelegramBot>();

app.Run();

Command Processors

Each command needs to be processed in it's own processor. Please note, that we should follow a calling convention for a processor and a command:

class <*YourCommandName*>CommandProcessor<TReplyMarkupBase> : CommandProcessor<*YourCommandName*Command> 

public class *YourCommandName*Command : ICommand

So, our command processor should be look like:

/// <summary>
/// A processor for "/GetUtc" command 
/// </summary>
/// <typeparam name="TReplyMarkupBase"></typeparam>
public class GetUtcCommandProcessor<TReplyMarkupBase> : CommandProcessor<GetUtcCommand> 
    where TReplyMarkupBase : class
{   
    public GetUtcCommandProcessor(ILogger<GetUtcCommandProcessor<TReplyMarkupBase>> logger,
        ICommandValidator<GetUtcCommand> validator,
        MetricsProcessor metricsProcessor)
        : base(logger, validator, metricsProcessor)
    {
    }

    protected override Task InnerProcessContact(Message message, string argsString, CancellationToken token)
    {
        return Task.CompletedTask;
    }

    protected override Task InnerProcessPoll(Message message, string argsString, CancellationToken token)
    {
        return Task.CompletedTask;
    }

    protected override Task InnerProcessLocation(Message message, string argsString, CancellationToken token)
    {
        return Task.CompletedTask;
    }

    /// <summary>
    /// All business logic is being called here...
    /// </summary>
    /// <param name="message"></param>
    /// <param name="args"></param>
    /// <param name="token"></param>
    protected override async Task InnerProcess(Message message, string args, CancellationToken token)
    {
        // Creates a message for sending
        var utcMessageRequest = new SendMessageRequest(Guid.NewGuid().ToString())
        {
            Message = new Message
            {
                Uid = Guid.NewGuid().ToString(),
                ChatIds = message.ChatIds,
                Body = $"Current UTC Time is: {DateTime.UtcNow.ToString(CultureInfo.InvariantCulture)}",
            }
        };

        // Tries to send a message using a concrete implementation of Bot (TelegramBot, for example)
        await _bot.SendMessageAsync(request: utcMessageRequest, optionsBuilder: (ISendOptionsBuilder<TReplyMarkupBase>)null!, token: token);
    }
}

Hosted service
Also, we should run a hosted service in order to keep our bot onair:

namespace VeryBasicBot.Telegram;

/// <summary>
///     This hosted service intended keeping an application alive till the termination
/// </summary>
public class VeryBasicBotService : IHostedService
{
    private readonly IOptionsMonitor<VeryBasicBotSettings> _settings;
    private readonly IBot<TelegramBot> _telegramBot;

    public VeryBasicBotService(IBot<TelegramBot> telegramBot, IOptionsMonitor<VeryBasicBotSettings> settings)
    {
        _telegramBot = telegramBot;
        _settings = settings;
    }

    public Task StartAsync(CancellationToken token)
    {
        Console.WriteLine("Start serving...");

        return Task.CompletedTask;
    }

    public Task StopAsync(CancellationToken cancellationToken)
    {
        Console.WriteLine("Stop serving...");

        return Task.CompletedTask;
    }
}

you can download a whole code here: github

First run
So, we need to run our bot now. We need to get a freshly-generated a bot Id:

Deploying an admin-side
Admin pane deployment scripts for Linux

First of all, you need to choose where to deploy and admin pane.
We've 2 parts of admin:

Backend
Frontend

After deploying using proposed scripts, we need to register. So, after setting up frontend and backend, you should go to: https://: and press Registration button. On a registration form, please, put in your email and press Register. If your backend email server settings are correct, you'll receive a registration letter with username and password.

NOTE
If you experiencing some problems with untrusted certificate for backend, you may go to https://: in your browser and allow using untrusted certificate.

So, after registration, you may refresh a page and log in.

Adding a bot to admin pane
After registering and logging in, we need to add own freshly developed bot onto a "Your bots" pane and activate it as it's shown on pictures:

Go to 'Your bots' pane:
Fill parameters and a description:
Press 'Unlock' button:

** Some additional settings **
In a bot solution, please, find appsettings.json and make some changes:


{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.AspNetCore": "Warning"
    }
  },
  "VeryBasicBotSettings": {
    "SecureStorageConnectionString": "Filename=database.db;Password=123;ReadOnly=false",
    "BotName": "TimeTellingBot"
  },
  "ServerSettings": {
    "ServerUri": "http://<backend_url>:<backend_http_port>/v1/"
  },
  "AnalyticsSettings": {
    "TargetUrl": "http://<analytics_url>:<analytics_http_port>/v1/"
  },
  "AllowedHosts": "*"
}

Since, we didn't deploy analytics component, we may set some mocking TargetUrl

Let's check the result
Now, all we need is to run a VeryBasicBot.Telegram project.

sources: github
based on BotticelliBots: https://botticellibots.com
email: botticellibots@gmail.com
telegram group: https://t.me/botticelli_bots
Air quality telegram bot, based on BotticelliBots: https://t.me/air_quality_info_bot

Botticelli framework: a chat bot development platform for .NET

BotticelliBots — Sun, 10 Dec 2023 12:06:31 +0000

Chatbots are becoming increasingly popular due to their ability to provide instant and efficient interaction with users, automate customer service processes, and deliver personalized content. The progress of artificial intelligence and machine learning has become the reason for more functional and smarter bots. Bots find their application in the fields of messengers, commerce, education, and healthcare providing users with convenience and service accessibility. The ability of chatbots to promptly respond to queries, provide information, and even perform specific tasks makes them not only a modern trend but also a crucial element in the business’s customer interaction strategy.

Bot builders provide convenient tools for creating chatbots without the need for deep programming knowledge. However, their functionality is often limited by templates and restricted options. Manual bot coding becomes necessary when developing more complex and individualized solutions. This allows for complete customization of the bot’s behavior, integration of specific functions, and the provision of a unique interaction experience. Such an approach requires deeper technical skills but ensures a more flexible and personalized result, which is particularly important in fields where a high degree of customization is required.

It is essential to carefully consider the ability to work with different messengers developing bots. The diversity in the messenger world is vast, ranging from WhatsApp, Telegram, and Facebook Messenger to VK, Signal, and WeChat. Despite the popularity of Telegram, in some countries, it may be blocked. This forces adaptation to local messengers, such as WeChat in China. This geographic variability emphasizes the importance of supporting various platforms.

We have developed the Botticelli framework, which can simplify the process of creating bots by ensuring compatibility with a wide range of messengers. Botticelli is an open-source .NET Core framework for building universal bots with integration for databases, message brokers, speech engines, and artificial intelligence (such as GPT-j and ChatGPT).

Our goal is to standardize the bot creation process for various platforms. BotticelliBots ensures compatibility with diverse messengers, social networks, and other communication channels. Using this platform, developers can create and manage bots in a unified interface, significantly simplifying the development and maintenance processes. BotticelliBots aims to provide a unified and user-friendly bot management process, contributing to increased efficiency and reduced complexity in deploying chatbots across different environments and platforms.

The key advantages of BotticelliBots include:

сross-platform support;
high reliability;
ease of usage (a guide to a quick start);
ease of deployment;
convenient database integration;
ease of implementing artificial intelligence ChatGPT, GPT-j (Botticelli.AI);
ease of interaction with speech synthesizers (Botticelli.Talks);
convenient integration with message brokers for highly loaded systems (Botticelli.Bus);
task planning convenience (Botticelli.Scheduler)

BotticelliBots is a highly flexible platform that not only enables the creation and management of bots, but also integration with advanced technologies such as GPT-j and ChatGPT. This unique capability allows the use of powerful text generation models for more intelligent and diverse bot responses. Additionally, BotticelliBots supports integration with speech synthesizers, expanding the spectrum of interaction with the bot by adding audio capabilities. This enables the creation of more natural and engaging chatbots capable of processing text queries and also providing information in audio format, enhancing the quality of their communication.

For interaction with external APIs, you can use the bus (Botticelli.Bus), and there is integration with RabbitMQ. You can see the interaction scheme here.

We are currently actively working on expanding functionality. One of the key directions of development is increasing the number of supported messengers. The integration with platforms such as Facebook and WeChat is planned in the near future.

In addition, we are also focused on expanding integration capabilities with cutting-edge artificial intelligence solutions, such as ChatGPT and GPT-j. This opens up new horizons for creating more intelligent, adaptive, and contextually oriented chatbots. Developing synergy with such solutions will enhance the quality of user interaction with bots and allow to provide more personalized content.

The BotticelliBots team follows a strategy of continuous development and innovation to create more intelligent and flexible solutions that meet the needs in the field of chatbots.

Website: http://botticellibots.com/

Telegram Channel: https://t.me/botticelli_bots

Email: botticellibots@gmail.com