Бөлісу құралы:

Агенты ИИ в Azure Cosmos DB

  • Қолданылады: ✅ NoSQL ✅ MongoDB vCore

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

В этой статье приведены общие сведения и подробные примеры реализации для агентов ИИ.

Что такое агенты ИИ?

В отличие от автономных крупных языковых моделей (LLMs) или систем программного обеспечения и оборудования на основе правил агенты ИИ имеют следующие общие функции:

  • Планирование: агенты ИИ могут планировать и последовательности действий для достижения конкретных целей. Интеграция LLMs революционизировала их возможности планирования.
  • Использование инструментов. Расширенные агенты ИИ могут использовать различные средства, такие как выполнение кода, поиск и вычислительные возможности, для эффективного выполнения задач. Агенты ИИ часто используют инструменты через вызов функций.
  • Восприятие: агенты ИИ могут воспринимать и обрабатывать информацию из своей среды, чтобы сделать их более интерактивным и контекстным. Эта информация включает визуальные, зрительные и другие сенсорные данные.
  • Память: агенты ИИ имеют возможность запоминать прошлые взаимодействия (использование инструментов и восприятие) и поведение (использование и планирование инструментов). Они хранят этот опыт и даже выполняют саморефлексию для определения будущих действий. Этот компонент памяти позволяет обеспечить непрерывность и улучшение производительности агента с течением времени.

Примечание.

Использование термина «память» в контексте агентов ИИ отличается от концепции памяти компьютера (например, энергозависимой, энергонезависимой и постоянной памяти).

Копилоты

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

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

Автономные агенты

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

  • Обратитесь к существующим сообщениям электронной почты, чатам, файлам и другим внутренним и общедоступным сведениям, связанным с предметом.
  • Выполните качественный или количественный анализ собранных сведений и вывести выводы, относящиеся к электронной почте.
  • Напишите полное сообщение электронной почты на основе выводов и включите вспомогательные доказательства.
  • Вложите соответствующие файлы в сообщение электронной почты.
  • Просмотрите сообщение электронной почты, чтобы убедиться, что все включенные сведения являются фактически точными и что утверждения действительны.
  • Выберите соответствующих получателей для To, Cc и Bcc, а затем найдите свои адреса электронной почты.
  • Запланируйте подходящее время для отправки сообщения электронной почты.
  • Выполняйте последующие действия, если ожидаете ответа, но его не получили.

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

Системы с несколькими агентами

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

Системы с несколькими агентами имеют следующие ключевые характеристики:

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

Система с несколькими агентами предоставляет следующие преимущества по сравнению с copilot или одним экземпляром вывода LLM:

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

Внедрение агентов ИИ

Обоснование и планирование

Сложное рассуждение и планирование являются отличительными чертами продвинутых автономных агентов. Популярные платформы для автономных агентов включают один или несколько из следующих методологий (со ссылками на страницы архива arXiv) по соображениям и планированию:

  • Самозапрос

    Улучшайте цепочку мысли, явно задав модель (и ответить) на последующие вопросы, прежде чем отвечать на первоначальный вопрос.

  • Причина и закон (ReAct)

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

  • Планирование и решение

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

  • Отражение/самокритика

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

Платформы

Различные платформы и средства могут упростить разработку и развертывание агентов ИИ.

Для использования и восприятия инструментов, которые не требуют сложного планирования и памяти, некоторые популярные фреймворки оркестрации LLM - это LangChain, LlamaIndex, Prompt Flow и Semantic Kernel.

Для расширенных и автономных рабочих процессов планирования и выполнения AutoGen запустила многоагентную волну, которая началась в конце 2022 года. API помощников OpenAI позволяет своим пользователям создавать агентов непосредственно в экосистеме GPT. Агенты LangChain и LlamaIndex агенты также появились примерно в то же время.

Совет

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

Система памяти агента ИИ

Распространенная практика экспериментирования с приложениями СИ с 2022 по 2024 год использует автономные системы управления базами данных для различных рабочих процессов или типов данных. Например, можно использовать базу данных в памяти для кэширования, реляционную базу данных для операционных данных (включая журналы трассировки и действия и журнал бесед LLM), а также чистую векторную базу данных для внедрения управления.

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

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

Базы данных в памяти

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

Реляционные базы данных

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

Чистые векторные базы данных

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

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

Характеристики надежной системы памяти агента ИИ

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

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

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

Объединение автономных баз данных в памяти, реляционных и векторных баз данных в единую систему (как описано выше) не является оптимальным решением для различных типов данных. Этот подход может работать для систем прототипов агентов. Однако она добавляет сложность и узкие места производительности, которые могут затруднять работу продвинутых автономных агентов.

Надежная система памяти должна иметь следующие характеристики.

Мультимодальный

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

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

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

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

Операционный

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

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

Шарабельный, но и разделимый

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

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

Создание надежной системы памяти агента ИИ

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

Вместо всех автономных баз данных Azure Cosmos DB может служить единым решением для систем памяти агента ИИ. Надёжность системы успешно позволила службе ChatGPT OpenAI масштабироваться динамически с высокой надёжностью и низкими затратами на обслуживание. Обеспечиваемый движком на основе atom-record-sequence, это первая в мире глобально распределенная служба, объединяющая NoSQL, реляционную и векторную базу данных, которая предлагает серверлесс-режим. Агенты ИИ, созданные на основе Azure Cosmos DB, предлагают скорость, масштабирование и простоту.

Скорость

Azure Cosmos DB обеспечивает однозначную задержку в миллисекундах. Эта возможность подходит для процессов, требующих быстрого доступа к данным и управления. Эти процессы включают кэширование (традиционное и семантическое кэширование, транзакции и операционные рабочие нагрузки.

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

Шкала

Azure Cosmos DB разработана для глобального распределения и горизонтальной масштабируемости. Она предлагает поддержку многорегионного ввода-вывода и многопользовательского использования.

Служба помогает гарантировать, что системы памяти могут легко расширяться и поддерживать быстро растущие агенты и связанные данные. Гарантия доступности в соглашении об уровне обслуживания (SLA) преобразуется менее чем на 5 минут простоя в год. Исключительно векторные базы данных, в отличие от этого, имеют 9 часов простоя или более. Эта доступность обеспечивает надежную основу для критически важных рабочих нагрузок. В то же время различные модели служб в Azure Cosmos DB, такие как зарезервированная емкость или бессерверные, могут помочь сократить финансовые затраты.

Простота

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

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

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

Azure Cosmos DB полностью управляется, что устраняет затраты на задачи администрирования базы данных, такие как масштабирование, исправление и резервное копирование. Без этой нагрузки разработчики могут сосредоточиться на создании и оптимизации агентов ИИ, не беспокоясь о базовой инфраструктуре данных.

Расширенные функции

Azure Cosmos DB включает дополнительные функции, такие как канал изменений, который позволяет отслеживать и реагировать на изменения в данных в режиме реального времени. Эта возможность полезна для агентов ИИ, которые должны оперативно реагировать на новые сведения.

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

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

Совет

Вы можете выбрать один из двух API Azure Cosmos DB для создания системы памяти агента ИИ:

  • Azure Cosmos DB для NoSQL, который предлагает гарантию доступности 99,999 % и предоставляет три алгоритма поиска векторов: IVF, HNSW и DiskANN
  • На основе виртуальных ядер Azure Cosmos DB для MongoDB предоставляется гарантия доступности 99,995 % и предоставляется два векторных алгоритма поиска: IVF и HNSW (DiskANN ожидается).

Сведения о гарантиях доступности для этих API см. в соглашениях об уровне обслуживания службы.

Пример реализации

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

Чат-боты — это давняя концепция, но агенты ИИ выходят за рамки простой человеческой беседы для выполнения задач на основе естественного языка. Эти задачи традиционно требуют закодированную логику. Агент по путешествиям ИИ в этом примере использования применяет фреймворк LangChain Agent для планирования действий агента, использования инструментов и перцепции.

Унифицированная система памяти агента искусственного интеллекта использует возможности векторной базы данных и хранилища документов Azure Cosmos DB для решения запросов путешественников и упрощения бронирования поездки. Использование Azure Cosmos DB для этой цели помогает обеспечить скорость, масштабирование и простоту, как описано ранее.

Образец агента работает на серверной части с использованием Python FastAPI. Он поддерживает взаимодействие пользователей с помощью пользовательского интерфейса React JavaScript.

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

  • Подписка Azure. Если у вас его нет, вы можете бесплатно попробовать Azure Cosmos DB в течение 30 дней без создания учетной записи Azure. Бесплатная пробная версия не требует кредитной карты, и никаких обязательств после пробного периода.
  • Учетная запись ДЛЯ API OpenAI или Службы Azure OpenAI.
  • Кластер виртуальных ядер в Azure Cosmos DB для MongoDB. Вы можете создать его, следуя этому краткому руководству.
  • Интегрированная среда разработки, например Visual Studio Code.
  • Python 3.11.4, установленный в среде разработки.

Скачивание проекта

Все код и примеры наборов данных доступны в этом репозитории GitHub. Репозиторий включает следующие папки:

  • загрузчик: эта папка содержит код Python для загрузки примеров документов и внедрения векторов в Azure Cosmos DB.
  • API: эта папка содержит проект Python FastAPI для размещения агента по путешествиям ИИ.
  • web: эта папка содержит код для веб-интерфейса React.

Загрузка документов для путешествий в Azure Cosmos DB

Репозиторий GitHub содержит проект Python в каталоге загрузчика . Он предназначен для загрузки примеров документов для путешествий в Azure Cosmos DB.

Настройка среды

Настройте виртуальную среду Python в каталоге загрузчика , выполнив следующую команду:

python -m venv venv

Активируйте среду и установите зависимости в каталоге загрузчика :

venv\Scripts\activate
python -m pip install -r requirements.txt

Создайте файл с именем .env в каталоге загрузчика , чтобы сохранить следующие переменные среды:

OPENAI_API_KEY="<your OpenAI key>"
MONGO_CONNECTION_STRING="mongodb+srv:<your connection string from Azure Cosmos DB>"

Загрузка документов и векторов

Файл Python main.py служит центральной точкой входа для загрузки данных в Azure Cosmos DB. Этот код обрабатывает пример данных о путешествиях из репозитория GitHub, включая сведения о кораблях и назначениях. Код также создает пакеты маршрутов для каждого корабля и назначения, чтобы путешественники могли забронировать их с помощью агента ИИ. Средство CosmosDBLoader отвечает за создание коллекций, векторных внедрений и индексов в экземпляре Azure Cosmos DB.

Ниже приведено содержимое main.py:

from cosmosdbloader import CosmosDBLoader
from itinerarybuilder import ItineraryBuilder
import json

cosmosdb_loader = CosmosDBLoader(DB_Name='travel')

#read in ship data
with open('documents/ships.json') as file:
        ship_json = json.load(file)

#read in destination data
with open('documents/destinations.json') as file:
        destinations_json = json.load(file)

builder = ItineraryBuilder(ship_json['ships'],destinations_json['destinations'])

# Create five itinerary packages
itinerary = builder.build(5)

# Save itinerary packages to Cosmos DB
cosmosdb_loader.load_data(itinerary,'itinerary')

# Save destinations to Cosmos DB
cosmosdb_loader.load_data(destinations_json['destinations'],'destinations')

# Save ships to Cosmos DB, create vector store
collection = cosmosdb_loader.load_vectors(ship_json['ships'],'ships')

# Add text search index to ship name
collection.create_index([('name', 'text')])

Загрузите документы, загрузите векторы и создайте индексы, выполнив следующую команду из каталога загрузчика :

python main.py

Ниже приведены выходные данные main.py:

--build itinerary--
--load itinerary--
--load destinations--
--load vectors ships--

Создание агента для путешествий ИИ с помощью Python FastAPI

Агент путешествий ИИ размещается в серверном API через Python FastAPI, который упрощает интеграцию с интерфейсным пользовательским интерфейсом. Проект API обрабатывает запросы агента, заземляя запросы LLM к уровню данных, в частности векторы и документы в Azure Cosmos DB.

Агент использует различные средства, особенно функции Python, предоставляемые на уровне служб API. В этой статье рассматривается код, необходимый для агентов ИИ в коде API.

Проект API в репозитории GitHub структурирован следующим образом:

  • Компоненты моделирования данных используют модели Pydantic.
  • Компоненты веб-слоя отвечают за маршрутизацию запросов и управление обменом данными.
  • Компоненты уровня служб отвечают за основную бизнес-логику и взаимодействие с уровнем данных, агентом LangChain и инструментами агента.
  • Компоненты уровня данных отвечают за взаимодействие с Azure Cosmos DB для хранилища документов MongoDB и векторного поиска.

Настройка среды для API

Мы использовали Python версии 3.11.4 для разработки и тестирования API.

Настройте виртуальную среду Python в каталоге API :

python -m venv venv

Активируйте среду и установите зависимости с помощью файла требований в каталоге API :

venv\Scripts\activate
python -m pip install -r requirements.txt

Создайте файл с именем .env в каталоге API , чтобы сохранить переменные среды:

OPENAI_API_KEY="<your Open AI key>"
MONGO_CONNECTION_STRING="mongodb+srv:<your connection string from Azure Cosmos DB>"

Теперь, когда вы настроили среду и настроили переменные, выполните следующую команду из каталога API , чтобы инициировать сервер:

python app.py

Сервер FastAPI запускается на сервере localhost loopback 127.0.0.1 порта 8000 по умолчанию. Доступ к документам Swagger можно получить с помощью следующего адреса localhost: http://127.0.0.1:8000/docs

Используйте сессию для памяти агента ИИ

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

Чтобы достичь этой цели, используйте журнал сообщений чата, хранящийся в экземпляре Azure Cosmos DB. Журнал для каждого сеанса чата хранится с помощью идентификатора сеанса, чтобы убедиться, что доступны только сообщения из текущего сеанса беседы. Эта необходимость является причиной существования Get Session метода в API. Это временный метод для управления веб-сеансами, чтобы продемонстрировать использование истории сообщений чата.

Выберите "Попробовать"./session/

Снимок экрана: использование метода get Session в Python FastAPI с кнопкой для пробного использования. 

{
  "session_id": "0505a645526f4d68a3603ef01efaab19"
}

Для агента ИИ необходимо имитировать сеанс. Метод stubbed-out просто возвращает созданный идентификатор сеанса для отслеживания журнала сообщений. В практической реализации этот сеанс будет храниться в Azure Cosmos DB и потенциально в React localStorage.

Ниже приведено содержимое web/session.py:

@router.get("/")
def get_session():
    return {'session_id':str(uuid.uuid4().hex)}

Начало беседы с агентом по путешествиям ИИ

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

Выберите "Попробовать"./agent/agent_chat

Скриншот использования метода Agent Chat в Python FastAPI с кнопкой для его опробования.

Используйте этот пример параметра:

{
  "input": "I want to take a relaxing vacation.",
  "session_id": "0505a645526f4d68a3603ef01efaab19"
}

Первоначальное выполнение приводит к рекомендации круизов Тихий Бриз и Фантастические Моря, потому что агент считает, что они являются самыми расслабляющими круизами, доступными через векторный поиск. Эти документы имеют самую высокую оценку для similarity_search_with_score вызова на уровне данных API data.mongodb.travel.similarity_search().

Оценки сходства отображаются в виде выходных данных API для отладки. Ниже приведены выходные данные после вызова data.mongodb.travel.similarity_search():

0.8394561085977978
0.8086545112328692
2

Совет

Если документы не возвращаются для векторного поиска, измените similarity_search_with_score ограничение или значение фильтра оценки по мере необходимости ([doc for doc, score in docs if score >=.78]в data.mongodb.travel.similarity_search()).

При первом вызове agent_chat создается новая коллекция с именем history в Azure Cosmos DB для хранения беседы по сеансу. Этот вызов позволяет агенту получить доступ к журналу сохраненных сообщений чата по мере необходимости. Последующие выполнения agent_chat с теми же параметрами дают различные результаты, так как программа использует данные из памяти.

Пошаговое руководство по агенту ИИ

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

В этом конкретном случае используется поиск данных MongoDB, который подключается к Azure Cosmos DB. Уровни упрощают обмен компонентами модели с агентом ИИ и кодом средства агента ИИ, находящимся на уровне службы. Такой подход обеспечивает простое взаимозаменяемость источников данных. Он также расширяет возможности агента ИИ с дополнительными, более сложными функциями или инструментами.

Схема слоёв FastAPI агента ИИ для путешествий.

Уровень служб

Слой служб формирует краеугольный камень основной бизнес-логики. В этом конкретном сценарии уровень служб играет важную роль в качестве репозитория для кода агента LangChain. Это упрощает интеграцию запросов пользователей с данными Azure Cosmos DB, памятью беседы и функциями агента для агента ИИ.

Уровень служб использует модуль единого шаблона для обработки инициализаций, связанных с агентом, в файле init.py . Вот содержимое service/init.py:

from dotenv import load_dotenv
from os import environ
from langchain.globals import set_llm_cache
from langchain_openai import ChatOpenAI
from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory
from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.runnables.history import RunnableWithMessageHistory
from langchain.agents import AgentExecutor, create_openai_tools_agent
from service import TravelAgentTools as agent_tools

load_dotenv(override=False)

chat : ChatOpenAI | None=None
agent_with_chat_history : RunnableWithMessageHistory | None=None

def LLM_init():
    global chat,agent_with_chat_history
    chat = ChatOpenAI(model_name="gpt-3.5-turbo-16k",temperature=0)
    tools = [agent_tools.vacation_lookup, agent_tools.itinerary_lookup, agent_tools.book_cruise ]

    prompt = ChatPromptTemplate.from_messages(
    [
        (
            "system",
            "You are a helpful and friendly travel assistant for a cruise company. Answer travel questions to the best of your ability providing only relevant information. In order to book a cruise you will need to capture the person's name.",
        ),
        MessagesPlaceholder(variable_name="chat_history"),
        ("user", "Answer should be embedded in html tags. {input}"),
         MessagesPlaceholder(variable_name="agent_scratchpad"),
    ]
    )

    #Answer should be embedded in HTML tags. Only answer questions related to cruise travel, If you can not answer respond with \"I am here to assist with your travel questions.\". 


    agent = create_openai_tools_agent(chat, tools, prompt)
    agent_executor  = AgentExecutor(agent=agent, tools=tools, verbose=True)

    agent_with_chat_history = RunnableWithMessageHistory(
        agent_executor,
        lambda session_id: MongoDBChatMessageHistory( database_name="travel",
                                                 collection_name="history",
                                                   connection_string=environ.get("MONGO_CONNECTION_STRING"),
                                                   session_id=session_id),
        input_messages_key="input",
        history_messages_key="chat_history",
)

LLM_init()

Файл init.py инициирует загрузку переменных среды из env-файла с помощью load_dotenv(override=False) метода. Затем для агента инициализируется глобальная переменная agent_with_chat_history. Этот агент предназначен для использования TravelAgent.py.

Метод LLM_init() вызывается во время инициализации модуля, чтобы настроить агент ИИ для беседы с помощью веб-слоя API. Объект OpenAI chat создается с помощью модели GPT-3.5 и включает определенные параметры, такие как имя модели и температура. Объект chat , список инструментов и шаблон запроса объединяются для создания AgentExecutor, который работает в качестве агента ИИ.

Агент с историей agent_with_chat_history устанавливается через RunnableWithMessageHistory с журналом чата (MongoDBChatMessageHistory). Это действие позволяет поддерживать полный журнал бесед с помощью Azure Cosmos DB.

Подсказка

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

Средства агента

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

При создании агента необходимо предоставить ему набор инструментов, которые он может использовать. Декоратор @tool предлагает самый простой подход к определению пользовательского инструмента.

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

Ниже приведено содержимое службы или TravelAgentTools.py:

from langchain_core.tools import tool
from langchain.docstore.document import Document
from data.mongodb import travel
from model.travel import Ship


@tool
def vacation_lookup(input:str) -> list[Document]:
    """find information on vacations and trips"""
    ships: list[Ship] = travel.similarity_search(input)
    content = ""

    for ship in ships:
        content += f" Cruise ship {ship.name}  description: {ship.description} with amenities {'/n-'.join(ship.amenities)} "

    return content

@tool
def itinerary_lookup(ship_name:str) -> str:
    """find ship itinerary, cruise packages and destinations by ship name"""
    it = travel.itnerary_search(ship_name)
    results = ""

    for i in it:
        results += f" Cruise Package {i.Name} room prices: {'/n-'.join(i.Rooms)} schedule: {'/n-'.join(i.Schedule)}"

    return results


@tool
def book_cruise(package_name:str, passenger_name:str, room: str )-> str:
    """book cruise using package name and passenger name and room """
    print(f"Package: {package_name} passenger: {passenger_name} room: {room}")

    # LLM defaults empty name to John Doe 
    if passenger_name == "John Doe":
        return "In order to book a cruise I need to know your name."
    else:
        if room == '':
            return "which room would you like to book"            
        return "Cruise has been booked, ref number is 343242"

Файл TravelAgentTools.py определяет три средства:

  • vacation_lookup выполняет поиск вектора в Azure Cosmos DB. Это использует similarity_search для получения соответствующего материала, связанного с путешествиями.
  • itinerary_lookup получает сведения о круизном пакете и расписания для указанного круизного корабля.
  • book_cruise бронирует круизный пакет для пассажира.

Конкретные инструкции ("Чтобы забронировать круиз я должен знать ваше имя") может потребоваться, чтобы убедиться, что запись имени пассажира и номер номера для бронирования круизного пакета, даже если вы включили такие инструкции в запрос LLM.

Агент ИИ

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

Ниже приведено содержимое service/TravelAgent.py:

from .init import agent_with_chat_history
from model.prompt import PromptResponse
import time
from dotenv import load_dotenv

load_dotenv(override=False)


def agent_chat(input:str, session_id:str)->str:

    start_time = time.time()

    results=agent_with_chat_history.invoke(
    {"input": input},
    config={"configurable": {"session_id": session_id}},
    )

    return  PromptResponse(text=results["output"],ResponseSeconds=(time.time() - start_time))

Файл TravelAgent.py прост, так как и его зависимости (средства, запросы и LLM) инициализированы и настроены в agent_with_chat_history. Этот файл вызывает агент, используя данные, полученные от пользователя, а также идентификатор сеанса для хранения истории беседы. PromptResponse Затем возвращается (модель или запрос) с выходными данными и временем отклика агента.

Интеграция агента ИИ с пользовательским интерфейсом React

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

Настройка среды для React

Установите Node.js и зависимости перед тестированием интерфейса React.

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

npm ci

Затем создайте файл с именем ENV в веб-каталоге , чтобы упростить хранение переменных среды. Добавьте следующие сведения в созданный env-файл :

REACT_APP_API_HOST=http://127.0.0.1:8000

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

npm start

При выполнении предыдущей команды откроется веб-приложение React.

Пошаговое руководство по веб-интерфейсу React

Веб-проект репозитория GitHub — это простое приложение для упрощения взаимодействия пользователей с агентом ИИ. Основными компонентами, необходимыми для взаимодействия с агентом, являются TravelAgent.js и ChatLayout.js. Файл Main.js служит центральным модулем или целевой страницей пользователя.

Снимок экрана: веб-интерфейс React JavaScript.

Главная

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

Ниже приведено содержимое main.js:

import React, {  Component } from 'react'
import { Stack, Link, Paper } from '@mui/material'
import TravelAgent from './TripPlanning/TravelAgent'

import './Main.css'

class Main extends Component {
  constructor() {
    super()

  }

  render() {
    return (
      <div className="Main">
        <div className="Main-Header">
          <Stack direction="row" spacing={5}>
            <img src="/mainlogo.png" alt="Logo" height={'120px'} />
            <Link
              href="#"
              sx={{ color: 'white', fontWeight: 'bold', fontSize: 18 }}
              underline="hover"
            >
              Ships
            </Link>
            <Link
              href="#"
              sx={{ color: 'white', fontWeight: 'bold', fontSize: 18 }}
              underline="hover"
            >
              Destinations
            </Link>
          </Stack>
        </div>
        <div className="Main-Body">
          <div className="Main-Content">
            <Paper elevation={3} sx={{p:1}} >
            <Stack
              direction="row"
              justifyContent="space-evenly"
              alignItems="center"
              spacing={2}
            >
              
                <Link href="#">
                  <img
                    src={require('./images/destinations.png')} width={'400px'} />
                </Link>
                <TravelAgent ></TravelAgent>
                <Link href="#">
                  <img
                    src={require('./images/ships.png')} width={'400px'} />
                </Link>
              
              </Stack>
              </Paper>
          </div>
        </div>
        <div className="Main-Footer">
          <b>Disclaimer: Sample Application</b>
          <br />
          Please note that this sample application is provided for demonstration
          purposes only and should not be used in production environments
          without proper validation and testing.
        </div>
      </div>
    )
  }
}

export default Main

Турагент

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

Ниже приведено содержимое TripPlanning/TravelAgent.js:

import React, { useState, useEffect } from 'react'
import { Button, Box, Link, Stack, TextField } from '@mui/material'
import SendIcon from '@mui/icons-material/Send'
import { Dialog, DialogContent } from '@mui/material'
import ChatLayout from './ChatLayout'
import './TravelAgent.css'

export default function TravelAgent() {
  const [open, setOpen] = React.useState(false)
  const [session, setSession] = useState('')
  const [chatPrompt, setChatPrompt] = useState(
    'I want to take a relaxing vacation.',
  )
  const [message, setMessage] = useState([
    {
      message: 'Hello, how can I assist you today?',
      direction: 'left',
      bg: '#E7FAEC',
    },
  ])

  const handlePrompt = (prompt) => {
    setChatPrompt('')
    setMessage((message) => [
      ...message,
      { message: prompt, direction: 'right', bg: '#E7F4FA' },
    ])
    console.log(session)
    fetch(process.env.REACT_APP_API_HOST + '/agent/agent_chat', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ input: prompt, session_id: session }),
    })
      .then((response) => response.json())
      .then((res) => {
        setMessage((message) => [
          ...message,
          { message: res.text, direction: 'left', bg: '#E7FAEC' },
        ])
      })
  }

  const handleSession = () => {
    fetch(process.env.REACT_APP_API_HOST + '/session/')
      .then((response) => response.json())
      .then((res) => {
        setSession(res.session_id)
      })
  }

  const handleClickOpen = () => {
    setOpen(true)
  }

  const handleClose = (value) => {
    setOpen(false)
  }

  useEffect(() => {
    if (session === '') handleSession()
  }, [])

  return (
    <Box>
      <Dialog onClose={handleClose} open={open} maxWidth="md" fullWidth="true">
        <DialogContent>
          <Stack>
            <Box sx={{ height: '500px' }}>
              <div className="AgentArea">
                <ChatLayout messages={message} />
              </div>
            </Box>
            <Stack direction="row" spacing={0}>
              <TextField
                sx={{ width: '80%' }}
                variant="outlined"
                label="Message"
                helperText="Chat with AI Travel Agent"
                defaultValue="I want to take a relaxing vacation."
                value={chatPrompt}
                onChange={(event) => setChatPrompt(event.target.value)}
              ></TextField>
              <Button
                variant="contained"
                endIcon={<SendIcon />}
                sx={{ mb: 3, ml: 3, mt: 1 }}
                onClick={(event) => handlePrompt(chatPrompt)}
              >
                Submit
              </Button>
            </Stack>
          </Stack>
        </DialogContent>
      </Dialog>
      <Link href="#" onClick={() => handleClickOpen()}>
        <img src={require('.././images/planvoyage.png')} width={'400px'} />
      </Link>
    </Box>
  )
}

Выберите "Без усилий" планируйте свой рейс , чтобы открыть помощник по путешествиям.

Макет чата

Компонент макета чата контролирует расположение чата. Он систематически обрабатывает сообщения чата и реализует форматирование, указанное в объекте message JSON.

Ниже приведено содержимое TripPlanning/ChatLayout.js:

import React from 'react'
import {  Box, Stack } from '@mui/material'
import parse from 'html-react-parser'
import './ChatLayout.css'

export default function ChatLayout(messages) {
  return (
    <Stack direction="column" spacing="1">
      {messages.messages.map((obj, i = 0) => (
        <div className="bubbleContainer" key={i}>
          <Box
            key={i++}
            className="bubble"
            sx={{ float: obj.direction, fontSize: '10pt', background: obj.bg }}
          >
            <div>{parse(obj.message)}</div>
          </Box>
        </div>
      ))}
    </Stack>
  )
}

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

Снимок экрана: чат с агентом ИИ.

Когда агент ИИ готов перейти в рабочую среду, можно использовать семантическое кэширование для повышения производительности запросов на 80 % и снижения затрат на вывод LLM и вызовов API. Для реализации семантического кэширования смотрите этот пост в блоге Stochastic Coder.

Схема семантического кэширования для агентов ИИ.

Связанный контент