Поделиться через

Агент ИИ

  • Статья

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

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

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

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

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

Примечание.

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

Копилоты

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

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

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

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

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

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

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

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

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

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

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

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

Реализация агентов ИИ

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

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

  • Самозапросить

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

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

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

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

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

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

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

Платформы

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

Для использования и восприятия инструментов, которые не требуют сложного планирования и памяти, некоторые популярные платформы оркестратора LLM являются LangChain, LlamaIndex, Flow и семантического ядра.

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

Совет

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вместо всех автономных баз данных 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 для планирования агентов, использования инструментов и восприятия.

Унифицированная система памяти агента искусственного интеллекта использует возможности векторной базы данных и хранилища документов 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.

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

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

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

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

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

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

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

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

Первоначальное выполнение приводит к рекомендации для Спокойного Бриза Круиз и фантазии Seas Adventure Cruise, потому что агент ожидает, что они являются самыми расслабленными круизами, доступными через векторный поиск. Эти документы имеют самую высокую оценку для 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 . Ниже приведено содержимое службы или 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.

Prompt

Запрос 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.

Агент ИИ

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

Ниже приведено содержимое службы или 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 прост, так как agent_with_chat_history и его зависимости (средства, запросы и LLM) инициализированы и настроены в файле init.py. Этот файл вызывает агент с помощью входных данных, полученных от пользователя, а также идентификатор сеанса для памяти беседы. PromptResponse Затем возвращается (модель или запрос) с выходными данными и временем отклика агента.

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

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

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

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

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

    npm ci

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

REACT_APP_API_HOST=http://127.0.0.1:8000

Теперь выполните следующую команду из веб-каталога , чтобы инициировать веб-интерфейс 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.py:

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.

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

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