Agenci sztucznej inteligencji w usłudze Azure Cosmos DB

• Dotyczy:

  ✅ NoSQL ✅ MongoDB vCore

Agenci sztucznej inteligencji mają na celu wykonywanie określonych zadań, odpowiadanie na pytania i automatyzowanie procesów dla użytkowników. Ci agenci różnią się znacznie w złożoności. Obejmują one od prostych czatbotów, po copilots, do zaawansowanych asystentów sztucznej inteligencji w postaci systemów cyfrowych lub robotycznych, które mogą uruchamiać złożone przepływy pracy autonomicznie.

Ten artykuł zawiera omówienie pojęć i szczegółowe przykłady implementacji dla agentów sztucznej inteligencji.

Co to są agenci sztucznej inteligencji?

W przeciwieństwie do autonomicznych dużych modeli językowych (LLMs) lub opartych na regułach oprogramowania/systemów sprzętowych, agenci sztucznej inteligencji mają następujące typowe funkcje:

• Planowanie: Agenci sztucznej inteligencji mogą planować i sekwencjonować działania w celu osiągnięcia określonych celów. Integracja llMs zrewolucjonizowała swoje możliwości planowania.
• Użycie narzędzi: Zaawansowani agenci sztucznej inteligencji mogą używać różnych narzędzi, takich jak wykonywanie kodu, wyszukiwanie i obliczenia, aby efektywnie wykonywać zadania. Agenci sztucznej inteligencji często używają narzędzi za pośrednictwem wywoływania funkcji.
• Postrzeganie: Agenci sztucznej inteligencji mogą postrzegać i przetwarzać informacje ze swojego środowiska, aby uczynić ich bardziej interaktywnymi i kontekstowymi. Te informacje obejmują dane wizualne, słuchowe i inne dane sensoryczne.
• Pamięć: agenci sztucznej inteligencji mają możliwość zapamiętywania wcześniejszych interakcji (użycie i postrzeganie narzędzi) oraz zachowań (użycie i planowanie narzędzi). Przechowują te środowiska, a nawet wykonują samoreleksję, aby informować przyszłe działania. Ten składnik pamięci umożliwia ciągłość i poprawę wydajności agenta w czasie.

Uwaga

Użycie terminu pamięć w kontekście agentów sztucznej inteligencji różni się od koncepcji pamięci komputera (na przykład nietrwałej, niewolnej i trwałej pamięci).

Copilots

Copilots to typ agenta sztucznej inteligencji. Współpracują one z użytkownikami, a nie działają niezależnie. W przeciwieństwie do w pełni zautomatyzowanych agentów, copilots udostępnia sugestie i zalecenia ułatwiające użytkownikom wykonywanie zadań.

Na przykład gdy użytkownik pisze wiadomość e-mail, copilot może sugerować frazy, zdania lub akapity. Użytkownik może również poprosić policjanta o znalezienie odpowiednich informacji w innych wiadomościach e-mail lub plikach w celu obsługi sugestii (zobacz generowanie rozszerzonego pobierania). Użytkownik może zaakceptować, odrzucić lub edytować sugerowane fragmenty.

Agenci autonomiczni

Agenci autonomiczni mogą działać niezależnie. Podczas konfigurowania agentów autonomicznych w celu ułatwienia tworzenia wiadomości e-mail można umożliwić im wykonywanie następujących zadań:

• Zapoznaj się z istniejącymi wiadomościami e-mail, czatami, plikami i innymi informacjami wewnętrznymi i publicznymi, które są związane z tematem.
• Wykonaj analizę jakościową lub ilościową na zebranych informacjach i wyciągaj wnioski istotne dla wiadomości e-mail.
• Napisz pełną wiadomość e-mail na podstawie wniosków i uwzględnij dowody pomocnicze.
• Dołącz odpowiednie pliki do wiadomości e-mail.
• Przejrzyj wiadomość e-mail, aby upewnić się, że wszystkie zawarte informacje są dokładne i że twierdzenia są prawidłowe.
• Wybierz odpowiednich adresatów poleceń Do, DW i Bcc, a następnie wyszukaj swoje adresy e-mail.
• Zaplanuj odpowiedni czas wysyłania wiadomości e-mail.
• Wykonaj kolejne czynności, jeśli odpowiedzi są oczekiwane, ale nie zostały odebrane.

Agentów można skonfigurować tak, aby wykonali każde z powyższych zadań z zatwierdzeniem przez człowieka lub bez jego zatwierdzenia.

Systemy z wieloma agentami

Popularną strategią osiągnięcia wydajnych agentów autonomicznych jest użycie systemów z wieloma agentami. W systemach wieloa agentów wiele autonomicznych agentów, zarówno w formie cyfrowej, jak i robotyki, wchodzi w interakcję lub współpracuj ze sobą, aby osiągnąć cele indywidualne lub zbiorowe. Agenci w systemie mogą działać niezależnie i posiadać własną wiedzę lub informacje. Każdy agent może również mieć możliwość postrzegania środowiska, podejmowania decyzji i wykonywania akcji na podstawie jego celów.

Systemy z wieloma agentami mają następujące kluczowe cechy:

• Autonomiczny: każdy agent działa niezależnie. Podejmuje własne decyzje bez bezpośredniej interwencji człowieka ani kontroli innych agentów.
• Interaktywne: Agenci komunikują się ze sobą i współpracują ze sobą, aby udostępniać informacje, negocjować i koordynować swoje działania. Ta interakcja może wystąpić za pośrednictwem różnych protokołów i kanałów komunikacyjnych.
• Zorientowany na cel: Agenci w systemie wieloa agentów są projektowani w celu osiągnięcia określonych celów, które można dopasować do poszczególnych celów lub wspólnego celu między agentami.
• Rozproszone: systemy z wieloma agentami działają w sposób rozproszony, bez jednego punktu kontroli. Ta dystrybucja zwiększa niezawodność systemu, skalowalność i wydajność zasobów.

System multi-agent zapewnia następujące korzyści w porównaniu z copilot lub pojedynczym wystąpieniem wnioskowania LLM:

• Dynamiczne rozumowanie: w porównaniu z tworzeniem łańcuchów myśli lub monitowaniem drzewa, systemy wieloa agentów umożliwiają dynamiczną nawigację za pośrednictwem różnych ścieżek rozumowania.
• Zaawansowane możliwości: Systemy wielo agentów mogą obsługiwać złożone lub na dużą skalę problemy, przeprowadzając dokładne procesy decyzyjne i dystrybuując zadania między wielu agentów.
• Ulepszona pamięć: systemy z wieloma agentami z pamięcią mogą przezwyciężyć okna kontekstowe llMs, aby umożliwić lepsze zrozumienie i przechowywanie informacji.

Implementacja agentów sztucznej inteligencji

Rozumowanie i planowanie

Złożone rozumowanie i planowanie są znakiem rozpoznawczym zaawansowanych agentów autonomicznych. Popularne struktury dla agentów autonomicznych zawierają co najmniej jedną z następujących metodologii (z linkami do stron archiwum arXiv) z przyczyn i planowania:

• Samodzielne zadawanie pytań

  Popraw łańcuch myśli przez jawne zadawanie sobie pytań (i odpowiedzi) przez jawne zadawanie pytań przez model przed udzieleniem odpowiedzi na początkowe pytanie.

• Reason and Act (ReAct)

  Użyj funkcji LLMs, aby wygenerować zarówno ślady rozumowania, jak i akcje specyficzne dla zadania w sposób przeplatany. Ślady rozumowania pomagają modelowi wywoływać, śledzić i aktualizować plany działania oraz obsługiwać wyjątki. Akcje umożliwiają modelowi łączenie się ze źródłami zewnętrznymi, takimi jak baza wiedzy lub środowiska, w celu zebrania dodatkowych informacji.

• Planowanie i rozwiązywanie problemów

  Opracuj plan dzielenia całego zadania na mniejsze podzadania, a następnie wykonaj podzadania zgodnie z planem. To podejście ogranicza błędy obliczeń, błędy brakujące kroków i błędy nieporozumień semantycznych, które często występują w łańcuchu myśli zero-shot.

• Odzwierciedlenie/krytyka samozwań

  Używaj agentów refleksji , które słownie odzwierciedlają sygnały opinii o zadaniach. Agenci ci utrzymują własny tekst odbijający się w buforze pamięci epizodycznej, aby wywołać lepsze podejmowanie decyzji w kolejnych próbach.

Platformy

Różne struktury i narzędzia mogą ułatwić opracowywanie i wdrażanie agentów sztucznej inteligencji.

W przypadku użycia narzędzi i postrzegania, które nie wymagają zaawansowanego planowania i pamięci, niektóre popularne struktury orkiestratora LLM to LangChain, LlamaIndex, Prompt Flow i Semantic Kernel.

W przypadku zaawansowanych i autonomicznych przepływów pracy planowania i wykonywania autogen napędzała falę wielo agentów, która rozpoczęła się pod koniec 2022 roku. Interfejs API Asystentów openAI umożliwia użytkownikom tworzenie agentów natywnie w ekosystemie GPT. W tym samym czasie pojawiły się również agenci LangChain i Agenci LlamaIndex.

Napiwek

Przykład implementacji w dalszej części tego artykułu pokazuje, jak utworzyć prosty system z wieloma agentami przy użyciu jednej z popularnych struktur i ujednoliconego systemu pamięci agenta.

System pamięci agenta sztucznej inteligencji

Powszechna praktyka eksperymentowania z aplikacjami rozszerzonymi przez sztuczną inteligencję od 2022 do 2024 r. korzysta z autonomicznych systemów zarządzania bazami danych dla różnych przepływów pracy lub typów danych. Na przykład można użyć bazy danych w pamięci do buforowania, relacyjnej bazy danych na potrzeby danych operacyjnych (w tym dzienników śledzenia/aktywności i historii konwersacji LLM) oraz czystej bazy danych wektorów do zarządzania osadzaniem.

Jednak zastosowanie złożonej sieci autonomicznych baz danych może zaszkodzić wydajności agenta sztucznej inteligencji. Zintegrowanie wszystkich tych różnych baz danych z spójnym, współdziałalnym i odpornym systemem pamięci dla agentów sztucznej inteligencji jest własnym wyzwaniem.

Ponadto wiele często używanych usług baz danych nie jest optymalnych dla szybkości i skalowalności potrzebnych systemów agentów sztucznej inteligencji. Poszczególne słabości tych baz danych są zaostrzone w systemach z wieloma agentami.

Bazy danych w pamięci

Bazy danych w pamięci są doskonałe do szybkiego użycia, ale mogą zmagać się z trwałością danych na dużą skalę, których potrzebują agenci sztucznej inteligencji.

Relacyjne bazy danych

Relacyjne bazy danych nie są idealne dla różnych modalności i płynnych schematów danych obsługiwanych przez agentów. Relacyjne bazy danych wymagają ręcznego wysiłku, a nawet przestoju w celu zarządzania aprowizowaniem, partycjonowaniem i fragmentowaniem.

Czyste bazy danych wektorów

Czysta wektorowa baza danych zwykle jest mniej skuteczna w przypadku operacji transakcyjnych, aktualizacji w czasie rzeczywistym i obciążeń rozproszonych. Popularne bazy danych czystych wektorów w dzisiejszych czasach zwykle oferują:

• Brak gwarancji na odczyty i zapisy.
• Ograniczona przepływność pozyskiwania.
• Niska dostępność (poniżej 99,9% lub roczna awaria wynosząca 9 godzin lub więcej).
• Jeden poziom spójności (ostateczna).
• Indeks wektora w pamięci intensywnie korzystający z zasobów.
• Ograniczone opcje wielodostępności.
• Ograniczone zabezpieczenia.

Charakterystyka niezawodnego systemu pamięci agenta sztucznej inteligencji

Tak jak wydajne systemy zarządzania bazami danych mają kluczowe znaczenie dla wydajności aplikacji oprogramowania, kluczowe znaczenie ma zapewnienie agentom opartym na usłudze LLM odpowiednich i przydatnych informacji ułatwiających wnioskowanie. Niezawodne systemy pamięci umożliwiają organizowanie i przechowywanie różnych rodzajów informacji, które agenci mogą pobierać w czasie wnioskowania.

Obecnie aplikacje oparte na technologii LLM często używają rozszerzonej generacji pobierania, która używa podstawowego wyszukiwania semantycznego lub wyszukiwania wektorowego do pobierania fragmentów lub dokumentów. Wyszukiwanie wektorowe może być przydatne do znajdowania ogólnych informacji. Jednak wyszukiwanie wektorowe może nie przechwytywać określonego kontekstu, struktury lub relacji, które są istotne dla określonego zadania lub domeny.

Jeśli na przykład zadanie polega na pisaniu kodu, wyszukiwanie wektorowe może nie być w stanie pobrać drzewa składni, układu systemu plików, podsumowań kodu lub sygnatur interfejsu API, które są ważne do generowania spójnego i poprawnego kodu. Podobnie, jeśli zadaniem jest praca z danymi tabelarycznymi, wyszukiwanie wektorów może nie być w stanie pobrać schematu, kluczy obcych, procedur składowanych lub raportów, które są przydatne do wykonywania zapytań lub analizowania danych.

Tkanie ze sobą sieci autonomicznych baz danych w pamięci, relacyjnych i wektorowych (zgodnie z wcześniejszym opisem) nie jest optymalnym rozwiązaniem dla różnych typów danych. Takie podejście może działać w przypadku prototypowych systemów agentów. Jednak zwiększa złożoność i wąskie gardła wydajności, które mogą utrudniać wydajność zaawansowanych agentów autonomicznych.

Niezawodny system pamięci powinien mieć następujące cechy.

Multimodalnego

Systemy pamięci agenta sztucznej inteligencji powinny udostępniać kolekcje, które przechowują metadane, relacje, jednostki, podsumowania lub inne typy informacji, które mogą być przydatne w różnych zadaniach i domenach. Te kolekcje mogą być oparte na strukturze i formacie danych, takich jak dokumenty, tabele lub kod. Mogą też być oparte na zawartości i znaczeniu danych, takich jak pojęcia, skojarzenia lub kroki proceduralne.

Systemy pamięci nie mają tylko kluczowego znaczeniu dla agentów sztucznej inteligencji. Są one również ważne dla ludzi, którzy rozwijają, utrzymują i używają tych agentów.

Na przykład ludzie mogą potrzebować nadzorować przepływy pracy planowania i wykonywania agentów niemal w czasie rzeczywistym. Podczas nadzoru ludzie mogą wtrącić się ze wskazówkami lub dokonać wbudowanych edycji dialogów lub monologów agentów. Ludzie mogą również potrzebować inspekcji rozumowania i akcji agentów, aby zweryfikować ważność końcowych danych wyjściowych.

Interakcje z ludźmi/agentami są prawdopodobnie w językach naturalnych lub programowania, podczas gdy agenci "myślą", "uczą się" i "pamiętaj" za pomocą osadzania. Ta różnica stanowi kolejne wymaganie spójności systemów pamięci między modalnościami danych.

Operacyjne

Systemy pamięci powinny udostępniać banki pamięci, które przechowują informacje istotne dla interakcji z użytkownikiem i środowiskiem. Takie informacje mogą obejmować historię czatów, preferencje użytkownika, dane sensoryczne, podjęte decyzje, informacje poznane lub inne dane operacyjne, które są aktualizowane z wysoką częstotliwością i na dużych ilościach.

Te banki pamięci mogą pomóc agentom zapamiętać krótkoterminowe i długoterminowe informacje, unikać powtarzania lub zaprzeczania sobie i utrzymywać spójność zadań. Te wymagania muszą być spełnione, nawet jeśli agenci wykonują wiele niepowiązanych zadań z rzędu. W zaawansowanych przypadkach agenci mogą również testować wiele planów gałęzi, które różnią się lub zbiegają się w różnych punktach.

Możliwość udostępniania, ale także separable

Na poziomie makr systemy pamięci powinny umożliwić wielu agentom sztucznej inteligencji współpracę nad problemem lub procesem różnych aspektów problemu przez udostępnienie pamięci udostępnionej dostępnej dla wszystkich agentów. Pamięć współdzielona może ułatwić wymianę informacji i koordynację działań między agentami.

Jednocześnie system pamięci musi zezwalać agentom na zachowanie własnej osoby i cech, takich jak ich unikatowe kolekcje monitów i wspomnień.

Tworzenie niezawodnego systemu pamięci agenta sztucznej inteligencji

Powyższe cechy wymagają, aby systemy pamięci agenta sztucznej inteligencji miały wysoką skalowalność i szybkość. Żmudnie tkanie różnych baz danych w pamięci, relacyjnych i wektorowych (zgodnie z wcześniejszym opisem) może działać w przypadku aplikacji z obsługą sztucznej inteligencji na wczesnym etapie. Jednak takie podejście zwiększa złożoność i wąskie gardła wydajności, które mogą utrudniać wydajność zaawansowanych agentów autonomicznych.

Zamiast wszystkich autonomicznych baz danych usługa Azure Cosmos DB może służyć jako ujednolicone rozwiązanie dla systemów pamięci agenta sztucznej inteligencji. Jej niezawodność została pomyślnie włączona w usłudze ChatGPT platformy OpenAI w celu dynamicznego skalowania z wysoką niezawodnością i niską konserwacją. Obsługiwany przez aparat atom-record-sequence, jest to pierwsza na świecie globalnie rozproszona usługa bazy danych NoSQL, relacyjna i wektorowa, która oferuje tryb bezserwerowy. Agenci sztucznej inteligencji oparty na usłudze Azure Cosmos DB oferują szybkość, skalę i prostotę.

Szybkość

Usługa Azure Cosmos DB zapewnia jednocyfrowe opóźnienie milisekundowe. Ta funkcja nadaje się do procesów wymagających szybkiego dostępu do danych i zarządzania nimi. Procesy te obejmują buforowanie (zarówno tradycyjne, jak i semantyczne buforowanie, transakcje i obciążenia operacyjne.

Małe opóźnienie ma kluczowe znaczenie dla agentów sztucznej inteligencji, którzy muszą wykonywać złożone rozumowanie, podejmować decyzje w czasie rzeczywistym i zapewniać natychmiastowe odpowiedzi. Ponadto użycie algorytmu DiskANN przez usługę zapewnia dokładne i szybkie wyszukiwanie wektorów przy minimalnym użyciu pamięci.

Skaluj

Usługa Azure Cosmos DB jest zaprojektowana pod kątem globalnej dystrybucji i skalowalności poziomej. Oferuje obsługę wielu regionów we/wy i wielodostępności.

Usługa pomaga zapewnić, że systemy pamięci mogą bezproblemowo rozszerzać i nadążać za szybko rosnącymi agentami i skojarzonymi danymi. Gwarancja dostępności w umowie dotyczącej poziomu usług (SLA) przekłada się na mniej niż 5 minut przestojów rocznie. Natomiast usługi czystej bazy danych wektorów mają 9 godzin lub więcej przestojów. Ta dostępność zapewnia solidną podstawę dla obciążeń o znaczeniu krytycznym. Jednocześnie różne modele usług w usłudze Azure Cosmos DB, takie jak pojemność zarezerwowana lub bezserwerowa, mogą pomóc zmniejszyć koszty finansowe.

Prostota

Usługa Azure Cosmos DB może uprościć zarządzanie danymi i architekturę, integrując wiele funkcji bazy danych z pojedynczą spójną platformą.

Jej zintegrowane funkcje wektorowej bazy danych mogą przechowywać, indeksować i wykonywać zapytania osadzania wraz z odpowiednimi danymi w językach naturalnym lub programowania. Ta funkcja zapewnia większą spójność danych, skalę i wydajność.

Jego elastyczność obsługuje różne modalności i schematy płynów metadanych, relacji, jednostek, podsumowań, historii czatów, preferencji użytkownika, danych sensorycznej, decyzji, faktów poznanych lub innych danych operacyjnych zaangażowanych w przepływy pracy agenta. Baza danych automatycznie indeksuje wszystkie dane bez konieczności zarządzania schematami lub indeksami, co ułatwia agentom sztucznej inteligencji szybkie i wydajne wykonywanie złożonych zapytań.

Usługa Azure Cosmos DB jest w pełni zarządzana, co eliminuje obciążenie zadań administracyjnych baz danych, takich jak skalowanie, stosowanie poprawek i tworzenie kopii zapasowych. Bez tego obciążenia deweloperzy mogą skupić się na tworzeniu i optymalizowaniu agentów sztucznej inteligencji bez obaw o podstawową infrastrukturę danych.

Funkcje zaawansowane

Usługa Azure Cosmos DB zawiera zaawansowane funkcje, takie jak zestawienie zmian, które umożliwiają śledzenie zmian i reagowanie na zmiany w czasie rzeczywistym. Ta funkcja jest przydatna w przypadku agentów sztucznej inteligencji, którzy muszą szybko reagować na nowe informacje.

Ponadto wbudowana obsługa zapisów wielowzorcowych umożliwia wysoką dostępność i odporność, aby zapewnić ciągłą obsługę agentów sztucznej inteligencji, nawet po awariach regionalnych.

Pięć dostępnych poziomów spójności (od silnej do ostatecznej) może również obsługiwać różne obciążenia rozproszone, w zależności od wymagań scenariusza.

Napiwek

Do utworzenia systemu pamięci agenta sztucznej inteligencji można wybrać dwa interfejsy API usługi Azure Cosmos DB:

• Usługa Azure Cosmos DB for NoSQL, która oferuje gwarancję dostępności na 99,999% i udostępnia trzy algorytmy wyszukiwania wektorowego: IVF, HNSW i DiskANN
• Oparta na rdzeniach wirtualnych usługa Azure Cosmos DB dla bazy danych MongoDB, która oferuje gwarancję dostępności na 99,995% i udostępnia dwa algorytmy wyszukiwania wektorowego: IVF i HNSW (DiskANN jest nadchodzący)

Aby uzyskać informacje na temat gwarancji dostępności dla tych interfejsów API, zobacz umowy SLA usługi.

Przykład implementacji

W tej sekcji omówiono wdrażanie autonomicznego agenta w celu przetwarzania zapytań podróżnych i rezerwacji w aplikacji podróży dla linii wycieczkowej.

Czatboty to długotrwała koncepcja, ale agenci sztucznej inteligencji rozwijają się poza podstawową rozmową ludzką w celu wykonywania zadań opartych na języku naturalnym. Te zadania tradycyjnie wymagały zakodowanej logiki. Agent podróży sztucznej inteligencji w tym przykładzie implementacji używa struktury Agent LangChain do planowania agenta, użycia narzędzi i percepcji.

Ujednolicony system pamięci agenta podróży sztucznej inteligencji korzysta z możliwości wektorowej bazy danych i magazynu dokumentów usługi Azure Cosmos DB w celu rozwiązywania problemów z zapytaniami podróżnych i ułatwiania rezerwacji podróży. Korzystanie z usługi Azure Cosmos DB w tym celu pomaga zapewnić szybkość, skalę i prostotę, zgodnie z wcześniejszym opisem.

Przykładowy agent działa w zapleczu fastAPI języka Python. Obsługuje interakcje użytkowników za pośrednictwem interfejsu użytkownika react JavaScript.

Wymagania wstępne

• Subskrypcja platformy Azure. Jeśli go nie masz, możesz bezpłatnie wypróbować usługę Azure Cosmos DB przez 30 dni bez tworzenia konta platformy Azure. Bezpłatna wersja próbna nie wymaga karty kredytowej, a żadne zobowiązanie nie jest zgodne z okresem próbnym.
• Konto interfejsu API OpenAI lub usługi Azure OpenAI Service.
• Klaster rdzeni wirtualnych w usłudze Azure Cosmos DB dla bazy danych MongoDB. Możesz go utworzyć, wykonując czynności opisane w tym przewodniku Szybki start.
• Zintegrowane środowisko programistyczne, takie jak Visual Studio Code.
• Język Python 3.11.4 zainstalowany w środowisku deweloperów.

Pobieranie projektu

Wszystkie przykładowe zestawy danych i kod są dostępne w tym repozytorium GitHub. Repozytorium zawiera następujące foldery:

• moduł ładujący: ten folder zawiera kod języka Python do ładowania przykładowych dokumentów i osadzania wektorów w usłudze Azure Cosmos DB.
• api: ten folder zawiera projekt FastAPI języka Python do hostowania agenta podróży sztucznej inteligencji.
• web: ten folder zawiera kod interfejsu internetowego react.

Ładowanie dokumentów podróży do usługi Azure Cosmos DB

Repozytorium GitHub zawiera projekt języka Python w katalogu modułu ładującego . Jest ona przeznaczona do ładowania przykładowych dokumentów podróży do usługi Azure Cosmos DB.

Konfigurowanie środowiska

Skonfiguruj środowisko wirtualne języka Python w katalogu modułu ładującego , uruchamiając następujące polecenie:

python -m venv venv

Aktywuj środowisko i zainstaluj zależności w katalogu modułu ładującego :

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

Utwórz plik o nazwie env w katalogu modułu ładującego , aby przechowywać następujące zmienne środowiskowe:

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

Ładowanie dokumentów i wektorów

Plik języka Python main.py służy jako centralny punkt wejścia do ładowania danych do usługi Azure Cosmos DB. Ten kod przetwarza przykładowe dane podróży z repozytorium GitHub, w tym informacje o statkach i miejscach docelowych. Kod generuje również pakiety podróży dla każdego statku i miejsca docelowego, dzięki czemu podróżni mogą zarezerwować je przy użyciu agenta sztucznej inteligencji. Narzędzie CosmosDBLoader jest odpowiedzialne za tworzenie kolekcji, osadzania wektorów i indeksów w wystąpieniu usługi Azure Cosmos DB.

Oto zawartość 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')])

Załaduj dokumenty, załaduj wektory i utwórz indeksy, uruchamiając następujące polecenie z katalogu modułu ładującego :

python main.py

Oto dane wyjściowe main.py:

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

Tworzenie agenta podróży sztucznej inteligencji przy użyciu interfejsu FastAPI języka Python

Agent podróży sztucznej inteligencji jest hostowany w interfejsie API zaplecza za pośrednictwem interfejsu FastAPI języka Python, co ułatwia integrację z interfejsem użytkownika frontonu. Projekt interfejsu API przetwarza żądania agenta przez uziemienie monitów LLM względem warstwy danych, w szczególności wektorów i dokumentów w usłudze Azure Cosmos DB.

Agent korzysta z różnych narzędzi, szczególnie funkcji języka Python udostępnianych w warstwie usługi interfejsu API. Ten artykuł koncentruje się na kodzie niezbędnym dla agentów sztucznej inteligencji w kodzie interfejsu API.

Projekt interfejsu API w repozytorium GitHub ma strukturę w następujący sposób:

• Składniki modelowania danych używają modeli Pydantic.
• Składniki warstwy internetowej są odpowiedzialne za kierowanie żądań i zarządzanie komunikacją.
• Składniki warstwy usług są odpowiedzialne za podstawową logikę biznesową i interakcję z warstwą danych, agentem LangChain i narzędziami agenta.
• Składniki warstwy danych są odpowiedzialne za interakcję z usługą Azure Cosmos DB dla magazynu dokumentów mongoDB i wyszukiwania wektorów.

Konfigurowanie środowiska dla interfejsu API

Użyliśmy języka Python w wersji 3.11.4 na potrzeby programowania i testowania interfejsu API.

Skonfiguruj środowisko wirtualne języka Python w katalogu api :

python -m venv venv

Aktywuj środowisko i zainstaluj zależności przy użyciu pliku wymagań w katalogu api :

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

Utwórz plik o nazwie env w katalogu api , aby przechowywać zmienne środowiskowe:

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

Po skonfigurowaniu środowiska i skonfigurowaniu zmiennych uruchom następujące polecenie z katalogu api , aby zainicjować serwer:

python app.py

Serwer FastAPI jest domyślnie uruchamiany na pętli localhost 127.0.0.1 port 8000. Dostęp do dokumentów programu Swagger można uzyskać przy użyciu następującego adresu localhost: http://127.0.0.1:8000/docs.

Używanie sesji dla pamięci agenta sztucznej inteligencji

Konieczne jest, aby agent podróży mógł odwoływać się do wcześniej dostarczonych informacji w ramach trwającej konwersacji. Ta możliwość jest powszechnie znana jako pamięć w kontekście llMs.

Aby osiągnąć ten cel, użyj historii wiadomości czatu przechowywanej w wystąpieniu usługi Azure Cosmos DB. Historia każdej sesji czatu jest przechowywana za pośrednictwem identyfikatora sesji, aby upewnić się, że dostępne są tylko wiadomości z bieżącej sesji konwersacji. Taka potrzeba jest przyczyną Get Session istnienia metody w interfejsie API. Jest to metoda zastępcza do zarządzania sesjami internetowymi, aby zilustrować użycie historii wiadomości czatu.

Wybierz pozycję Wypróbuj dla elementu /session/.

{
  "session_id": "0505a645526f4d68a3603ef01efaab19"
}

W przypadku agenta sztucznej inteligencji wystarczy symulować sesję. Metoda stubbed-out zwraca tylko wygenerowany identyfikator sesji do śledzenia historii komunikatów. W praktycznej implementacji ta sesja będzie przechowywana w usłudze Azure Cosmos DB i potencjalnie w rozwiązaniu React localStorage.

Oto zawartość witryny internetowej/session.py:

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

Rozpoczynanie rozmowy z agentem podróży sztucznej inteligencji

Użyj identyfikatora sesji uzyskanego z poprzedniego kroku, aby rozpocząć nowy dialog z agentem sztucznej inteligencji, aby można było zweryfikować jego funkcjonalność. Przeprowadź test, przesyłając następujące wyrażenie: "Chcę wziąć relaksujące wakacje."

Wybierz pozycję Wypróbuj dla elementu /agent/agent_chat.

Użyj tego przykładowego parametru:

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

Wstępne wykonanie powoduje zalecenie dla Tranquil Breeze Cruise i Fantasy Seas Adventure Cruise, ponieważ agent przewiduje, że są to najbardziej relaksujące rejsy dostępne za pośrednictwem wyszukiwania wektorowego. Te dokumenty mają najwyższy wynik dla similarity_search_with_score wywołania w warstwie danych interfejsu API . data.mongodb.travel.similarity_search()

Wyniki wyszukiwania podobieństwa są wyświetlane jako dane wyjściowe z interfejsu API na potrzeby debugowania. Oto dane wyjściowe po wywołaniu metody data.mongodb.travel.similarity_search():

0.8394561085977978
0.8086545112328692
2

Napiwek

Jeśli dokumenty nie są zwracane do wyszukiwania wektorowego, zmodyfikuj similarity_search_with_score limit lub wartość filtru oceny zgodnie z potrzebami ([doc for doc, score in docs if score >=.78]) w pliku data.mongodb.travel.similarity_search().

Wywołanie agent_chat metody po raz pierwszy tworzy nową kolekcję o nazwie history w usłudze Azure Cosmos DB do przechowywania konwersacji według sesji. To wywołanie umożliwia agentowi dostęp do przechowywanej historii wiadomości czatu zgodnie z potrzebami. Kolejne wykonania z agent_chat tymi samymi parametrami generują różne wyniki, ponieważ pobiera je z pamięci.

Przewodnik po agencie sztucznej inteligencji

Podczas integrowania agenta sztucznej inteligencji z interfejsem API składniki wyszukiwania w Internecie są odpowiedzialne za inicjowanie wszystkich żądań. Po składnikach wyszukiwania w Internecie następuje usługa wyszukiwania, a na koniec składniki danych.

W tym konkretnym przypadku użyjesz wyszukiwania danych Bazy danych MongoDB łączącego się z usługą Azure Cosmos DB. Warstwy ułatwiają wymianę składników modelu za pomocą agenta sztucznej inteligencji i kodu narzędzia agenta sztucznej inteligencji znajdującego się w warstwie usługi. Takie podejście umożliwia bezproblemową wymianę źródeł danych. Rozszerza również możliwości agenta sztucznej inteligencji o dodatkowe, bardziej skomplikowane funkcje lub narzędzia.

Warstwa usługi

Warstwa usługi stanowi podstawę podstawowej logiki biznesowej. W tym konkretnym scenariuszu warstwa usługi odgrywa kluczową rolę jako repozytorium kodu agenta LangChain. Ułatwia bezproblemową integrację monitów użytkownika z danymi usługi Azure Cosmos DB, pamięcią konwersacji i funkcjami agenta dla agenta sztucznej inteligencji.

Warstwa usługi korzysta z pojedynczego modułu wzorca do obsługi inicjowania związanych z agentem w pliku init.py . Oto zawartość usługi/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()

Plik init.py inicjuje ładowanie zmiennych środowiskowych z pliku env przy użyciu load_dotenv(override=False) metody . Następnie wystąpienie zmiennej globalnej o nazwie agent_with_chat_history jest tworzone dla agenta. Ten agent jest przeznaczony do użytku przez TravelAgent.py.

Metoda jest wywoływana LLM_init() podczas inicjowania modułu w celu skonfigurowania agenta sztucznej inteligencji na potrzeby konwersacji za pośrednictwem warstwy internetowej interfejsu API. Obiekt OpenAI chat jest tworzone za pośrednictwem modelu GPT-3.5 i zawiera określone parametry, takie jak nazwa modelu i temperatura. Obiekt chat , lista narzędzi i szablon monitu są łączone w celu wygenerowania AgentExecutorelementu , który działa jako agent podróży sztucznej inteligencji.

Agent z historią agent_with_chat_history, jest ustanawiany za pomocą RunnableWithMessageHistory historii czatu (MongoDBChatMessageHistory). Ta akcja umożliwia utrzymanie pełnej historii konwersacji za pośrednictwem usługi Azure Cosmos DB.

Monit

LlM monit początkowo rozpoczął się od prostego oświadczenia "Jesteś pomocnym i przyjaznym asystentem podróży dla firmy wycieczkowej." Jednak testy wykazały, że można uzyskać bardziej spójne wyniki, dołączając instrukcję "Odpowiadanie na pytania podróżne do najlepszych możliwości, dostarczając tylko odpowiednie informacje. Aby zarezerwować rejs, uchwycenie nazwiska osoby jest niezbędne." Wyniki są wyświetlane w formacie HTML, aby zwiększyć atrakcyjność wizualną interfejsu internetowego.

Narzędzia agenta

Narzędzia to interfejsy, których agent może używać do interakcji ze światem, często za pośrednictwem wywoływania funkcji.

Podczas tworzenia agenta musisz dostarczyć go za pomocą zestawu narzędzi, których może używać. Dekorator @tool oferuje najprostsze podejście do definiowania niestandardowego narzędzia.

Domyślnie dekorator używa nazwy funkcji jako nazwy narzędzia, chociaż można ją zastąpić, podając ciąg jako pierwszy argument. Dekorator używa dokumentu funkcji jako opisu narzędzia, dlatego wymaga aprowizacji dokumentu.

Oto zawartość usługi/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"

Plik TravelAgentTools.py definiuje trzy narzędzia:

• vacation_lookup przeprowadza wyszukiwanie wektorów w usłudze Azure Cosmos DB. Używa similarity_search go do pobierania odpowiednich materiałów związanych z podróżą.
• itinerary_lookup pobiera szczegóły pakietu wycieczkowego i harmonogramy dla określonego statku wycieczkowego.
• book_cruise książka pakietu wycieczkowego dla pasażera.

Konkretne instrukcje ("Aby zarezerwować rejs, muszę znać swoje imię") może być konieczne, aby zapewnić przechwycenie nazwy i numeru pokoju pasażera na potrzeby rezerwacji pakietu wycieczkowego, mimo że takie instrukcje zostały uwzględnione w wierszu polecenia LLM.

Agent sztucznej inteligencji

Podstawową koncepcją, która stanowi podstawy agentów, jest użycie modelu językowego do wybierania sekwencji akcji do wykonania.

Oto zawartość usługi/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))

Plik TravelAgent.py jest prosty, ponieważ agent_with_chat_history jego zależności (narzędzia, monit i LLM) są inicjowane i konfigurowane w pliku init.py. Ten plik wywołuje agenta przy użyciu danych wejściowych odebranych od użytkownika wraz z identyfikatorem sesji dla pamięci konwersacji. PromptResponse Następnie (model/monit) jest zwracany z danymi wyjściowymi i czasem odpowiedzi agenta.

Integracja agenta sztucznej inteligencji z interfejsem użytkownika platformy React

Po pomyślnym załadowaniu danych i ułatwień dostępu agenta sztucznej inteligencji za pośrednictwem interfejsu API możesz teraz ukończyć rozwiązanie, ustanawiając internetowy interfejs użytkownika (przy użyciu platformy React) dla witryny internetowej podróży. Korzystanie z możliwości platformy React pomaga zilustrować bezproblemową integrację agenta sztucznej inteligencji z witryną podróży. Ta integracja zwiększa komfort pracy użytkownika z asystentem konwersacyjnej podróży na potrzeby zapytań i rezerwacji.

Konfigurowanie środowiska dla platformy React

Przed rozpoczęciem testowania interfejsu React zainstaluj Node.js i zależności.

Uruchom następujące polecenie z katalogu internetowego, aby przeprowadzić czystą instalację zależności projektu. Instalacja może zająć trochę czasu.

npm ci

Następnie utwórz plik o nazwie env w katalogu internetowym , aby ułatwić przechowywanie zmiennych środowiskowych. Uwzględnij następujące szczegóły w nowo utworzonym pliku env :

REACT_APP_API_HOST=http://127.0.0.1:8000

Teraz uruchom następujące polecenie z katalogu internetowego , aby zainicjować interfejs użytkownika sieci Web platformy React:

npm start

Uruchomienie poprzedniego polecenia powoduje otwarcie aplikacji internetowej React.

Zapoznaj się z interfejsem internetowym platformy React

Projekt internetowy repozytorium GitHub to prosta aplikacja ułatwiając interakcję użytkownika z agentem sztucznej inteligencji. Podstawowe składniki wymagane do rozmowy z agentem są TravelAgent.js i ChatLayout.js. Plik Main.js służy jako centralna strona docelowa modułu lub użytkownika.

Główne

Główny składnik służy jako centralny menedżer aplikacji. Działa jako wyznaczony punkt wejścia do routingu. W funkcji renderowania tworzy kod JSX w celu wyliniowania układu strony głównej. Ten układ obejmuje elementy zastępcze aplikacji, takie jak logo i linki, sekcja zawierająca składnik agenta podróży oraz stopkę zawierającą przykładowe zastrzeżenie dotyczące charakteru aplikacji.

Oto zawartość 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

Agent podróży

Składnik agenta podróży ma prosty cel: przechwytywanie danych wejściowych użytkownika i wyświetlanie odpowiedzi. Odgrywa kluczową rolę w zarządzaniu integracją z agentem sztucznej inteligencji zaplecza, przede wszystkim przez przechwytywanie sesji i przekazywanie monitów użytkowników do usługi FastAPI. Wynikowe odpowiedzi są przechowywane w tablicy na potrzeby wyświetlania, obsługiwane przez składnik układu czatu.

Oto zawartość rozwiązania 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>
  )
}

Wybierz pozycję Bez wysiłku zaplanuj podróż , aby otworzyć asystenta podróży.

Układ czatu

Składnik układu czatu nadzoruje rozmieszczenie czatu. Systematycznie przetwarza komunikaty czatu i implementuje formatowanie określone w message obiekcie JSON.

Oto zawartość witryny 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>
  )
}

Monity użytkownika znajdują się po prawej stronie i kolorze niebieskim. Odpowiedzi od biura podróży sztucznej inteligencji znajdują się po lewej stronie i są kolorem zielonym. Jak pokazano na poniższej ilustracji, odpowiedzi w formacie HTML są uwzględniane w konwersacji.

Gdy agent sztucznej inteligencji jest gotowy do przejścia do środowiska produkcyjnego, możesz użyć buforowania semantycznego, aby zwiększyć wydajność zapytań o 80% i zmniejszyć koszty wnioskowania usługi LLM i wywołania interfejsu API. Aby zaimplementować buforowanie semantyczne, zobacz ten wpis na blogu Stochastic Coder.

Powiązana zawartość

• 30-dniowa bezpłatna wersja próbna bez subskrypcji platformy Azure
• 90-dniowa bezpłatna wersja próbna i do 6000 USD środków na przepływność dzięki usłudze Azure AI Advantage
• Warstwa bezpłatna okresu istnienia usługi Azure Cosmos DB