Sdílet prostřednictvím

Agent AI

  • Článek

Agenti AI jsou navrženi tak, aby prováděli konkrétní úlohy, odpovídali na otázky a automatizovali procesy pro uživatele. Tito agenti se značně liší ve složitosti. Liší se od jednoduchých chatovacích robotů až po kopírovací roboty až po pokročilé asistenty umělé inteligence ve formě digitálních nebo robotických systémů, které můžou samostatně spouštět složité pracovní postupy.

Tento článek obsahuje koncepční přehledy a podrobné ukázky implementace pro agenty AI.

Co jsou agenti AI?

Na rozdíl od samostatných rozsáhlých jazykových modelů (LLM) nebo hardwarových systémů založených na pravidlech mají agenti umělé inteligence tyto společné funkce:

  • Plánování: Agenti umělé inteligence můžou plánovat a sekvencovat akce pro dosažení konkrétních cílů. Integrace LLMs změnila své možnosti plánování.
  • Použití nástrojů: Pokročilí agenti umělé inteligence můžou k efektivnímu provádění úloh používat různé nástroje, jako je spouštění kódu, vyhledávání a výpočetní funkce. Agenti umělé inteligence často používají nástroje prostřednictvím volání funkcí.
  • Vnímání: Agenti umělé inteligence mohou vnímat a zpracovávat informace ze svého prostředí, aby je mohli interaktivněji a kontextově inifikovat. Mezi tyto informace patří vizuální, auditorská a další senzorická data.
  • Paměť: Agenti umělé inteligence mají možnost pamatovat si minulé interakce (využití a vnímání nástrojů) a chování (využití a plánování nástrojů). Ukládají tato prostředí a dokonce provádějí samo reflexi, aby informovaly budoucí akce. Tato součást paměti umožňuje v průběhu času kontinuitu a zlepšení výkonu agenta.

Poznámka:

Použití termínů paměti v kontextu agentů umělé inteligence se liší od konceptu počítačové paměti (jako volatile, nonvolatile a trvalá paměť).

Kopírky

Copilots je typ agenta AI. Pracují společně s uživateli a nepracují nezávisle. Na rozdíl od plně automatizovaných agentů nabízí copiloty návrhy a doporučení, které uživatelům pomůžou při dokončování úkolů.

Když třeba uživatel píše e-mail, může kopírovací objekt navrhovat fráze, věty nebo odstavce. Uživatel může také požádat copilot, aby v jiných e-mailech nebo souborech našel relevantní informace o podpoře návrhu (viz generování rozšířeného načítání). Uživatel může přijmout, odmítnout nebo upravit navrhované pasáže.

Autonomní agenti

Autonomní agenti mohou pracovat nezávisle na sobě. Když nastavíte autonomní agenty, které vám pomůžou s složením e-mailu, můžete jim umožnit provádět následující úlohy:

  • Projděte si existující e-maily, chaty, soubory a další interní a veřejné informace, které souvisejí s danou problematikou.
  • Proveďte kvalitativní nebo kvantitativní analýzu shromážděných informací a nakreslete závěry, které jsou relevantní pro e-mail.
  • Napište úplný e-mail na základě závěrů a začleňte podpůrné důkazy.
  • Připojte k e-mailu relevantní soubory.
  • Zkontrolujte e-mail a ujistěte se, že všechny zahrnuté informace jsou fakticky přesné a že kontrolní výrazy jsou platné.
  • Vyberte vhodné příjemce pro Komu, Kopie a Skrytá kopie a vyhledejte jejich e-mailové adresy.
  • Naplánujte odpovídající čas odeslání e-mailu.
  • Proveďte následné zpracování, pokud jsou odpovědi očekávané, ale nepřijímané.

Agenty můžete nakonfigurovat tak, aby prováděly jednotlivé předchozí úkoly s nebo bez lidského schválení.

Systémy s více agenty

Oblíbenou strategií pro dosažení výkonných autonomních agentů je použití systémů s více agenty. V systémech s více agenty, více autonomních agentů, ať už v digitální nebo robotické formě, interagují nebo spolupracují na dosažení individuálních nebo kolektivních cílů. Agenti v systému mohou pracovat nezávisle a mít své vlastní znalosti nebo informace. Každý agent může mít také schopnost vnímat své prostředí, rozhodovat se a provádět akce na základě svých cílů.

Systémy s více agenty mají tyto klíčové charakteristiky:

  • Autonomní: Každý agent funguje nezávisle. Provádí vlastní rozhodnutí bez přímého lidského zásahu nebo kontroly jinými agenty.
  • Interaktivní: Agenti vzájemně komunikují a spolupracují, aby sdíleli informace, vyjednali a koordinovali své akce. K této interakci může dojít prostřednictvím různých protokolů a komunikačních kanálů.
  • Cíleně orientované: Agenti v systému s více agenty jsou navrženi tak, aby dosáhli konkrétních cílů, které mohou být v souladu s individuálními cíli nebo sdíleným cílem mezi agenty.
  • Distribuované: Systémy s více agenty fungují distribuovaně bez jediného bodu kontroly. Tato distribuce zvyšuje odolnost, škálovatelnost a efektivitu prostředků systému.

Systém s více agenty poskytuje následující výhody oproti kopírování nebo jedné instanci odvozování LLM:

  • Dynamické zdůvodnění: V porovnání s řetězem myšlenkových nebo stromových výzev umožňují systémy s více agenty dynamickou navigaci různými cestami.
  • Sofistikované schopnosti: Systémy s více agenty můžou zpracovávat složité nebo rozsáhlé problémy tím, že provádějí důkladné rozhodovací procesy a distribuují úlohy mezi několik agentů.
  • Vylepšená paměť: Systémy s více agenty s pamětí mohou překonat kontextová okna LLM, která umožňují lepší porozumění informacím a uchovávání informací.

Implementace agentů AI

Odůvodnění a plánování

Komplexní odůvodnění a plánování jsou znaménou znakem pokročilých autonomních agentů. Oblíbené architektury pro autonomní agenty zahrnují jednu nebo více následujících metodologií (s odkazy na archivní stránky arXiv) z důvodů a plánování:

  • Sebepožádejte se

    Vylepšete řetěz myšlenek tím, že se model explicitně zeptá (a odpoví) na následné otázky před zodpovězením počáteční otázky.

  • Důvod a zákon (ReAct)

    Pomocí LLM můžete vygenerovat jak trasování, tak akce specifické pro konkrétní úkoly prokládáním. Trasování příčin pomáhá modelu indukovat, sledovat a aktualizovat akční plány spolu s výjimkami. Akce umožňují modelu připojit se k externím zdrojům, jako jsou znalostní báze nebo prostředí, aby shromáždil další informace.

  • Plánování a řešení

    Vytvořte plán rozdělení celého úkolu na menší dílčí úkoly a pak proveďte dílčí úkoly podle plánu. Tento přístup zmírní chyby výpočtu, chyby chybějícího kroku a sémantické chyby nedorozumění, které se často vyskytují v nulovém řetězu myšlenkových výzev.

  • Reflect/Self-critique

    Používejte reflexní agenty, které se verbálně odrážejí na signálech zpětné vazby úkolů. Tito agenti udržují svůj vlastní reflexní text v episodické paměti vyrovnávací paměti, aby indukovali lepší rozhodování v následných studiích.

Architektury

Různé architektury a nástroje můžou usnadnit vývoj a nasazení agentů AI.

Pro použití a vnímání nástrojů, které nevyžadují sofistikované plánování a paměť, některé oblíbené architektury orchestrátoru LLM jsou LangChain, LlamaIndex, Prompt Flow a sémantické jádro.

V případě pokročilých a autonomních pracovních postupů plánování a provádění autoGen vynutil vlnu s více agenty, která začala na konci roku 2022. Rozhraní API asistentů OpenAI umožňuje uživatelům nativně vytvářet agenty v ekosystému GPT. Agenti LangChain a LlamaIndex agenti se také objevili přibližně ve stejnou dobu.

Tip

Ukázka implementace dále v tomto článku ukazuje, jak vytvořit jednoduchý systém s více agenty pomocí jedné z oblíbených architektur a jednotného systému paměti agenta.

Systém paměti agenta AI

Běžným postupem pro experimentování s aplikacemi s rozšířenými AI z roku 2022 až 2024 se používají samostatné systémy pro správu databází pro různé datové pracovní postupy nebo typy. Můžete například použít databázi v paměti pro ukládání do mezipaměti, relační databázi pro provozní data (včetně protokolů trasování/aktivit a historie konverzací LLM) a čistě vektorovou databázi pro správu vkládání.

Tento postup použití komplexního webu samostatných databází ale může poškodit výkon agenta AI. Integrace všech těchto různorodých databází do soudržného, interoperabilního a odolného paměťového systému pro agenty AI je vlastní výzvou.

Řada často používaných databázových služeb také není optimální pro rychlost a škálovatelnost, kterou potřebují systémy agentů AI. Jednotlivé nedostatky těchto databází jsou v systémech s více agenty horší.

Databáze v paměti

Databáze v paměti jsou vynikající pro rychlost, ale můžou se potýkat s trvalostí velkých objemů dat, které agenti AI potřebují.

Relační databáze

Relační databáze nejsou ideální pro různé způsoby a schémata tekutin dat, která agenti zpracovávají. Relační databáze vyžadují ruční úsilí a dokonce i výpadky pro správu zřizování, dělení a horizontálního dělení.

Čistě vektorové databáze

Čistě vektorové databáze bývají méně efektivní pro transakční operace, aktualizace v reálném čase a distribuované úlohy. Populární čistě vektorové databáze dnes obvykle nabízejí:

  • Žádné záruky čtení a zápisu.
  • Omezená propustnost příjmu dat.
  • Nízká dostupnost (nižší než 99,9 % nebo roční výpadek 9 hodin nebo více).
  • Jedna úroveň konzistence (případná).
  • Index vektorů náročných na prostředky v paměti.
  • Omezené možnosti pro víceklientské prostředí
  • Omezené zabezpečení.

Charakteristiky robustního systému paměti agenta AI

Stejně jako efektivní systémy pro správu databází jsou důležité pro výkon softwarových aplikací, je důležité poskytnout agentům LLM relevantní a užitečné informace, které jim pomůžou odvozovat. Robustní paměťové systémy umožňují uspořádat a ukládat různé druhy informací, které mohou agenti načíst v době odvozování.

V současné době aplikace využívající LLM často používají generování rozšířeného načítání, které k načítání pasáží nebo dokumentů používá základní sémantické vyhledávání nebo vektorové vyhledávání. Hledání vektorů může být užitečné pro vyhledání obecných informací. Vektorové vyhledávání ale nemusí zachytit konkrétní kontext, strukturu nebo relace, které jsou relevantní pro konkrétní úkol nebo doménu.

Pokud je například úkolem psát kód, vektorové vyhledávání nemusí být schopné načíst strom syntaxe, rozložení systému souborů, souhrny kódu nebo podpisy rozhraní API, které jsou důležité pro generování koherentního a správného kódu. Podobně platí, že pokud má úloha pracovat s tabulkovými daty, nemusí být vektorové vyhledávání schopno načíst schéma, cizí klíče, uložené procedury nebo sestavy, které jsou užitečné pro dotazování nebo analýzu dat.

Skládání webu samostatných databází v paměti, relačních a vektorových databází (jak je popsáno výše) není optimálním řešením pro různé datové typy. Tento přístup může fungovat pro prototypické systémy agentů. Zvyšuje ale složitost a kritické body výkonu, které můžou bránit výkonu pokročilých autonomních agentů.

Robustní paměťový systém by měl mít následující charakteristiky.

Multimodální

Systémy paměti agenta AI by měly poskytovat kolekce, které ukládají metadata, vztahy, entity, souhrny nebo jiné typy informací, které můžou být užitečné pro různé úlohy a domény. Tyto kolekce můžou být založené na struktuře a formátu dat, jako jsou dokumenty, tabulky nebo kód. Nebo mohou být založeny na obsahu a významu dat, jako jsou koncepty, asociace nebo procedurální kroky.

Paměťové systémy nejsou jen důležité pro agenty umělé inteligence. Jsou také důležité pro lidi, kteří vyvíjejí, udržují a používají tyto agenty.

Lidé můžou například potřebovat dohlížet na pracovní postupy plánování a provádění agentů téměř v reálném čase. Při dohledu mohou lidé interžít s pokyny nebo provádět v souladu úpravy dialogů nebo monologů agentů. Lidé také mohou potřebovat auditovat odůvodnění a akce agentů, aby ověřili platnost konečného výstupu.

Interakce člověka/agenta jsou pravděpodobně v přirozeném nebo programovacím jazyce, zatímco agenti si myslí, "učí" a "pamatují" prostřednictvím vkládání. Tento rozdíl představuje další požadavek na konzistenci paměťových systémů v různých datových režimech.

Provoz

Paměťové systémy by měly poskytovat paměťové banky, které ukládají informace, které jsou relevantní pro interakci s uživatelem a prostředím. Tyto informace můžou zahrnovat historii chatu, předvolby uživatelů, senzorická data, rozhodnutí, naučená fakta nebo jiná provozní data, která se aktualizují vysokou frekvencí a velkými objemy.

Tyto paměťové banky mohou pomoci agentům pamatovat krátkodobé a dlouhodobé informace, vyhnout se opakování nebo v rozporu se sebou a zachovat soudržnost úkolů. Tyto požadavky musí platit i v případě, že agenti provádějí velké množství nesouvisejících úkolů po sobě. V pokročilých případech mohou agenti testovat také řadu plánů větví, které se rozbíhají nebo konvergují v různých bodech.

Shable, ale také oddělitelné

Na úrovni makra by systémy paměti měly umožnit více agentům umělé inteligence spolupracovat na problému nebo zpracovávat různé aspekty problému tím, že poskytují sdílenou paměť, která je přístupná všem agentům. Sdílená paměť může usnadnit výměnu informací a koordinaci akcí mezi agenty.

Současně musí systém paměti umožnit agentům zachovat své vlastní osoby a charakteristiky, jako jsou jejich jedinečné kolekce výzev a pamětí.

Vytvoření robustního systému paměti agenta AI

Předchozí charakteristiky vyžadují, aby systémy paměti agenta AI byly vysoce škálovatelné a rychlé. Pro aplikace s podporou umělé inteligence s podporou umělé inteligence v rané fázi můžou fungovat velmi bolestné prokládání různorodých databází v paměti, relačních databázích a vektorech (jak je popsáno výše). Tento přístup ale zvyšuje složitost a kritické body výkonu, které mohou bránit výkonu pokročilých autonomních agentů.

Místo všech samostatných databází může Azure Cosmos DB sloužit jako jednotné řešení pro systémy paměti agenta AI. Jeho robustnost úspěšně povolila službu ChatGPT openAI tak, aby se dynamicky škálovala s vysokou spolehlivostí a nízkou údržbou. Je to první globálně distribuovaná služba NoSQL, relační a vektorové databáze , která nabízí bezserverový režim. Agenti umělé inteligence postavené na službě Azure Cosmos DB nabízejí rychlost, škálování a jednoduchost.

Rychlost

Azure Cosmos DB poskytuje latenci v řádu milisekund. Tato funkce je vhodná pro procesy, které vyžadují rychlý přístup k datům a správu. Mezi tyto procesy patří ukládání do mezipaměti (tradiční i sémantické ukládání do mezipaměti), transakce a provozní úlohy.

Nízká latence je zásadní pro agenty umělé inteligence, kteří potřebují provádět složité důvody, rozhodovat se v reálném čase a poskytovat okamžité odpovědi. Použití algoritmu DiskANN navíc poskytuje přesné a rychlé vektorové vyhledávání s minimální spotřebou paměti.

Měřítko

Služba Azure Cosmos DB je navržena pro globální distribuci a horizontální škálovatelnost. Nabízí podporu více oblastí vstupně-výstupních operací a víceklientské architektury.

Služba pomáhá zajistit, aby se paměťové systémy mohly bezproblémově rozšiřovat a udržovat krok s rychle rostoucími agenty a souvisejícími daty. Záruka dostupnosti ve smlouvě o úrovni služeb (SLA) znamená méně než 5 minut výpadků za rok. Naproti tomu služby čistě vektorové databáze mají 9 hodin nebo více výpadků. Tato dostupnost poskytuje solidní základ pro klíčové úlohy. Současně můžou různé modely služeb ve službě Azure Cosmos DB, jako je rezervovaná kapacita nebo bezserverová, pomoct snížit finanční náklady.

Jednoduchost

Azure Cosmos DB může zjednodušit správu a architekturu dat díky integraci více databázových funkcí do jediné, soudržné platformy.

Funkce integrované vektorové databáze mohou ukládat, indexovat a dotazovat vkládání společně s odpovídajícími daty v přirozeném nebo programovacím jazyce. Tato funkce umožňuje větší konzistenci dat, škálování a výkon.

Její flexibilita podporuje různé způsoby a schémata tekutin metadat, vztahů, entit, souhrnů, historie chatu, uživatelské předvolby, senzorická data, rozhodnutí, fakta naučená nebo jiná provozní data zapojená do pracovních postupů agentů. Databáze automaticky indexuje všechna data bez nutnosti správy schématu nebo indexu, což pomáhá agentům umělé inteligence rychle a efektivně provádět složité dotazy.

Azure Cosmos DB je plně spravovaná, což eliminuje režii úloh správy databází, jako je škálování, opravy a zálohy. Bez této režie se vývojáři můžou soustředit na vytváření a optimalizaci agentů umělé inteligence, aniž by se museli starat o podkladovou datovou infrastrukturu.

Rozšířené funkce

Azure Cosmos DB zahrnuje pokročilé funkce, jako je kanál změn, které umožňují sledovat změny dat v reálném čase a reagovat na ně. Tato funkce je užitečná pro agenty umělé inteligence, kteří potřebují okamžitě reagovat na nové informace.

Kromě toho integrovaná podpora zápisů s více hlavními instancemi umožňuje vysokou dostupnost a odolnost, která pomáhá zajistit nepřetržitý provoz agentů AI i po regionálních selháních.

Pět dostupných úrovní konzistence (od silného po konečné) se může v závislosti na požadavcích scénáře také vyhovět různým distribuovaným úlohám.

Tip

Pro sestavení systému paměti agenta AI si můžete vybrat ze dvou rozhraní API služby Azure Cosmos DB:

  • Azure Cosmos DB for NoSQL, která nabízí záruku dostupnosti 99,999 % a poskytuje tři algoritmy vektorových vyhledávání: IVF, HNSW a DiskANN
  • Azure Cosmos DB založené na virtuálních jádrech pro MongoDB, která nabízí záruku dostupnosti 99,995 % a poskytuje dva algoritmy vektorového vyhledávání: IVF a HNSW (připravuje se DiskANN)

Informace ozárukch

Ukázka implementace

Tato část zkoumá implementaci autonomního agenta ke zpracování dotazů a rezervací cestovatelů v cestovní aplikaci pro výletní linku.

Chatovací roboti jsou dlouhodobým konceptem, ale agenti umělé inteligence postupují nad rámec základní lidské konverzace, aby prováděli úkoly založené na přirozeném jazyce. Tyto úlohy tradičně vyžadovaly kódovanou logiku. Cestovní agent AI v této ukázce implementace používá architekturu agenta LangChain pro plánování agentů, využití nástrojů a vnímání.

Systém sjednocené paměti cestovního agenta AI využívá funkce vektorové databáze a úložiště dokumentů služby Azure Cosmos DB k řešení dotazů cestovatelů a usnadnění rezervací výletů. Použití služby Azure Cosmos DB pro tento účel pomáhá zajistit rychlost, škálování a jednoduchost, jak je popsáno výše.

Ukázkový agent funguje v back-endu Python FastAPI. Podporuje interakce uživatelů prostřednictvím uživatelského rozhraní React JavaScriptu.

Požadavky

  • Předplatné Azure. Pokud ho nemáte, můžete si službu Azure Cosmos DB vyzkoušet zdarma po dobu 30 dnů bez vytvoření účtu Azure. Bezplatná zkušební verze nevyžaduje platební kartu a žádný závazek se řídí zkušebním obdobím.
  • Účet pro rozhraní OPENAI API nebo službu Azure OpenAI.
  • Cluster virtuálních jader ve službě Azure Cosmos DB pro MongoDB Můžete ho vytvořit pomocí tohoto rychlého startu.
  • Integrované vývojové prostředí, jako je Visual Studio Code.
  • Python 3.11.4 nainstalovaný ve vývojovém prostředí

Stažení projektu

V tomto úložišti GitHubu jsou k dispozici všechny kódy a ukázkové datové sady. Úložiště obsahuje tyto složky:

  • loader: Tato složka obsahuje kód Pythonu pro načítání ukázkových dokumentů a vektorových vkládání ve službě Azure Cosmos DB.
  • api: Tato složka obsahuje projekt Python FastAPI pro hostování cestovního agenta AI.
  • web: Tato složka obsahuje kód pro webové rozhraní React.

Načtení cestovních dokumentů do služby Azure Cosmos DB

Úložiště GitHub obsahuje projekt Pythonu v adresáři zavaděče. Je určená k načtení ukázkových cestovních dokumentů do služby Azure Cosmos DB.

Nastavení prostředí

Spuštěním následujícího příkazu nastavte virtuální prostředí Pythonu v adresáři zavaděče :

    python -m venv venv

Aktivujte prostředí a nainstalujte závislosti v adresáři zavaděče:

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

V adresáři zavaděče vytvořte soubor s názvem .env a uložte následující proměnné prostředí:

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

Načtení dokumentů a vektorů

Soubor Pythonu main.py slouží jako centrální vstupní bod pro načítání dat do služby Azure Cosmos DB. Tento kód zpracovává ukázková cestovní data z úložiště GitHub, včetně informací o lodích a cílech. Kód také generuje balíčky cestovních itinerářů pro každou loď a cíl, aby si je cestovatelé mohli rezervovat pomocí agenta AI. Nástroj CosmosDBLoader zodpovídá za vytváření kolekcí, vektorových vkládání a indexů v instanci služby Azure Cosmos DB.

Tady je obsah 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')])

Načtěte dokumenty, načtěte vektory a vytvořte indexy spuštěním následujícího příkazu z adresáře zavaděče:

    python main.py

Tady je výstup main.py:

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

Sestavení cestovního agenta AI pomocí Python FastAPI

Cestovní agent AI je hostovaný v back-endovém rozhraní API prostřednictvím Python FastAPI, který usnadňuje integraci s front-endovým uživatelským rozhraním. Projekt rozhraní API zpracovává požadavky agenta tím , že zřídí výzvy LLM vůči datové vrstvě, konkrétně vektory a dokumenty ve službě Azure Cosmos DB.

Agent využívá různé nástroje, zejména funkce Pythonu poskytované ve vrstvě služby API. Tento článek se zaměřuje na kód potřebný pro agenty AI v kódu rozhraní API.

Projekt rozhraní API v úložišti GitHub je strukturovaný takto:

  • Komponenty modelování dat používají Pydantické modely.
  • Komponenty webové vrstvy zodpovídají za směrování požadavků a správu komunikace.
  • Komponenty vrstvy služeb zodpovídají za primární obchodní logiku a interakci s datovou vrstvou, agentem LangChain a nástroji agenta.
  • Komponenty datové vrstvy zodpovídají za interakci s úložištěm dokumentů a vektorovým vyhledáváním ve službě Azure Cosmos DB pro MongoDB.

Nastavení prostředí pro rozhraní API

Pro vývoj a testování rozhraní API jsme použili Python verze 3.11.4.

Nastavte virtuální prostředí Pythonu v adresáři rozhraní API :

    python -m venv venv

Aktivujte prostředí a nainstalujte závislosti pomocí souboru požadavků v adresáři rozhraní API :

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

Vytvořte soubor s názvem .env v adresáři rozhraní API pro uložení proměnných prostředí:

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

Teď, když jste nakonfigurovali prostředí a nastavili proměnné, spusťte z adresáře rozhraní API následující příkaz, kterým zahájíte server:

    python app.py

Server FastAPI se spustí ve výchozím nastavení na zpětné smyčce localhost 127.0.0.1 port 8000. K dokumentům Swaggeru můžete přistupovat pomocí následující adresy localhost: http://127.0.0.1:8000/docs.

Použití relace pro paměť agenta AI

Je nezbytné, aby cestovní agent mohl v probíhající konverzaci odkazovat na dříve poskytnuté informace. Tato schopnost se v kontextu LLM běžně označuje jako paměť .

K dosažení tohoto cíle použijte historii zpráv chatu uloženou v instanci služby Azure Cosmos DB. Historie každé relace chatu je uložena prostřednictvím ID relace, aby se zajistilo, že jsou přístupné jenom zprávy z aktuální relace konverzace. Tato nutnost je důvodem existence Get Session metody v rozhraní API. Jedná se o zástupnou metodu pro správu webových relací, která ilustruje použití historie chatových zpráv.

Vyberte Vyzkoušet pro /session/.

Snímek obrazovky s použitím metody Get Session v Pythonu FastAPI s tlačítkem pro vyzkoušení 

{
  "session_id": "0505a645526f4d68a3603ef01efaab19"
}

Pro agenta AI stačí simulovat jenom relaci. Metoda stubbed-out pouze vrací vygenerované ID relace pro sledování historie zpráv. V praktické implementaci by tato relace byla uložena ve službě Azure Cosmos DB a potenciálně v Reactu localStorage.

Tady je obsah webu nebo session.py:

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

Zahájení konverzace s cestovním agentem AI

Pomocí ID relace, které jste získali z předchozího kroku, spusťte nový dialog s agentem AI, abyste mohli ověřit jeho funkčnost. Proveďte test tak, že odešlete následující frázi: "Chci si odpočinout na dovolenou".

Vyberte Vyzkoušet pro /agent/agent_chat.

Snímek obrazovky s použitím metody Chat agenta v Pythonu FastAPI s tlačítkem pro vyzkoušení

Použijte tento ukázkový parametr:

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

Počáteční spuštění má za následek doporučení pro Tranquil Breeze Cruise a Fantasy Seas Adventure Cruise, protože agent předpokládá, že jsou nejvíce relaxační výlety dostupné prostřednictvím vektorového vyhledávání. Tyto dokumenty mají nejvyšší skóre pro similarity_search_with_score volání v datové vrstvě rozhraní API, data.mongodb.travel.similarity_search().

Skóre vyhledávání podobnosti se zobrazí jako výstup z rozhraní API pro účely ladění. Tady je výstup po volání data.mongodb.travel.similarity_search():

0.8394561085977978
0.8086545112328692
2

Tip

Pokud nejsou dokumenty vráceny pro vektorové vyhledávání, upravte similarity_search_with_score limit nebo hodnotu filtru skóre podle potřeby ([doc for doc, score in docs if score >=.78]) v data.mongodb.travel.similarity_search().

Při prvním volání agent_chat se vytvoří nová kolekce pojmenovaná history ve službě Azure Cosmos DB pro uložení konverzace podle relace. Toto volání umožňuje agentu podle potřeby přistupovat k historii uložených zpráv chatu. Následné spuštění agent_chat se stejnými parametry vytváří různé výsledky, protože se načítá z paměti.

Projděte si agenta AI

Při integraci agenta AI do rozhraní API zodpovídají komponenty webového vyhledávání za inicializování všech požadavků. Za komponentami vyhledávání na webu následuje vyhledávací služba a nakonec datové komponenty.

V tomto konkrétním případě použijete vyhledávání dat MongoDB, které se připojuje ke službě Azure Cosmos DB. Vrstvy usnadňují výměnu součástí modelu s agentem AI a kódem nástroje AI umístěným ve vrstvě služby. Tento přístup umožňuje bezproblémovou výměnu zdrojů dat. Rozšiřuje také možnosti agenta AI o další, složitější funkce nebo nástroje.

Diagram vrstev FastAPI cestovního agenta AI

Vrstva služby

Vrstva služeb tvoří základní základní obchodní logiku. V tomto konkrétním scénáři hraje vrstva služby zásadní roli jako úložiště pro kód agenta LangChain. Usnadňuje bezproblémovou integraci uživatelských výzev s daty, pamětí konverzace a funkcemi agenta služby Azure Cosmos DB pro agenta AI.

Vrstva služby používá modul s jedním vzorem pro zpracování inicializací souvisejících s agenty v souboru init.py . Tady je obsah služby/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()

Soubor init.py zahájí načítání proměnných prostředí ze souboru .env pomocí load_dotenv(override=False) metody. Potom se vytvoří instance globální proměnné agent_with_chat_history pro agenta. Tento agent je určený pro použití TravelAgent.py.

Metoda LLM_init() se vyvolá během inicializace modulu a nakonfiguruje agenta AI pro konverzaci prostřednictvím webové vrstvy rozhraní API. Objekt OpenAI chat se vytvoří prostřednictvím modelu GPT-3.5 a zahrnuje konkrétní parametry, jako je název modelu a teplota. Objekt chat , seznam nástrojů a šablona výzvy jsou kombinovány pro generování AgentExecutor, která funguje jako cestovní agent AI.

Agent s historií , agent_with_chat_historyje vytvořen prostřednictvím RunnableWithMessageHistory historie chatu (MongoDBChatMessageHistory). Tato akce umožňuje udržovat úplnou historii konverzací prostřednictvím služby Azure Cosmos DB.

Instrukce

Výzva LLM původně začala jednoduchým prohlášením "Jste užitečným a přátelským cestovním asistentem pro výletní společnost". Testování však ukázalo, že můžete získat konzistentnější výsledky tím, že zahrnete pokyn "Odpovědět na cestovní otázky na to nejlepší z vaší schopnosti a poskytnout pouze relevantní informace. Pro rezervaci výletu, zachycení jména člověka je nezbytné." Výsledky se zobrazí ve formátu HTML, aby se zlepšil vizuální odvolání webového rozhraní.

Nástroje agenta

Nástroje jsou rozhraní, která může agent používat k interakci se světem, často prostřednictvím volání funkcí.

Při vytváření agenta ho musíte zajistit sadou nástrojů, které může používat. Dekorátor @tool nabízí nejjednodušší přístup k definování vlastního nástroje.

Ve výchozím nastavení dekorátor používá název funkce jako název nástroje, i když ho můžete nahradit zadáním řetězce jako prvního argumentu. Dekorátor používá jako popis nástroje docstring funkce, takže vyžaduje zřízení řetězce docstring.

Tady je obsah služby/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"

Soubor TravelAgentTools.py definuje tři nástroje:

  • vacation_lookup provádí vektorové vyhledávání ve službě Azure Cosmos DB. Používá similarity_search k získání relevantních materiálů souvisejících s cestováním.
  • itinerary_lookup načte podrobnosti o výletních balíčcích a plány pro zadanou výletní loď.
  • book_cruise si zapisuje výletní balíček pro cestující.

Konkrétní pokyny ("Za účelem rezervace výletu potřebuji znát vaše jméno") mohou být nezbytné k zajištění zachycení jména a čísla pokoje pro rezervaci výletního balíčku, i když jste tyto pokyny zahrnuli do výzvy LLM.

Agent AI

Základním konceptem, který tvoří základ agentů, je použití jazykového modelu k výběru posloupnosti akcí, které se mají provést.

Tady je obsah služby nebo 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))

Soubor TravelAgent.py je jednoduchý, protože agent_with_chat_history a jeho závislosti (nástroje, výzvy a LLM) se inicializují a konfigurují v souboru init.py . Tento soubor volá agenta pomocí vstupu přijatého uživatelem spolu s ID relace pro paměť konverzace. PromptResponse Poté se vrátí (model/výzva) s výstupem a dobou odezvy agenta.

Integrace agenta AI s uživatelským rozhraním Reactu

Díky úspěšnému načtení dat a přístupnosti agenta AI prostřednictvím rozhraní API teď můžete řešení dokončit vytvořením webového uživatelského rozhraní (pomocí Reactu) pro váš cestovní web. Použití funkcí Reactu pomáhá znázornit bezproblémovou integraci agenta AI do cestovního webu. Tato integrace vylepšuje uživatelské prostředí pomocí konverzačního cestovního asistenta pro dotazy a rezervace.

Nastavení prostředí pro React

Před testováním rozhraní React nainstalujte Node.js a závislosti.

Spuštěním následujícího příkazu z webového adresáře proveďte čistou instalaci závislostí projektu. Instalace může nějakou dobu trvat.

    npm ci

Dále ve webovém adresáři vytvořte soubor s názvem .env, který usnadňuje ukládání proměnných prostředí. Do nově vytvořeného souboru .env zadejte následující podrobnosti:

REACT_APP_API_HOST=http://127.0.0.1:8000

Teď spusťte z webového adresáře následující příkaz, který zahájí webové uživatelské rozhraní Reactu:

    npm start

Spuštění předchozího příkazu otevře webovou aplikaci React.

Procházení webového rozhraní Reactu

Webový projekt úložiště GitHub je jednoduchá aplikace, která usnadňuje interakci uživatelů s agentem AI. Primární komponenty potřebné ke komunikaci s agentem jsou TravelAgent.js a ChatLayout.js. Soubor Main.js slouží jako centrální modul nebo cílová stránka uživatele.

Snímek obrazovky s webovým rozhraním React JavaScript

Hlavní

Hlavní komponenta slouží jako centrální správce aplikace. Funguje jako určený vstupní bod pro směrování. V rámci vykreslovací funkce vytvoří kód JSX, který definuje rozložení hlavní stránky. Toto rozložení zahrnuje zástupné prvky aplikace, jako jsou loga a odkazy, oddíl, který obsahuje součást cestovního agenta, a zápatí, které obsahuje ukázkové právní omezení týkající se povahy aplikace.

Tady je obsah 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

Cestovní agent

Komponenta cestovního agenta má jednoduchý účel: zachytávání uživatelských vstupů a zobrazování odpovědí. Hraje klíčovou roli při správě integrace s back-endovým agentem umělé inteligence, a to především zachycením relací a předáváním uživatelských výzev službě FastAPI. Výsledné odpovědi jsou uloženy v poli pro zobrazení, které usnadňuje komponenta rozložení chatu.

Tady je obsah tripplanningu /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>
  )
}

Vyberte Snadné plánování cesty a otevřete cestovního asistenta.

Rozložení chatu

Komponenta rozložení chatu dohlíží na uspořádání chatu. Systematicky zpracovává chatové zprávy a implementuje formátování zadané v objektu message JSON.

Tady je obsah 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>
  )
}

Výzvy uživatelů jsou na pravé straně a mají modrou barvu. Odpovědi od cestovního agenta AI jsou na levé straně a barevné zelené. Jak je vidět na následujícím obrázku, odpovědi ve formátu HTML se započítávají do konverzace.

Snímek obrazovky s chatem

Až bude agent AI připravený do produkčního prostředí, můžete použít sémantické ukládání do mezipaměti ke zlepšení výkonu dotazů o 80 % a snížení nákladů na odvozování LLM a volání rozhraní API. Pokud chcete implementovat sémantické ukládání do mezipaměti, přečtěte si tento příspěvek na blogu Stochastic Coder.

Diagram sémantické ukládání do mezipaměti

Související obsah