Инструкция по созданию чат бота telegram

This guide will walk you through everything you need to know to build your first Telegram Bot.
If you already know your way around some of the basic steps, you can jump directly to the part you’re missing. Equivalent examples are available in C#, Python, Go and TypeScript .

• Introduction
• Basic Tutorial

• Advanced Tutorial

• Further Reading

Introduction

At its core, you can think of the Telegram Bot API as software that provides JSON-encoded responses to your queries.

A bot, on the other hand, is essentially a routine, software or script that queries the API by means of an HTTPS request and waits for a response. There are several types of requests you can make, as well as many different objects that you can use and receive as responses.

Since your browser is capable of sending HTTPS requests, you can use it to quickly try out the API. After obtaining your token, try pasting this string into your browser:

https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getMe

In theory, you could interact with the API with basic requests like this, either via your browser or other tailor-made tools like cURL. While this can work for simple requests like the example above, it’s not practical for larger applications and doesn’t scale well.
For that reason, this guide will show you how to use libraries and frameworks, along with some basic programming skills, to build a more robust and scalable project.

If you know how to code, you’ll fly right through each step in no time – and if you’re just starting out, this guide will show you everything you need to learn.

We will use Java throughout this guide as it’s one of the most popular programming languages, however, you can follow along with any language as all the steps are fundamentally the same.
Since Java is fully cross-platform, each code example will work with any operating system.
If you pick another language, equivalent examples are available in C#, Python, Go and TypeScript .

Getting Ready

First, we will briefly cover how to create your first project, obtain your API token and download all necessary dependencies and libraries.

For the purposes of this guide, a copy of the bot you will be creating is also live at @TutorialBot – feel free to check it out along the way to see how your own implementation should look after each step.

Obtain Your Bot Token

In this context, a token is a string that authenticates your bot (not your account) on the bot API. Each bot has a unique token which can also be revoked at any time via @BotFather.

Obtaining a token is as simple as contacting @BotFather, issuing the /newbot command and following the steps until you’re given a new token. You can find a step-by-step guide here.

Your token will look something like this:

4839574812:AAFD39kkdpWt3ywyRZergyOLMaJhac60qc

Make sure to save your token in a secure place, treat it like a password and don’t share it with anyone.

Download an IDE

To program in Java you’ll need an IDE – a special text editor that will let you write, compile and run your code.
In this tutorial, we’ll use IntelliJ – there are several free, open source alternatives like Eclipse or NetBeans which work in the exact same way.

You will also need a JDK, a software kit that allows your Java code to run.
Most IDEs don’t include a JDK, so you should download a version compatible with your operating system separately. You can find a free, open source version here.

If you use another language, the steps are identical. You will just have to download a different IDE and software development kit.

Pick a Framework or Library

You can think of a framework as software that handles all the low-level logic for you, including the API calls, and lets you focus on your bot-specific logic.

In this tutorial, we’ll use TelegramBots, but you can follow along with any equivalent implementation, since all the underlying methods are either similar or exactly the same.

You can find many frameworks, along with code examples, in our dedicated list.

Create Your Project

In IntelliJ, go to File > New > Project.

Fill in the fields accordingly:

• Name — The name of your project. For example, BotTutorial.
• Location — Where to store your project. You can use the default value.
• Language — Java
• Build System — The framework that will handle your dependencies. Pick Maven.
• JDK — Pick whichever version you downloaded. We’ll be using version 17.
• Add Sample Code — Leave this selected, it will generate some needed files for you.
• Advanced Settings > GroupId — We suggest tutorial.
• Advanced Settings > ArtifactId — You can use the default value.

After hitting Create, if you did everything correctly, your Project view in the top left should show a project structure along these lines:

BotTutorial
├─ .idea
├─ src
│  └─ main
│     └─ java
│        └─ tutorial
│           └─ Main
└─ pom.xml

Other IDEs will follow a similar pattern. Your dependency management system will have a different name (or no name at all if it’s built-in) depending on the language you chose.

If this looks scary, don’t worry. We will only be using the Main file and the pom.xml file.
In fact, to check that everything is working so far, double click on Main and click on the small green arrow on the left of public class Main, then select the first option.
If you followed the steps correctly, Hello world! should appear in the console below.

Add Framework Dependency

We will now instruct the IDE to download and configure everything needed to work with the API.
This is very easy and happens automatically behind the scenes.

First, locate your pom.xml file on the left side of the screen.
Open it by double-clicking and simply add:

<dependencies>
    <dependency>
        <groupId>org.telegram</groupId>
        <artifactId>telegrambots</artifactId>
        <version>6.0.1</version>
    </dependency>
</dependencies>

right after the </properties> tag.

When you’re done, your pom.xml should look something like this.

Start Coding

We are ready to start coding. If you’re a beginner, consider that being familiar with your language of choice will greatly help. With this tutorial, you’ll be able to teach your bot basic behaviors, though more advanced features will require some coding experience.

Creating a Bot Class

If you’re familiar with object-oriented programming, you’ll know what a class is.
If you’ve never heard of it before, consider a class as a file where you write some logic.

To create the class that will contain the bot logic, right click on tutorial from the project tree on the left and select New > Java Class. Name it Bot and hit enter.

Now we have to connect this class to the bot framework. In other words, we must make sure it extends TelegramLongPollingBot. To do that, just add extends TelegramLongPollingBot right after Bot.
A red line will appear – it simply means we’re missing some important methods.

To fix this, hover over the red line, click on implement methods, then hit OK.
Depending on the IDE, this option may be called implement missing methods or something similar.

You should end up with this – if something went wrong, feel free to copy it from here and paste it in your class:

package tutorial;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Update;

public class Bot extends TelegramLongPollingBot {

  @Override
  public String getBotUsername() {
      return null;
  }

  @Override
  public String getBotToken() {
      return null;
  }

  @Override
  public void onUpdateReceived(Update update) {}

}

If you get a red line under TelegramLongPollingBot, it means you didn’t set up your pom.xml correctly. If this is the case, restart from here.

Available Methods

Let’s look into these 3 methods one by one.

• getBotUsername — This method must be edited to always return your bot’s username. You should replace the null return value with it.
• getBotToken — This method will be used by the framework to retrieve your bot token. You should replace the null return value with the token.
• onUpdateReceived — This is the most important method. It will be called automatically whenever a new Update is available. Let’s add a System.out.println(update); call in there to quickly show what we are getting.

After you’ve replaced all the strings, you should end up with this:

@Override
public String getBotUsername() {
    return "TutorialBot";
}

@Override
public String getBotToken() {
    return "4839574812:AAFD39kkdpWt3ywyRZergyOLMaJhac60qc";
}

@Override
public void onUpdateReceived(Update update) {
    System.out.println(update);
}

At this point, the bot is configured and ready to go – time to register it on the API and start processing updates.

In the future, you should consider storing your token in a dedicated settings file or in environment variables. Keeping it in the code is fine for the scope of this tutorial, however, it’s not very versatile and is generally considered bad practice.

Registering the Bot

To register the bot on the API, simply add a couple of lines in the main method that will launch the application. If you named your class Bot, this is what your main method should look like:

public static void main(String[] args) throws TelegramApiException {
  TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);
  botsApi.registerBot(new Bot());
}

You can place this method in any class. Since we have an auto-generated main method in the Main class, we’ll be using that one for this tutorial.

First Run

It’s time to run your bot for the first time.
Hit the green arrow to the left of public static void main and select the first option.

And then there was nothing. Yes, a bit anticlimactic.
This is because your bot has nothing to print – there are no new updates because nobody messaged it yet.

If you try messaging the bot on Telegram, you’ll then see new updates pop up in the console. At this point, you have your very own Telegram Bot – quite the achievement. Now, on to making it a bit more intelligent.

If nothing pops up, make sure you messaged the right bot and that the token you pasted in the code is correct.

Receiving Messages

Every time someone sends a private message to your bot, your onUpdateReceived method will be called automatically and you’ll be able to handle the update parameter, which contains the message, along with a great deal of other info which you can see detailed here.

Let’s focus on two values for now:

• The user — Who sent the message. Access it via update.getMessage().getFrom().
• The message — What was sent. Access it via update.getMessage().

Knowing this, we can make it a bit more clear in the console output.

@Override
public void onUpdateReceived(Update update) {
    var msg = update.getMessage();
    var user = msg.getFrom();

    System.out.println(user.getFirstName() + " wrote " + msg.getText());
}

This is just a basic example – you can now play around with all the methods to see everything you can pull out of these objects. You can try getUsername, getLanguageCode, and dozens more.

Knowing how to receive, process and print incoming messages, now it’s time to learn how to answer them.

Remember to stop and re-launch your bot after each change to the code.

Sending Messages

To send a private text message, you generally need three things:

• The user must have contacted your bot first. (Unless the user sent a join request to a group where your bot is an admin, but that’s a more advanced scenario).
• You must have previously saved the User ID (user.getId())
• A String object containing the message text, 1-4096 characters.

With that out of the way, let’s create a new method to send the first message:

public void sendText(Long who, String what){
   SendMessage sm = SendMessage.builder()
                    .chatId(who.toString()) //Who are we sending a message to
                    .text(what).build();    //Message content
   try {
        execute(sm);                        //Actually sending the message
   } catch (TelegramApiException e) {
        throw new RuntimeException(e);      //Any error will be printed here
   }
}

And proceed to run this in the main method, right after registering the bot.
For this example, we’ll assume your User ID is 1234.

public static void main(String[] args) throws TelegramApiException {
   TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);
   Bot bot = new Bot();                  //We moved this line out of the register method, to access it later
   botsApi.registerBot(bot);            
   bot.sendText(1234L, "Hello World!");  //The L just turns the Integer into a Long
}

If you did everything correctly, your bot should text you Hello World! every time you launch your code. Sending messages to groups or channels – assuming you have the relevant permissions – is as simple as replacing 1234 with the ID of the respective chat.

Try experimenting with other types of messages, like SendPhoto, SendSticker, SendDice…
A full list is available starting here.

Echo Bot

Let’s practice everything we tried so far by coding an Echo Bot.
Its functionality will be rather simple: every text message it receives will be sent right back to the user.

Copying Text

The most intuitive way of coding this is saving the User ID and calling sendText right after each update.

In other words:

@Override
public void onUpdateReceived(Update update) {
    var msg = update.getMessage();
    var user = msg.getFrom();
    var id = user.getId();

    sendText(id, msg.getText());
}

This works for text but can be extended to stickers, media and files.

Copying Everything

There are more specific functions that can be used to copy messages and send them back.
Let’s build a method to do just that:

public void copyMessage(Long who, Integer msgId){
   CopyMessage cm = CopyMessage.builder()
              .fromChatId(who.toString())  //We copy from the user
           .chatId(who.toString())      //And send it back to him
           .messageId(msgId)            //Specifying what message
           .build();
    try {
        execute(cm);
    } catch (TelegramApiException e) {
        throw new RuntimeException(e);
    }
}

After replacing the method call inonUpdateReceived, running the code will result in a fully functional Echo Bot.

This tutorial assumes that updates always contain messages for the sake of simplicity. This may not always be true – be sure to implement all the proper checks in your code to handle every type of update with the appropriate methods.

Executing Commands

To learn what a command is and how it works, we recommend reading this dedicated summary.
In this guide, we’ll focus on the technical side of things.

Creating Your Command

Begin by opening @BotFather.
Type /mybots > Your_Bot_Name > Edit Bot > Edit Commands.

Now send a new command, followed by a brief description.
For the purpose of this tutorial, we’ll implement two simple commands:

scream - Speak, I'll scream right back 
whisper - Shhhhhhh

Command Logic

We want the Echo Bot to reply in uppercase when it’s in scream mode and normally otherwise.

First, let’s create a variable to store the current mode.

public class Bot extends TelegramLongPollingBot {

   private boolean screaming = false;

   [...]
}

Then, let’s change some logic to account for this mode.

public void onUpdateReceived(Update update) {
    [...]                                   //Same variables as the previous versions
   if(screaming)                            //If we are screaming
       scream(id, update.getMessage());     //Call a custom method
   else
       copyMessage(id, msg.getMessageId()); //Else proceed normally
}

private void scream(Long id, Message msg) {
   if(msg.hasText())
       sendText(id, msg.getText().toUpperCase());
   else
       copyMessage(id, msg.getMessageId());  //We can't really scream a sticker
}

Finally, let’s add a couple more lines to the onUpdateReceived method to process each command before replying.

if(msg.isCommand()){ 
   if(msg.getText().equals("/scream"))         //If the command was /scream, we switch gears
      screaming = true;
   else if (msg.getText().equals("/whisper"))  //Otherwise, we return to normal
      screaming = false;

   return;                                     //We don't want to echo commands, so we exit
}

As you can see, it checks if the message is a command. If it is, the bot enters scream mode.
In the update method, we check which mode we are in and either copy the message or convert it to upper case before sending it back.

And that’s it. Now the bot can execute commands and change its behavior accordingly.

Naturally, this simplified logic will change the bot’s behavior for everyone – not just the person who sent the command. This can be fun for this tutorial but won’t work in a production environment – consider using a Map, dictionary or equivalent data structure to assign settings for individual users.

Remember to always implement a few basic global commands.
You can practice by implementing a simple feedback to the /start command, which we intentionally left out.

Buttons and Keyboards

To streamline and simplify user interaction with your bot, you can replace many text-based exchanges with handy buttons. These buttons can perform a wide variety of actions and can be customized for each user.

Button Types

There are two main types of buttons:

• Reply Buttons — used to provide a list of predefined text reply options.
• Inline Buttons — used to offer quick navigation, shortcuts, URLs, games and so much more.

Using these buttons is as easy as attaching a ReplyKeyboardMarkup or an InlineKeyboardMarkup to your SendMessage object.

This guide will focus on inline buttons since they only require a few extra lines of code.

Creating Buttons

First of all, let’s create some buttons.

 var next = InlineKeyboardButton.builder()
            .text("Next").callbackData("next")           
            .build();

 var back = InlineKeyboardButton.builder()
            .text("Back").callbackData("back")
            .build();

 var url = InlineKeyboardButton.builder()
            .text("Tutorial")
            .url("https://core.telegram.org/bots/api")
            .build();

Let’s go back through the fields we specified:

• Text — This is what the user will see, the text that appears on the button
• Callback Data — This will be sent back to the code instance as part of a new Update, so we can quickly identify what button was clicked.
• Url — A button that specifies a URL doesn’t specify callbackdata since its behavior is predefined – it will open the given link when tapped.

Creating Keyboards

The buttons we created can be assembled into two keyboards, which will then be used to navigate back and forth between two sample menus.

First, add two fields to store the necessary keyboards.

private boolean screaming = false;

private InlineKeyboardMarkup keyboardM1;
private InlineKeyboardMarkup keyboardM2;

Then, build and assign them.

keyboardM1 = InlineKeyboardMarkup.builder()
          .keyboardRow(List.of(next)).build();  

//Buttons are wrapped in lists since each keyboard is a set of button rows
keyboardM2 = InlineKeyboardMarkup.builder()
          .keyboardRow(List.of(back))
          .keyboardRow(List.of(url))
          .build();

You can place this code wherever you prefer, the important thing is making sure that keyboard variables are accessible from the method call that will send the new menu. If you’re confused by this concept and don’t know where to put them, just paste them above the command processing flow.

Sending Keyboards

Sending a keyboard only requires specifying a reply markup for the message.

public void sendMenu(Long who, String txt, InlineKeyboardMarkup kb){
    SendMessage sm = SendMessage.builder().chatId(who.toString())
            .parseMode("HTML").text(txt)
            .replyMarkup(kb).build();

    try {
        execute(sm);
    } catch (TelegramApiException e) {
        throw new RuntimeException(e);
    }
}

You may have noticed that we also added a new parameter, HTML.
This is called a formatting option and will allow us to use HTML tags and add formatting to the text later on.

Menu Trigger

We could send a new menu for each new user, but for simplicity let’s add a new command that will spawn a menu. We can achieve this by adding a new else clause to the previous command flow.

 var txt = msg.getText();
 if(msg.isCommand()) {
        if (txt.equals("/scream"))
            screaming = true;
        else if (txt.equals("/whisper"))
            screaming = false;
        else if (txt.equals("/menu"))
            sendMenu(id, "<b>Menu 1</b>", keyboardM1);
        return;
 }

Try sending /menu to your bot now. If you did everything correctly, you should see a brand new menu pop up.

In a production environment, commands should be handled with an appropriate design pattern that isolates them into different executor classes – modular and separated from the main logic.

Navigation

When building complex bots, navigation is essential. Your users must be able to move seamlessly from one menu to the next.

In this example, we want the Next button to lead the user to the second menu.
The Back button will send us back.
To do that, we will start processing incoming CallbackQueries, which are the results we get after the user taps on a button.

A CallbackQuery is essentially composed of three main parameters:

• queryId — Needed to close the query. You must always close new queries after processing them – if you don’t, a loading symbol will keep showing on the user’s side on top of each button.
• data — This identifies which button was pressed.
• from — The user who pressed the button.

Processing in this context just means executing the action uniquely identified by the button, then closing the query.

A very basic button handler could look something like:

private void buttonTap(Long id, String queryId, String data, int msgId) {

    EditMessageText newTxt = EditMessageText.builder()
            .chatId(id.toString())
            .messageId(msgId).text("").build();

    EditMessageReplyMarkup newKb = EditMessageReplyMarkup.builder()
            .chatId(id.toString()).messageId(msgId).build();                           

    if(data.equals("next")) {
        newTxt.setText("MENU 2");
        newKb.setReplyMarkup(keyboardM2);
    } else if(data.equals("back")) {
        newTxt.setText("MENU 1");
        newKb.setReplyMarkup(keyboardM1);
    }

    AnswerCallbackQuery close = AnswerCallbackQuery.builder()
            .callbackQueryId(queryId).build();

    execute(close);
    execute(newTxt);
    execute(newKb);
}

With this handler, whenever a button is tapped, your bot will automatically navigate between inline menus.
Expanding on this concept allows for endless combinations of navigable submenus, settings and dynamic pages.

Database

Telegram does not host an update database for you – once you process and consume an update, it will no longer be available. This means that features like user lists, message lists, current user inline menu, settings, etc. have to be implemented and maintained by bot developers.

If your bot needs one of these features and you want to get started on data persistence, we recommend that you look into serialization practices and libraries for your language of choice, as well as available databases.

Implementing a database is out of scope for this guide, however, several guides are available online for simple embedded open source software solutions like SQLite, HyperSQL, Derby and many more.

Your language of choice will also influence which databases are available and supported – the list above assumes you followed this Java tutorial.

Hosting

So far, your bot has been running on your local machine – your PC. While this may be good for developing, testing and debugging, it is not ideal for a production environment.
You’ll want your bot to be available and responsive at all times, but your computer might not always be online.

This can be done in four steps:

• Package your code
  Making your bot easy to move and runnable outside of an IDE is essential to host it elsewhere.
  If you followed this tutorial, this standard guide will work for you. If you didn’t, look into export or packaging guides for your IDE and language of choice – procedures may vary but the end result is the same.

• Purchase a VPS or equivalent service
  A server is essentially a machine that is always online and running, without you having to worry about anything. To host your bot, you can opt for a VPS which serves this purpose and can be rented from several different providers.
  Another option would be to purchase a network-capable microcontroller, which come in all different specs and sizes depending on your needs.

You should ensure that all user data remains heavily encrypted at all times in your database to guarantee the privacy of your users. The same concept applies to your local instance, however, this becomes especially important once you transfer your database to a remote server.

• Upload your executable/package

Once you have a working ssh connection between your machine and your new server, you should upload your executable and all associated files.
We will assume the runnable jar TutorialBot.jar and its database dbase.db are currently in the /TBot folder.

$ scp -r /TBot/ username@server_ip:/bots/TBotRemote/

• Run your application

Depending on which language you chose, you might have to configure your server environment differently. If you chose Java, you just need to install a compatible JDK.

$ apt install openjdk-17-jre
$ java -version

If you did everything correctly, you should see a Java version as the output, along with a few other values. This means you’re ready to run your application.

Now, to run the executable:

$ cd /bots/TBotRemote/
$ java -jar TutorialBot.jar

Your bot is now online and users can interact with it at any time.

To streamline and modularize this process, you could employ a specialized docker container or equivalent service.
If you followed along in one of the equivalent examples (C#, Python, Go and TypeScript) you can find a detailed set of instructions to export and run your code here.

Further Reading

If you got this far, you might be interested in these additional guides and docs:

• General Bot Platform Overview
• Detailed List of Bot Features
• Full API Reference

If you encounter any issues while following this guide, you can contact us on Telegram at @BotSupport.

Чат-боты — это программное обеспечение, которое имитирует общение с пользователями. Сейчас их используют для совершенно любых целей: это может быть простой справочник или сложный сервис с интеграцией в CRM и платежные системы.

Ботов создают для разных мессенджеров. У каждой платформы — свои правила и возможности: где-то нет оплаты, где-то нет гибких клавиатур. В статье говорим о Telegram: он удобен, у него простой API и активная аудитория.

В этой статье мы расскажем:

• как создать чат бот в Телеграме самостоятельно,
• когда удобно использовать конструкторы для разработки,
• как интегрировать чат-бот с внешними сервисами и API,
• что необходимо для бесперебойной работы бота,
• основные функции aiogram — популярной библиотеки для разработки чат-ботов на Python.

Создание чат-бота в Телеграме без навыков программирования

Сейчас всё более интенсивно набирают популярность конструкторы — это сервисы, где бота собирают через понятный интерфейс «drag-and-drop». Для работы с ними совсем не нужно знать языки программирования. Можно просто выстраивать логику блоками, как в детской игре. 

Существуют недостатки подобных решений:

• Ограниченная функциональность. Большинство конструкторов предлагает пользователям лишь часть функционала Telegram API. Например, интеграция со сторонними сервисами через HTTP-запросы есть не у всех. А те, кто имеет такой функционал, предлагают завышенные тарифы.

• Одинаковые сценарии. Минимальная гибкость конструкторов приводит к тому, что все боты на конструкторе выглядят и работают одинаково.

• Зависимость от сервиса. Если платформа «ляжет» или внезапно подорожает, придется переносить бота.

Конструкторы весьма удобны для прототипов и простых сценариев — приветственное сообщение, ответ на пару вопросов, сбор контактных данных. Более сложные алгоритмы требуют знания переменных, логики обработки данных и функционала Telegram API. Даже в конструкторе нужно понимать, как обратиться к пользователю по имени, как работают inline-клавиатуры и обработка состояний.

Зачастую бесплатные версии таких сервисов имеют ограничения: добавляют свои рекламные сообщения, запрещают интеграцию с нужными API или накладывают лимиты на количество пользователей. Это снижает лояльность аудитории, а сам чат-бот может остаться неиспользуемым. Платные версии в перспективе обходятся дороже, чем разработка бота с нуля и его размещение на сервере.

Если чат-бот должен решать реальные бизнес-задачи, автоматизировать процессы или работать с базами данных, конструктора зачастую будет недостаточно. В таком случае проще обратиться к разработчику: он сразу заложит гибкую архитектуру, подберет оптимальные технологии и избавит от технических ограничений, которые могут стать проблемой при масштабировании проекта. В качестве технического задания для разработчика можно использовать алгоритм из конструктора, если он уже есть. 

Как создать чат-бота в Телеграме самостоятельно

Теперь обсудим создание чат-бота в Telegram на языке программирования Python. Для работы понадобятся базовые знания о переменных, условных конструкциях, циклах и функциях в Python.

Для разработки чат-ботов чаще всего используют фреймворк — это набор инструментов, библиотек и готовых решений, которые помогают разрабатывать программное обеспечение. Можно использовать чистый Telegram API и реализовывать функционал на HTTP-запросах. Но всё это — тысячи строк кода даже для простых задач.

В статье будем использовать фреймворк aiogram — один из самых популярных фреймворков для разработки чат-ботов в Telegram на Python. 

Шаг первый. Создайте виртуальное окружение проекта 

Использовать виртуальное окружение в любом проекте на Python считается хорошим тоном. К тому же, чат-боты зачастую устанавливаются на облачных серверах, где потребуется установка зависимостей. Удобно экспортировать список зависимостей, принадлежащих конкретному проекту, поможет виртуальное окружение. 

О создании виртуального окружения мы рассказывали в нашей инструкции.

Шаг второй. Установите зависимые библиотеки

Установите саму библиотеку фреймворка через pip:

pip install aiogram

Добавьте библиотеку для работы с переменными окружения. Мы рекомендуем использовать этот способ передачи токенов в любом проекте, даже если вы не планируете выкладывать его в открытый доступ. Это снижает риск случайной публикации конфиденциальных данных.

pip install python-dotenv

Далее можете установить другие зависимости по необходимости.

Шаг третий. Инициализируйте чат-бота через BotFather

Несложный этап, но зачастую именно он вызывает затруднения. Нам самим нужно обратиться к чат-боту, который создаст и пришлет токен нашего проекта. 

Перейдите в Телеграм в диалог с @BotFather и нажмите кнопку «Начать».

Картинка с сайта: timeweb.cloud

Бот выдаст приветственное сообщение. Отправьте следующую команду:

/newbot

Бот спросит название будущего бота, которое будет отображаться в списке чатов пользователя. 

Далее нужно ввести имя пользователя (username) бота. Оно должно быть уникальным, чтобы любой пользователь смог найти его в поиске Телеграма. Обратите внимание, что имя пользователя должно оканчиваться на «bot». 

Картинка с сайта: timeweb.cloud

Всё готово: BotFather создал чат-бота, присвоил ему имя пользователя и токен. 

Внимание! Всегда храните токен в секрете. По нему любой человек сможет писать сообщения от лица вашего чат-бота. Если токен мог быть скомпрометирован, немедленно замените его в BotFather.

Перейдите в чат с только что созданным ботом и нажмите на кнопку «Изм.» (1), чтобы поменять фотографию (2), приветствие (3), описание (4) и предложение команд по умолчанию (5). 

Картинка с сайта: timeweb.cloud

Далее создайте файл окружение с названием .env (файл не имеет имени, а название содержит только расширение). Добавьте в файл строку в формате:

BOT_TOKEN = полученный токен

В Linux и MacOS для быстрой записи можно использовать команду:

echo "BOT_TOKEN = полученный токен" > .env

apps

Шаг четвертый. Создание скрипта

В рабочей директории создайте файл main.py — тут будет вестись основная работа. 

Импортируйте в файл тестовый код, который отправит пользователю приветственное сообщение при получении команды /start.

import asyncio  # Библиотека для работы с асинхронным кодом
import os  # Модуль для работы с переменными окружения
from dotenv import load_dotenv  # Функция для загрузки переменных окружения из файла .env
from aiogram import Bot, Dispatcher, Router  # Импорт необходимых классов из библиотеки aiogram
from aiogram.types import Message  # Импорт класса Message для обработки входящих сообщений
from aiogram.filters import CommandStart  # Импорт фильтра для обработки команды /start
 
# Создаем роутер, который будет содержать обработчики сообщений
router = Router()
 
# Загружаем переменные окружения из файла .env
load_dotenv()
 
# Обработчик команды /start
@router.message(CommandStart())  # Фильтр, который проверяет, является ли сообщение командой /start
async def cmd_start(message: Message) -> None:
    # Получаем имя пользователя (first_name) и фамилию (last_name), если она есть
    first_name = message.from_user.first_name
    last_name = message.from_user.last_name or ""  # Если фамилии нет, подставляем пустую строку
 
    # Отправляем пользователю приветственное сообщение
    await message.answer(f"Привет, {first_name} {last_name}!")
 
# Главная асинхронная функция, которая запускает бота
async def main():
    # Создаем объект бота, используя токен из переменных окружения
    bot = Bot(token=os.getenv("BOT_TOKEN"))
 
    # Создаем диспетчер для обработки сообщений
    dp = Dispatcher()
 
    # Подключаем роутер с обработчиками команд
    dp.include_router(router)
 
    # Запускаем бота в режиме опроса (polling)
    await dp.start_polling(bot)
 
# Если этот скрипт запускается напрямую (а не импортируется как модуль),
# то запускаем асинхронную функцию main()
if __name__ == "__main__":
    asyncio.run(main())

В примере основные компоненты закомментированы — изучите эти краткие пояснения, если не желаете вникать более глубоко. Можно продолжить узнавать функционал библиотеки aiogram, приняв использование Dispatcher, Router как данность. Далее в статье разберем функционал этих компонентов. 

Для начала любого проекта можно использовать эту готовую структуру: по ходу разработки будут добавляться новые обработчики, клавиатуры, состояния. 

Шаг пятый. Запуск и проверка работоспособности

Запустите созданный скрипт:

python main.py

Теперь можно проверить открыть диалог с ботом и начать его:

Картинка с сайта: timeweb.cloud

Обзор основного функционала фреймворка aiogram версии 3.x

Для создания чат-бота в Телеграм необходимое знание немногих компонентов и функций.

В этом разделе будет использоваться версия aiogram v3.x, выпущенная 1 сентября 2023 года. Подойдет любая версия, начинающаяся с тройки. Проекты с версиями ниже встречаются в работе, но aiogram 2.x считается устаревшим.

Ключевые компоненты aiogram

Bot

Bot — это ваш интерфейс к Telegram API. Через него вы отправляете сообщения, картинки и другие данные пользователям.

bot = Bot(token=os.getenv("BOT_TOKEN"))

Токен, разумеется, можно передать напрямую в аргументы класса Bot, без использования переменных окружения. Но мы рекомендуем сразу привыкать к именно такому способу передачи токена бота, во избежание случайного попадания токена в открытый доступ. 

Процесс получения токена описан в третьем шаге предыдущего раздела.

Dispatcher

Dispatcher — «сердце» фреймворка. Он принимает апдейты (входящие сообщения и события) и передает их нужным обработчикам. В v3 используется новая схема с Router (см. ниже), но Dispatcher остается для инициализации и запуска.

dp = Dispatcher()

Router

В aiogram v3 обработчики группируют в Router. Это отдельная сущность, которая хранит логику — хендлеры команд, сообщений, колбэков и т.д.

from aiogram import Router

router = Router()

Потом разработчики регистрируют хендлеры внутри роутера и добавляют router в экземпляр Dispatcher:

dp.include_router(router)

Обзор возможностей фреймворка aiogram v3.x

Знание следующих инструментов и умение их использовать позволит разработчику реализовать большинство алгоритмов чат-ботов. 

Обработка команд

Самый популярный сценарий — реагировать на команды вроде /start или /help.

from aiogram import F
from aiogram.types import Message

@router.message(F.text == "/start")
async def cmd_start(message: Message):
	await message.answer("Привет! Я бот на aiogram.")

F.text == "/start" — это новый способ фильтрации сообщений через объект F.

message.answer(...) отправляет ответ пользователю.

Обработка обычных сообщений

Для реакции на любое сообщение уберите фильтр или сделайте другой:

@router.message()
async def echo_all(message: Message):
	await message.answer(f"Вы написали: {message.text}")

В этом примере бот возвращает текст, который прислал пользователь.

Inline-кнопки и клавиатуры

from aiogram.types import InlineKeyboardButton, InlineKeyboardMarkup

inline_kb = InlineKeyboardMarkup(
	inline_keyboard=[
    	[InlineKeyboardButton(text="Нажми!", callback_data="press_button")]
	]
)

@router.message(F.text == "/buttons")
async def show_buttons(message: Message):
	await message.answer("Мои кнопки:", reply_markup=inline_kb)

Когда пользователь нажмет кнопку, бот получит callback_data="press_button" — обработать это можно отдельно:

from aiogram.types import CallbackQuery

@router.callback_query(F.data == "press_button")
async def handle_press_button(callback: CallbackQuery):
	await callback.message.answer("Вы нажали кнопку!")
	await callback.answer()  # нужно, чтобы убрать "часики" в верхней части диалога

Визуально в чате inline-кнопки выглядят так:

Картинка с сайта: timeweb.cloud

Обычные кнопки (Reply Keyboard)

Обычные кнопки отличаются от inline-кнопок тем, что появляются вместо клавиатуры. Пользователь видит сразу список готовых вариантов для ответа. Отслеживать такие кнопки надо через текст сообщения, а не через callback_data.

from aiogram.types import ReplyKeyboardMarkup, KeyboardButton, ReplyKeyboardRemove
reply_kb = ReplyKeyboardMarkup(
   keyboard=[
       [
           KeyboardButton(text="Посмотреть меню"),
           KeyboardButton(text="Оформить заказ")
       ]
   ],
   resize_keyboard=True  # Кнопки будут автоматически подгоняться по размеру
)

@router.message(F.text == "/start")
async def start_cmd(message: Message):
   await message.answer(
       "Добро пожаловать! Выберите действие:",
       reply_markup=reply_kb
   )

@router.message(F.text == "Посмотреть меню")
async def show_menu(message: Message):
   await message.answer("У нас есть пицца и напитки.")

@router.message(F.text == "Оформить заказ")
async def make_order(message: Message):
   await message.answer("Что будем заказывать?")

@router.message(F.text == "/hide")
async def hide_keyboard(message: Message):
   await message.answer("Убираем клавиатуру", reply_markup=ReplyKeyboardRemove())

Модули filters, middlewares и т.д.

Filters (фильтры) помогают гибко определять, какие сообщения ловить. Например, можно составлять кастомные фильтры.

from aiogram.filters import Filter
class IsAdmin(Filter):
   def __init__(self, admin_id: int):
       self.admin_id = admin_id

   async def __call__(self, message: Message) -> bool:
       return message.from_user.id == self.admin_id

@router.message(IsAdmin(admin_id=12345678), F.text == "/admin")
async def admin_cmd(message: Message):
   await message.answer("Привет, админ! У тебя есть особые права.")

Middlewares (промежуточные слои) вставляются между входящим запросом и хендлером. Можно перехватывать сообщения, редактировать их, проверять права доступа и т.д.

class LoggingMiddleware(BaseMiddleware):
   async def __call__(self, handler, event, data):
       if isinstance(event, Message):
           logging.info(f"[Message] from {event.from_user.id}: {event.text}")
       elif isinstance(event, CallbackQuery):
           logging.info(f"[CallbackQuery] from {event.from_user.id}: {event.data}")

       # Передаём обработку дальше
       return await handler(event, data)

async def main():
   load_dotenv()
   logging.basicConfig(level=logging.INFO)
   bot = Bot(token=os.getenv("BOT_TOKEN"))
   dp = Dispatcher()
   dp.update.middleware(LoggingMiddleware())
   dp.include_router(router)

   await dp.start_polling(bot)

Работа с состояниями (FSM)

Aiogram 3 поддерживает машину состояний (Finite State Machine). Это удобно, когда нужно пошагово собирать данные (например, регистрацию пользователя). FSM — это основной инструмент реализации ветвлений. 

Представим, что перед нами стоит задача разработать чат-бот для заказа пиццы. Нам нужно узнать у пользователя размер пиццы и адрес доставки. Сделать это нужно последовательно: нельзя сразу перепрыгнуть на второй шаг без первого. Причем нужно сохранять данные, которые отправляет пользователь, на всех этапах работы с чат-ботом. 

1. Объявите состояния:

from aiogram.fsm.state import State, StatesGroup

class OrderPizza(StatesGroup):
	waiting_for_size = State()
	waiting_for_address = State()

1. Переключайтесь между состояниями:

from aiogram.fsm.context import FSMContext

@router.message(F.text == "/order")
async def cmd_order(message: Message, state: FSMContext):
   # Создаём inline-кнопки для выбора размера
   size_keyboard = InlineKeyboardMarkup(
       inline_keyboard=[
           [
               InlineKeyboardButton(text="Большая", callback_data="size_big"),
               InlineKeyboardButton(text="Средняя", callback_data="size_medium"),
               InlineKeyboardButton(text="Маленькая", callback_data="size_small")
           ]
       ]
   )

   await message.answer(
       "Какую пиццу хотите? Нажмите на одну из кнопок:",
       reply_markup=size_keyboard
   )
   # Устанавливаем состояние, при котором мы ждём, что пользователь выберет размер
   await state.set_state(OrderPizza.waiting_for_size)

# Шаг 2. Обрабатываем нажатие на кнопку с выбором размера
@router.callback_query(OrderPizza.waiting_for_size, F.data.startswith("size_"))
async def choose_size_callback(callback: CallbackQuery, state: FSMContext):
   # Callback data может быть size_big / size_medium / size_small
   size_data = callback.data.split("_")[1]  # например, "big", "medium" или "small"

   # Сохраняем выбранный размер пиццы во временное хранилище состояния
   await state.update_data(pizza_size=size_data)

   # Подтверждаем, что кнопку нажали (убираем "часики" в интерфейсе Telegram)
   await callback.answer()

   await callback.message.answer("Укажите адрес доставки:")
   await state.set_state(OrderPizza.waiting_for_address)

# Шаг 2а. Если пользователь напишет сообщение вместо нажатия кнопки (в состоянии waiting_for_size),
# можно отреагировать отдельно. Например, попросим всё же нажать кнопку.
@router.message(OrderPizza.waiting_for_size)
async def handle_text_during_waiting_for_size(message: Message, state: FSMContext):
   await message.answer(
       "Пожалуйста, выберите размер пиццы, используя кнопки выше. "
       "Без этого мы не можем продолжить."
   )

# Шаг 3. Пользователь присылает адрес
@router.message(OrderPizza.waiting_for_address)
async def set_address(message: Message, state: FSMContext):
   address = message.text
   user_data = await state.get_data()
   pizza_size = user_data["pizza_size"]

   size_text = {
       "big": "большую",
       "medium": "среднюю",
       "small": "маленькую"
   }.get(pizza_size, "неопределённую")

   await message.answer(f"Вы заказали {size_text} пиццу по адресу: {address}")
   # Очищаем состояние -- сценарий завершён
   await state.clear()

Обратите внимание, как хранится информация в промежуточных состояниях — используется внутреннее хранилище, принадлежащее конкретному пользователю, без использования базы данных. 

Так пользователь идет по цепочке вопросов, а в конце можно отправить информацию о заказе на внутренний API.

Картинка с сайта: timeweb.cloud

Подбор конфигурации сервера для размещения бота

Мы подготовили таблицу для универсального подбора конфигурации в зависимости от задач чат-бота. Поля в первой колонке кликабельны — там ссылки на создание сервера выбранной конфигурации в панели управления Timeweb Cloud.

Развертывание бота: запуск на сервере

Разберем два основных способа деплоя (развертывания проекта на сервере)

Быстрый способ: Docker + Timeweb Cloud Apps

Этот способ не требует никаких знаний системного администрирования, весь деплой производится автоматически. К тому же, этот способ позволяет сэкономить (стоимость минимальной конфигурации — 188 рублей в месяц). Следуйте этим шагам:

1. Выгрузите все зависимости проекта в файл requirements.txt. Здесь пригождается использование виртуального окружения, чтобы не тянуть библиотеки со всего компьютера. Выполните в Терминале в директории проекта:

pip freeze > requirements.txt

1. Добавьте в директорию проекта новый файл для деплоя — Dockerfile. Расширения у файла нет, только имя. Вставьте следующее содержимое:

FROM python:3.11
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 9999
CMD ["python", "main.py"]

1. Создайте Git-репозиторий и выложите его на GitHub. Для этого можно воспользоваться минимальным набором команд git из нашей статьи, выполнив эти команды последовательно.
   Не забудьте добавить файл переменных окружения .env в .gitignore — он не должен попасть в общий доступ.

2. Осталось немного: перейдите в панель управления Timeweb Cloud, выберите таб «Apps», нажмите кнопку «Добавить» или «Создать». Во вкладке «Тип» перейдите на таб «Dockerfile».

3. Привяжите свой аккаунт GitHub или подключите Git-репозиторий по URL.

Картинка с сайта: timeweb.cloud

1. Выберите репозиторий из списка после того, как привязали свой аккаунт с GitHub.

Картинка с сайта: timeweb.cloud

1. Выберите конфигурацию. В Timeweb Cloud Apps доступна конфигурация CPU 1 x 3.3ГГц, RAM 1Гб, NVMe 15Гб стоимостью 188 рублей в месяц. Она отлично подходит для простых текстовых ботов, проектов с небольшими inline-клавиатурами, базовой FSM-логикой, не требовательными API-запросами, работы с SQLite или легковесными JSON-файлами. Такая конфигурация может обрабатывать до 50-100 пользователей в минуту.

2. Добавьте токен в переменные окружения. Во вкладке «5. Настройка приложения» нажмите на кнопку «+ Добавить». Ключ — BOT_TOKEN, а в значение вставьте токен, полученный из BotFather.

Картинка с сайта: timeweb.cloud

1. Запустите деплой и дождитесь его окончания. После этого бот будет запущен.

Картинка с сайта: timeweb.cloud

Стандартный способ: Ubuntu + systemd

1. Выгрузите все зависимости проекта в файл requirements.txt. Выполните следующую команду в Терминале, находясь в директории проекта:

pip freeze > requirements.txt

1. Создайте облачный сервер в панели Timeweb Cloud с нужной конфигурацией и ОС Ubuntu.

2. Перенесите файлы проекта в директорию на удаленном сервере. Проще всего это сделать с помощью утилиты rsync, если используете Ubuntu / MacOS:

rsync -av --exclude="venv" --exclude=".idea" --exclude=".git" ./ root@176.53.160.13:/root/project

Не забудьте вставить IP сервера и исправить конечную директорию.

Картинка с сайта: timeweb.cloud

Для пользователей на Windows — используйте отправку файлов через FileZilla. Об этом рассказано в нашей документации. 

1. Подключитесь к серверу по SSH. Если возникают сложности, воспользуйтесь информацией из нашей документации по UNIX-системам. 

2. Установите пакет для виртуального окружения:

sudo apt install python3.10-venv

1. Перейдите в директорию проекта, куда прежде отправили файлы. Создайте виртуальное окружение и выполните установку зависимостей.

python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

1. Проверьте работоспособность бота — запустите его с помощью:

python main.py

Если всё работает, то переходите к следующему шагу.

1. Создайте юнит-файл /etc/systemd/system/telegram-bot.service:

sudo nano /etc/systemd/system/telegram-bot.service

Добавьте в файл следующее содержимое содержимое:

[Unit]
Description=Telegram Bot Service
After=network.target

[Service]
User=root
WorkingDirectory=/root/project
ExecStart=/root/proj/venv/bin/python /root/proj/main.py
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

Измените значения следующих переменных:

• WorkingDirectory — директория проекта
• ExecStart — команда для запуска чат-бота в формате <интерпретатор> <полный путь до файла>

При использовании виртуального окружения интерпретатор находится по тому же пути, как в примере. Если работаете без venv, то используйте /usr/local/bin/python3.

1. Перезапустите systemd и включите службу:

sudo systemctl daemon-reload
sudo systemctl enable telegram-bot.service
sudo systemctl start telegram-bot.service

1. Проверьте статус службы и просмотрите логи, при необходимости:

sudo systemctl status telegram-bot.service

При нормальном запуске в поле «Active» находится значение «active (running)».

Картинка с сайта: timeweb.cloud

Просмотр логов бота:

sudo journalctl -u telegram-bot.service -f

1. При необходимости, управляйте службой следующими командами:

   • Перезапуск бота

sudo systemctl restart telegram-bot.service

• • Остановка бота

sudo systemctl stop telegram-bot.service

• • Удаление службы (если нужно)

sudo systemctl disable telegram-bot.service
sudo rm /etc/systemd/system/telegram-bot.service
sudo systemctl daemon-reload

Заключение

Создание чат-бота в Telegram на Python — задача, которую можно решить даже без опыта в программировании, используя конструкторы. 

Если вам нужна гибкость и более широкие возможности, лучше освоить фреймворк aiogram и развернуть собственный проект. Вы сразу получите контроль над кодом, сможете легко дорабатывать функционал, управлять интеграциями и не зависеть от ограничений платных тарифов. Для запуска бота на продакшене достаточно выбрать подходящую конфигурацию сервера и настроить автоматический деплой. Уделите внимание безопасности: храните токен в переменной окружения и шифруйте важные данные. 

В будущем бота можно масштабировать, добавлять поддержку вебхуков, подключать платёжные системы, системы аналитики и работать с ML-моделями, если потребуются AI-функции.

Уровень сложностиПростой

Время на прочтение15 мин

Количество просмотров53K

Картинка с сайта: habr.com

Мы напишем вот такого бота

В наше время любой человек без навыков программирования может самостоятельно написать простого чат-бота. Например, чтобы предоставлять услуги через Telegram, организовать работу сообщества и т. д. Скажем, для отметки посещаемости в учебном классе, для общения в домовом чате, для скачивания фильмов и музыки. А техническому специалисту написать такого бота вообще тривиальная задача. Зачем нужны чат-боты, как их использовать бизнесу и частным лицам, как написать бота самостоятельно, если у вас есть навыки программирования или их нет, поговорим в этой статье.

Определение и предназначение чат-ботов

Простыми словами, чат-бот в телеграме — это небольшое приложение (программа) в мессенджере, способное выполнять различные задачи при взаимодействии с пользователем. Существующих ботов уже немало, и их число продолжает расти, потому что создавать эти приложения может любой пользователь, потратив немного времени и сил.

Боты можно использовать в личных целях, область применения их широка. Они могут применяться для напоминаний о чем-либо, заказа билетов на поезд, в театр, кино и т. д., для скачивания фильмов и музыки, поиска информации в интернете или иных источниках и т.д.

Широко боты используются в бизнесе. Они показывают каталоги товаров и услуг, консультируют по ним, принимают оплату и оформляют доставку, выступают в роли техподдержки, принимают заявки у пользователей и отвечают на их вопросы, работают в качестве секретаря, напоминая о встречах, создавая записи в расписании, назначая собеседования и т. д.: способов применения приложений и в этой сфере очень много.

Принцип работы чат-бота выглядит так: после запуска он приветствует пользователя и предлагает ему написать вопрос или выбрать действие из доступных вариантов. Человек нажимает на одну из доступных кнопок или пишет сообщение. Приложение видит ответ и реагирует на него, выполняя запрос или присылая следующее сообщение. Такой диалог продолжается до тех пор, пока вопрос человека не будет решен или бот не переведет разговор на живого сотрудника, если решит, что не может справиться с задачей.

Если вам потребуется бот для определенных задач, его можно заказать на специализированных площадках. Однако понимая принцип работы бота, написать его под свои потребности можно самостоятельно. Существуют два способа:

• Конструкторы чат-ботов. Через них можно делать ботов, не имея никаких специальных навыков. Вы регистрируетесь на такой площадке и либо создаёте приложение сами, прописывая сценарий (каждое сообщение и действие, выполняемое ботом), либо используете один из многочисленных шаблонов. Конструкторы просты в обращении, подходят для неопытных пользователей и обычно предлагают серию уроков, объясняющих, как пользоваться доступными инструментами.
• Программирование. Если у вас есть соответствующие навыки, вы сможете написать бота с нуля. Такой способ сложнее и подходит не каждому.

Ниже мы подробнее поговорим о создании ботов обоими способами.

Вариант 1. Пишем сами

При наличии навыков программирования написать своего бота совсем несложно. Как вариант, кастомный чат-бот можно заказать у программиста-фрилансера за скромную сумму.

Обычно чат-ботов пишут на Python, но можно использовать и другие языки: Java, C++, Ruby и т.д. Если вы не знакомы ни с одним из них, можно потратить время на их изучение или поступить иначе: составить техническое задание и обратиться к программисту. Найти его можно в интернете, через соцсети, биржи фрилансеров, специализированные компании, при помощи знакомых.

Инструкция по написанию чат-бота на Питоне:
Для создания бота нужно обратиться к уже существующему боту в телеграм BotFather. У него выбираем команду /newbot и придумываем название и имя пользователя (обязательно должно заканчиваться на ‘bot’) своего бота. BotFather присылает токен нашего нового бота и мы его копируем. Также тут можно сразу добавить аватарку, описание и многое другое, используя интерактивное меню.

Картинка с сайта: habr.com

Теперь нужно установить на компьютере необходимую библиотеку telebot (pyTelegramBotAPI). Для этого открываем командную строку и прописываем pip install pyTelegramBotAPI.

Затем переходим в любую среду для написания кода Python и импортируем эту библиотеку, а также, чтобы создавать разные объекты, нужно подключить модуль types. После этого создаём самого бота.

Картинка с сайта: habr.com

Добавляем приветствие после запуска и ещё одну команду, необходимую для работы без сбоев, после чего самый простой бот готов.

Картинка с сайта: habr.com

Для примера, создадим несложного бота для салона красоты. В его функционал будет входить просмотр необходимой о нём информации, а также запись на приём. Для этого создаем шаблон клавиатуры и несколько кнопок с помощью модуля types и добавляем эти кнопки в шаблон. Также повторим действия для кнопки «Назад».

Чтобы пользователь видел эту клавиатуру, нужно добавить параметр reply_markup в строку с выводом сообщения бота.

Картинка с сайта: habr.com

Картинка с сайта: habr.com

При нажатии на любую из кнопок пользователь автоматически отправляет сообщение с соответствующим текстом. Чтобы бот реагировал на такие сообщения, нужно добавить функцию, в которой программа просто проводит сравнения и исходя их них выводит нужный текст. В качестве клавиатуры ответа для всех кнопок, кроме «Записаться», выводим уже созданную «Назад».

Картинка с сайта: habr.com

Чтобы заказы после регистрации приходили лично вам, нужно создать группу и добавить в неё своего бота. После этого создаём новую функцию forward, которая будет пересылать сообщение пользователя к вам в группу и выводить некоторый текст. В параметр chat_id вставляем ссылку на группу с заказами.

Картинка с сайта: habr.com

После этого прописываем метод register_next_step_handler для того, чтобы бот подождал следующего сообщения пользователя и выполнил функцию forward.

Картинка с сайта: habr.com

Вот такой результат получился:

Картинка с сайта: habr.com

Картинка с сайта: habr.com

API и технические детали
Большое значение при программировании бота имеет API — программный интерфейс, при использовании которого программы, веб-сервисы и приложения обмениваются данными. Ботами в телеграме управляют программы, которые обращаются к серверам мессенджера, чтобы получать данные (к примеру, о сообщении, полученном ботом) и отправлять команды (например, отправить ответ на сообщение). Связь между программами, руководящими ботами и серверами выполняется через API.

Основной API, при помощи которого происходит обмен данными, — это Telegram API (MTProto API). Он базируется на протоколе MTProto, созданном командой Telegram и открыт, чтобы разработчики смогли писать собственные программы для мессенджера. Кроме него, существует Bot API — это дополнительно разработанное API поверх MTProto API, на котором действуют лишь боты. Создан он, чтобы программисты имели возможность писать ботов на стандартных HTML-запросах, не тратя время на знакомство с MTProto.

Для разработки ботов можно использовать библиотеки и для Telegram API, и для Bot API. Для Bot API их количество больше, однако и ограничений будет больше: к примеру, он не позволяет скачивать объёмные файлы или подгружать устаревшие сообщения из истории переписки.

Изучить технические данные протокола MTProto можно в справочной службе Telegram.

Каким должно быть техническое задание на создание бота при заказе у программиста

При обращении к программисту для написания бота нужно подготовить техническое задание. Чем подробнее и точнее оно составлено, тем лучше чат-бот будет выполнять поставленные задачи и соответствовать вашим ожиданиям. Вот что должно быть указано в техническом задании:

• Цель создания бота. Ради чего разрабатывается приложение, что именно вы от него ожидаете, какие задачи оно должно выполнять.
• Целевая аудитория, с которой будет взаимодействовать чат-бот. Здесь вы указываете, с кем предстоит разговаривать чат-боту, какой стиль общения допустим, как он должен обращаться к людям (на «ты» или на «вы»), может ли позволять себе шутки, присылать развлекательный контент и т. д. Чем подробнее будет этот раздел, тем лучше приложение будет взаимодействовать с будущей аудиторией.
• Функциональность бота. Здесь вы объясняете, какие инструменты должны быть у приложения, что оно будет делать: отвечать на вопросы, принимать заказы и т. д.
• Слова-триггеры и риск-тематики. Здесь вы указываете реплики, при которых бот должен перевести разговор на живого специалиста. Это может быть, например, фраза «я перестану с вами работать», нецензурная брань и т. п.
• Производительность. Рассчитывается исходя из размера потенциальной аудитории. Здесь должны быть учтены паузы между ответами, продолжительность ответа и т. д. Чем быстрее приложение будет работать, тем быстрее оно закончит разговор с пользователем и сможет перейти к следующему клиенту: это важно в так называемый «час пик», когда количество людей, нуждающихся в его помощи, большое.
• Интеграции. Если нужно, чтобы бот работал с платёжными и CRM-системами или другими внешними платформами, сообщите об этом в данном разделе.
• Безопасность решения. Здесь указываются требования к конфиденциальности и защите личных данных пользователей. Если приложение собирает такую информацию, механизмы шифрования и аутентификации должны быть надёжные.
• Используемые технологии. Здесь указывается программное обеспечение и технологии, выбранные для работы с приложением.
• Личность чат-бота. Имя, описание, характер бота: всё, что поможет людям наладить с ним взаимодействие и воспринимать его как личность.
• Персонализированное общение. Если бот может обращаться к человеку по имени, это улучшает их взаимодействие.
• Использование нейросетей и ИИ. Если они должны быть задействованы при разработке бота, нужно указать, какие именно платформы должны быть использованы, должны ли они дообучаться в процессе работы с клиентом, как будет обеспечиваться защита данных в процессе работы с ними и т.д.
• Критерии успеха. Здесь вы указываете, какой результат хотите получить, как будете его оценивать, по каким параметрам, как он будет трактоваться и т. д.

Чем точнее и подробнее будет составлено техническое задание, тем лучший результат вы получите и тем меньше времени потратите вы и программист на вероятные доработки.

После того, как техническое задание создано, оформите его в письменном виде и обсудите с разработчиками. Убедитесь, что они смогут его выполнить с учётом ваших пожеланий и обсудите стоимость работ.

Конструкторы для создания чат-ботов

Другой вариант сборки бота с нуля — использовать конструктор. Здесь вы создаёте блоки, в которых прописываете текст бота и его действия и соединяете их между собой в определённом порядке. С тремя лучшими конструкторами можете познакомиться ниже.

Botman
Конструктор чат-ботов и автоворонок продаж для Telegram и ВК. В бесплатном тарифе вы получите базовые возможности, которые позволят создавать простых чат-ботов и применять их для решения ваших задач. Серия видеоуроков доступно и понятно расскажет вам, как работать на площадке и научит создавать приложения различной сложности.

Картинка с сайта: habr.com

Использовать чат-ботов можно в следующих сферах:

• продажа товаров и услуг (консультация по продукции, работа с возражениями клиентов);
• инфобизнес;
• ведение сообществ и групп в соцсетях, каналов в мессенджерах;
• получение платежей и оформление выдачи или доставки продуктов.

Достоинства Botman:

• бесплатный базовый функционал;
• можно разрабатывать ботов для использования в разных сферах;
• простые и информативные видеокурсы и текстовые инструкции;
• аналитические инструменты для сбора статистических данных и отслеживания эффективности чат-бота;
• большой выбор шаблонов;
• интеграции с платежными системами, сервисами Google, CRM-системами.

Если вы не захотите работать над созданием бота, на площадке можно заказать для себя такое приложение. Для этого нужно подать заявку и рассказать в ней, что именно требуется. После этого с вами свяжется специалист и обсудит детали. Отдельным плюсом платформы можно отметить бесплатный курс по разработке ботов без навыков программирования от самого основателя.

Botmother
Платформа для создания чат ботов любой сложности. Здесь можно конструировать приложения для Телеграм, Viber, WhatsApp, Одноклассников и ВКонтакте при помощи простого перетаскивания готовых блоков в визуальном редакторе.

Картинка с сайта: habr.com

Предусмотрены готовые шаблоны, которые вы можете отредактировать под себя или использовать в том виде, в каком они есть. После регистрации будет доступен бесплатный тестовый тариф, на котором можно сделать до десяти ботов с ограничением по количеству пользователей и пересылаемых сообщений. Чтобы их снять, нужно оплатить один из четырёх платных тарифов.

Multy
Мульти — это мультиконструктор для создания чат ботов и сайтов. Имеет простой и понятный интерфейс, множество шаблонов для разных случаев жизни, а также бесплатное обучение для знакомства с инструментами площадки.

Картинка с сайта: habr.com

С помощью Multy можно создавать чат-ботов и автоматизировать бизнес-процессы, настраивать рассылки в Telegram и в ВК, конструировать сайты. Доступны широкие возможности для интеграции с платёжными системами, ИИ, CRM-системами и другими сервисами и платформами. Бесплатных тарифов нет, но можно в течение 14-ти дней знакомиться с возможностями Мульти, а затем выбрать один из трёх тарифных планов.

Что учесть при создании чат-бота

При разработке чат ботов важно учитывать, что сделано следующее:

• определена и чётко сформулирована цель;
• выбран сайт-конструктор или язык программирования при самостоятельном создании бота или подобран специалист/организация для выполнения работы;
• определена аудитория приложения и подобран стиль общения;
• разработан сценарий работы чат-бота;
• определены дизайн и интерфейс;
• бот прост и понятен для пользователя, не перегружен лишними функциями без большой необходимости;
• вариантов ответов приложения на вопросы пользователей достаточно, чтобы бот мог с большой вероятностью самостоятельно им помочь и завершить диалог: если он будет постоянно прибегать к помощи сотрудника, это снизит целесообразность его использования;
• бот безопасен: если вы собираете персональные данные пользователей, уделите должное внимание их защите, применены соответствующие протоколы шифрования.

Если всё это учтено, можно переходить к созданию.

Технические характеристики чат-ботов

Чтобы создать бота, нужно понимать принцип его работы и знать, как прописываются сценарии и какие у них бывают типы в зависимости от вида приложения.

Принцип работы
Принцип работы бота можно представить так:

1. Пользователь запускает бота.
2. Приложение приветствует человека, рассказывает, какие задачи выполняет и предлагает ввести вопрос или выбрать из доступных вариантов (это может быть несколько кнопок с функциями бота или же варианты фраз, которые нужно ввести: «Цены», «Услуги», «Справка» и т.п.).
3. Человек пишет сообщение или делает выбор.
4. Приложение анализирует сообщение пользователя и либо делает ответ, либо переводит диалог на оператора.

Шаги 3-4 повторяются, пока вопрос человека не будет решен или же пока бот не определит, что не может помочь пользователю и не пригласит специалиста.

Разработка сценариев для чат-ботов под определённый вид

В сфере чат ботов ключевое значение имеет сценарий, он же структура. Он выглядит как логическая цепочка блоков с сообщениями, по которой передвигается человек до момента решения своей проблемы. Чем точнее сделан сценарий, чем лучше продумана его цепочка и ответвления, тем быстрее пользователь получит результат.

Сценарий составляется с учётом вида бота, который, в свою очередь, определяется с учётом целей, задач, которые выполняет приложение, и его функционала.

Виды
Существует много классификаций ботов по различным критериям. Вот некоторые виды ботов:

• Интеллектуальные и ограниченные. К первым относятся приложения, для которых предусмотрено машинное обучение и постепенное расширение и улучшение сценариев. Вторые работают по фиксированному сценарию, не допускающему изменений.
• Платформа. Для какого устройства и ОС создается бот: для ПК, смартфонов, для Android, iOS и Windows и т. д.
• Область применения. Приложения создаются для работы в мессенджерах, соцсетях и на сайтах.
• Вид общения. Текстовые боты или голосовые.
• Задачи. Приложение только находит и присылает данные по запросу или самостоятельно что-то делает.
• Цели создания. Боты могут быть для консультаций и продаж, для техподдержки организаций, ассистенты, информационные, для привлечения лидов, приёма платежей и оформления доставки и т.д.
• Кнопочные или с вводом текста. Для взаимодействия с приложением нужно отправлять сообщения или нажимать на кнопки меню.
• Боты с интеллектуальными подсказками или без. При вводе слова пользователь видит популярные запросы, связанные с этим словом, которые предлагает приложение.
• Смарт-боты. Взаимодействие с ними максимально похоже на общение с человеком, они распознают речь и отвечают практически как живые люди. К таким приложениям относятся голосовые помощники. Яркие примеры — Алиса от Яндекса или Google Ассистент.

Под каждый вид бота подбирается свой сценарий, чтобы добиться его максимальной эффективности.

Разработка сценария под каждый вид бота
Сделать сценарий под чат-бота можно по следующей схеме:

1. Определите цель создания приложения и продумайте задачи, которые он должен выполнять.
2. Продумайте ход сценария, от приветствия до прощания с клиентом.
3. Разбейте сценарий на шаги, на каждом из которых определяйте информацию, которую нужно донести до клиента, отработку его возможных возражений и т.д., то есть всё, что должно быть на этом этапе и что приведет к переходу на следующий.
4. Каждый шаг оформите в форме диалога с клиентом.
5. Пропишите одобрения действий пользователя, чтобы наладить с ним взаимодействие и установить эмоциональную связь.
6. Создайте портрет чат-бота, одушевите его: придумайте пол, имя, аватар. Определите его статус: консультант, помощник, сотрудник поддержки, друг пользователя и т. д.
7. На каждом шаге предусмотрите вариант перевода разговора на живого оператора.

Для разных видов ботов подходят разные типы сценариев. Возможные варианты:

• «Пещера времени» («Пирамида»). Универсальный и простейший тип сценария, оптимальный для приложений, ведущих консультации по услугам и товарам. Бот присылает первое сообщение, чтобы узнать вопросы клиента, а затем, в зависимости от ответа, предлагает ряд вариантов. Может использоваться для интернет-магазинов, бизнес-консультантов, техподдержки.
• «Перчатка». Тип сценария, основой которого является столб в центре. От него идут в стороны ветви, которые завершаются прекращением работы бота или возвратом назад на несколько шагов. Подходит для учебных курсов. Бот отправляет материалы, задаёт финальный вопрос и, проанализировав ответ, решает, стоит ли переходить к новому заданию или вернуться назад для повтора. Также может быть использован для тренажёров и воронок продаж.
• «Перчатка 2.0» («Ветвистая схема», «Ветки и бутылочное горлышко»). Как и предыдущий вид сценария, имеет столб в центре и ответвления, но последние в определённых местах могут пересекаться на ключевых моментах. Сделан для разработки объёмных приложений в бизнесе, с внушительным функционалом.
• «Игровая модель». Сценарий реализуется в виде теста, квеста или квиза, имеет множество соединяющихся ветвей, предполагающих несколько финалов. Подходит для учёбы: информация в игровой форме лучше запоминается.
• «Свободное пространство». Сценарий подразумевает развитие в обе стороны. Есть центральный столб, от него идут ответвления, от которых, в свою очередь, идут блоки. Простая, наглядная и понятная схема.
• «Открытая карта». Пользователь свободно перемещается между уровнями взаимодействия с ботом. Применяется для приложений, включающих себя несколько более простых ботов, выполняющих различные функции.

От продуманного выбора сценария будет зависеть эффективность вашего приложения.

Полезные рекомендации по созданию ботов

Ряд советов и рекомендаций, которые помогут в написании эффективного бота:

1. Чётко определяйте задачи, которые будет решать приложение: это поможет вам или людям, которые будут работать над вашим заказом, добиться результата, который вы хотите получить.
2. Приветствуя пользователя, бот должен рассказать, какие задачи он выполняет, как он работает и как он может помочь людям. Это упростит взаимодействие человека и бота.
3. Работая над ботом, стремитесь, чтобы на вопросы, которые он задавал, можно было дать односложный ответ, или же предоставляйте выбор из нескольких вариантов (для каждого отдельная кнопка). Не используйте способ взаимодействия, при котором пользователь сможет на вопрос приложения ввести развёрнутый ответ: это может сбить бота, и он не выполнит свою задачу.
4. Чтобы бот не отклонялся от сценария, прописывайте его работу так, чтобы он мог вернуться к тем темам разговора, которые ему знакомы, если пользователь уводит диалог в сторону.
5. Бот должен задавать уточняющие вопросы, которые помогут точно установить потребности пользователя и, если ему не удается этого сделать, нужно, чтобы он переводил разговор на живого сотрудника.
6. При взаимодействии с приложением пользователи могут отправлять ему сообщения или выбирать нужные варианты ответа из предложенных кнопок. Остановитесь на втором варианте: так бот не собьётся со сценария, если человек начнёт писать развёрнутые вопросы или спрашивать о том, что не прописано в сценарии.
7. Определите вашу потенциальную аудиторию и настройте боту стиль общения, максимально ей соответствующий.
8. Не предлагайте слишком много функций сразу: это запутает пользователей. Лучше изначально установить минимум возможностей, а затем постепенно добавлять новые, предупреждая о них людей и объясняя, как ими пользоваться.
9. Всегда должен быть человек, на которого бот может перевести диалог. Это нужно для работы с конфликтными клиентами или в случаях, когда возможностей приложения недостаточно.
10. По возможности используйте конструкторы чат-ботов вместо программирования: они просты в использовании и, потратив немного времени на обучение, вы сможете сами создавать чат-ботов и проектировать их именно так, как вам нужно. Если у вас нет навыков программирования, обучиться ему будет сложнее, а заказ приложения у программистов потребует дополнительного вливания средств.
11. Тестируйте чат-бота перед запуском: убедитесь, что он работает правильно и решает вопросы пользователей.
12. Продвигайте чат-бота. Если у вас есть сайт, расскажите там о приложении. Напишите о нём в ваших группах и сообществах в соцсетях и мессенджерах. Если вы работаете с людьми напрямую, например, оказываете какие-либо услуги, сообщайте им, что можно воспользоваться ботом, например, чтобы записаться к вам на консультацию или получить информацию о товарах или услугах.

Следуйте этим правилам, и получившийся бот будет хорошо взаимодействовать с пользователями и помогать им в решении их вопросов.

Вопросы и ответы по чат-ботам (FAQ)

— Что выбрать: создать чат-бота через конструктор или заказать у программиста?
— Возможны оба варианта, но самостоятельная работа над приложением в визуальном конструкторе будет дешевле, чем обращение к программистам. При этом вы будете контролировать каждый шаг при разработке приложения и сможете получить именно тот результат, который максимально отвечает вашим запросам.

— Где можно использовать чат-ботов, в каких социальных сетях или мессенджерах?
— Область применения чат-ботов очень широка. Обычно их используют в телеграме, реже — в ВК, но вы можете сделать чат-бота для WhatsApp, Viber, «Одноклассников», Инстаграм* или Facebook, для вашего сайта. Приложения могут быть разработаны для внешнего общения с клиентами, партнёрами или иными людьми, а также для внутреннего, например, в компании для проверки выполненных задач или для работы с отчётами.

— Кто такие боты и почему они так называются?
— Бот (сокращение от слова «робот») – это небольшое приложение или программа, способная выполнять определённые задачи при взаимодействии с пользователем. Боты могут использоваться в личных целях и в бизнесе, область их применения очень широка.

— Почему чат-боты стали так популярны?
— Чат-боты популярны, потому что они могут упростить выполнение самых разных задач: с их помощью вы не забудете о важном событии, сможете скачать видео или музыку, переведёте иностранные слова и т.д. В бизнесе чат-боты помогают наладить процесс взаимодействия с клиентами, улучшить продажи и существенно экономить на сотрудниках: сегодня такие приложения успешно работают в техподдержке, выступают в качестве персональных ассистентов, оформляют продажи и доставку товаров, записывают на приём или на консультацию, а также решают множество других задач. Даже если вы заказываете их разработку у программистов или на сайтах с конструкторами ботов, это окупится на дистанции, так как вы улучшите работу с клиентами, а, соответственно, и продажи, а также сможете сэкономить на оплате работы сотрудников, которых заменит приложение.

— Можно подключить ботов к другим сервисам и платформам?
— Да, боты сегодня успешно интегрируются с другими площадками. Это могут быть платёжные или CRM-системы, сервисы Google (Google Таблицы и т.д.), обучающие платформы, телефония, сервисы рекламы и многое другое.

Бот в Telegram — это популярное решение для бизнесов и компаний, которые хотят автоматизировать коммуникацию с аудиторией, улучшить взаимодействие с клиентами в мессенджере или создать развлекательную площадку. Рассказываем, как сделать чат-бота в Телеграме, начиная от идеи и заканчивая его размещением на сервере.

• Что такое чат-боты и зачем они нужны?
• Руководство по разработке и запуску чат бота в Телеграм
  • Шаг 1: подготовка к созданию бота
  • Шаг 2: регистрация бота через BotFather
  • Шаг 3: установка Python и библиотек
  • Шаг 4: написание простого бота
  • Шаг 5: тестирование
• Как сделать бота Telegram более функциональным?
  • Кнопки и команды
  • Интеграция с внешними платформами
• Как развернуть Telegram-бота на сервере?

Что такое чат-боты и зачем они нужны?

Чат-бот в Телеграм — это программа, работающая внутри мессенджера Телеграм. Она может отвечать на сообщения, выполнять заранее установленные команды, отправлять уведомления и взаимодействовать с другими сервисами. На вопрос «Как работает чат-бот в Телеграме?» можно ответить просто: он использует Telegram Bot API для связи с пользователями в мессенджере.

Чат-боты многофункциональны, их можно использовать для решения разных задач:

• Бизнес-задачи. Автоматизация обработки заявок, сбор отзывов, автоворонки для продажи товаров и услуг.
• Развлечения. Игры, викторины или общение с ИИ-ботом.
• Образование. Виртуальные ассистенты с предписанными обучающими материалами.

Руководство по разработке и запуску чат бота в Телеграм

Если вам интересно, как написать чат-бота на Python в Телеграмме, следуйте пошаговой инструкции о том, как создать бот в Телеграмме самостоятельно, приведенному ниже.

Шаг 1: подготовка к созданию бота

Прежде чем начать, определитесь, какую бизнес-задачу решает ваш чат-бот и какой ему нужен функционал. Например, у информационного сервиса об актуальных погодных условиях и у бота для тестов на определения уровня депрессии разные задачи и функции. Первый должен высылать уведомления, тогда как второй предполагает несколько сценариев коммуникации.

Еще до начала создания Telegram-бота понадобится:

• Учетная запись Telegram.
• Знания Python, который можно освоить на курсе Python-разработчик.
• Хостинг для размещения бота (Heroku, AWS и т. д.).

Шаг 2: регистрация бота через BotFather

1. Найдите бота @BotFather в Telegram.
2. Отправьте команду /newbot.
3. Укажите имя и @username для бота. Username обязательно должен заканчиваться словом bot.
4. BotFather выдаст вам токен для доступа к Telegram Bot API.

Важно: токен должен храниться только у владельца бота, передавать его другим лицам нельзя. Если токен скомпрометирован, то необходимо пересоздать его. Для каждого бота нужно создавать отдельный токен.

Читайте также:
Что такое хостинг?

Шаг 3: установка Python и библиотек

Поскольку мы разрабатываем телеграм-бот на Python, нужно начать с настройки виртуального окружения и установки библиотеки для удобного создания ботов.

1. Скачайте Python с официального сайта (об установке Python детальнее написано здесь).
2. Установите библиотеку python-telegram-bot:

pip install python-telegram-bot

1. Если ваша ОС — Windows, убедитесь, что при установке вы отметили опцию «Add Python to PATH». Это упростит доступ к Python из командной строки.

В терминале выполните:

python -m venv myenv

Где myenv — это название виртуального окружения.

Активируйте окружение:

• На Windows:
  
myenv\Scripts\activate

• На macOS/Linux:
  
source myenv/bin/activate


После активации в командной строке должно появиться название окружения:

(myenv) C:\>

Шаг 4: написание простого бота

Самый простой из возможных ботов называется эхо-бот. Он просто повторяет сообщения, отправленные пользователем. Если пользователь пишет «Привет», бот отвечает «Привет». Это идеальная отправная точка для новичков в программировании ботов, поскольку он помогает понять, как работает взаимодействие между пользователем и ботом через Telegram Bot API.

На примере эхо-бота мы увидим:

• Как обрабатывать входящие сообщения.
• Как отправлять ответы пользователю.
• Как настроить основную структуру бота.

Вот пример простого эхо-бота, который отвечает на сообщения пользователя:

from telegram import Update
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, CallbackContext

# Обработчик входящих сообщений

def echo(update: Update, context: CallbackContext):
    update.message.reply_text(update.message.text)

# Основная функция
def main():
    # Инициализация Updater
    updater = Updater("BOT_TOKEN")

    # Диспетчер для обработки входящих обновлений
    dp = updater.dispatcher

    # Добавляем обработчик сообщений
    dp.add_handler(MessageHandler(Filters.text & ~Filters.command, echo))

    # Запуск бота
    updater.start_polling()

    # Ожидаем завершения работы (например, через Ctrl+C)
    updater.idle()

if __name__ == '__main__':
    main()

Разберем ключевые части:

1. Импорт библиотек Updater, CommandHandler, MessageHandler, Filters, CallbackContext. Эти библиотеки предоставляют инструменты для взаимодействия с Telegram и для настройки логики бота.
2. Функция обработки сообщений:
   • update.message.text содержит текст сообщения, отправленного пользователем.
   • reply_text отправляет этот текст обратно пользователю.
3. Основная функция:
   • Updater: управляет обменом данными с Telegram.
   • Dispatcher (dp): распределяет задачи между обработчиками.
   • MessageHandler: отвечает за обработку текстовых сообщений.
   • start_polling: запускает цикл обработки новых сообщений.

Также интересно:
Как я писал telegram бот с админкой на Django

Шаг 5: тестирование

Запустите скрипт и отправьте сообщение вашему боту в Telegram. Он должен ответить, повторяя ваше сообщение. При тестировании нужно проверить каждую функцию вашего бота, чтобы убедиться в корректности его работы и избежать неприятных сюрпризов.

Как сделать бота Telegram более функциональным?

Эхо-бот — это лишь основа. После успешного тестирования вы можете:

• Добавить команды, например /start, /help.
• Разработать интерактивное меню с кнопками.
• Интегрировать API сторонних сервисов, чтобы бот мог, например, показывать погоду.
• Превратить его в полноценного чат-бота с искусственным интеллектом.

Кнопки и команды

Они упрощают взаимодействие чат-бота с пользователями в мессенджере, позволяя пользователю выбрать доступное действие из списка. Вот пример, как их можно создать:

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

def start(update: Update, context: CallbackContext):
    keyboard = [[InlineKeyboardButton("Кнопка 1", callback_data='1'),
                 InlineKeyboardButton("Кнопка 2", callback_data='2')]]
    reply_markup = InlineKeyboardMarkup(keyboard)
    update.message.reply_text('Выберите опцию:', reply_markup=reply_markup)

Разберем ключевые части.

1. Импорты InlineKeyboardButton используются для создания кнопок с текстом и данными (callback_data). InlineKeyboardMarkup задает структуру клавиатуры для размещения кнопок.
2. Функция start активируется, когда пользователь вводит команду /start.
3. Переменная keyboard:
   • Список списков, где каждый вложенный список — это строка кнопок на клавиатуре.
   • Кнопка создается с помощью InlineKeyboardButton, ее текст отображается пользователю, а callback_data передается при нажатии для последующей обработки.
4. Переменная reply_markup используется для прикрепления кнопок к сообщению.
5. Метод reply_text отправляет сообщение пользователю вместе с разметкой клавиатуры (reply_markup), которая позволяет пользователю выбирать опции, нажимая на кнопки.

Интеграция с внешними платформами

Бота можно интегрировать с различными платформами, такими как CRM, социальными сетями и другими ресурсами. Например, добавим прогноз погоды через OpenWeather API:

1. Получите API-ключ на OpenWeather.
2. Напишите функцию:

import requests

def get_weather(city):
    api_key = "API_KEY"  # Замените на ваш ключ API из OpenWeather
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"

    try:
        response = requests.get(url)
        response.raise_for_status()  # Проверяем, нет ли ошибок HTTP
        data = response.json()

        if 'main' in data:
            return f"Температура в {city}: {data['main']['temp']}°C"
        else:
            return f"Не удалось получить данные о погоде для города: {city}. Убедитесь, что название введено правильно."
    except requests.exceptions.RequestException as e:
        return f"Произошла ошибка при запросе: {e}"

if __name__ == "__main__":
    city = input("Введите название города: ")  # Запрос ввода города у пользователя
    print(get_weather(city))

Как развернуть Telegram-бота на сервере?

Чтобы Telegram-бот работал 24/7, его нужно разместить на сервере. Один из самых простых способов — использовать Heroku. Heroku — это PaaS (Platform as a Service), то есть платформа как услуга, которая предоставляет готовую инфраструктуру для запуска приложений, включая серверы, базы данных и инструменты для деплоя. С помощью Heroku вы можете разместить своего Telegram-бота, чтобы он работал круглосуточно, без необходимости настраивать и поддерживать сервер самостоятельно. Сделать это несложно:

1. Зарегистрируйтесь на Heroku.
2. Создайте requirements.txt (список зависимостей вашего проекта), выполнив команду:
   python
pip freeze > requirements.txt

3. Установите Heroku CLI и загрузите свой код.

Не забудьте протестировать работу бота после разворачивания его на сервере.

Теперь вы знаете, как сделать бота в Telegram. Это не только полезный навык, но и увлекательный процесс. Научиться создавать Telegram-ботов, а также автоматизировать другие бизнес-задачи, можно на курсе Python-разработчика от компании Хекслет.