Привет! В этой статье разберём, как связать облачные модели с Python-приложением: дать ИИ-агенту инструменты, добавить обработку изображений, голосовой ввод и озвучку ответов. Для примеров я собрал AI Inbox, почтовый ассистент с веб-интерфейсом на FastAPI и OpenAI Agents SDK. Почта здесь даёт конкретные задачи, на которых можно проследить работу агента, а сами механики пригодятся и в других проектах.
Для экспериментов хотелось подключить всё через одного провайдера: основную модель для текста, изображений и вызова инструментов, ASR для распознавания речи и TTS для озвучки. При этом не хотелось тратить много денег и отдельно разбираться с подключением и оплатой каждой модели.
В AI Inbox агент может читать письма, делать по ним сводки, создавать задачи со сроками и готовить ответы. Например, можно загрузить фотографию счёта и попросить перенести его данные в задачу. Или продиктовать команду: приложение распознает речь и покажет текст, который можно проверить и отредактировать перед отправкой агенту. Ответы и дайджесты по непрочитанным письмам и открытым задачам можно озвучить и прослушать в браузере.
Сначала покажу запуск и несколько сценариев работы, затем перейду к реализации. Разбирать весь проект по косточкам не буду: остановлюсь на том, как модель выбирает инструменты, как приложение выполняет их вызовы, сохраняет историю диалога и передаёт ответ в браузер. На примере отправки письма разберу, как связать действие с конкретной версией черновика и отдельным подтверждением пользователя. Покажу и программную работу с почтой через IMAP и SMTP, которую используют интерфейс и агент.
Сразу оставлю исходный код проекта, чтобы по ходу статьи можно было открыть нужный модуль и посмотреть реализацию целиком.
Что понадобится для проекта
Приложение запускается локально, запросы к моделям отправляются в облако. Для этого нужны:
Почтовый ящик с доступом по IMAP для чтения писем и SMTP для отправки.
Доступ к трём моделям: LLM с поддержкой изображений и вызова инструментов, ASR для распознавания речи и TTS для озвучки текста. Извлекать текст и данные из фотографий будет сама LLM. Все три модели можно подключить через одного прокси-провайдера, как в моём случае, или через разные сервисы. Принцип работы приложения останется тем же.
Python 3.12 или новее, uv для установки зависимостей, ffmpeg и ffprobe для обработки аудио.
Подготовка почты
Для статьи я завёл отдельный ящик на Mail.ru и покажу настройку на его примере. Выбор сервиса здесь не принципиален: для этого проекта подойдёт другой ящик с доступом по IMAP и SMTP через логин и пароль приложения. Общий принцип похожий: разрешить внешнему приложению доступ к почте, получить данные для подключения и указать серверы. Названия настроек и порядок действий у сервисов могут отличаться.
В Mail.ru для программного доступа потребуется отдельный пароль для внешнего приложения. Обычный пароль, с которым вы заходите в почту, например, через браузер, здесь не подойдёт. Шаги есть в инструкции Mail.ru.
После создания ящика порядок такой:
Проверить, что к аккаунту привязан телефон: Mail.ru требует его для создания пароля приложения.
Открыть почту и перейти в Настройки → Все настройки → Безопасность → Пароли для внешних приложений.
Нажать "Создать" и указать название, например AI Inbox, чтобы потом понимать, для чего выдан пароль.

Выбрать "Полный доступ к Почте". Для своего тестового ящика я выбрал этот вариант, поскольку приложению нужны и чтение, и отправка писем.

Завершить создание и скопировать пароль. В настройках проекта адрес ящика будет в MAIL_USER, а этот пароль в MAIL_PASS.

Пароль использует серверная часть приложения при подключении к почте. Агент обращается к ней через инструменты; передавать пароль в чат не нужно.
Для Mail.ru сервер входящей почты: imap.mail.ru, порт 993; исходящей: smtp.mail.ru, порт 465. Оба подключения используют SSL/TLS.
Теперь можно проверить отправку отдельно от AI Inbox. Например, через curl. Сначала нужно сохранить тестовое письмо в файл test-email.eml, подставив свои адреса отправителя и получателя:
From: your-address@mail.ru To: recipient@example.com Subject: AI Inbox SMTP test MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Test message sent through Mail.ru SMTP.
Затем из каталога с этим файлом выполнить:
curl --url 'smtps://smtp.mail.ru:465' \ --user 'your-address@mail.ru' \ --mail-from 'your-address@mail.ru' \ --mail-rcpt 'recipient@example.com' \ --crlf \ --upload-file test-email.eml
curl запросит пароль отдельно. Здесь нужен созданный пароль для внешнего приложения. Назначение параметров описано в документации curl.
В моей проверке тестовое письмо с нового ящика пришло на Gmail:

Отправку проверил. Данные для подключения по IMAP и SMTP готовы, теперь перейду к моделям.
Подготовка моделей
Для проекта я искал доступ к моделям, который можно оплачивать из России и использовать без настройки VPN под каждый отдельный API. Хотелось также получить текст, работу с изображениями, распознавание и синтез речи с одним ключом и балансом.
В процессе поиска нашёл AnyModel. Это агрегатор моделей с OpenAI-совместимым API. Через него подключил все три модели для AI Inbox. Баланс можно пополнить российской картой, через СБП или криптовалютой, что удобно для экспериментов.
После пробных запросов остановился на такой связке:
cx/gpt-6.1-terra: диалог с агентом, сводки писем и извлечение данных из фотографий.
dg/nova-3: распознавание речи, ASR.
anyvoice/builtin-7: озвучка текста, TTS.
Повторить такую схему можно и через другого провайдера. Для проекта важно, чтобы основная LLM справлялась с письмами, извлекала данные из фотографий и вызывала инструменты с нужными аргументами. От речевых моделей нужны распознавание русской речи и понятная озвучка. Эти сценарии стоит проверить на своих примерах до подключения моделей к приложению.
Подключение начинается с регистрации на сайте. После входа в кабинете доступен раздел "API-ключ": оттуда нужны сам ключ и базовый адрес https://anymodel.org/v1.

В настройках AI Inbox этот ключ укажу как MAIN_KEY, базовый адрес как BASE_URL, а идентификаторы выбранных моделей как LLM_MODEL, ASR_MODEL и TTS_MODEL.
В кабинете можно посмотреть расходы по моделям и количество входных и выходных токенов. Это помогает отслеживать, сколько стоят запросы во время экспериментов.

Проверка подключения
Перед подключением Agents SDK можно проверить ключ и выбранную LLM обычным запросом через curl. В примере ключ вводится отдельно и сохраняется в переменную MAIN_KEY:
curl 'https://anymodel.org/v1/chat/completions' \ -H "Authorization: Bearer ${MAIN_KEY}" \ -H 'Content-Type: application/json' \ --data '{ "model": "cx/gpt-6.1-terra", "messages": [ {"role": "user", "content": "Привет! Как дела? Кто ты и чем можешь помочь?"} ], "max_tokens": 256 }'
Я выполнил этот запрос и получил ответ:

Текст ответа находится в choices[0].message.content. В этом запуске сервер вернул finish_reason: "stop", а в usage указал 154 входных и 125 выходных токенов, всего 279. Так я проверил авторизацию и получение текстового ответа от выбранного маршрута.
OpenAI-совместимый формат позволяет использовать привычный клиент с другим base_url. Поддержка инструментов, изображений и потоковых ответов зависит от выбранной модели и маршрута. В AI Inbox эти возможности использует основная LLM. При подготовке письма приложение также запрашивает JSON с темой и текстом, затем отдельно проверяет его структуру и значения.
Для распознавания речи используется /audio/transcriptions, для озвучки /audio/speech. Ключ и базовый адрес у этих запросов те же, меняются путь, идентификатор модели и формат данных.
Запуск проекта
К этому моменту должны быть готовы доступ к трём моделям и почтовый ящик с паролем приложения. Теперь покажу, как запустить AI Inbox локально и проверить его на нескольких сценариях, прежде чем переходить к реализации.
Для запуска нужны Python 3.12 или новее, uv, ffmpeg и ffprobe. Ниже использую Python 3.13. Последние две утилиты должны быть доступны в PATH: приложение вызывает их при обработке аудио.
Сначала нужно скачать проект и установить зависимости. Для повторения примеров зафиксирую версию 90f0838, на которой подготовлена статья:
git clone https://github.com/Yakvenalex/ai-inbox-habr-project.git cd ai-inbox-habr-project git checkout 90f0838 uv sync --frozen --python 3.13 cp .env.example .env
Последняя команда создаёт файл настроек из шаблона. Если .env уже заполнен, повторно копировать шаблон поверх него не нужно.

Переменные окружения
В .env.example есть все настройки проекта. Для первого запуска достаточно заполнить доступ к моделям, почте и самому приложению. Ниже фрагмент .env, остальные параметры остаются из шаблона:
AUTH_USERNAME='admin' AUTH_PASSWORD='replace-with-local-login-password' JWT_SECRET_KEY='replace-with-generated-jwt-secret' BASE_URL='https://anymodel.org/v1' MAIN_KEY='replace-with-anymodel-key' LLM_MODEL='cx/gpt-6.1-terra' ASR_MODEL='dg/nova-3' ASR_LANGUAGE='ru' TTS_MODEL='anyvoice/builtin-7' MAIL_USER='your-mailbox@mail.ru' MAIL_PASS='replace-with-mail-app-password' MAIL_IMAP_HOST='imap.mail.ru' MAIL_IMAP_PORT='993' MAIL_SMTP_HOST='smtp.mail.ru' MAIL_SMTP_PORT='465' APP_TIMEZONE='Europe/Moscow' DIGEST_ENABLED='false'
Значения с префиксом replace- нужно заменить своими, как и адрес почты. MAIN_KEY содержит ключ провайдера моделей, MAIL_PASS содержит пароль для внешнего почтового приложения. Для другого почтового сервиса нужно также заменить адреса серверов и порты.
AUTH_USERNAME и AUTH_PASSWORD задают отдельный вход в AI Inbox. Приложение рассчитано на одного владельца, регистрации пользователей здесь нет. Пароль для входа должен отличаться от почтового пароля и API-ключа.
JWT_SECRET_KEY используется для подписи токенов входа. Для него нужна отдельная случайная строка длиной не менее 32 байт. Сгенерировать её можно из каталога проекта:
uv run python -c "import secrets; print(secrets.token_urlsafe(48))"

Полученную строку нужно скопировать в JWT_SECRET_KEY. Она также должна отличаться от остальных секретов. .env исключён из Git, ключи и пароли остаются в локальной конфигурации.
На время первых проверок отключу ежедневный дайджест через DIGEST_ENABLED='false', чтобы запускать генерацию вручную. APP_TIMEZONE задаёт часовой пояс для отображения сроков и расписания; в примерах использую московское время.
Миграции и запуск
После заполнения .env нужно создать структуру SQLite через Alembic и запустить приложение:
uv run alembic upgrade head uv run python -m ai_inbox
Отдельный сервер базы данных не нужен. SQLite хранится в data/ai-inbox.sqlite3, загруженные файлы и аудио в data/media. Эти пути заданы в шаблоне настроек.
Приложение запускается одним процессом. Несколько workers и --reload для этой версии не используются: расписание и состояние текущих потоковых запросов рассчитаны на один процесс. После изменения .env приложение нужно перезапустить.
Во втором терминале можно проверить, что HTTP-сервер отвечает:
curl http://127.0.0.1:18763/health
Ожидаемый ответ:
{"status":"ok"}
Этот маршрут проверяет работу процесса. Подключение к почте и моделям он не проверяет и внешние запросы не выполняет.
Теперь можно открыть веб-интерфейс и войти с логином и паролем из AUTH_USERNAME и AUTH_PASSWORD. Документация API доступна по адресу http://127.0.0.1:18763/docs.


По адресу /docs открывается Swagger UI со списком маршрутов. Через него можно вызывать API вручную; получение токена разберу в разделе об авторизации.

Первые проверки
Перед проверкой стоит наполнить тестовый ящик. Ниже три учебных письма: одно требует ответа, во втором есть срок проверки счёта, третье оставлено для информации. Отправьте их на подключённый адрес и оставьте непрочитанными.
В примерах и на скриншотах использованы даты ноябрьской демонстрации 2026 года. При повторении замените их своими, чтобы сроки писем и задач не оказались в прошлом.
Учебные письма
Тема: Согласование встречи по проекту
Привет! Предлагаю обсудить прототип 18 ноября 2026 года в 14:00 по Москве. Встреча займёт 30 минут. Подтверди, пожалуйста, до 17 ноября, 12:00 по Москве, подходит ли время.
Это учебное письмо для демонстрации.
Тема: Проверка счёта ЖЮ-3082
Привет! Направляю учебный счёт ЖЮ-3082 на сумму 89 406,75 руб. Проверь сумму и состав работ до 19 ноября 2026 года, 09:20 по Москве. При расхождениях ответь на это письмо. Оплата не требуется.
Это учебное письмо для демонстрации.
Тема: Обновление документации
Привет! Обновил описание API и примеры запуска проекта. Изменения справочные, отвечать и выполнять действия не нужно.
Это учебное письмо для демонстрации.
Задача из фотографии счёта
Для проверки работы с изображениями прикреплю фотографию учебного счёта и попрошу: "Создай задачу проверить этот счёт со сроком из документа. В заметках сохрани номер и сумму с копейками".

В ответе на скриншоте видны номер ЖЮ-3082, сумма 89 406,75 руб. и срок 19 ноября 2026 года, 09:20 по Москве. Ниже текста появилась квитанция create_task с идентификатором созданной записи.

Затем открою "Задачи" и сверю название, заметки и срок. Так можно проверить, что результат действительно сохранён в приложении. Если в другом документе не окажется времени, его нужно уточнить в диалоге.

Задача из голосовой команды
Следующий запрос продиктую: "Напомни завтра связаться с поставщиком и уточнить реквизиты". Сначала приложение покажет расшифровку для проверки. После её переноса в поле чата отправлю текст агенту.

В команде нет времени, поэтому ассистент задаёт уточняющий вопрос. В демонстрации отвечаю: "В половине десятого утра, по Москве". После этого в чате появляется результат create_task, а в списке задач запись со сроком 17 ноября, 09:30.

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

Готовый дайджест сохраняется в одноимённом разделе. В нём собраны письма и открытые задачи; из списка можно перейти к полному тексту.

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

Для проверки TTS можно нажать "Озвучить дайджест" или "Озвучить" у ответа в чате. Запрос к речевой модели и управление воспроизведением разберу ниже. Дальше перейду к коду, который связывает эти действия.
Как это устроено
Выше я показал, как пользоваться приложением. Теперь заглянем под капот и разберём, как всё это работает: от запроса в браузере до обращения к модели, вызова инструментов и сохранения результата. Остановлюсь на семи основных механиках:
Авторизацию: отдельный вход владельца, JWT, cookie в интерфейсе и проверку доступа к API.
Работу агента: описание инструментов, их аргументов и результатов, выбор действия моделью и выполнение кода через Agents SDK.
Программную работу с почтой: IMAP и SMTP, прямые действия из интерфейса и вызовы тех же сценариев через инструменты агента. Здесь же разберу подтверждение отправки письма.
Стриминг: передачу текста и статусов инструментов в браузер по SSE.
Голосовой ввод: запись или загрузку аудио, ASR и проверку расшифровки перед отправкой команды.
Озвучку: запрос к TTS, получение MP3 и управление воспроизведением в браузере.
Интерфейс: шаблоны Jinja2, Tailwind/daisyUI и JavaScript для чата, загрузок и аудио. На этой части остановлюсь коротко.
Дальше буду исходить из того, что у вас уже есть базовое представление о FastAPI и его работе: вы знакомы с маршрутами, обработкой запросов и зависимостями через Depends. Каждую конструкцию фреймворка пояснять не буду, остановлюсь на важных блоках кода и решениях в этом проекте. Если хочется сначала разобраться с основами или углубиться в отдельную тему, у меня на Хабре есть много учебного материала по FastAPI, в том числе цикл о создании собственного API.
Авторизацию и аутентификацию покажу в том же формате: как устроен вход в AI Inbox, откуда берётся токен и как приложение проверяет доступ. Подробную теорию этих механизмов я уже разбирал в отдельной статье.
Авторизация
AI Inbox рассчитан на одного владельца. Регистрацию, таблицу пользователей и роли я намеренно не добавлял: для этого проекта достаточно пары AUTH_USERNAME и AUTH_PASSWORD из окружения. При запуске приложение читает их через Settings и передаёт сервису JwtTokens. Пароль почтового ящика и ключ провайдера моделей в этой проверке не участвуют.
Вход состоит из двух этапов. Сначала приложение проверяет логин и пароль, это аутентификация. После успешной проверки выдаёт токен, по которому разрешает доступ к защищённым маршрутам. Отдельного разграничения прав здесь нет: действующий токен владельца даёт доступ к почте, задачам и чату.
Выдача токена
Для API вход находится по адресу POST /api/v1/auth/token. Обработчик принимает поля формы username и password через OAuth2PasswordRequestForm и передаёт их в сценарий Authenticate, который вызывает JwtTokens.authenticate.
Проверить вход можно через кнопку Authorize в Swagger UI. В username и password укажу значения AUTH_USERNAME и AUTH_PASSWORD. Поля client_id и client_secret в этом проекте заполнять не нужно: обработчик использует только логин и пароль владельца.

Этот метод сравнивает оба значения с настройками владельца. При несовпадении возвращается ошибка 401. После успешной проверки создаётся JWT. Вот фрагмент метода из infrastructure/auth/jwt.py; импорты и предыдущая проверка логина и пароля опущены:
now = self.clock.now() token = jwt.encode( { "sub": self.username, "iat": now, "exp": now + timedelta(seconds=self.ttl), "iss": self.issuer, "aud": self.audience, "csrf": secrets.token_urlsafe(32), }, self.secret, algorithm="HS256", ) return {"access_token": token, "token_type": "bearer", "expires_in": self.ttl}
В sub записан логин владельца, в iat время выдачи, в exp срок действия. iss и aud задают издателя токена и приложение, для которого он предназначен. Поле csrf понадобится для запросов из браузера. По умолчанию токен действует 60 минут, срок задаётся через ACCESS_TOKEN_EXPIRE_MINUTES.
self.secret получает значение JWT_SECRET_KEY из конфигурации. Этот ключ используется для подписи HS256 и остаётся на сервере. Содержимое такого JWT можно прочитать без ключа, поэтому паролей и ключей моделей в нём нет. Назначение подписи и устройство JWT также описаны в документации FastAPI.
Проверка защищённых запросов
В ответ на вход клиент получает access_token. Дальше при обращении к API он передаёт эту строку в HTTP-заголовке:
Authorization: Bearer <access_token>
Bearer означает, что для обращения к ресурсу клиент предъявляет сам токен. JWT задаёт формат токена в этом проекте. Порядок передачи через Authorization определён в RFC 6750.
Из заголовка строку извлекает OAuth2PasswordBearer, подключённый через Depends. Сам по себе он не проверяет подпись JWT. Эту работу выполняет сервис приложения, который вызывается из зависимости current_owner. В presentation/api/dependencies.py выбор источника токена выглядит так:
c = container(request) header_present = "authorization" in request.headers token = bearer if header_present else request.cookies.get(c.settings.auth_cookie_name) if not token: raise Unauthorized("Войди в приложение.") claims = c.validate_token(token)
Если заголовок Authorization передан, используется только он. При неверном Bearer-токене приложение вернёт ошибку, даже если в браузере есть действующая cookie. Когда заголовка нет, токен берётся из cookie.
Внутри JwtTokens.validate вызывается PyJWT с явными параметрами проверки:
claims = jwt.decode( token, self.secret, algorithms=["HS256"], issuer=self.issuer, audience=self.audience, options={"require": ["exp", "sub", "iss", "aud", "iat", "csrf"]}, )
Библиотека проверяет подпись, срок действия и значения издателя и получателя. Перечисленные в require поля обязательны. После этого код дополнительно сверяет sub с логином владельца и проверяет тип csrf. Подделанный, просроченный или неподходящий токен приводит к 401 при обращении к API. Проверки exp, iss и aud описаны в документации PyJWT.
Чтобы подключить эту проверку к маршрутам, в проекте объявлен тип Owner = Annotated[dict[str, Any], Depends(current_owner)]. Обработчик указывает аргумент owner: Owner, и FastAPI выполняет зависимость до вызова его тела. Например, GET /api/v1/auth/me возвращает логин из уже проверенного owner["sub"]. Так одна зависимость используется в обработчиках почты, задач и чата.
Вход из браузера
Веб-интерфейс использует тот же сервис проверки логина и пароля. Форма отправляется на POST /auth/login, после успешного входа JWT записывается в HttpOnly-cookie. Браузер отправляет её с последующими запросами, JavaScript не читает сам токен.

Для запросов с cookie, которые меняют данные, сервер дополнительно проверяет Origin и CSRF-токен. Случайное значение csrf из JWT передаётся браузеру в отдельной cookie, доступной JavaScript; при запросах к API интерфейс возвращает его в заголовке X-CSRF-Token. Сервер сравнивает его со значением в проверенном JWT. Эти проверки нужны потому, что браузер прикладывает cookie автоматически. Для Bearer-запросов эта ветка проверки не выполняется.
Выход из веб-интерфейса удаляет cookie. Отдельно выданный Bearer-токен остаётся действительным до истечения срока; списка отозванных токенов в этой версии нет. После истечения срока нужно снова войти с логином и паролем.
Как устроен агент и его инструменты
После проверки доступа запрос пользователя попадает в чат. Дальше нужно связать его с действиями приложения: прочитать письмо, создать задачу или подготовить ответ. Для этого я подключил к модели инструменты, которые вызывают написанную на Python прикладную логику.
В этом проекте я не использовал LangGraph и не строил явный граф узлов и переходов. Для цикла работы агента мне хватило OpenAI Agents SDK. MCP-серверы тоже намеренно не добавлял: операции с почтой, задачами и черновиками реализованы обычными Python-классами и асинхронными методами, которые вызываются внутри приложения.
Что делает OpenAI Agents SDK
OpenAI Agents SDK установлен в проекте как пакет openai-agents. В нём использую три основных элемента: Agent с инструкциями, моделью и инструментами, FunctionTool для описания отдельного инструмента и Runner для выполнения цикла запросов к модели и вызовов инструментов.
Пакет openai, который также есть в зависимостях, предоставляет API-клиент. Agents SDK управляет последовательностью работы: отправляет контекст модели, обрабатывает запросы инструментов и возвращает их результаты в диалог. Прикладной код чтения почты или сохранения задач остаётся в самом проекте.
Конкретная задача агента эту схему не меняет. Можно дать ему функцию чтения письма, поиска документа или расчёта стоимости. Для каждого действия нужны реализация, описание назначения и схема аргументов. Инструменты и ReAct я уже разбирал в статье из цикла по LangGraph, а подключение через MCP в отдельном материале. Здесь покажу прямое подключение Python-кода.
Как метод становится инструментом
Возьму read_email, который читает письмо по идентификатору. В infrastructure/ai/assistant.py есть словарь TOOL_DEFINITIONS. Ниже сокращённый фрагмент: оставил один инструмент и раскрыл константу TEXT в схему строки:
TOOL_DEFINITIONS = { "read_email": ( "Прочитать письмо по ID без изменения флага прочтения.", {"email_id": {"type": "string"}}, ), }
Модель получает имя инструмента, описание и JSON Schema аргументов. По ним она определяет, подходит ли действие для запроса, и формирует вызов с конкретным email_id. Исходный Python-код метода в это описание не входит.
Функция build_tools проходит по словарю и для каждого элемента создаёт объект SDK. Вот фрагмент из её цикла:
FunctionTool( name=name, description=description, params_json_schema=tool_schema(properties), on_invoke_tool=build_invoke(name), )
tool_schema собирает схему объекта: перечисляет свойства, делает их обязательными и запрещает дополнительные поля через additionalProperties=False. В on_invoke_tool передаётся обработчик, который SDK вызовет после получения запроса инструмента от модели.
Для read_email основной путь внутри этого обработчика сводится к трём строкам. Обработка ошибок и преобразования аргументов других инструментов здесь опущены:
args = json.loads(raw) result = await execute(tool_name, args, context.tool_call_id) return json.dumps(result, ensure_ascii=False)
В raw приходят аргументы в JSON, tool_name содержит имя инструмента, а tool_call_id связывает вызов с его результатом. Функция execute передаёт действие в AssistantTools. Там проверяются имя и поля аргументов, после чего выбирается нужный прикладной сценарий. Ветка чтения письма выглядит так:
if name == "read_email": return await self.mail.read(text_arg(args, "email_id", 500))
Именно здесь сервер вызывает Python-метод. Модель до этого только запросила действие и предложила аргументы. Результат выполнения возвращается в SDK, затем попадает в контекст следующего обращения к модели.
Как агент выбирает следующий шаг
В основе такого поведения цикл: модель оценивает запрос и текущий контекст, выбирает действие, получает результат и определяет следующий шаг. Эта идея лежит в основе ReAct, Reasoning and Acting. В AI Inbox использую цикл с вызовами инструментов через Agents SDK; отдельного текстового протокола для разбора рассуждений здесь нет.
Например, для просьбы "Найди письмо со счётом и создай задачу на оплату" возможна такая последовательность:
Модель запрашивает list_unread_emails, чтобы получить список писем.
По результату выбирает письмо и вызывает read_email с его идентификатором.
Получив содержимое, запрашивает недостающие данные у пользователя либо вызывает create_task.
После результата создания сообщает пользователю данные задачи и её ID.
Эта последовательность не задана в коде как обязательный маршрут. На каждом обращении модель сама решает, нужен ли инструмент и какой именно. Если на вопрос можно ответить по текущему контексту, она может сразу вернуть текст. Запуск нового действия зависит от запроса пользователя, инструкций и доступных инструментов.
Сборка агента и обычный запуск находятся в методе AnyModelAssistant.chat. Во фрагменте опущены обработка ошибок и проверка итогового ответа:
agent = Agent( name="AI Inbox", instructions=ASSISTANT.format(now=now.isoformat(), timezone=self.timezone), model=self.model, model_settings=self.options, tools=build_tools(execute), ) result = await Runner.run( agent, history, max_turns=self.max_turns, run_config=RunConfig(tracing_disabled=True), )
history содержит сообщения и предыдущие вызовы с результатами. В instructions передаются правила работы, текущее время и часовой пояс. В частности, агенту указано создавать задачи только по просьбе пользователя, уточнять неполный срок и опираться на результат инструмента при сообщении об успехе.
Runner повторяет обращения к модели и выполнение инструментов до итогового ответа или достижения лимита. В проекте он задаётся через AGENT_MAX_TURNS, по умолчанию 8. Потоковая версия использует Runner.run_streamed с тем же набором инструментов; передачу событий в браузер разберу в разделе о стриминге.
Инструкции модели дополняются серверными проверками. Приложение проверяет аргументы и состояние объектов, сохраняет квитанции действий и учитывает повторные вызовы. Например, при отправке письма смысл подтверждения определяет модель, а сервер проверяет привязку к ранее показанной версии черновика и отдельному следующему сообщению владельца.
Какие инструменты доступны в AI Inbox
В этой версии агенту передаются десять инструментов:
list_unread_emails: получить список непрочитанных писем с ограничением количества.
read_email: прочитать письмо по ID без изменения флага прочтения.
create_task: создать задачу с заметками, источником и сроком, если он указан.
list_tasks: получить задачи с фильтром по статусу.
complete_task: завершить задачу по ID.
create_draft: сохранить локальный черновик ответа на входящее письмо.
prepare_outgoing_email: подготовить исходящее письмо с получателем, темой и текстом.
review_outgoing_email: показать актуальный исходящий черновик для проверки.
send_outgoing_email: запросить отправку черновика, показанного в предыдущем ходе. Аргументов выбора письма у этого инструмента нет.
generate_digest: сформировать и сохранить дайджест.
Кнопки интерфейса и инструменты агента используют общие прикладные сценарии. Например, чтение письма в обоих случаях проходит через Mail, а создание задачи через Tasks. У агента доступен только перечисленный набор действий; операции вроде переноса письма в корзину выполняются через интерфейс или API.
Дальше прослежу эту связь на почте: как Mail получает письма через IMAP, как исходящее письмо передаётся SMTP и как к тем же операциям обращаются интерфейс и агент.
Программная работа с почтой
Значительная часть AI Inbox опирается на обычные почтовые операции. Чтобы прочитать письмо, получить список непрочитанных или отправить ответ, сначала нужен код, который умеет подключаться к ящику и выполнять эти действия. Инструменты агента дают модели доступ к этому коду.
Для отправки нужны получатель, тема, текст и, если требуется, вложения. Учётные данные отправителя и параметры SMTP уже заданы в настройках приложения. Почтовый код получает подготовленные данные независимо от того, кто заполнил поля: пользователь вручную или модель по его просьбе. Проверка адреса, сборка письма и передача серверу выполняются одной реализацией.
От наброска к письму
Это можно увидеть в разделе "Написать письмо". В редакторе есть получатель, тема, текст и список вложений. Все поля можно заполнить вручную, сохранить черновик, проверить его и подтвердить отправку.
На первом скриншоте я указал получателя, прикрепил файл и написал набросок для модели. В нём попросил вежливо поздравить адресата, отметить, что сообщение сгенерировано ИИ, и добавить пожелания:

Кнопка "Составить тему и текст" отправляет набросок на POST /api/v1/outbox/compose. Сценарий Outbox.compose вызывает модель и проверяет полученные тему и текст. JavaScript подставляет их в редактор. Получатель и прикреплённые файлы остаются прежними:

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

На следующем скриншоте это письмо уже открыто в Gmail получателя вместе с прикреплённым JPG.

В этом вызове модели инструменты не передаются: она возвращает JSON с полями subject и body. Модель получает только набросок, поля получателя и вложений из редактора в запрос не входят. Прикреплённый на скриншоте JPG будет вложением исходящего письма; для анализа фотографии в чате используется отдельный сценарий.
В чате работает агент с инструментами из предыдущего раздела. По просьбе пользователя он может подготовить письмо через prepare_outgoing_email, показать его и после одобрения в следующем сообщении вызвать send_outgoing_email. Получатель должен быть указан самим пользователем в диалоге. Новое письмо этот инструмент подготовки создаёт без вложений; добавить файлы можно в редакторе.
Общая логика отправки
Редактор сохраняет исходящее письмо через Outbox.save. Тот же метод вызывает инструмент prepare_outgoing_email. Он проверяет поля и сохраняет черновик в SQLite. Для самой отправки и HTTP-обработчик, и инструмент агента вызывают Outbox.send.
Внутри Outbox.send проверяются подтверждение и версия содержимого. Если после просмотра изменились адрес, тема, текст или список вложений, требуется проверить актуальную версию. Для этого используется content_token, хеш этих полей. request_id связывает попытку отправки с квитанцией: повтор того же запроса возвращает существующий результат.
После проверок сценарий собирает OutgoingMessage с данными письма и файлами, затем передаёт его адаптеру SmtpSender. Ниже фрагмент его метода _send; обработка ошибок и закрытие соединения опущены:
message = build_message(self.user, outgoing) connection = TrackingSMTP( self.host, self.port, context=ssl.create_default_context(), timeout=self.timeout ) connection.login(self.user, self.password) refused = connection.send_message( message, from_addr=self.user, to_addrs=[outgoing.recipient] )
build_message создаёт объект email.message.EmailMessage: задаёт отправителя, получателя, тему, Message-ID и дату, добавляет текст и MIME-вложения. TrackingSMTP наследуется от smtplib.SMTP_SSL и дополнительно отслеживает передачу данных и ответ сервера. Сведений о том, какое действие в интерфейсе или чате привело к отправке, этому адаптеру не требуется.
В текущей версии у письма один получатель и обычный текст. Можно прикрепить до 10 файлов общим размером до 15 МБ до MIME-кодирования. Эти ограничения проверяются при работе с черновиком, поэтому действуют для общего сценария отправки.
Перед обращением к SMTP попытка фиксируется в базе со статусом sending. После неё интерфейс показывает результат. sent означает, что почтовый сервер принял письмо, подтверждения доставки адресату здесь нет. Если соединение оборвалось и неизвестно, принял ли сервер данные, выставляется unknown, а повтор блокируется. Автоматически повторять SMTP-отправку приложение не будет.
Состояния видны в разделе "Исходящие": там хранятся черновики, принятые сервером письма и неудачные или неопределённые попытки. При отправке из чата результат также появляется в квитанции действия.
Подключение и чтение входящих
В Container параметры почты из Settings передаются двум адаптерам: ImapMail для входящих и SmtpSender для исходящих. Оба используют MAIL_USER и MAIL_PASS, а адреса серверов и порты задаются отдельно. IMAP подключается через imaplib.IMAP4_SSL, SMTP через smtplib.SMTP_SSL. Синхронные сетевые вызовы этих библиотек вынесены в пулы потоков, из асинхронных методов приложение ожидает их результат через run_in_executor.
Прикладной сценарий Mail предоставляет чтение, список писем, изменение прочитанности, сводки и перенос в корзину. Например, его read используется и API, который вызывает интерфейс, и инструментом read_email.
Входящие читаются из папки INBOX. Идентификатор письма содержит имя папки, UIDVALIDITY и UID. Это позволяет проверить, что запрос относится к письму из прежнего состояния ящика. Если UIDVALIDITY изменился, приложение требует обновить список.
Само получение содержимого выполняется через BODY.PEEK[]. Фрагмент из ImapMail._read:
status, parts = conn.uid("fetch", uid, "(UID FLAGS BODY.PEEK[])")
Чтение агентом, создание сводки и дайджеста сохраняют флаг прочитанности. Когда пользователь открывает письмо в интерфейсе, JavaScript отдельно запрашивает изменение статуса. Адаптер выполняет UID STORE для флага \Seen и повторно запрашивает его у сервера. Поэтому отметка относится к состоянию ящика на почте, а не только к карточке в браузере.
Во "Входящих" есть вкладки непрочитанных и всех писем, постраничная загрузка и групповые действия. В открытом письме можно изменить прочитанность, подготовить локальный черновик ответа, перенести данные в задачу или перейти к обсуждению с ассистентом. Сводка по выбранным письмам возвращается с идентификаторами источников, чтобы можно было открыть исходные сообщения.
Перенос в корзину и хранение черновиков
Кнопка удаления открывает подтверждение. После него Mail.delete передаёт действие адаптеру IMAP, который выполняет UID MOVE в серверную папку с флагом \Trash. Сервер должен поддерживать MOVE, а подходящая корзина должна определяться однозначно. Если эти условия не выполнены, приложение возвращает ошибку.
Изменение происходит на почтовом сервере. В интерфейсе письмо убирается из входящих после подтверждённого результата. Для группы возвращается результат по каждому письму, поскольку одна операция может пройти, а другая завершиться ошибкой. Удаление в этой версии доступно через UI и API, инструмента для агента нет.
Черновики ответов и исходящие письма хранятся локально в SQLite. Приложение не записывает их в серверные папки Drafts или Sent. У входящих вложений в интерфейсе показаны метаданные, например имя и размер; загрузка их содержимого этой версией не реализована.
Диалог с ассистентом
Почтовые операции и задачи доступны из панели ассистента. Здесь можно начать новый диалог, выбрать сохранённый или продолжить обсуждение письма. На пустом экране есть несколько примеров запросов, но вводить команды по шаблону не требуется:

К запуску агента подключены описания десяти инструментов, инструкции ASSISTANT и история выбранного диалога. В инструкции подставляются текущее время и часовой пояс. Там же заданы правила: уточнять неполный срок, создавать задачи по просьбе пользователя и отправлять письмо после отдельного подтверждения. Тексты писем, изображения и результаты инструментов объявлены входными данными, указания из них агенту запрещено выполнять.
Инструкции подключаются при каждом запуске отдельно от истории сообщений. Для сводок и подготовки темы и текста письма в проекте есть свои инструкции, SUMMARY и COMPOSE_EMAIL, которые используются в соответствующих вызовах модели.
Для примера прошу в чате подготовить предложение о сотрудничестве и указываю адрес получателя. В этом сценарии использован временный ящик, чтобы проверить отправку.

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

После правки снова просматриваю письмо и подтверждаю отправку отдельным сообщением: "Супер. Можешь отправлять!"

В чате появился результат send_outgoing_email: SMTP-сервер принял письмо, приложение сохранило Message-ID. Это результат передачи серверу; получение письма проверю отдельно.

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

По похожему принципу работают инструменты в Claude Code и Codex: модель выбирает действие по запросу и контексту, окружение выполняет его и возвращает результат. В AI Inbox таким окружением служит приложение с ограниченным набором почтовых операций и действий над задачами.
Где хранится история
Диалоги сохраняются в той же SQLite, что задачи и черновики. Таблица conversations содержит название диалога и sdk_history, историю для следующего запуска агента. В messages записываются видимые сообщения пользователя и ассистента: текст, роль, ссылка на изображение и квитанции действий. chat_runs хранит идентификатор запроса, его состояние и итоговый ответ, а actions содержит результаты вызовов инструментов.
Для модели важны и сообщения, и результаты действий. Если в прошлом ходе был вызван read_email, при продолжении диалога ей нужно получить результат этого вызова вместе с остальным контекстом. Поэтому после успешного запуска SDK возвращает историю через result.to_input_list(), которую приложение сохраняет в sdk_history.
Перед следующим запуском к ней добавляется новое сообщение. В ChatWithAssistant этот участок выглядит так:
history = conversation.sdk_history + [{"role": "user", "content": content}] starts = [i for i, item in enumerate(history) if item.get("role") == "user"] if len(starts) > 12: history = history[starts[-12] :]
В content находится текст или текст с изображением. В запрос к модели попадают последние 12 пользовательских ходов с ответами и результатами инструментов между ними. Обрезка выполняется по границе пользовательского сообщения, чтобы сохранить пары вызовов инструментов и их результатов. Это ограничение рабочего контекста; видимые сообщения продолжают храниться в базе. В интерфейс репозиторий выдаёт последние 500 сообщений диалога.
Сообщение пользователя и запись о начатом запросе сохраняются перед обращением к модели. После завершения сохраняются ответ ассистента, его квитанции, обновлённая история SDK и итог запроса. При открытии диалога браузер загружает сообщения с сервера, поэтому перезагрузка страницы не стирает переписку.
В диалоге также хранится pending_email, ссылка на конкретную версию показанного черновика и связанный с ним ход. Благодаря этому подтверждение отправки связано с состоянием приложения, а не только с тем, что написано в истории. При удалении диалога удаляются его сообщения и записи действий; созданные задачи, черновики и файлы остаются отдельными сущностями.
Сохранённые диалоги доступны в выпадающем списке. Можно вернуться к предыдущему обсуждению или удалить ненужный диалог кнопкой рядом с его названием.

Как реализован стриминг
Ответ проходит два участка: от модели до Python-приложения и от приложения до браузера. На первом использую Runner.run_streamed. Он возвращает объект запуска, события которого можно читать через async for. Ниже фрагмент AnyModelAssistant.chat_stream; создание агента и обработка ошибок опущены:
result = Runner.run_streamed( agent, history, max_turns=self.max_turns, run_config=RunConfig(tracing_disabled=True), ) async for event in result.stream_events(): if event.type != "raw_response_event": continue if event.data.type == "response.created": await emit({"type": "message_start"}) elif event.data.type == "response.output_text.delta": await emit({"type": "delta", "text": event.data.delta})
Текстовые фрагменты преобразуются в события delta. message_start сообщает о начале нового ответа модели и сбрасывает временный текст в интерфейсе. События tool_start и tool_end формируются отдельно, вокруг выполнения Python-инструмента. Во время работы с почтой пользователь видит статус действия, затем продолжение ответа.
На втором участке сервер отдаёт события в формате SSE, Server-Sent Events. Для чата это POST /api/v1/conversations/{id}/messages/stream: в теле передаются текст, request_id и при необходимости ссылка на изображение. Обработчик получает задание job у StreamChat и подписывает HTTP-ответ на его события:
async def events(): async for event in job.subscribe(): if event["type"] == "heartbeat": yield ": keepalive\n\n" else: payload = json.dumps(jsonable_encoder(event), ensure_ascii=False) yield f"id: {event['sequence']}\nevent: {event['type']}\ndata: {payload}\n\n" return StreamingResponse( events(), media_type="text/event-stream", headers={"X-Accel-Buffering": "no"} )
Здесь StreamingResponse из FastAPI передаёт части ответа по мере работы генератора. Каждое SSE-событие содержит имя и JSON-данные, конец события обозначается пустой строкой. При отсутствии новых данных сервер периодически отправляет комментарий keepalive.
В браузере использую fetch с POST и чтение response.body.getReader(). Парсер в chat-stream.js накапливает полученные данные в буфере и собирает полные события: граница сетевого фрагмента может оказаться внутри строки или JSON. Дальше интерфейс обрабатывает их по типу:
delta добавляет текст к текущему ответу.
tool_start и tool_end обновляют статус инструмента.
snapshot заменяет временный текст и статус текущим состоянием запроса.
done передаёт сохранённый итог с текстом и квитанциями. Поле result.status показывает, завершился запрос успешно или с ошибкой. Событие error сообщает об ошибке обработки запроса.
Промежуточные события содержат текст для пользователя и статусы действий. Рассуждения модели и аргументы инструментов в них не передаются. Финальный done отправляется после записи ответа и квитанций в SQLite, поэтому конец потока связан с сохранённым результатом.
Что происходит при обрыве соединения
В StreamChat работа агента запускается отдельной asyncio.Task, а HTTP-соединение подписывается на её события. Если браузер отключился, сама задача продолжает выполняться. При переподключении к выполняющемуся заданию с тем же request_id клиент получает snapshot с уже собранным текстом, затем новые события.
После перезагрузки страницы интерфейс запрашивает активный запрос выбранного диалога и подключается к нему с прежним идентификатором. Завершённый запрос можно восстановить из сохранённого результата. Для задания в оперативном буфере повторный request_id с другим текстом или изображением приведёт к конфликту.
Буфер текущего потока хранится в памяти одного процесса, история и результаты находятся в SQLite. После остановки приложения при следующем запуске незавершённый запрос помечается как прерванный с сохранением квитанций уже выполненных действий. Автоматически заново выполнять такой запрос приложение не будет.
Голосовой ввод
Для голосового ввода пользователь нажимает микрофон и диктует текст. Браузер запрашивает доступ к микрофону через getUserMedia, а MediaRecorder собирает аудио. После остановки записи из полученных фрагментов создаётся объект File. Его браузер отправляет в приложение на POST /api/v1/speech/transcriptions. Можно также загрузить готовый аудиофайл.
На сервере AnyModelSpeech.transcribe сначала приводит запись к Ogg/Opus через ffmpeg, затем отправляет её в AnyModel. Модель задаётся через ASR_MODEL, в этом проекте это dg/nova-3, язык через ASR_LANGUAGE='ru'. ASR возвращает распознанный текст; решение о вызове инструментов появится позже, когда этот текст получит агент.
Запрос к ASR
Запрос к провайдеру передаёт файл и параметры как multipart-форму. Ниже его эквивалент через curl для подготовленного файла asr-test-recording.ogg. В MAIN_KEY находится тот же API-ключ, который использовался для текстовой модели:
curl 'https://anymodel.org/v1/audio/transcriptions' \ -H "Authorization: Bearer ${MAIN_KEY}" \ -F 'model=dg/nova-3' \ -F 'language=ru' \ -F 'file=@asr-test-recording.ogg;filename=recording.ogg;type=audio/ogg'
Для проверки API я использовал короткую синтезированную запись фразы "Напомни завтра связаться с поставщиком и уточнить реквизиты." Её подготовила TTS-модель anyvoice/builtin-7, после чего запись была преобразована в Ogg/Opus и отправлена в ASR. Оба запроса вернули HTTP 200. Из реального ответа ASR оставлю поле text:
{ "text": "Напомни завтра связаться с поставщиком и уточнить реквизиты." }
В этой проверке текст совпал с исходной фразой. Это отдельный тест на синтезированной речи; ниже показан пример диктовки через интерфейс.
Проверка текста перед отправкой
Ответ ASR открывается в окне "Проверь расшифровку". Здесь можно исправить слова, числа или имена перед тем, как отправлять запрос агенту:

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

В этом примере указано "завтра", но нет времени. Поэтому ассистент уточняет его перед созданием задачи. На показанном этапе инструменты ещё не вызывались.
Озвучка текста
Для озвучки ответов и дайджестов использую anyvoice/builtin-7, маршрут задан в TTS_MODEL. Голос отдельно не выбирал: параметр voice в запросе не передаётся, переключателя голосов в интерфейсе тоже нет. В примере ниже можно послушать, какой вариант озвучки возвращает этот маршрут.
Запрос к TTS
На вход TTS передаётся текст, в ответ приходит MP3. Прямой запрос к AnyModel выглядит так:
curl 'https://anymodel.org/v1/audio/speech' \ -H "Authorization: Bearer ${MAIN_KEY}" \ -H 'Content-Type: application/json' \ --data '{ "model": "anyvoice/builtin-7", "input": "Напомни завтра связаться с поставщиком и уточнить реквизиты.", "response_format": "mp3" }' \ --output speech.mp3
Здесь MAIN_KEY содержит тот же ключ провайдера, а --output сохраняет полученные байты в файл. Именно эту фразу я использовал в предыдущей проверке TTS и ASR. Запрос к синтезу вернул HTTP 200 и MP3, который затем был передан на распознавание:
Пример MP3, полученного от anyvoice/builtin-7: прослушать MP3
Воспроизведение в интерфейсе
Кнопка "Озвучить" доступна у ответов ассистента, сводок и дайджестов. Для обычного текста браузер вызывает POST /api/v1/speech/synthesis. Сервер проверяет длину исходного текста, до 5000 символов, и подготавливает его через prepare_speech: разворачивает суммы в рублях, даты и время в слова, убирает часть символов Markdown. Затем AnyModelSpeech.synthesize отправляет запрос к TTS.
Приложение проверяет, что в ответе есть MP3, сохраняет файл в data/media и запись о нём в SQLite. Браузеру возвращаются file_id и URL защищённого маршрута /api/v1/media/{id}. JavaScript создаёт элемент <audio>, задаёт ему этот URL и вызывает play(). Рядом появляется ссылка "Скачать MP3".
При подготовке кнопка показывает "Готовлю голос...", при воспроизведении становится кнопкой "Стоп". Новая озвучка останавливает предыдущую, одновременно на странице играет одна запись. Если нажать кнопку во время подготовки, интерфейс перестанет ждать автозапуска. Сам уже отправленный TTS-запрос продолжится, но его поздний ответ не начнёт играть; готовое аудио можно использовать при следующем нажатии.
Если браузер заблокировал автозапуск, интерфейс предлагает нажать "Озвучить" ещё раз. Файл к этому моменту уже готов. Для дайджеста ссылка на аудио также сохраняется в базе, поэтому повторная озвучка использует существующий MP3, пока файл доступен. По умолчанию срок хранения аудио составляет семь дней и задаётся через AUDIO_RETENTION_DAYS.
Интерфейс: Jinja2, Tailwind и JavaScript
Если развивать приложение с большим числом взаимосвязанных экранов и сложным клиентским состоянием, я бы рассматривал React или Vue. Для небольшого проекта можно обойтись серверными шаблонами и обычным JavaScript. В AI Inbox использую такой вариант: FastAPI отдаёт начальную HTML-страницу, дальнейшие действия выполняются через API.
Jinja2 позволяет описать HTML-шаблон с переменными, условиями, циклами и наследованием. Python передаёт в него данные, а шаблонизатор формирует HTML для браузера. Например, маршрут главной страницы передаёт логин владельца, часовой пояс и время ежедневного дайджеста. В сокращённом фрагменте index.html подстановка логина выглядит так:
{% extends 'base.html' %} {% block body %} <p class="text-sm font-medium truncate">{{ username }}</p> {% endblock %}
base.html содержит общую разметку страницы и подключения стилей и скриптов. Дочерний шаблон заполняет блок body, а вместо {{ username }} сервер подставляет значение из контекста.
Для оформления взял Tailwind: отступы, размеры, сетку и адаптивное расположение элементов можно задавать классами прямо в шаблоне. Например, text-sm и font-medium в этом фрагменте задают размер и насыщенность шрифта. Для кнопок, карточек и полей использую daisyUI, набор компонентов поверх Tailwind. Классы вроде btn btn-primary задают оформление кнопки, а дополнительные утилиты позволяют поправить размер или отступы. Специфичные стили приложения находятся в app.css.
Jinja2 формирует начальную разметку. Загрузку писем и задач, обновление чата, обработку SSE, запись микрофона и воспроизведение MP3 выполняет JavaScript. Он обращается к тем же API-маршрутам, которые доступны через Swagger.
В учебной версии Tailwind и daisyUI подключены через CDN, поэтому для запуска не нужна отдельная Node.js-сборка. Для рабочего развёртывания Tailwind следует собирать в статический CSS: используемый здесь Play CDN предназначен для разработки.
Что получилось
В AI Inbox я связал почту, задачи и мультимодальные модели через инструменты агента. Запрос можно написать, продиктовать или дополнить фотографией, а ответ прослушать. Все три модели в этом проекте подключены через AnyModel. Исходный код доступен, чтобы запустить приложение у себя и посмотреть реализацию целиком.
Больше моих разборов, примеров кода и учебных материалов можно найти в Telegram-канале Легкий путь в Python. Там я публикую в том числе материалы, которые не выходят на Хабре.
