Utbildning
Modul
Guidat projekt – Skapa en AI-resebyrå - Training
Utveckla en proof of concept AI Travel assistant chatbot med hjälp av Semantic Kernel SDK.
Den här webbläsaren stöds inte längre.
Uppgradera till Microsoft Edge och dra nytta av de senaste funktionerna och säkerhetsuppdateringarna, samt teknisk support.
AI-agenter är utformade för att utföra specifika uppgifter, besvara frågor och automatisera processer för användare. Dessa agenter varierar mycket i komplexitet. De sträcker sig från enkla chattrobotar, till andrepiloter, till avancerade AI-assistenter i form av digitala system eller robotsystem som kan köra komplexa arbetsflöden autonomt.
Den här artikeln innehåller konceptuella översikter och detaljerade implementeringsexempel för AI-agenter.
Till skillnad från fristående stora språkmodeller (LLM) eller regelbaserade programvaru-/maskinvarusystem har AI-agenter följande vanliga funktioner:
Anteckning
Användningen av termen minne i samband med AI-agenter skiljer sig från begreppet datorminne (som flyktigt, icke-volatilt och beständigt minne).
Copilots är en typ av AI-agent. De fungerar tillsammans med användare i stället för att arbeta oberoende av varandra. Till skillnad från helt automatiserade agenter ger andrepiloter förslag och rekommendationer för att hjälpa användare att utföra uppgifter.
När en användare till exempel skriver ett e-postmeddelande kan en andrepilot föreslå fraser, meningar eller stycken. Användaren kan också be andrepiloten att hitta relevant information i andra e-postmeddelanden eller filer för att stödja förslaget (se hämtningsförhöjd generering). Användaren kan acceptera, avvisa eller redigera de föreslagna avsnitten.
Autonoma agenter kan arbeta mer självständigt. När du konfigurerar autonoma agenter för att hjälpa till med e-postsammansättning kan du göra så att de kan utföra följande uppgifter:
Du kan konfigurera agenterna att utföra var och en av de föregående uppgifterna med eller utan mänskligt godkännande.
En populär strategi för att uppnå högpresterande autonoma agenter är användningen av system med flera agenter. I system med flera agenter interagerar eller samarbetar flera autonoma agenter, oavsett om de är i digital eller robotiserad form, för att uppnå individuella eller kollektiva mål. Agenter i systemet kan arbeta självständigt och ha sina egna kunskaper eller information. Varje agent kan också ha möjlighet att uppfatta sin miljö, fatta beslut och utföra åtgärder baserat på dess mål.
System med flera agenter har följande viktiga egenskaper:
Ett system med flera agenter ger följande fördelar jämfört med en andrepilot eller en enda instans av LLM-slutsatsdragning:
Komplexa resonemang och planering är kännetecknet för avancerade autonoma agenter. Populära ramverk för autonoma agenter innehåller en eller flera av följande metoder (med länkar till arXiv-arkivsidor) för resonemang och planering:
Förbättra tankekedjan genom att låta modellen uttryckligen ställa sig själv (och svara på) uppföljningsfrågor innan du svarar på den första frågan.
Använd LLM:er för att generera både resonemangsspårningar och uppgiftsspecifika åtgärder på ett interfolierat sätt. Resonemangsspårningar hjälper modellen att inducera, spåra och uppdatera åtgärdsplaner, tillsammans med att hantera undantag. Med åtgärder kan modellen ansluta till externa källor, till exempel kunskapsbas eller miljöer, för att samla in ytterligare information.
Utforma en plan för att dela upp hela uppgiften i mindre underaktiviteter och sedan utföra underaktiviteterna enligt planen. Den här metoden minimerar beräkningsfel, fel som saknas i steget och semantiska missförståndsfel som ofta finns i nollskottskedja med tankesökning.
Använd reflexionsagenter som verbalt reflekterar över feedbacksignaler för uppgifter. Dessa agenter behåller sin egen reflekterande text i en episodisk minnesbuffert för att få bättre beslutsfattande i efterföljande försök.
Olika ramverk och verktyg kan underlätta utvecklingen och distributionen av AI-agenter.
För verktygsanvändning och uppfattning som inte kräver avancerad planering och minne är vissa populära LLM-orkestreringsramverk LangChain, LlamaIndex, Prompt Flow och Semantic Kernel.
För avancerade och autonoma arbetsflöden för planering och körning drev AutoGen den multiagentvåg som började i slutet av 2022. Med OpenAI:s API för assistenter kan användarna skapa agenter internt i GPT-ekosystemet. LangChain-agenter och LlamaIndex-agenter uppstod också ungefär samtidigt.
Tips
Implementeringsexemplet senare i den här artikeln visar hur du skapar ett enkelt system med flera agenter med hjälp av ett av de populära ramverken och ett enhetligt agentminnessystem.
Den vanliga metoden för att experimentera med AI-förbättrade program från 2022 till 2024 har använt fristående databashanteringssystem för olika dataarbetsflöden eller typer. Du kan till exempel använda en minnesintern databas för cachelagring, en relationsdatabas för driftdata (inklusive spårnings-/aktivitetsloggar och LLM-konversationshistorik) och en ren vektordatabas för inbäddningshantering.
Den här metoden med att använda ett komplext nät av fristående databaser kan dock skada en AI-agent prestanda. Att integrera alla dessa olika databaser i ett sammanhängande, driftskompatibelt och motståndskraftigt minnessystem för AI-agenter är en egen utmaning.
Dessutom är många av de databastjänster som används ofta inte optimala för den hastighet och skalbarhet som AI-agentsystem behöver. Dessa databasers enskilda svagheter förvärras i system med flera agenter.
Minnesinterna databaser är utmärkta för hastighet men kan kämpa med den storskaliga datapersistence som AI-agenter behöver.
Relationsdatabaser är inte idealiska för de olika modaliteter och vätskescheman för data som agenter hanterar. Relationsdatabaser kräver manuella åtgärder och till och med stilleståndstid för att hantera etablering, partitionering och horisontell partitionering.
Rena vektordatabaser tenderar att vara mindre effektiva för transaktionsåtgärder, realtidsuppdateringar och distribuerade arbetsbelastningar. De populära rena vektordatabaserna erbjuder vanligtvis:
Precis som effektiva databashanteringssystem är viktiga för programprestanda är det viktigt att tillhandahålla LLM-baserade agenter relevant och användbar information för att vägleda deras slutsatsdragning. Robusta minnessystem gör det möjligt att organisera och lagra olika typer av information som agenterna kan hämta vid slutsatsdragningstid.
För närvarande använder LLM-baserade program ofta hämtningsförhöjd generation som använder grundläggande semantisk sökning eller vektorsökning för att hämta passager eller dokument. Vektorsökning kan vara användbart för att hitta allmän information. Men vektorsökning kanske inte avbildar den specifika kontext, struktur eller relationer som är relevanta för en viss uppgift eller domän.
Om uppgiften till exempel är att skriva kod kanske vektorsökningen inte kan hämta syntaxträdet, filsystemets layout, kodsammanfattningar eller API-signaturer som är viktiga för att generera sammanhängande och korrekt kod. På samma sätt, om uppgiften ska fungera med tabelldata, kanske vektorsökning inte kan hämta schemat, sekundärnycklarna, lagrade procedurer eller de rapporter som är användbara för att fråga eller analysera data.
Att väva ihop en webb med fristående minnesbaserade databaser, relationsdatabaser och vektordatabaser (som beskrevs tidigare) är inte en optimal lösning för de olika datatyperna. Den här metoden kan fungera för prototypiska agentsystem. Det lägger dock till komplexitet och prestandaflaskhalsar som kan hämma prestanda för avancerade autonoma agenter.
Ett robust minnessystem bör ha följande egenskaper.
AI-agentminnessystem bör tillhandahålla samlingar som lagrar metadata, relationer, entiteter, sammanfattningar eller andra typer av information som kan vara användbara för olika uppgifter och domäner. Dessa samlingar kan baseras på datastrukturen och formatet, till exempel dokument, tabeller eller kod. Eller så kan de baseras på innehållet och innebörden av data, till exempel begrepp, associationer eller processuella steg.
Minnessystem är inte bara viktiga för AI-agenter. De är också viktiga för de människor som utvecklar, underhåller och använder dessa agenter.
Människor kan till exempel behöva övervaka agenternas planerings- och körningsarbetsflöden nästan i realtid. Under övervakningen kan människor ingripa med vägledning eller göra infogade redigeringar av agenters dialoger eller monologer. Människor kan också behöva granska agenternas resonemang och åtgärder för att verifiera giltigheten för de slutliga utdata.
Interaktioner mellan människa och agent är sannolikt på naturliga språk eller programmeringsspråk, medan agenter "tänker", "lär sig" och "kommer ihåg" via inbäddningar. Den här skillnaden utgör ett annat krav på minnessystemens konsekvens mellan datamodaliteter.
Minnessystem bör tillhandahålla minnesbankar som lagrar information som är relevant för interaktionen med användaren och miljön. Sådan information kan omfatta chatthistorik, användarinställningar, sensoriska data, beslut som fattas, inlärda fakta eller andra driftdata som uppdateras med hög frekvens och på höga volymer.
Dessa minnesbanker kan hjälpa agenterna att komma ihåg kortsiktig och långsiktig information, undvika att upprepa eller motsäga sig själva och upprätthålla uppgiftssammanhållning. Dessa krav måste gälla även om agenterna utför en mängd orelaterade uppgifter i följd. I avancerade fall kan agenter också testa flera grenplaner som avviker eller konvergerar vid olika tidpunkter.
På makronivå bör minnessystem göra det möjligt för flera AI-agenter att samarbeta om ett problem eller bearbeta olika aspekter av problemet genom att tillhandahålla delat minne som är tillgängligt för alla agenter. Delat minne kan underlätta informationsutbyte och samordning av åtgärder mellan agenterna.
Samtidigt måste minnessystemet tillåta agenter att bevara sin egen persona och egenskaper, till exempel deras unika samlingar av uppmaningar och minnen.
De föregående egenskaperna kräver att AI-agentens minnessystem är mycket skalbara och snabba. Att noggrant väva samman olika minnesbaserade databaser, relationsdatabaser och vektordatabaser (enligt beskrivningen tidigare) kan fungera för AI-aktiverade program i ett tidigt skede. Den här metoden lägger dock till komplexitets- och prestandaflaskhalsar som kan hämma prestanda för avancerade autonoma agenter.
I stället för alla fristående databaser kan Azure Cosmos DB fungera som en enhetlig lösning för AI-agentminnessystem. Dess robusthet har gjort det möjligt för OpenAI:s ChatGPT-tjänst att skala dynamiskt med hög tillförlitlighet och lågt underhåll. Den drivs av en atom-postsekvensmotor och är världens första globalt distribuerade NoSQL-, relations- och vektordatabastjänst som erbjuder ett serverlöst läge. AI-agenter som bygger på Azure Cosmos DB erbjuder snabbhet, skalning och enkelhet.
Azure Cosmos DB ger ensiffrig svarstid på millisekunder. Den här funktionen gör den lämplig för processer som kräver snabb dataåtkomst och hantering. Dessa processer omfattar cachelagring (både traditionell och semantisk cachelagring, transaktioner och driftarbetsbelastningar.
Låg svarstid är avgörande för AI-agenter som behöver utföra komplexa resonemang, fatta realtidsbeslut och ge omedelbara svar. Dessutom ger tjänstens användning av DiskANN-algoritmen korrekt och snabb vektorsökning med minimal minnesförbrukning.
Azure Cosmos DB är utformat för global distribution och horisontell skalbarhet. Den erbjuder stöd för I/O och flera regioner i flera regioner.
Tjänsten hjälper till att säkerställa att minnessystemen kan utökas sömlöst och hålla jämna jämna år med snabbt växande agenter och associerade data. Tillgänglighetsgarantin i serviceavtalet (SLA) innebär mindre än 5 minuters stilleståndstid per år. Rena vektordatabastjänster har däremot 9 timmar eller mer stilleståndstid. Den här tillgängligheten ger en solid grund för verksamhetskritiska arbetsbelastningar. Samtidigt kan de olika tjänstmodellerna i Azure Cosmos DB, till exempel Reserverad kapacitet eller Serverlös, bidra till att minska de ekonomiska kostnaderna.
Azure Cosmos DB kan förenkla datahantering och arkitektur genom att integrera flera databasfunktioner i en enda sammanhängande plattform.
Dess integrerade vektordatabasfunktioner kan lagra, indexera och fråga inbäddningar tillsammans med motsvarande data i naturliga språk eller programmeringsspråk. Den här funktionen ger bättre datakonsekvens, skalning och prestanda.
Dess flexibilitet stöder olika metoder och vätskescheman för metadata, relationer, entiteter, sammanfattningar, chatthistorik, användarinställningar, sensoriska data, beslut, fakta som lärts eller andra driftdata som ingår i agentarbetsflöden. Databasen indexerar automatiskt alla data utan att behöva schema- eller indexhantering, vilket hjälper AI-agenter att utföra komplexa frågor snabbt och effektivt.
Azure Cosmos DB hanteras fullständigt, vilket eliminerar kostnaderna för databasadministrationsuppgifter som skalning, korrigering och säkerhetskopior. Utan den här kostnaden kan utvecklare fokusera på att skapa och optimera AI-agenter utan att behöva bekymra sig om den underliggande datainfrastrukturen.
Azure Cosmos DB innehåller avancerade funktioner som ändringsflöde, vilket gör det möjligt att spåra och svara på ändringar i data i realtid. Den här funktionen är användbar för AI-agenter som snabbt behöver reagera på ny information.
Dessutom möjliggör det inbyggda stödet för skrivningar med flera original hög tillgänglighet och motståndskraft för att säkerställa kontinuerlig drift av AI-agenter, även efter regionala fel.
De fem tillgängliga konsekvensnivåerna (från stark till slutlig) kan också tillgodose olika distribuerade arbetsbelastningar, beroende på scenariokraven.
Tips
Du kan välja mellan två Azure Cosmos DB-API:er för att skapa ditt AI-agentminnessystem:
Information om tillgänglighetsgarantierna för dessa API:er finns i serviceavtalen.
I det här avsnittet går vi igenom implementeringen av en autonom agent för att bearbeta reseförfrågningar och bokningar i en reseansökan för en kryssningslinje.
Chattrobotar är ett långvarigt koncept, men AI-agenter avancerar bortom grundläggande mänsklig konversation för att utföra uppgifter baserade på naturligt språk. Dessa uppgifter krävde traditionellt kodad logik. AI-resebyrån i det här implementeringsexemplet använder LangChain Agent-ramverket för agentplanering, verktygsanvändning och uppfattning.
AI-resebyråns enhetliga minnessystem använder vektordatabasen och dokumentlagringsfunktionerna i Azure Cosmos DB för att hantera reseförfrågningar och underlätta resebokningar. Att använda Azure Cosmos DB för det här ändamålet hjälper till att säkerställa hastighet, skalning och enkelhet, enligt beskrivningen tidigare.
Exempelagenten fungerar i en Python FastAPI-serverdel. Den stöder användarinteraktioner via ett React JavaScript-användargränssnitt.
Alla kod- och exempeldatauppsättningar är tillgängliga på den här GitHub-lagringsplatsen. Lagringsplatsen innehåller följande mappar:
GitHub-lagringsplatsen innehåller ett Python-projekt i inläsningskatalogen. Den är avsedd att läsa in exempelresedokumenten i Azure Cosmos DB.
Konfigurera din virtuella Python-miljö i inläsningskatalogen genom att köra följande kommando:
python -m venv venv
Aktivera din miljö och installera beroenden i inläsningskatalogen:
venv\Scripts\activate
python -m pip install -r requirements.txt
Skapa en fil med namnet .env i inläsningskatalogen för att lagra följande miljövariabler:
OPENAI_API_KEY="<your OpenAI key>"
MONGO_CONNECTION_STRING="mongodb+srv:<your connection string from Azure Cosmos DB>"
Python-filen main.py fungerar som den centrala startpunkten för inläsning av data till Azure Cosmos DB. Den här koden bearbetar exempelresedata från GitHub-lagringsplatsen, inklusive information om fartyg och mål. Koden genererar också reseresepaket för varje fartyg och destination, så att resenärer kan boka dem med hjälp av AI-agenten. CosmosDBLoader-verktyget ansvarar för att skapa samlingar, vektorinbäddningar och index i Azure Cosmos DB-instansen.
Här är innehållet i 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')])
Läs in dokumenten, läs in vektorerna och skapa index genom att köra följande kommando från lastarkatalogen:
python main.py
Här är utdata från main.py:
--build itinerary--
--load itinerary--
--load destinations--
--load vectors ships--
AI-resebyrån finns i ett serverdels-API via Python FastAPI, vilket underlättar integrering med klientdelens användargränssnitt. API-projektet bearbetar agentbegäranden genom att jorda LLM-prompterna mot datalagret, särskilt vektorerna och dokumenten i Azure Cosmos DB.
Agenten använder olika verktyg, särskilt De Python-funktioner som tillhandahålls på API-tjänstnivån. Den här artikeln fokuserar på den kod som krävs för AI-agenter i API-koden.
API-projektet på GitHub-lagringsplatsen är strukturerat på följande sätt:
Vi använde Python version 3.11.4 för utveckling och testning av API:et.
Konfigurera din virtuella Python-miljö i api-katalogen :
python -m venv venv
Aktivera din miljö och installera beroenden med hjälp av kravfilen i api-katalogen :
venv\Scripts\activate
python -m pip install -r requirements.txt
Skapa en fil med namnet .env i api-katalogen för att lagra dina miljövariabler:
OPENAI_API_KEY="<your Open AI key>"
MONGO_CONNECTION_STRING="mongodb+srv:<your connection string from Azure Cosmos DB>"
Nu när du har konfigurerat miljön och konfigurerat variabler kör du följande kommando från api-katalogen för att initiera servern:
python app.py
FastAPI-servern startar som standard på localhost-loopback 127.0.0.1 port 8000. Du kan komma åt Swagger-dokumenten med hjälp av följande localhost-adress: http://127.0.0.1:8000/docs
.
Det är absolut nödvändigt att resebyrån kan referera till tidigare tillhandahållen information i den pågående konversationen. Den här möjligheten kallas ofta för minne i kontexten för LLM:er.
För att uppnå det här målet använder du chattmeddelandehistoriken som lagras i Azure Cosmos DB-instansen. Historiken för varje chattsession lagras via ett sessions-ID för att säkerställa att endast meddelanden från den aktuella konversationssessionen är tillgängliga. Den här nödvändigheten är orsaken till att det finns en Get Session
metod i API:et. Det är en platshållarmetod för att hantera webbsessioner för att illustrera användningen av chattmeddelandehistorik.
Välj Prova för /session/
.
{
"session_id": "0505a645526f4d68a3603ef01efaab19"
}
För AI-agenten behöver du bara simulera en session. Metoden stubbed-out returnerar bara ett genererat sessions-ID för spårning av meddelandehistorik. I en praktisk implementering skulle den här sessionen lagras i Azure Cosmos DB och eventuellt i React localStorage
.
Här är innehållet i web/session.py:
@router.get("/")
def get_session():
return {'session_id':str(uuid.uuid4().hex)}
Använd sessions-ID:t som du hämtade från föregående steg för att starta en ny dialog med AI-agenten, så att du kan verifiera dess funktioner. Utför testet genom att skicka in följande fras: "Jag vill ta en avkopplande semester."
Välj Prova för /agent/agent_chat
.
Använd den här exempelparametern:
{
"input": "I want to take a relaxing vacation.",
"session_id": "0505a645526f4d68a3603ef01efaab19"
}
Den första körningen resulterar i en rekommendation för Tranquil Breeze Cruise och Fantasy Seas Adventure Cruise, eftersom agenten förväntar sig att de är de mest avkopplande kryssningarna som är tillgängliga genom vektorsökningen. Dessa dokument har den högsta poängen för similarity_search_with_score
anropat i api:ets datalager, data.mongodb.travel.similarity_search()
.
Likhetssökningspoängen visas som utdata från API:et i felsökningssyfte. Här är utdata efter ett anrop till data.mongodb.travel.similarity_search()
:
0.8394561085977978
0.8086545112328692
2
Tips
Om dokument inte returneras för vektorsökning ändrar du similarity_search_with_score
gränsen eller poängfiltervärdet efter behov ([doc for doc, score in docs if score >=.78]
) i data.mongodb.travel.similarity_search()
.
När du anropar agent_chat
för första gången skapas en ny samling med namnet history
i Azure Cosmos DB för att lagra konversationen efter session. Det här anropet gör det möjligt för agenten att komma åt den lagrade chattmeddelandehistoriken efter behov. Efterföljande körningar av agent_chat
med samma parametrar ger varierande resultat, eftersom det drar från minnet.
När du integrerar AI-agenten i API:et ansvarar webbsökningskomponenterna för att initiera alla begäranden. Webbsökningskomponenterna följs av söktjänsten och slutligen datakomponenterna.
I det här specifika fallet använder du en MongoDB-datasökning som ansluter till Azure Cosmos DB. Lagren underlättar utbytet av modellkomponenter, med AI-agenten och AI-agentens verktygskod som finns i tjänstskiktet. Den här metoden möjliggör sömlös utbyte av datakällor. Den utökar även AI-agentens funktioner med ytterligare, mer invecklade funktioner eller verktyg.
Tjänstlagret utgör hörnstenen i kärnaffärslogik. I det här scenariot spelar tjänstlagret en avgörande roll som lagringsplats för LangChain Agent-koden. Det underlättar sömlös integrering av användarfrågor med Azure Cosmos DB-data, konversationsminne och agentfunktioner för AI-agenten.
Tjänstskiktet använder en singleton-mönstermodul för hantering av agentrelaterade initieringar i init.py-filen. Här är innehållet i tjänsten/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()
Filen init.py initierar inläsningen av miljövariabler från en .env-fil med hjälp load_dotenv(override=False)
av metoden . Sedan instansieras en global variabel med namnet agent_with_chat_history
för agenten. Den här agenten är avsedd för användning av TravelAgent.py.
Metoden LLM_init()
anropas under modulinitiering för att konfigurera AI-agenten för konversation via API-webblagret. OpenAI-objektet chat
instansieras via GPT-3.5-modellen och innehåller specifika parametrar som modellnamn och temperatur. Objektet chat
, verktygslistan och promptmallen kombineras för att generera AgentExecutor
, som fungerar som AI-resebyrå.
Agenten med historik, agent_with_chat_history
, upprättas via RunnableWithMessageHistory
med chatthistorik (MongoDBChatMessageHistory
). Med den här åtgärden kan den upprätthålla en fullständig konversationshistorik via Azure Cosmos DB.
LLM-prompten började ursprungligen med det enkla uttalandet "Du är en användbar och vänlig reseassistent för ett kryssningsföretag." Testningen visade dock att du kunde få mer konsekventa resultat genom att inkludera instruktionen "Besvara resefrågor efter bästa förmåga och ge endast relevant information. För att boka en kryssning är det viktigt att fånga personens namn." Resultatet visas i HTML-format för att förbättra webbgränssnittets visuella attraktionskraft.
Verktyg är gränssnitt som en agent kan använda för att interagera med världen, ofta via funktionsanrop.
När du skapar en agent måste du förse den med en uppsättning verktyg som den kan använda. Dekoratören @tool
erbjuder det enklaste sättet att definiera ett anpassat verktyg.
Som standard använder dekoratören funktionsnamnet som verktygsnamn, även om du kan ersätta det genom att ange en sträng som det första argumentet. Dekoratören använder funktionens dokumentsträng som verktygets beskrivning, så det kräver etablering av en dokumentsträng.
Här är innehållet i tjänsten/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"
Filen TravelAgentTools.py definierar tre verktyg:
vacation_lookup
utför en vektorsökning mot Azure Cosmos DB. Det används similarity_search
för att hämta relevant reserelaterat material.itinerary_lookup
hämtar information om kryssningspaket och scheman för ett angivet kryssningsfartyg.book_cruise
bokar ett kryssningspaket för en passagerare.Specifika instruktioner ("För att boka en kryssning behöver jag veta ditt namn") kan vara nödvändiga för att säkerställa fångsten av passagerarens namn och rumsnummer för bokning av kryssningspaketet, även om du inkluderade sådana instruktioner i LLM-prompten.
Det grundläggande konceptet som ligger till grund för agenter är att använda en språkmodell för att välja en sekvens med åtgärder som ska köras.
Här är innehållet i tjänsten/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))
Den TravelAgent.py filen är enkel eftersom agent_with_chat_history
och dess beroenden (verktyg, prompt och LLM) initieras och konfigureras i init.py-filen. Den här filen anropar agenten med hjälp av indata som tagits emot från användaren, tillsammans med sessions-ID:t för konversationsminne. Därefter PromptResponse
returneras (modell/prompt) med agentens utdata- och svarstid.
Med den lyckade inläsningen av data och tillgänglighet för AI-agenten via API:et kan du nu slutföra lösningen genom att upprätta ett webbanvändargränssnitt (med React) för din resewebbplats. Genom att använda funktionerna i React kan du illustrera den sömlösa integreringen av AI-agenten i en resewebbplats. Den här integreringen förbättrar användarupplevelsen med en samtalsreseassistent för förfrågningar och bokningar.
Installera Node.js och beroendena innan du testar React-gränssnittet.
Kör följande kommando från webbkatalogen för att utföra en ren installation av projektberoenden. Installationen kan ta lite tid.
npm ci
Skapa sedan en fil med namnet .env i webbkatalogen för att underlätta lagringen av miljövariabler. Inkludera följande information i den nyligen skapade .env-filen :
REACT_APP_API_HOST=http://127.0.0.1:8000
Kör nu följande kommando från webbkatalogen för att initiera React-webbanvändargränssnittet:
npm start
När du kör föregående kommando öppnas React-webbprogrammet.
Webbprojektet för GitHub-lagringsplatsen är ett enkelt program som underlättar användarinteraktion med AI-agenten. De primära komponenter som krävs för att kommunicera med agenten är TravelAgent.js och ChatLayout.js. Filen Main.js fungerar som den centrala modulen eller användarens landningssida.
Huvudkomponenten fungerar som central chef för programmet. Den fungerar som den avsedda startpunkten för routning. I återgivningsfunktionen genererar den JSX-kod för att avgränsa huvudsideslayouten. Den här layouten omfattar platshållarelement för programmet, till exempel logotyper och länkar, ett avsnitt som innehåller resebyråkomponenten och en sidfot som innehåller ett exempel på ansvarsfriskrivning om programmets natur.
Här är innehållet i 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
Resebyråkomponenten har ett enkelt syfte: att samla in användarindata och visa svar. Den spelar en viktig roll för att hantera integreringen med backend-AI-agenten, främst genom att samla in sessioner och vidarebefordra användarfrågor till FastAPI-tjänsten. De resulterande svaren lagras i en matris för visning, vilket underlättas av chattlayoutkomponenten.
Här är innehållet i 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>
)
}
Välj Enkelt planera din resa för att öppna reseassistenten.
Komponenten för chattlayout övervakar arrangemanget av chatten. Den bearbetar systematiskt chattmeddelandena och implementerar den formatering som anges i message
JSON-objektet.
Här är innehållet i 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>
)
}
Användarprompter är på höger sida och färgade blå. Svar från AI-resebyrån finns på vänster sida och färgade gröna. Som följande bild visar redovisas de HTML-formaterade svaren i konversationen.
När DIN AI-agent är redo att gå in i produktion kan du använda semantisk cachelagring för att förbättra frågeprestanda med 80 % och minska kostnaderna för LLM-slutsatsdragning och API-anrop. Information om hur du implementerar semantisk cachelagring finns i det här inlägget på stochastic Coder-bloggen.
Utbildning
Modul
Guidat projekt – Skapa en AI-resebyrå - Training
Utveckla en proof of concept AI Travel assistant chatbot med hjälp av Semantic Kernel SDK.