ChatterBot: чат-бот на Python с обучением на своих данных

Библиотека Python ChatterBot позволяет быстро создавать чат-бота для командной строки всего за пару строк кода. Вы настраиваете базового бота, очищаете данные переписки Telegram с помощью регулярных выражений и обучаете его на этом пользовательском наборе данных. Кроме того, через Ollama подключаете локальную языковую модель (LLM), чтобы расширить возможности бота за счет дополнительной информации

К концу этого руководства вы поймёте, что:

• ChatterBot — это библиотека Python, которая сочетает обработку текста, машинное обучение и локальную базу данных для генерации ответов чат-бота
• Минимальный скрипт ChatterBot создаёт экземпляр ChatBot, собирает пользовательский ввод в цикле и возвращает подходящие ответы через .get_response()
• Обучение с помощью ListTrainer и настроек по умолчанию сохраняет пары диалогов в базе данных SQLite, которую ChatterBot запрашивает с использованием расстояния Левенштейна для выбора каждого ответа
• ChatterBot может вызывать локальную LLM через OllamaLogicAdapter, конкурируя с другими логическими адаптерами по показателю уверенности
• ChatterBot был возрождён в 2025 году с поддержкой NLP на основе spaCy, тренерами для CSV и JSON, а также экспериментальной поддержкой LLM

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

Предварительный просмотр чат-бота

В конце этого руководства у вас будет чат-бот для командной строки, способный отвечать на ваши сообщения полуосмысленными репликами

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

Обзор проекта

Библиотека ChatterBot объединяет обработку текста и алгоритмы машинного обучения, а также позволяет эффективно хранить и извлекать информацию. Это дает вам возможность создавать специализированные чат-боты, отвечающие определённым задачам

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

Примечание: после долгого перерыва ChatterBot был возрождён в начале 2025 года с поддержкой современного Python, новыми форматами обучения для данных CSV и JSON, а также экспериментальной интеграцией с LLM. Под капотом ChatterBot теперь использует spaCy для обработки языка, что обеспечивает более надёжный конвейер NLP (обработки естественного языка), чем прежде

В этом руководстве вы начнёте с необученного чат-бота, который продемонстрирует, насколько быстро можно создать интерактивного чат-бота с помощью Python ChatterBot. Вы также заметите, насколько мал словарный запас необученного чат-бота

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

Вам понадобится либо история переписки одного из ваших Telegram-чатов, либо предоставленный файл chat.txt. Обычно данные приходят не в том формате, который нужен, поэтому вам предстоит очистить экспортированные данные, чтобы привести их в удобный для работы вид. Это поможет освоить инструменты очистки данных, которые пригодятся для подготовки других входных данных для вашего чат-бота

Очистив данные, вы повторно обучите чат-бота и протестируете его, чтобы оценить улучшенные результаты. В конечном итоге вы подключите локальную LLM к вашему чат-боту, что позволит ему давать более разнообразные и актуальные ответы

Завершив все этапы, вы получите ясное представление о процессе разработки и обучения чат-бота на Python с использованием библиотеки ChatterBot, обеспечивая пользователям интерактивное взаимодействие и релевантные ответы

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

По этой теме полезно отдельно посмотреть Аннотации типов для декораторов в Python, чтобы расширить контекст и сравнить подходы

Предварительные требования

Прежде чем начать, убедитесь, что у вас установлен Python 3.10 или более поздней версии — это минимальная версия Python, которую поддерживает ChatterBot. Если вам нужна помощь с настройкой Python, обратитесь к руководству по установке и настройке Python 3

Как только у вас будет подходящая версия Python, вы готовы приступить к работе. В ходе руководства вы затронете несколько концепций Python:

• Условные операторы
• Циклы while для итерации
• Списки и кортежи
• Функции Python
• Проверка подстрок и замена подстрок
• Ввод/вывод файлов
• Включения Python и генераторные выражения
• Регулярные выражения (regex) с использованием re

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

Вы всегда можете остановиться и изучить дополнительные ресурсы, если зайдёте в тупик

Создание чат-бота с помощью ChatterBot

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

Чтобы начать работу над проектом, создайте и активируйте виртуальное окружение, затем установите chatterbot:

$ python -m venv venv
$ source venv/bin/activate
(venv) $ python -m pip install chatterbot

Эта команда установит ChatterBot и все его зависимости в новое виртуальное окружение Python

После завершения установки команда python -m pip freeze выведет список установленных зависимостей — он должен совпадать с содержимым файла requirements.txt из примера кода к этому руководству

Установка завершена — можно приступать. Создайте новый файл Python, назовите его bot.py и добавьте код для запуска базового чат-бота:

1 from chatterbot import ChatBot
2
3 chatbot = ChatBot("Chatpot")
4
5 exit_conditions = (":q", "quit", "exit")
6 while True:
7 query = input("> ")
8 if query in exit_conditions:
9 break
10 else:
11 print(f"🪴 {chatbot.get_response(query)}")

После импорта ChatBot в строке 1 вы создаёте экземпляр ChatBot в строке 3. Единственный обязательный аргумент — имя, и здесь оно задано как "Chatpot". Нет, это не опечатка — в этом руководстве мы действительно создаём болтливый чат-бот в образе цветочного горшка. Горшки, как вы скоро убедитесь, не лучшие собеседники

В строке 6 запускается цикл while, который продолжает работу до тех пор, пока пользователь не введёт одно из условий выхода, определённых в строке 5. В строке 11 вызывается .get_response() на экземпляре ChatBot, которому передаётся пользовательский ввод из строки 7, сохранённый в переменной query

Вызов .get_response() — это единственное взаимодействие с чат-ботом в этом коротком скрипте. И тем не менее у вас уже есть работающий чат-бот в командной строке, с которым можно поиграть

При первом запуске bot.py ChatterBot может выдать подробное сообщение об ошибке — о том, что языковая модель spaCy для обработки текста отсутствует:

Traceback (most recent call last): ...
chatterbot.chatterbot.ChatBot.ChatBotException: Setup error: The Spacy model for "English" language is missing.
Please install the model using the command:
python -m spacy download en_core_web_sm
See https://spacy.io/usage/models for more information about available models.

Если вы столкнулись с этим, выполните предложенную команду для установки недостающей языковой модели:

(venv) $ python -m spacy download en_core_web_sm

Команда выведет в консоль информацию об установке. При последующих запусках Python не будет загружать эти данные повторно

Когда всё готово, запустите файл:

(venv) $ python bot.py

Вы увидите знак «больше» (>), заданный в bot.py в качестве приглашения для ввода. Можно начинать общение с болтливым горшком:

> hello
🪴 hello
> are you a plant?
🪴 hello
> can you chat, pot?
🪴 hello

Chatpot отвечает, но явно не может выйти за рамки одной фразы. Сложно ожидать большего от горшечного растения — оно никогда не видело мира

Примечание: В Windows PowerShell эмодзи с горшечным растением (🪴) может отображаться некорректно. Его можно заменить любым другим символом приглашения

Даже если чат-бот пока мало что говорит, он уже учится. Чтобы проверить это, остановите текущий сеанс, введя одно из условий выхода — ":q", "quit" или "exit". Затем снова запустите чат-бот. Введите другое сообщение — и вы заметите, что бот помнит то, что вы вводили в предыдущем сеансе:

> hi
🪴 hello
> what's up?
🪴 are you a plant?

При первом запуске ChatterBot создал файл базы данных SQLite, в котором сохранил все вводы и связал их с возможными ответами. В рабочем каталоге должны появиться три новых файла:

./
├── bot.py
├── db.sqlite3
├── db.sqlite3-shm
└── db.sqlite3-wal

ChatterBot использует стандартный SQLStorageAdapter и создаёт файловую базу данных SQLite, если не указан другой адаптер хранилища

Примечание: Основной файл базы данных — db.sqlite3, тогда как два других, с расширениями -wal и -shm, являются временными вспомогательными файлами. Они существуют только во время активного сеанса разговора

Поскольку в начале чата были введены и hello, и hi, Chatpot усвоил, что эти сообщения можно использовать взаимозаменяемо. Это означает: чем больше вы общаетесь с новым чат-ботом, тем постепенно лучше становятся его ответы. Но улучшать ответы вручную — процесс долгий

Теперь, когда работающий чат-бот в командной строке готов, следующий шаг — обучение, чтобы разговоры стали немного интереснее

Базовое обучение чат-бота через ListTrainer

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

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

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

1 from chatterbot import ChatBot
2 from chatterbot.trainers import ListTrainer
3
4 chatbot = ChatBot("Chatpot")
5
6 trainer = ListTrainer(chatbot)
7 trainer.train([
8 "Hi",
9 "Welcome, friend 🤗",
10 ])
11 trainer.train([
12 "Are you a plant?",
13 "No, I'm the pot below the plant!",
14 ])
15
16 exit_conditions = (":q", "quit", "exit")
17 while True:
18 query = input("> ")
19 if query in exit_conditions:
20 break
21 else:
22 print(f"🪴 {chatbot.get_response(query)}")

В строке 2 импортируется ListTrainer, которому в строке 6 передаётся экземпляр чат-бота для создания объекта trainer

В строках 7–10 настраивается первый раунд обучения: в trainer.train() передаётся список из двух строк. Вызов .train() добавляет записи в базу данных, расширяя граф-структуру (graph structure), которую ChatterBot использует для выбора возможных ответов

Примечание: Если в ListTrainer.train() передаётся итерируемый объект ровно из двух элементов, ChatterBot считает первый элемент высказыванием, а второй — допустимым ответом на него

В строках 11–14 добавляется ещё одна пара «высказывание — ответ» в базу данных чат-бота. Проводить несколько сессий обучения можно без ограничений

Если теперь снова запустить интерактивного чат-бота командой python bot.py, ответы станут заметно разнообразнее:

> hi
🪴 Welcome, friend 🤗
> hello
🪴 are you a plant?
> me?
🪴 are you a plant?
> yes
🪴 hi
> are you a plant?
🪴 No, I'm the pot below the plant!
> cool
🪴 Welcome, friend 🤗

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

Библиотека ChatterBot поставляется с несколькими корпусами, которые можно использовать для обучения. Для работы с ними предназначен ChatterBotCorpusTrainer — он без проблем работает с актуальными версиями Python

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

from chatterbot.trainers import JsonFileTrainer

Экспорт истории чата из Telegram

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

Если вы собираетесь работать с предоставленным образцом истории чата, переходите сразу к следующему разделу — там мы займёмся очисткой экспорта

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

• Нажмите на три точки (⋮) в правом верхнем углу, чтобы открыть главное меню
• Выберите Ещё, чтобы открыть дополнительные пункты меню
• Выберите Экспортировать чат, чтобы создать TXT-экспорт переписки

На составных скриншотах ниже вы можете видеть три последовательных шага, пронумерованных и выделенных красным

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

В этом примере файл экспорта был сохранён в папку Google Drive с названием Chat exports. Папку нужно создать заранее, чтобы она появилась в качестве варианта. Использовать Google Drive необязательно — главное сохранить или отправить файл так, чтобы получить к нему доступ на компьютере

После этого вернитесь к компьютеру, найдите сохранённый файл и скачайте его на свою машину

Сохраните файл в папку, где находится bot.py, и переименуйте его в chat.txt. Затем откройте его в любимом текстовом редакторе, чтобы изучить полученные данные:

1/15/26, 14:50 - Messages and calls are end-to-end encrypted.
⮑ Only people in this chat can read, listen to, or share them. *Learn more*
1/15/26, 14:49 - Philipp: Hi Martin, Philipp here!
1/15/26, 14:50 - Philipp: I'm ready to talk about plants!
1/15/26, 14:51 - Martin: Oh that's great!
1/15/26, 14:52 - Martin: I've been waiting for a good convo about
⮑ plants for a long time
1/15/26, 14:52 - Philipp: We all have.
1/15/26, 14:52 - Martin: Did you know they need water to grow?
...

Если вспомнить, как ChatterBot обрабатывает обучающие данные, становится очевидно, что этот формат не идеален для обучения

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

Чтобы избежать этой проблемы, данные экспорта нужно очистить перед подачей в ChatterBot

Очистка экспортированных данных регулярными выражениями

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

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

Мусор на входе — мусор на выходе

Уделите время изучению данных и выявлению потенциальных проблем:

1/15/26, 14:50 - Messages and calls are end-to-end encrypted.
⮑ Only people in this chat can read, listen to, or share them. *Learn more*
...
1/15/26, 14:50 - Philipp: I'm ready to talk about plants!
...
1/16/26, 06:34 - Martin: <Media omitted>
...

Например, первая строка экспорта — это системное уведомление, а не часть разговора. Каждое реальное сообщение начинается с метаданных: дата, время и имя отправителя. Если прокрутить файл дальше, встретятся строки <Media omitted> — Telegram заменяет ими медиафайлы, которые вы не включили в экспорт

Все эти данные будут мешать выводу чат-бота и сделают его речь значительно менее разговорной. Поэтому имеет смысл удалить их до начала обучения

Откройте новый файл Python для предварительной обработки данных перед передачей их в ChatterBot. Начните с чтения содержимого файла и удаления метаданных чата:

1 import re
2
3 def remove_chat_metadata(chat_export_file):
4 date_time = r"(\d+\/\d+\/\d+,\s\d+:\d+)" # e.g. "1/15/26, 14:50"
5 dash_whitespace = r"\s-\s" # " - "
6 username = r"([\w\s]+)" # e.g. "Martin"
7 metadata_end = r":\s" # ": "
8 pattern = date_time + dash_whitespace + username + metadata_end
9
10 with open(chat_export_file, "r") as corpus_file:
11 content = corpus_file.read()
12 cleaned_corpus = re.sub(pattern, "", content)
13 return tuple(cleaned_corpus.split("\n"))
14
15 if __name__ == "__main__":
16 print(remove_chat_metadata("chat.txt"))

Эта функция удаляет метаданные сообщений из файла экспорта с помощью встроенного модуля re (регулярные выражения):

Строка 1 импортирует re

Строки 4–7 определяют несколько шаблонов регулярных выражений. Создание нескольких шаблонов помогает отслеживать, что именно вы сопоставляете, и даёт гибкость для использования отдельных групп захвата при дальнейшей предобработке. Например, имея доступ к username, вы могли бы группировать разговоры, объединяя сообщения, последовательно отправленные одним и тем же пользователем

Строка 8 объединяет шаблоны из строк 4–7 в единый шаблон, который соответствует всем метаданным, подлежащим удалению

Строки 10 и 11 открывают файл экспорта и считывают данные в память

Строка 12 использует re.sub() для замены каждого вхождения шаблона пустой строкой (""), фактически удаляя метаданные из текста

Строка 13 разбивает строку содержимого файла на элементы списка с помощью .split("\n") — каждая строка становится отдельным элементом. Затем список преобразуется в кортеж (tuple) и возвращается из remove_chat_metadata()

Строки 15 и 16 используют идиому name-main (конструкцию if __name__ == "__main__") в Python для вызова remove_chat_metadata() с аргументом "chat.txt", чтобы можно было проверить вывод при запуске скрипта

В конечном счёте вы будете использовать cleaner как модуль и импортировать функциональность непосредственно в bot.py. Но пока вы разрабатываете скрипт, полезно проверять промежуточные результаты с помощью вызова print(), как показано в строке 16

Примечание: Рекомендуется часто запускать скрипт в процессе разработки. В качестве альтернативы выводу результатов можно использовать breakpoint() для проверки кода с помощью pdb. Отладчик pdb позволяет взаимодействовать с объектами кода в интерактивном режиме, а не просто выводить их статическое представление

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

1 # ...
2
3 def remove_non_message_text(export_text_lines):
4 messages = export_text_lines[1:-1]
5
6 filter_out_msgs = ("<Media omitted>",)
7 return tuple((msg for msg in messages if msg not in filter_out_msgs))
8
9 if __name__ == "__main__":
10 message_corpus = remove_chat_metadata("chat.txt")
11 cleaned_corpus = remove_non_message_text(message_corpus)
12 print(cleaned_corpus)

В remove_non_message_text() написан код для удаления нерелевантных строк из корпуса разговора:

Строка 4 удаляет первую вводную строку, которая присутствует в каждом экспорте чата Telegram, а также пустую строку в конце файла

Строка 6 создаёт кортеж, в котором определяются строки, подлежащие исключению из обучающих данных. Пока он содержит только одну строку, но при необходимости можно быстро добавить дополнительные элементы

Строка 7 фильтрует сообщения по строкам из filter_out_msgs с помощью генераторного выражения (generator expression), которое преобразуется в кортеж перед возвратом

Строки 10–12 также изменились: теперь возвращаемое значение первого вызова функции сохраняется в переменной message_corpus, затем используется как аргумент для remove_non_message_text(). Результат сохраняется в cleaned_corpus и выводится в консоль в строке 12

Поскольку вы хотите использовать cleaner как модуль и запускать код очистки в bot.py, лучше всего выполнить рефакторинг (refactoring) кода в идиоме name-main, преобразовав его в функцию main, которую затем можно импортировать и вызывать в bot.py:

1 import re
2
3 def clean_corpus(chat_export_file):
4 message_corpus = remove_chat_metadata(chat_export_file)
5 cleaned_corpus = remove_non_message_text(message_corpus)
6 return cleaned_corpus
7
8 # ...
9
10 # Deleted: if __name__ == "__main__":

Вызовы функций перемещаются из идиомы name-main в отдельную функцию clean_corpus(), которая определяется в начале файла. В строке 4 строка "chat.txt" заменяется параметром chat_export_file, чтобы сделать функцию универсальной — имя файла передаётся при вызове. Функция clean_corpus() возвращает очищенный корпус, готовый к использованию для обучения чат-бота

После создания модуля очистки можно вернуться к bot.py и интегрировать этот код в общий конвейер обработки данных

Обучение чат-бота на пользовательских данных

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

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

Поэтому удалите упоминания ListTrainer из bot.py и откройте новый файл — назовём его trainer.py. Добавьте нужные импорты и вызовите основную функцию очистки:

1 from chatterbot import ChatBot
2 from chatterbot.trainers import ListTrainer
3 from cleaner import clean_corpus
4
5 CORPUS_FILE = "chat.txt"
6
7 chatbot = ChatBot("Chatpot")
8 trainer = ListTrainer(chatbot)
9 cleaned_corpus = clean_corpus(CORPUS_FILE)
10 trainer.train(cleaned_corpus)

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

Строка 3 импортирует clean_corpus() из cleaner

Строка 5 определяет имя файла экспорта чата. В примере предполагается, что файл называется "chat.txt" и находится в том же каталоге, что и trainer.py. Для более продвинутой обработки путей стоит обратить внимание на модуль pathlib в Python

Строка 9 применяет код очистки к файлу истории чата и возвращает кортеж (tuple) очищенных сообщений — cleaned_corpus

Строка 10 передаёт эти данные в .train(), который обновляет базу данных SQLite обучающими данными

После запуска скрипта база данных пополнится данными из переписки Telegram, и чат-бот сможет ими пользоваться

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

Вы также можете предоставлять более длинные списки обучающих диалогов. Это установит каждый элемент в списке как возможный ответ на предшествующий ему элемент. (Источник)

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

Чтобы справиться с этим, можно применить дополнительную предобработку (preprocessing) данных — например, объединить все сообщения одного человека в одну строку или разбить экспорт по времени и дате. Тогда сообщения, отправленные в течение определённого периода, можно считать единым разговором

Всегда найдётся что ещё почистить, чтобы улучшить входные данные. Но для этого руководства пришло время снова запустить разговорного чат-бота о комнатных растениях. Запустите bot.py и пообщайтесь со своим болтливым горшком, чтобы проверить, как изменились ответы после обучения:

> hi
🪴 Welcome, friend 🤗
> thanks for the green welcome
🪴 I let you
> you let me be here?
🪴 It's a monsters!
> did you mean monstera?
🪴 The leafs are getting dryer and dryer. But she's growing new ones
> who?
🪴 Do raindrops touch their leaves?
> very philosophical!
🪴 Lol
> ;)
🪴 I don't grow any crop at home
> no crops in pots
🪴 Ah, gotcha!
> ah, I just thought you meant that
🪴 But water makes sense
> yes, water in pots
🪴 Do you have any plant care pro tips?
> water.
🪴 I always thought that love and music was more than enough
> haha
🪴 Well, no. Just the balcony. This worked best
> ok, balcony is notes
🪴 I let you

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

ChatterBot использует полные предложения в качестве ответов, а обучение проводилось лишь на небольшой выборке разговорных данных. Маленький объём обучающего корпуса означает ограниченный пул ответов для выбора. К тому же разговорные данные не всегда содержат предложения, пригодные в роли ответов. Но Chatpot делает всё возможное, чтобы найти наиболее подходящий ответ на каждое новое сообщение

Чтобы выбрать ответ на ввод пользователя, ChatterBot по умолчанию использует логический адаптер (logic adapter) BestMatch. Этот адаптер применяет расстояние Левенштейна (Levenshtein distance) для сравнения входной строки со всеми утверждениями в базе данных, а затем выбирает ответ на утверждение, наиболее близкое к вводу

ChatterBot также поддерживает сравнение на основе spaCy — как альтернативный метод, который может давать лучшие результаты для семантически похожих предложений

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

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

В этом разделе мы собрали всё воедино и обучили чат-бота на очищенном корпусе из экспорта переписки Telegram. На этом этапе уже можно вести забавные беседы с ботом — пусть они иногда и выходят несколько бессмысленными. В зависимости от объёма и качества обучающих данных чат-бот может быть более или менее полезным

Теперь, когда чат-бот обучен на пользовательских разговорных данных, следующий шаг — придать ему ускорение с помощью ИИ, используя локальную большую языковую модель

Интеграция локальной LLM через OllamaLogicAdapter

На предыдущем шаге мы обучили Chatpot на реальных данных разговоров и увидели, как он отвечает на основе сопоставления шаблонов и расстояния Левенштейна (edit distance). Результаты забавные, но возникает закономерный вопрос: можно ли сделать болтливый цветочный горшок чуть умнее?

Начиная с версии 1.2.7, ChatterBot имеет экспериментальную поддержку больших языковых моделей (LLM, Large Language Model) через встроенный клиент Ollama. LLM не заменяет обученные ответы — он работает вместе с существующими логическими адаптерами (logic adapters) ChatterBot. Думайте об этом как о предоставлении горшечному растению доступа к оранжерее, полной знаний

Чтобы попробовать это, установите ChatterBot с dev-дополнениями, которые подтягивают клиентские библиотеки Ollama и OpenAI:

(venv) $ python -m pip install "chatterbot[dev]"

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

$ ollama pull llama3.2:latest

Это загружает модель Llama 3.2 размером около 2 ГБ. Она достаточно мала, чтобы работать на большинстве современных ноутбуков, и достаточно мощна, чтобы дать чат-боту заметно лучшие ответы

Теперь обновите bot.py, чтобы включить конфигурацию LLM в качестве дополнительного логического адаптера. Обратите внимание: нужно явно добавить BestMatch, если вы хотите сохранить данные из предыдущего обучающего запуска:

1 from chatterbot import ChatBot
2
3 chatbot = ChatBot(
4 "Chatpot",
5 logic_adapters=[
6 {
7 "import_path": "chatterbot.logic.BestMatch",
8 },
9 {
10 "import_path": "chatterbot.logic.OllamaLogicAdapter",
11 "model": "llama3.2:latest",
12 "host": "http://localhost:11434",
13 },
14 ],
15 )
16
17 exit_conditions = (":q", "quit", "exit")
18 while True:
19 query = input("> ")
20 if query in exit_conditions:
21 break
22 else:
23 print(f"🪴 {chatbot.get_response(query)}")

В строках 9–13 второй словарь в списке logic_adapters указывает ChatterBot использовать OllamaLogicAdapter с последней моделью Llama 3.2, запущенной на локальной машине. Первый словарь, в строках 6–8, явно возвращает логический адаптер BestMatch по умолчанию, который бот использовал неявно до сих пор. Если его не добавить, бот будет использовать только LLM для генерации ответов

Перечислив оба адаптера, LLM участвует в выборе ответа ChatterBot наряду с традиционными логическими адаптерами — и обучающие данные по-прежнему имеют значение

Примечание: В таких гибридных конфигурациях каждый адаптер голосует с оценкой уверенности (confidence score) о том, насколько вероятно, что он даст хороший ответ. ChatterBot затем выбирает ответ с наивысшей оценкой. Пороги уверенности для адаптеров можно настраивать отдельно

После подключения локального LLM к чат-боту разница становится очевидной:

привет
🪴 Привет! Как проходит день?

Ты разговариваешь со своими растениями?
🪴 Да!

Что им нравится слышать?
🪴 Мотивационные речи.

Растениям нужен солнечный свет?
🪴 Да, большинству растений нужен солнечный свет для фотосинтеза, так они производят себе питание. Как поживает твой комнатный сад?

А монстерам?
🪴 Монстера любит яркий рассеянный свет. Прямое солнце может быть слишком интенсивным, поэтому окна на восток или запад подойдут отлично.

Ты правда вырос, Chatpot!
🪴 Спасибо! Я впитывал знания, как корни впитывают воду

Это весьма значительное улучшение по сравнению с теми временами, когда Chatpot умел говорить только hello. Ответы на основе LLM более чёткие и контекстуально релевантные, при этом чат-бот сохраняет свои обученные ответы. В небольшом обучающем наборе большинство обычных вопросов будут приводить к ответам на основе LLM, но обученные ответы по-прежнему срабатывают при вводе точных строк из оригинального набора

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

Если вы предпочитаете облачный LLM вместо локального, ChatterBot также имеет клиент OpenAI под названием OpenAILogicAdapter, который работает с OpenAI API. Этот вариант требует платного API-ключа и отправляет данные на серверы OpenAI

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

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

Поздравляем — вы создали Python-чат-бот с использованием библиотеки ChatterBot. Ваш чат-бот пока не является умным растением, но все с чего-то начинают. Вы уже помогли ему вырасти: обучили предобработанными данными разговоров из экспорта чата Telegram, а затем дали ИИ-буст с помощью локального LLM

В этом руководстве вы научились:

• Создавать чат-бот командной строки с ChatterBot
• Обучать чат-бот для настройки его ответов
• Подготавливать данные чата Telegram для обучения с использованием регулярных выражений
• Переобучать чат-бот на пользовательских данных разговоров
• Изучать интеграцию локального LLM ChatterBot с Ollama

Поскольку отраслевые данные чата в предоставленном экспорте Telegram были сосредоточены на комнатных растениях, Chatpot теперь имеет собственные мнения об уходе за ними — и охотно поделится ими, если спросить. Или даже если не спрашивать

С большими данными приходят большие результаты. Обучение чат-бота на большем количестве входных данных — особенно более релевантных — даёт лучшие ответы. В сочетании с LLM скромный горшечный питомец вполне способен превратиться в настоящего ботанического эксперта

Следующие шаги

ChatterBot предоставляет возможность установить библиотеку как Django-приложение. В качестве следующего шага можно интегрировать ChatterBot в Django-проект и развернуть его как веб-приложение

Вы также можете заменить бэкенд базы данных, используя другой адаптер хранилища (storage adapter). ChatterBot поддерживает MongoDB и даже Redis Vector Storage Adapter для семантического сопоставления, наряду со стандартным SQLite

После завершения этой настройки развёрнутый чат-бот сможет продолжать улучшаться на основе ответов пользователей

Даже если вы пока продолжаете запускать чат-бот в CLI, есть множество способов улучшить проект и продолжить изучение библиотеки ChatterBot:

• Обработка граничных случаев: шаблон регулярного выражения может не охватывать все имена пользователей Telegram. Стоит подбросить ему граничные случаи и повысить стабильность парсинга, одновременно создавая тесты для кода.
• Углублённое изучение регулярных выражений: курс Real Python «Regular Expressions and Building Regexes in Python» охватывает построение шаблонов, классы символов и опережающие проверки — всё это пригодится, когда формат экспорта чата становится сложнее.
• Улучшение диалогов: группируйте входные данные как разговоры, чтобы обучающие данные рассматривали последовательные сообщения одного пользователя в течение часа как единое сообщение.
• Использование тренеров CSV/JSON: если есть структурированные данные диалогов, CsvFileTrainer и JsonFileTrainer из ChatterBot позволяют загружать наборы данных в большом масштабе без написания пользовательского кода парсинга.
• Создание пользовательского логического адаптера: создайте адаптер, который срабатывает на определённые вводимые данные — например, когда пользователи просят рассказать анекдот.
• Добавление дополнительных логических адаптеров: ChatterBot поставляется с несколькими предустановленными адаптерами, например для математических вычислений и логики времени. Добавьте их, чтобы бот мог выполнять вычисления и сообщать текущее время.
• Дальнейшее изучение чат-ботов на основе LLM: если вы хотите выйти за рамки экспериментальной поддержки LLM в ChatterBot, обратитесь к материалам «Build an LLM RAG Chatbot With LangChain», «How to Integrate Local LLMs With Ollama and Python» и «How to Integrate ChatGPT’s API With Python Projects».

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

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

Ответы на эти вопросы могут быть для вас полезными

Можно ли использовать ChatterBot с облачными LLM вместо локальных?

Да. ChatterBot включает OpenAILogicAdapter, который работает с OpenAI API. Этот вариант требует платного API-ключа и отправляет данные на серверы OpenAI — в отличие от локального Ollama, который работает полностью на вашей машине

Что происходит, если оба адаптера — BestMatch и OllamaLogicAdapter — дают разные ответы?

Каждый адаптер возвращает ответ вместе с оценкой уверенности. ChatterBot выбирает ответ с наивысшей оценкой. Пороги уверенности можно настраивать, чтобы управлять тем, когда именно подключается LLM

Обязательно ли добавлять BestMatch явно при использовании OllamaLogicAdapter?

Да. Если вы указываете список logic_adapters вручную, BestMatch больше не подключается автоматически. Без него бот будет использовать только LLM и проигнорирует все обучающие данные из базы

Насколько стабильна LLM-интеграция в ChatterBot?

Функции LLM в ChatterBot помечены как экспериментальные, и API может измениться в будущих релизах. Для продакшн-сценариев стоит рассмотреть более зрелые фреймворки — например, LangChain с RAG-архитектурой

Можно ли развернуть ChatterBot как веб-приложение?

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