AI-ügynökök az Azure Cosmos DB-ben

Az AI-ügynökök speciális feladatok elvégzésére, kérdések megválaszolására és folyamatok automatizálására szolgálnak a felhasználók számára. Ezek az ügynökök rendkívül összetettek. Ezek az egyszerű csevegőrobotoktól a copilotokig, a fejlett AI-asszisztensekig terjednek digitális vagy robotikus rendszerek formájában, amelyek képesek összetett munkafolyamatokat önállóan futtatni.

Ez a cikk fogalmi áttekintéseket és részletes implementációs mintákat tartalmaz az AI-ügynökök számára.

Mik azok az AI-ügynökök?

Az önálló nagy nyelvi modellekkel (LLM-ekkel) vagy szabályalapú szoftver-/hardverrendszerekkel ellentétben az AI-ügynökök az alábbi gyakori funkciókkal rendelkeznek:

• Tervezés: Az AI-ügynökök megtervezhetik és sorrendbe állíthatják a műveleteket, hogy konkrét célokat érjenek el. Az LLM-k integrációja forradalmasította tervezési képességeiket.
• Eszközhasználat: A speciális AI-ügynökök különböző eszközöket, például kódvégrehajtási, keresési és számítási képességeket használhatnak a feladatok hatékony végrehajtásához. Az AI-ügynökök gyakran használnak eszközöket függvényhívással.
• Észlelés: Az AI-ügynökök képesek észlelni és feldolgozni a környezetükből származó információkat, hogy interaktívabbá és környezettudatosabbá tegyék őket. Ezek az információk vizuális, hallási és egyéb érzékszervi adatokat is tartalmaznak.
• Memória: Az AI-ügynökök képesek emlékezni a múltbeli interakciókra (eszközhasználat és észlelés) és viselkedésekre (eszközhasználat és tervezés). Ezeket a szolgáltatásokat tárolják, és még önreflexiót is végrehajtanak a jövőbeli műveletek tájékoztatása érdekében. Ez a memóriaösszetevő lehetővé teszi az ügynök teljesítményének időbeli folytonosságát és javulását.

Copilots

A copilotok az AI-ügynökök egy típusa. Nem egymástól függetlenül, hanem a felhasználókkal dolgoznak együtt. A teljesen automatizált ügynököktől eltérően a copilotok javaslatokat és javaslatokat nyújtanak a felhasználók számára a feladatok elvégzéséhez.

Ha például egy felhasználó e-mailt ír, a másodpilóta kifejezéseket, mondatokat vagy bekezdéseket javasolhat. A felhasználó arra is megkérheti a másodpilótát, hogy keressen releváns információkat más e-mailekben vagy fájlokban a javaslat támogatásához (lásd a lekéréses kiegészítésű generációt). A felhasználó elfogadhatja, elutasíthatja vagy szerkesztheti a javasolt szakaszokat.

Autonóm ügynökök

Az autonóm ügynökök egymástól függetlenül is működhetnek. Ha autonóm ügynököket állít be az e-mailek összeállításához, engedélyezheti számukra a következő feladatok elvégzését:

• Tekintse meg a témával kapcsolatos meglévő e-maileket, csevegéseket, fájlokat és egyéb belső és nyilvános információkat.
• Minőségi vagy mennyiségi elemzést végezhet az összegyűjtött információkról, és levonhatja az e-mail szempontjából releváns következtetéseket.
• Írja meg a teljes e-mailt a következtetések alapján, és tartalmazza az alátámasztó bizonyítékokat.
• Csatolja a megfelelő fájlokat az e-mailhez.
• Tekintse át az e-mailt, és győződjön meg arról, hogy az összes beépített információ tényszerű, és hogy az állítások érvényesek.
• Válassza ki a Címzett, Másolatot kap és Titkos másolat címzettjeinek megfelelő címzetteket, és keresse meg az e-mail-címüket.
• Ütemezzen egy megfelelő időpontot az e-mail elküldéséhez.
• Ha a válaszok várhatók, de nem érkeznek meg, végezze el a nyomon követéseket.

Az ügynököket úgy konfigurálhatja, hogy az előző feladatokat emberi jóváhagyással vagy anélkül hajtják végre.

Többügynök-rendszerek

A teljesítményalapú autonóm ügynökök elérésének népszerű stratégiája a többügynök-rendszerek használata. Többügynök-rendszerekben több autonóm ügynök, akár digitális, akár robotikus formában, együttműködik vagy együttműködik az egyéni vagy kollektív célok elérése érdekében. A rendszerben lévő ügynökök önállóan működhetnek, és saját tudással vagy információval rendelkeznek. Minden ügynök képes lehet arra is, hogy érzékelje a környezetét, döntéseket hozzon, és a célkitűzései alapján műveleteket hajtson végre.

A többügynök-rendszerek a következő fő jellemzőkkel rendelkeznek:

• Autonóm: Minden ügynök egymástól függetlenül működik. Saját döntéseket hoz közvetlen emberi beavatkozás vagy más ügynökök általi ellenőrzés nélkül.
• Interaktív: Az ügynökök kommunikálnak és együttműködnek egymással az információk megosztásához, a tárgyalásokhoz és a műveletek koordinálásához. Ez az interakció különböző protokollokon és kommunikációs csatornákon keresztül történhet.
• Célorientált: A többügynök-rendszer ügynökei meghatározott célok elérésére vannak kialakítva, amelyek igazodhatnak az egyes célokhoz vagy az ügynökök közös céljához.
• Elosztott: A többügynök-rendszerek elosztott módon működnek, egyetlen vezérlési pont nélkül. Ez az elosztás növeli a rendszer robusztusságát, méretezhetőségét és erőforrás-hatékonyságát.

A többügynök-rendszer a következő előnyöket nyújtja a copilot vagy az LLM-következtetés egyetlen példányával szemben:

• Dinamikus érvelés: A gondolatlánchoz vagy a gondolatfa-kéréshez képest a többügynökös rendszerek lehetővé teszik a dinamikus navigációt a különböző érvelési útvonalakon.
• Kifinomult képességek: A többügynök-rendszerek összetett vagy nagy léptékű problémákat képesek kezelni alapos döntéshozatali folyamatok végrehajtásával és a feladatok több ügynök közötti elosztásával.
• Továbbfejlesztett memória: A memóriával rendelkező többügynök-rendszerek képesek leküzdeni az LLM-ek környezetablakait, hogy jobb megértést és információmegőrzést tegyenek lehetővé.

AI-ügynökök implementálása

Érvelés és tervezés

Az összetett érvelés és tervezés a fejlett autonóm ügynökök jellemzője. Az autonóm ügynökök népszerű keretrendszerei az alábbi módszerek közül egyet vagy többet tartalmaznak (az arXiv archív oldalakra mutató hivatkozásokkal) az érveléshez és a tervezéshez:

• Önfelkérdezés

  Fejlessze a gondolatláncot úgy, hogy a modell a kezdeti kérdés megválaszolása előtt kifejezetten felteheti magát (és megválaszolhatja) az utánkövetési kérdéseket.

• Ok és cselekmény (ReAct)

  Az LLM-ekkel oknyomokat és feladatspecifikus műveleteket hozhat létre egymással összefüggő módon. Az érvelési nyomkövetések segítenek a modellnek a műveleti tervek indukálásában, nyomon követésében és frissítésében, valamint a kivételek kezelésében. A műveletek lehetővé teszik, hogy a modell külső forrásokkal, például tudásbázis vagy környezetekkel csatlakozzon, és további információkat gyűjtsön.

• Tervezés és megoldás

  Dolgozzon ki egy tervet, amely a teljes feladatot kisebb altevékenységekre osztja, majd végrehajtja az altevékenységeket a terv szerint. Ez a megközelítés enyhíti a számítási hibákat, a hiányzó lépésekkel kapcsolatos hibákat és a szemantikai félreértéseket, amelyek gyakran előfordulnak a gondolatláncok nulla lövésű kérésében.

• Tükrözés/önkritika

  Használjon olyan reflexiós ügynököket, amelyek verbálisan tükrözik a feladatvisszajelzéseket. Ezek az ügynökök saját tükröző szöveget tartanak fenn egy epizodikus memóriapufferben, hogy jobb döntéshozatalt indukáljanak a későbbi kísérletekben.

Keretrendszerek

A különböző keretrendszerek és eszközök megkönnyítik az AI-ügynökök fejlesztését és üzembe helyezését.

A kifinomult tervezést és memóriát nem igénylő eszközhasználat és észlelés érdekében néhány népszerű LLM vezénylő keretrendszer a LangChain, a LlamaIndex, a Prompt Flow és a Szemantikus kernel.

A fejlett és autonóm tervezési és végrehajtási munkafolyamatok esetében az AutoGen elindította a 2022 végén kezdődött többügynök-hullámot. Az OpenAI Assistants API lehetővé teszi a felhasználók számára, hogy natív módon hozzanak létre ügynököket a GPT-ökoszisztémában. A LangChain-ügynökök és a LlamaIndex-ügynökök is ugyanabban az időben jelentek meg.

AI-ügynök memóriarendszere

A 2022 és 2024 közötti AI-továbbfejlesztett alkalmazásokkal való kísérletezés elterjedt gyakorlata különálló adatbázis-kezelő rendszereket használ különböző adat-munkafolyamatokhoz vagy -típusokhoz. Használhat például egy memórián belüli adatbázist gyorsítótárazáshoz, egy relációs adatbázist a működési adatokhoz (beleértve a nyomkövetési/tevékenységnaplókat és az LLM beszélgetési előzményeit), valamint egy tiszta vektoradatbázist a beágyazási felügyelethez.

Az önálló adatbázisok összetett webjének használata azonban ronthatja az AI-ügynökök teljesítményét. Ezeknek a különálló adatbázisoknak az AI-ügynökök összetartó, interoperábilis és rugalmas memóriarendszerbe való integrálása saját kihívás.

Emellett a gyakran használt adatbázis-szolgáltatások közül sok nem optimális az AI-ügynökrendszerek által igényelt sebességhez és méretezhetőséghez. Ezeknek az adatbázisoknak az egyéni gyengeségeit tovább súlyosbítják a többügynökökkel működő rendszerek.

Memóriabeli adatbázisok

A memóriabeli adatbázisok kiválóan alkalmasak a sebességre, de az AI-ügynökök számára szükséges nagy méretű adatmegőrzéssel is küszködhetnek.

Relációs adatbázisok

A relációs adatbázisok nem ideálisak az ügynökök által kezelt adatok változatos modalitásaihoz és folyadéksémáihoz. A relációs adatbázisok manuális erőfeszítéseket, sőt állásidőt igényelnek a kiépítés, particionálás és horizontális skálázás kezeléséhez.

Tiszta vektoradatbázisok

A tiszta vektoradatbázisok általában kevésbé hatékonyak a tranzakciós műveletek, a valós idejű frissítések és az elosztott számítási feladatok esetében. Manapság a népszerű tiszta vektoradatbázisok általában a következő lehetőségeket kínálják:

• Nincs garancia az olvasásra és az írásra.
• Korlátozott betöltési átviteli sebesség.
• Alacsony rendelkezésre állás (99,9% alatt, vagy 9 órás vagy annál nagyobb éves leállás).
• Egy konzisztenciaszint (végleges).
• Erőforrásigényes memóriabeli vektorindex.
• Korlátozott lehetőségek a több-bérlős használatra.
• Korlátozott biztonság.

A robusztus AI-ügynök memóriarendszer jellemzői

Ahogyan a hatékony adatbázis-kezelő rendszerek kritikus fontosságúak a szoftveralkalmazások teljesítménye szempontjából, az LLM-alapú ügynökök számára fontos, hogy releváns és hasznos információkat nyújtsanak a következtetésükhöz. A robusztus memóriarendszerek lehetővé teszik a különböző típusú információk rendszerezését és tárolását, amelyeket az ügynökök következtetési időben lekérhetnek.

Az LLM-alapú alkalmazások jelenleg gyakran használnak lekéréses kiegészítésű generációt , amely alapszintű szemantikai keresést vagy vektorkeresést használ a szakaszok vagy dokumentumok lekéréséhez. A vektorkeresés hasznos lehet az általános információk megkereséséhez. Előfordulhat azonban, hogy a vektorkeresés nem rögzíti az adott tevékenységhez vagy tartományhoz kapcsolódó adott környezetet, struktúrát vagy kapcsolatokat.

Ha például a feladat kód írása, előfordulhat, hogy a vektorkeresés nem tudja lekérni a szintaxisfát, a fájlrendszerelrendezést, a kódösszesítéseket vagy az API-aláírásokat, amelyek fontosak a koherens és helyes kód létrehozásához. Hasonlóképpen, ha a feladat táblázatos adatokkal dolgozik, előfordulhat, hogy a vektorkeresés nem tudja lekérni a sémát, az idegen kulcsokat, a tárolt eljárásokat vagy az adatok lekérdezéséhez vagy elemzéséhez hasznos jelentéseket.

A különálló memóriabeli, relációs és vektoradatbázisok hálójának (a korábban leírtaknak megfelelően) összefonása nem optimális megoldás a különböző adattípusokhoz. Ez a megközelítés a prototipikus ügynökrendszerek esetében is működik. Ez azonban összetettséghez és teljesítménybeli szűk keresztmetszetekhez ad hozzá, amelyek akadályozhatják a fejlett autonóm ügynökök teljesítményét.

A robusztus memóriarendszernek a következő jellemzőkkel kell rendelkeznie.

Multimodális

Az AI-ügynök memóriarendszereinek metaadatokat, kapcsolatokat, entitásokat, összegzéseket vagy más típusú információkat tároló gyűjteményeket kell biztosítaniuk, amelyek hasznosak lehetnek a különböző feladatokhoz és tartományokhoz. Ezek a gyűjtemények az adatok struktúráján és formátumán alapulhatnak, például dokumentumokon, táblákon vagy kódon. Vagy alapulhatnak az adatok tartalmán és jelentésén, például fogalmakon, társításokon vagy eljárási lépéseken.

A memóriarendszerek nem csak kritikus fontosságúak az AI-ügynökök számára. Az emberek számára is fontosak, akik fejlesztik, karbantartják és használják ezeket az ügynököket.

Előfordulhat például, hogy az embereknek közel valós időben kell felügyelni az ügynökök tervezési és végrehajtási munkafolyamatait. Felügyelet közben az emberek együttműködhetnek az útmutatással, vagy sorba szerkeszthetik az ügynökök párbeszédeit vagy monológjait. Előfordulhat, hogy az embereknek az ügynökök érvelését és műveleteit is ellenőriznie kell a végső kimenet érvényességének ellenőrzéséhez.

Az emberi/ügynöki interakciók valószínűleg természetes vagy programozási nyelveken vannak, míg az ügynökök beágyazásokon keresztül "gondolkodnak", "tanulnak" és "emlékeznek". Ez a különbség egy másik követelményt jelent a memóriarendszerek adatmódok közötti konzisztenciájára nézve.

Működik

A memóriarendszereknek olyan memóriabankokat kell biztosítaniuk, amelyek a felhasználóval és a környezettel való interakció szempontjából releváns információkat tárolják. Ilyen információk lehetnek például a csevegési előzmények, a felhasználói beállítások, az érzékszervi adatok, a meghozott döntések, a tanult tények vagy a nagy gyakorisággal és nagy mennyiségben frissített egyéb működési adatok.

Ezek a memóriabankok segíthetnek az ügynököknek emlékezni a rövid távú és hosszú távú információkra, elkerülhetik az ismétlődő vagy ellentmondó információkat, és fenntarthatják a feladat koherenciáját. Ezeknek a követelményeknek akkor is teljesülniük kell, ha az ügynökök egymás után számos, egymástól független feladatot végeznek. Speciális esetekben az ügynökök számos olyan ágtervet is tesztelhetnek, amelyek különböző pontokon térnek el vagy konvergálnak.

Megosztható, de elválasztható is

Makrószinten a memóriarendszereknek lehetővé kell tenniük, hogy több AI-ügynök működjön együtt egy problémán, vagy feldolgozzák a probléma különböző aspektusait azáltal, hogy az összes ügynök számára elérhető megosztott memóriát biztosítanak. A megosztott memória elősegítheti az információk cseréjét és a műveletek összehangolását az ügynökök között.

Ugyanakkor a memóriarendszernek lehetővé kell tennie az ügynökök számára, hogy megőrizzék saját személyiségüket és jellemzőiket, például a kérések és emlékek egyedi gyűjteményeit.

Robusztus AI-ügynökmemóriarendszer létrehozása

Az előző jellemzők megkövetelik, hogy az AI-ügynökök memóriarendszerei nagy mértékben méretezhetők és gyorsak legyenek. Az eltérő memóriabeli, relációs és vektoradatbázisok (a korábban ismertetettek szerint) együttes együttes használata a korai szakaszban használható AI-kompatibilis alkalmazások esetében is működhet. Ez a megközelítés azonban összetettségi és teljesítménybeli szűk keresztmetszeteket ad hozzá, amelyek akadályozhatják a fejlett autonóm ügynökök teljesítményét.

Az összes különálló adatbázis helyett az Azure Cosmos DB egységes megoldásként szolgálhat az AI-ügynökök memóriarendszereihez. Robusztussága lehetővé tette, hogy az OpenAI ChatGPT szolgáltatása dinamikusan, nagy megbízhatósággal és alacsony karbantartással skálázható legyen. Atom-rekordütemezési motorral a világ első globálisan elosztott NoSQL-, relációs és vektoradatbázis-szolgáltatása , amely kiszolgáló nélküli módot kínál. Az Azure Cosmos DB-n alapuló AI-ügynökök sebességet, skálázást és egyszerűséget kínálnak.

Sebesség

Az Azure Cosmos DB egyjegyű ezredmásodperc késést biztosít. Ez a képesség alkalmassá teszi a gyors adathozzáférést és -kezelést igénylő folyamatokhoz. Ezek a folyamatok magukban foglalják a gyorsítótárazást (a hagyományos és a szemantikai gyorsítótárazást, a tranzakciókat és az üzemeltetési számítási feladatokat is).

Az alacsony késés kulcsfontosságú az olyan AI-ügynökök számára, amelyeknek összetett érvelést kell végrehajtaniuk, valós idejű döntéseket kell hozniuk, és azonnali válaszokat kell adniuk. Emellett a DiskANN-algoritmus szolgáltatás általi használata pontos és gyors vektorkeresést biztosít minimális memóriahasználat mellett.

Hangsor

Az Azure Cosmos DB-t globális elosztásra és horizontális skálázhatóságra tervezték. Támogatja a többrégiós I/O-t és a több-bérlős felhasználókat.

A szolgáltatás biztosítja, hogy a memóriarendszerek zökkenőmentesen bővüljenek, és lépést tartsanak a gyorsan növekvő ügynökökkel és a kapcsolódó adatokkal. A szolgáltatásiszint-szerződésben (SLA) szereplő rendelkezésre állási garancia évente kevesebb mint 5 perc állásidőt jelent. A tiszta vektoradatbázis-szolgáltatások ezzel szemben 9 óra vagy több állásidővel járnak. Ez a rendelkezésre állás szilárd alapot biztosít a kritikus fontosságú számítási feladatokhoz. Ugyanakkor az Azure Cosmos DB különböző szolgáltatási modelljei, például a fenntartott kapacitás vagy a kiszolgáló nélküli, segíthetnek csökkenteni a pénzügyi költségeket.

Egyszerűség

Az Azure Cosmos DB egyszerűsítheti az adatkezelést és az architektúrát, ha több adatbázis-funkciót integrál egyetlen, egységes platformba.

Integrált vektoradatbázis-képességei a megfelelő adatok mellett természetes vagy programozási nyelveken is tárolhatják, indexelhetik és lekérdezhetik a beágyazásokat. Ez a képesség nagyobb adatkonzisztenciát, skálázást és teljesítményt tesz lehetővé.

Rugalmassága támogatja a metaadatok, kapcsolatok, entitások, összegzések, csevegési előzmények, felhasználói beállítások, érzékszervi adatok, döntések, tanult tények vagy az ügynök-munkafolyamatok egyéb működési adatainak változatos modalitását és folyadéksémáit. Az adatbázis automatikusan indexeli az összes adatot séma- vagy indexkezelés nélkül, ami segít az AI-ügynököknek az összetett lekérdezések gyors és hatékony végrehajtásában.

Az Azure Cosmos DB teljes körűen felügyelve van, ami kiküszöböli az olyan adatbázis-felügyeleti feladatok többletterhelését, mint a skálázás, a javítás és a biztonsági mentés. E többletterhelés nélkül a fejlesztők az AI-ügynökök létrehozására és optimalizálására összpontosíthatnak anélkül, hogy a mögöttes adatinfrastruktúra miatt kellene aggódniuk.

Speciális funkciók

Az Azure Cosmos DB olyan speciális funkciókat tartalmaz, mint a változáscsatorna, amely lehetővé teszi az adatok változásainak valós idejű nyomon követését és megválaszolását. Ez a képesség olyan AI-ügynökök számára hasznos, amelyeknek azonnal reagálnia kell az új információkra.

Emellett a több főkiszolgálós írások beépített támogatása magas rendelkezésre állást és rugalmasságot tesz lehetővé az AI-ügynökök folyamatos működésének biztosításához még a regionális hibák után is.

Az öt elérhető konzisztenciaszint (erőstől a véglegesig) a forgatókönyv követelményeitől függően különböző elosztott számítási feladatokra is képes.

Megvalósítási minta

Ez a szakasz egy önvezető ügynök implementálását ismerteti, amely feldolgozhatja az utazók kérdéseit és foglalásait egy utazási alkalmazásban egy körutazási vonalon.

A csevegőrobotok régóta léteznek, de az AI-ügynökök az alapszintű emberi beszélgetéseken túl is fejlődnek, hogy természetes nyelv alapján végezhessenek feladatokat. Ezek a feladatok hagyományosan kódolt logikát igényelnek. A megvalósítási mintában szereplő AI-utazási ügynök a LangChain-ügynök keretrendszerét használja az ügynöktervezéshez, az eszközhasználathoz és az észleléshez.

Az AI utazási ügynök egyesített memóriarendszere az Azure Cosmos DB vektoradatbázisát és dokumentumtárolási képességeit használja az utazók kérdéseinek kezeléséhez és az utazásfoglalások megkönnyítéséhez. Az Azure Cosmos DB erre a célra való használata segít biztosítani a sebesség, a skálázás és az egyszerűség biztosítását a korábban leírtaknak megfelelően.

A mintaügynök a Python FastAPI háttérrendszerében működik. A React JavaScript felhasználói felületén keresztül támogatja a felhasználói interakciókat.

Előfeltételek

• Azure-előfizetés. Ha nem rendelkezik ilyen fiókkal, 30 napig ingyenesen kipróbálhatja az Azure Cosmos DB-t azure-fiók létrehozása nélkül. Az ingyenes próbaverzióhoz nincs szükség hitelkártyára, és a próbaidőszakot semmilyen kötelezettségvállalás nem követi.
• Az OpenAI API vagy az Azure OpenAI szolgáltatás fiókja.
• Virtuális magfürt a MongoDB-hez készült Azure Cosmos DB-ben. Ezt a rövid útmutatót követve létrehozhat egyet.
• Integrált fejlesztési környezet, például Visual Studio Code.
• A fejlesztési környezetben telepített Python 3.11.4.

A projekt letöltése

Az összes kód és mintaadatkészlet elérhető ebben a GitHub-adattárban. Az adattár a következő mappákat tartalmazza:

• betöltő: Ez a mappa Python-kódot tartalmaz a mintadokumentumok és vektoros beágyazások Azure Cosmos DB-be való betöltéséhez.
• api: Ez a mappa tartalmazza az AI-utazási ügynök üzemeltetésére szolgáló Python FastAPI-projektet.
• web: Ez a mappa a React webes felület kódját tartalmazza.

Utazási dokumentumok betöltése az Azure Cosmos DB-be

A GitHub-adattár egy Python-projektet tartalmaz a betöltőkönyvtárban . A minta útidokumentumok Azure Cosmos DB-be való betöltésére szolgál.

A környezet beállítása

Állítsa be a Python virtuális környezetet a betöltőkönyvtárban az alábbi parancs futtatásával:

python -m venv venv

Aktiválja a környezetet, és telepítse a függőségeket a betöltőkönyvtárban :

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

Hozzon létre egy .env nevű fájlt a betöltőkönyvtárban a következő környezeti változók tárolásához:

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

Dokumentumok és vektorok betöltése

A Python-fájl main.py szolgál az adatok Azure Cosmos DB-be való betöltésének központi belépési pontjaként. Ez a kód feldolgozza a GitHub-adattárból származó minta utazási adatokat, beleértve a hajókra és a célállomásokra vonatkozó információkat is. A kód emellett utazási útvonalcsomagokat is létrehoz minden egyes hajóhoz és célhoz, hogy az utazók az AI-ügynök segítségével lefoglalhassák őket. A CosmosDBLoader eszköz feladata gyűjtemények, vektorbeágyazások és indexek létrehozása az Azure Cosmos DB-példányban.

Íme a main.py tartalma:

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')])

Töltse be a dokumentumokat, töltse be a vektorokat, és hozzon létre indexeket a következő parancs futtatásával a betöltőkönyvtárból :

python main.py

A main.py kimenete a következő:

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

Az AI utazási ügynök létrehozása a Python FastAPI használatával

Az AI-utazási ügynök egy háttér API-ban, a Python FastAPI-on keresztül működik, amely megkönnyíti az integrációt az előtérbeli felhasználói felülettel. Az API-projekt úgy dolgozza fel az ügynökkéréseket, hogy az LLM-kéréseket az adatrétegre, különösen az Azure Cosmos DB-ben található vektorokra és dokumentumokra alapozza.

Az ügynök különböző eszközöket használ, különösen az API-szolgáltatási rétegben biztosított Python-függvényeket. Ez a cikk az API-kódon belüli AI-ügynökök számára szükséges kódra összpontosít.

A GitHub-adattár API-projektje a következőképpen van felépítve:

• Az adatmodellezési összetevők Pydantic-modelleket használnak.
• A webes réteg összetevői felelősek az útválasztási kérésekért és a kommunikáció kezeléséért.
• A szolgáltatási réteg összetevői felelősek az elsődleges üzleti logikáért és az adatréteggel, a LangChain-ügynökkel és az ügynökeszközökkel való interakcióért.
• Az adatréteg-összetevők felelősek a MongoDB-hez készült Azure Cosmos DB-dokumentumok tárolásáért és vektorkereséséért.

Az API környezetének beállítása

Az API fejlesztéséhez és teszteléséhez a Python 3.11.4-es verzióját használtuk.

A Python virtuális környezet beállítása az API-címtárban :

python -m venv venv

Aktiválja a környezetet, és telepítse a függőségeket az API-címtárban található követelményfájl használatával:

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

Hozzon létre egy .env nevű fájlt az API-címtárban a környezeti változók tárolásához:

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

Most, hogy konfigurálta a környezetet, és beállította a változókat, futtassa a következő parancsot az API-címtárból a kiszolgáló elindításához:

python app.py

A FastAPI-kiszolgáló alapértelmezés szerint a 127.0.0.1 8000-s porton indul el a localhost visszacsatoláson. A Swagger-dokumentumokat a következő localhost-címmel érheti el: http://127.0.0.1:8000/docs.

Munkamenet használata az AI-ügynök memóriájához

Elengedhetetlen, hogy az utazási ügynök a folyamatban lévő beszélgetés során hivatkozhasson a korábban megadott információkra. Ezt a képességet gyakran memóriaként ismerjük az LLM-ekkel összefüggésben.

A cél eléréséhez használja az Azure Cosmos DB-példányban tárolt csevegőüzenetek előzményeit. Az egyes csevegések előzményeit egy munkamenet-azonosító tárolja, hogy csak az aktuális beszélgetési munkamenetből származó üzenetek legyenek elérhetők. Ez a szükségesség az oka annak, hogy létezik egy Get Session metódus az API-ban. Ez egy helyőrző módszer a webes munkamenetek kezelésére a csevegőüzenetek előzményeinek használatának szemléltetésére.

Válassza a Kipróbálás /session/lehetőséget.

{
  "session_id": "0505a645526f4d68a3603ef01efaab19"
}

Az AI-ügynök esetében csak egy munkamenetet kell szimulálnia. A csonkolt metódus csupán egy generált munkamenet-azonosítót ad vissza az üzenetelőzmények nyomon követéséhez. A gyakorlati megvalósítás során ez a munkamenet az Azure Cosmos DB-ben és potenciálisan a Reactben localStoragelesz tárolva.

A web/session.py tartalma a következő:

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

Beszélgetés indítása az AI utazási ügynökkel

Az előző lépésben beszerzett munkamenet-azonosítóval új párbeszédet kezdeményezhet az AI-ügynökkel, így ellenőrizheti annak működését. A tesztet a következő kifejezés beküldésével végezheti el: "Pihentető nyaralást szeretnék."

Válassza a Kipróbálás /agent/agent_chatlehetőséget.

Használja ezt a példaparamétert:

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

A kezdeti végrehajtás eredménye egy javaslatot a Tranquil Breeze Cruise és a Fantasy Seas Adventure Cruise, mert az ügynök azt várja, hogy ők a leglazítóbb cruises elérhető a vektorkeresés. Ezek a dokumentumok az API adatrétegében a legmagasabb pontszámmal similarity_search_with_score rendelkeznek. data.mongodb.travel.similarity_search()

A hasonlósági keresési pontszámok hibakeresési célokból az API kimeneteként jelennek meg. Az alábbi kimenet a következő hívás után jelenik meg data.mongodb.travel.similarity_search():

0.8394561085977978
0.8086545112328692
2

Az első híváskor agent_chat létrehoz egy új, az Azure Cosmos DB-ben elnevezett history gyűjteményt, amely munkamenetek szerint tárolja a beszélgetést. Ez a hívás lehetővé teszi az ügynök számára, hogy szükség szerint hozzáférjen a tárolt csevegőüzenetek előzményeihez. Az azonos paraméterekkel végzett későbbi végrehajtások agent_chat eltérő eredményeket eredményeznek, mivel a memóriából származik.

Az AI-ügynök végigjárása

Amikor az AI-ügynököt integrálja az API-ba, a webes keresési összetevők felelősek az összes kérés kezdeményezéséért. A webes keresési összetevőket a keresési szolgáltatás, végül az adatösszetevők követik.

Ebben az esetben mongoDB-adatkeresést használ, amely az Azure Cosmos DB-hez csatlakozik. A rétegek megkönnyítik a modellösszetevők cseréjét a szolgáltatásrétegben található AI-ügynökkel és az AI-ügynök eszközkódjával. Ez a megközelítés lehetővé teszi az adatforrások zökkenőmentes felcserélhetőségét. Emellett kibővíti az AI-ügynök képességeit további, bonyolult funkciókkal vagy eszközökkel.

Szolgáltatási réteg

A szolgáltatásréteg képezi az alapvető üzleti logika alapkövét. Ebben a konkrét forgatókönyvben a szolgáltatásréteg kulcsfontosságú szerepet játszik a LangChain-ügynök kódjának adattáraként. Megkönnyíti a felhasználói kérések zökkenőmentes integrációját az Azure Cosmos DB-adatokkal, a beszélgetési memóriával és az AI-ügynök ügynökfüggvényeivel.

A szolgáltatási réteg egy egytonos mintamodult alkalmaz az ügynökkel kapcsolatos inicializálások kezelésére a init.py fájlban. A szolgáltatás/init.py tartalma:

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()

A init.py fájl kezdeményezi a környezeti változók betöltését egy .env fájlból a load_dotenv(override=False) metódus használatával. Ezután a rendszer létrehoz egy névvel ellátott agent_with_chat_history globális változót az ügynök számára. Ezt az ügynököt TravelAgent.py használhatja.

A LLM_init() modul inicializálása során a rendszer meghívja a metódust, hogy konfigurálja az AI-ügynököt beszélgetésre az API webes rétegen keresztül. Az OpenAI chat objektum példányosítása a GPT-3.5 modellen keresztül történik, és olyan paramétereket tartalmaz, mint a modell neve és hőmérséklete. Az chat objektum, az eszközök listája és a parancssori sablon kombinálva jön létre AgentExecutor, amely az AI utazási ügynökeként működik.

Az előzményekkel agent_with_chat_historyrendelkező ügynök a csevegési előzményekkel (MongoDBChatMessageHistory) jön létreRunnableWithMessageHistory. Ez a művelet lehetővé teszi, hogy teljes beszélgetési előzményeket tartson fenn az Azure Cosmos DB-en keresztül.

Felszólítás

Az LLM parancssor kezdetben azzal az egyszerű állítással kezdődött, hogy "Ön egy segítőkész és barátságos utazási asszisztens egy körutazási vállalat számára." A tesztelés azonban azt mutatta, hogy konzisztensebb eredményeket érhet el az "Utazási kérdések megválaszolása a lehető legjobban" utasítással, amely csak releváns információkat tartalmaz. A hajóutak lefoglalásához elengedhetetlen a személy nevének rögzítése." Az eredmények HTML formátumban jelennek meg a webes felület vizuális vonzerejének növelése érdekében.

Ügynökeszközök

Az eszközök olyan felületek, amelyekkel egy ügynök kommunikálhat a világgal, gyakran függvényhívással.

Ügynök létrehozásakor olyan eszközökkel kell rendelkeznie, amelyeket használhat. A @tool lakberendező a legegyszerűbb módszert kínálja az egyéni eszközök meghatározásához.

Alapértelmezés szerint a dekorátor a függvény nevét használja az eszköz neveként, de lecserélheti egy sztringet első argumentumként. A dekoratőr a függvény dokumentációját használja az eszköz leírásaként, ezért szükség van egy docstring kiépítésére.

A szolgáltatás/TravelAgentTools.py tartalma:

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"

A TravelAgentTools.py fájl három eszközt határoz meg:

• vacation_lookup Vektorkeresést végez az Azure Cosmos DB-ben. A megfelelő utazással kapcsolatos anyagok lekérésére használ similarity_search .
• itinerary_lookup lekéri a cruise csomag részleteit és ütemezését egy adott körutazási hajóhoz.
• book_cruise könyv egy cruise csomagot egy utas számára.

Konkrét utasítások ("Annak érdekében, hogy foglaljon egy hajóút meg kell ismernie a nevét") lehet szükség annak érdekében, hogy rögzítse az utas nevét és a szoba számát foglalása a cruise csomag, annak ellenére, hogy az ilyen utasításokat az LLM prompt.

AI-ügynök

Az ügynökök alapfogalmának alapja egy nyelvi modell használata a végrehajtandó műveletek sorozatának kiválasztásához.

A szolgáltatás/TravelAgent.py tartalma:

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))

A TravelAgent.py fájl egyszerű, mert agent_with_chat_history a függőségei (eszközök, parancssor és LLM) inicializálva és konfigurálva vannak a init.py fájlban. Ez a fájl meghívja az ügynököt a felhasználótól kapott bemenettel, valamint a beszélgetési memória munkamenet-azonosítójával. Ezt követően a PromptResponse rendszer visszaadja a modellt/kérést az ügynök kimenetével és válaszidejével.

AI-ügynök integrációja a React felhasználói felülettel

Az AI-ügynök adatainak és az API-n keresztüli akadálymentességének sikeres betöltésével most már elvégezheti a megoldást úgy, hogy létrehoz egy webes felhasználói felületet (a React használatával) az utazási webhelyhez. A React képességeinek használatával szemlélteti az AI-ügynök zökkenőmentes integrációját egy utazási helyre. Ez az integráció növeli a felhasználói élményt egy beszélgetési utazási asszisztenssel a kérdések és a foglalások esetében.

A React környezetének beállítása

Telepítse a Node.js és a függőségeket a React-felület tesztelése előtt.

Futtassa a következő parancsot a webkönyvtárból a projektfüggőségek tiszta telepítésének végrehajtásához. A telepítés eltarthat egy ideig.

npm ci

Ezután hozzon létre egy .env nevű fájlt a webkönyvtárban, hogy megkönnyítse a környezeti változók tárolását. Adja meg az alábbi részleteket az újonnan létrehozott .env fájlban:

REACT_APP_API_HOST=http://127.0.0.1:8000

Most futtassa a következő parancsot a webkönyvtárból a React webes felhasználói felületének elindításához:

npm start

Az előző parancs futtatása megnyitja a React webalkalmazást.

A React webes felületének végigjárása

A GitHub-adattár webes projektje egy egyszerű alkalmazás, amely megkönnyíti a felhasználói interakciót az AI-ügynökkel. Az ügynökkel való társalkításhoz szükséges elsődleges összetevők TravelAgent.js és ChatLayout.js. A Main.js fájl szolgál központi modulként vagy felhasználói kezdőlapként.

Elsődleges

A fő összetevő az alkalmazás központi kezelője. Ez az útválasztás kijelölt belépési pontja. A renderelési függvényben JSX-kódot hoz létre a főoldal elrendezésének lehatárolásához. Ez az elrendezés magában foglalja az alkalmazás helyőrző elemeit, például az emblémákat és hivatkozásokat, az utazási ügynök összetevőjét tartalmazó szakaszt, valamint egy láblécet, amely az alkalmazás természetével kapcsolatos nyilatkozatmintát tartalmaz.

Az alábbi main.js tartalma:

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

Utazási ügynök

Az utazási ügynök összetevőnek egyszerű célja van: a felhasználói bemenetek rögzítése és a válaszok megjelenítése. Kulcsszerepet játszik a háttérbeli AI-ügynökkel való integráció kezelésében, elsősorban a munkamenetek rögzítésével és a felhasználói kérések FastAPI szolgáltatásba való továbbításával. Az eredményként kapott válaszok egy tömbben vannak tárolva megjelenítésre, amelyet a csevegéselrendezési összetevő segít.

A TripPlanning/TravelAgent.js tartalma:

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>
  )
}

Válassza a könnyedén megtervezett utazást az utazási asszisztens megnyitásához.

Csevegési elrendezés

A csevegés elrendezése összetevő felügyeli a csevegés elrendezését. Szisztematikusan dolgozza fel a csevegőüzeneteket, és implementálja a JSON-objektumban megadott formázást message .

A TripPlanning/ChatLayout.js tartalma:

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>
  )
}

A felhasználói kérések a jobb oldalon vannak, kék színűek. Az AI utazási ügynök válaszai a bal oldalon vannak, és zöld színűek. Ahogy az alábbi képen is látható, a HTML-formátumú válaszok a beszélgetésben lesznek elszámolva.

Ha az AI-ügynök készen áll az éles üzembe helyezésre, szemantikai gyorsítótárazással 80%-kal javíthatja a lekérdezési teljesítményt, és csökkentheti az LLM-következtetési és API-hívási költségeket. A szemantikai gyorsítótárazás implementálásához tekintse meg ezt a bejegyzést a Sztochasztikus Coder blogon.

Kapcsolódó tartalom

• 30 napos ingyenes próbaverzió Azure-előfizetés nélkül
• 90 napos ingyenes próbaidőszak és akár 6000 dollár értékű átviteli kredit az Azure AI Advantage használatával
• Az Azure Cosmos DB élettartamának ingyenes szintje