Freigeben über

KI-Agent

  • Artikel

KI-Agents sind dafür konzipiert, bestimmte Aufgaben auszuführen, Fragen zu beantworten und Prozesse für Benutzer zu automatisieren. Diese Agent unterscheiden sich stark in der Komplexität. Sie reichen von einfachen Chatbots über Copiloten bis hin zu fortgeschrittenen KI-Assistenten in Form von digitalen oder robotergestützten Systemen, die komplexe Workflows selbstständig ausführen können.

Dieser Artikel bietet einen konzeptionellen Überblick und detaillierte Implementierungsbeispiele für KI-Agents.

Was sind KI-Agents?

Im Gegensatz zu eigenständigen großen Sprachmodellen (Large Language Models, LLMs) oder regelbasierten Software-/Hardwaresystemen haben KI-Agents diese allgemeinen Merkmale:

  • Planung: KI-Agents können Aktionen planen und sequenzieren, um bestimmte Ziele zu erreichen. Die Planungsfunktionen wurden durch die Integration von LLMs revolutioniert.
  • Toolverwendung: Erweiterte KI-Agents können verschiedene Tools wie Codeausführung, Suche und Berechnungsfunktionen nutzen, um Aufgaben effektiv auszuführen. KI-Agents verwenden häufig Tools über Funktionsaufrufe.
  • Wahrnehmung: KI-Agents können Informationen aus ihrer Umgebung wahrnehmen und verarbeiten, um sie interaktiver und kontextfähiger zu machen. Diese Informationen umfassen visuelle, auditive und andere sensorische Daten.
  • Speicher; KI-Agents können sich frühere Interaktionen (Verwendung von Tools und Wahrnehmung) und Verhaltensweisen (Verwendung von Tools und Planung) merken. Sie speichern diese Erfahrungen und führen sogar eine Selbstreflexion durch, um zukünftige Aktionen zu steuern. Diese Speicherkomponente sorgt für Leistungskontinuität und ermöglicht eine Verbesserung der Agent-Leistung im Laufe der Zeit.

Hinweis

Der Begriff Speicher im Zusammenhang mit KI-Agents ist ein anderes Konzept als der Arbeitsspeicher (z. B. flüchtiger, nicht flüchtiger und persistenter Speicher).

Copiloten

Copilots sind eine Art KI-Agent. Sie arbeiten zusammen mit Benutzerinnen und Benutzern, anstatt unabhängig zu arbeiten. Anders als vollständig automatisierte Agents stellen Copilots Vorschläge und Empfehlungen bereit, die Benutzern bei der Durchführung von Aufgaben helfen.

Wenn ein Benutzer eine E-Mail schreibt, kann ein Copilot beispielsweise Ausdrücke, Sätze oder Absätze vorschlagen. Der Benutzer kann den Copilot auch auffordern, in anderen E-Mails oder Dateien nach relevanten Informationen zu suchen, die den Vorschlag unterstützen (siehe Retrieval Augmented Generation). Der Benutzer kann die vorgeschlagenen Textabschnitte annehmen, ablehnen oder bearbeiten.

Autonome Agents

Autonome Agents können unabhängiger arbeiten. Wenn Sie autonome Agents zur Unterstützung der E-Mail-Erstellung einrichten, können Sie sie zum Ausführen der folgenden Aufgaben konfigurieren:

  • Lesen vorhandener E-Mails, Chats, Dateien und anderer interner und öffentlicher Informationen, die mit dem Thema zusammenhängen
  • Durchführen qualitativer oder quantitativer Analysen der gesammelten Informationen und Ableiten relevanter Schlussfolgerungen für die E-Mail
  • Schreiben der vollständigen E-Mail auf Grundlage der Schlussfolgerungen und Einbeziehen unterstützender Nachweise
  • Anfügen relevanter Dateien an die E-Mail
  • Überprüfen der E-Mail, um sicherzustellen, dass alle enthaltenen Informationen sachlich korrekt und die Aussagen zutreffend sind
  • Auswählen der entsprechenden Empfänger für An, Cc und/oder Bcc und Ermitteln ihrer E-Mail-Adressen
  • Planen einer geeigneten Zeit zum Senden der E-Mail
  • Ausführen nachfolgender Kontaktaufnahmen, wenn Antworten erwartet, aber nicht empfangen werden

Sie können die Agents dafür konfigurieren, jeden der vorherigen Aufgaben mit oder ohne menschliche Genehmigung auszuführen.

Multi-Agent-Systeme

Die Verwendung von Multi-Agent-Systemen ist derzeit eine beliebte Strategie zum Implementieren leistungsfähiger autonomer Agents. In Multi-Agent-Systemen interagieren oder arbeiten mehrere autonome Agents (digital oder robotergesteuert) zusammen, um individuelle oder kollektive Ziele zu erreichen. Agents im System können unabhängig voneinander arbeiten und über eigenes Wissen oder eigene Informationen verfügen. Zudem könnte jeder Agent in der Lage sein, seine Umgebung wahrzunehmen, Entscheidungen zu treffen und Aktionen basierend auf seinen Zielen auszuführen.

Multi-Agent-Systeme weisen die folgenden wichtigsten Merkmale auf:

  • Autonom: Jeder Agent funktioniert unabhängig. Er trifft ohne direkte menschliche Intervention oder Kontrolle durch andere Agents eigene Entscheidungen.
  • Interaktiv: Agents kommunizieren miteinander und arbeiten zusammen, um Informationen auszutauschen, zu verhandeln und ihre Aktionen zu koordinieren. Diese Interaktion kann über verschiedene Protokolle und Kommunikationskanäle erfolgen.
  • Zielorientiert: Agents in einem Multi-Agent-System sind dafür konzipiert, bestimmte Ziele zu erreichen, die auf individuelle Zielsetzungen oder eine gemeinsame Zielsetzung der Agents ausgerichtet sein können.
  • Verteilt: Multi-Agent-Systeme arbeiten dezentral, ohne einen einzigen zentralen Steuerungspunkt. Diese Verteilung verbessert die Stabilität, Skalierbarkeit und Ressourceneffizienz des Systems.

Ein Multi-Agent-System bietet die folgenden Vorteile gegenüber einem Copilot oder einer einzelnen Instanz von LLM-Rückschlüssen:

  • Dynamische Begründung: Im Vergleich zum Chain-of-Thought (CoT)- oder Tree-of-Thought (ToT)-Prompting ermöglichen Multi-Agent-Systeme die dynamische Navigation durch verschiedene Begründungspfade.
  • Komplexe Fähigkeiten: Multi-Agent-Systeme können komplexe oder große Probleme bewältigen, indem sie gründliche Entscheidungsprozesse durchführen und Aufgaben auf mehrere Agents verteilen.
  • Erweiterter Arbeitsspeicher: Multi-Agent-Systeme mit Arbeitsspeicher können die Kontextfenster von LLMs überwinden, um ein besseres Verständnis und eine bessere Informationsaufbewahrung zu ermöglichen.

Implementierung von KI-Agents

Begründung und Planung

Fortschrittliche autonome Agents zeichnen sich durch komplexe Begründung und Planung aus. Beliebte Frameworks für autonome Agents umfassen eine oder mehrere der folgenden Methoden (mit Links zu den arXiv-Archivseiten) für die Begründung und Planung:

  • Selbstfragen

    Verbessern Sie die Gedankenkette, indem Sie das Modell explizit Folgefragen stellen (und beantworten) lassen, bevor es die Ausgangsfrage beantwortet.

  • Begründen und handeln (Reason and Act, ReAct)

    Die Agents verwenden LLMs, um sowohl Begründungstraces als auch aufgabenspezifische Aktionen verschachtelt zu generieren. Begründungstraces helfen dem Modell, Aktionspläne zu erstellen, zu verfolgen und zu aktualisieren sowie Ausnahmen zu behandeln. Aktionen ermöglichen es dem Modell, sich mit externen Quellen zu verbinden, z. B. mit Wissensdatenbanken oder Umgebungen, um zusätzliche Informationen zu sammeln.

  • Planen und Lösen

    Die Agents entwickeln einen Plan, um die gesamte Aufgabe in kleinere Teilaufgaben aufzuteilen und die Teilaufgaben dann gemäß dem Plan auszuführen. Durch diesen Ansatz werden Berechnungsfehler sowie Fehler aufgrund von fehlenden Schritten und semantischen Fehlerinterpretationen minimiert, die beim Zero-Shot-CoT-Prompting häufig auftreten.

  • Reflexion/Selbstkritik

    Verwenden Sie Reflexions-Agents, die verbal über die Signale des Aufgabenfeedbacks reflektieren. Diese Agents behalten ihren eigenen reflektierenden Text für eine bessere Entscheidungsfindung bei nachfolgenden Versuchen in einem episodischen Gedächtnispuffer.

Frameworks

Verschiedene Frameworks und Tools können die Entwicklung und Bereitstellung von KI-Agents erleichtern.

Beliebte LLM-Orchestratorframeworks für die Verwendung von Tools und die Wahrnehmung, die weder eine komplexe Planung noch Arbeitsspeicher erfordern, sind LangChain, LlamaIndex, Prompt Flow und Semantic Kernel.

Für erweiterte und autonome Planungs- und Ausführungsworkflows hat AutoGen die Welle von Multi-Agent-Systemen vorangetrieben, die Ende 2022 ihren Anfang hatte. Die Assistants-API von OpenAI ermöglicht es Benutzerinnen und Benutzern, Agents nativ innerhalb des GPT-Ökosystems zu erstellen. In etwa zur gleichen Zeit entstanden auch LangChain-Agents und LlamaIndex-Agents.

Tipp

Das Implementierungsbeispiel am Ende dieses Artikels zeigt, wie Sie ein einfaches Multi-Agent-System unter Verwendung eines der gängigen Frameworks und eines einheitlichen Agent-Speichersystems erstellen.

KI-Agent-Speichersystem

Die vorherrschende Praxis für das Experimentieren mit KI-gestützten Anwendungen von 2022 bis 2024 war die Verwendung eigenständiger Datenbank-Managementsysteme für verschiedene Datenworkflows oder -typen. Dabei können Sie beispielsweise eine In-Memory-Datenbank zum Zwischenspeichern, eine relationale Datenbank für operative Daten (einschließlich Ablaufverfolgungs-/Aktivitätsprotokolle und LLM-Konversationsverlauf) und eine reine Vektordatenbank für die Einbettungsverwaltung verwenden.

Die Verwendung eines solchen komplexen Netzwerks von eigenständigen Datenbanken kann jedoch die Leistung eines KI-Agents beeinträchtigen. Die Integration all dieser unterschiedlichen Datenbanken in ein zusammenhängendes, interoperables und resilientes Speichersystem für KI-Agents ist eine eigene Herausforderung.

Außerdem eignen sich viele der häufig verwendeten Datenbankdienste nicht optimal für die Geschwindigkeit und Skalierbarkeit, die KI-Agent-Systeme erfordern. Die individuellen Schwachstellen dieser Datenbanken werden in Multi-Agent-Systemen noch verschärft.

In-Memory-Datenbanken

In-Memory-Datenbanken sind zwar schnell, können aber möglicherweise nicht die umfangreiche Datenpersistenz bieten, die KI-Agents erfordern.

Relationale Datenbanken

Relationale Datenbanken eignen sich nicht ideal für die unterschiedlichen Modalitäten und flexiblen Datenschemas, die Agents verarbeiten. Relationale Datenbanken erfordern manuellen Aufwand und sogar Downtimes zum Verwalten der Bereitstellung, der Partitionierung und des Shardings.

Reine Vektordatenbanken

Reine Vektordatenbanken sind in der Regel weniger effektiv für Transaktionsvorgänge, Echtzeitaktualisierungen und verteilte Workloads. Die gängigen reinen Vektordatenbanken bieten heute in der Regel Folgendes:

  • Keine Garantie für Lese- und Schreibvorgänge
  • Beschränkten Erfassungsdurchsatz
  • Geringe Verfügbarkeit (unter 99,9 % oder einen jährlichen Ausfall von 9 Stunden oder mehr)
  • Eine (letztliche) Konsistenzebene
  • Einen ressourcenintensiven In-Memory-Vektorindex
  • Begrenzte Optionen für Mehrinstanzenfähigkeit
  • Begrenzte Sicherheit

Merkmale eines stabilen KI-Agent-Speichersystems

Ebenso wie effiziente Datenbank-Managementsysteme entscheidend für die Leistung von Softwareanwendungen sind, ist es wichtig, LLM-gestützten Agents relevante und nützliche Informationen für Rückschlüsse bereitzustellen. Stabile Speichersysteme ermöglichen das Organisieren und Speichern verschiedener Arten von Informationen, die zum Zeitpunkt des Rückschlusses von den Agents abgerufen werden.

Derzeit verwenden LLM-basierte Anwendungen häufig Retrieval Augmented Generation (RAG), eine Technik, die die grundlegende semantische Suche oder Vektorsuche verwendet, um Textabschnitte oder Dokumente abzurufen. Die Vektorsuche kann nützlich sein, um allgemeine Informationen zu finden. Die Vektorsuche erfasst aber möglicherweise nicht den spezifischen Kontext, die Struktur oder die Beziehungen, die für eine bestimmte Aufgabe oder ein Fachgebiet relevant sind.

Wenn die Aufgabe beispielsweise darin besteht, Code zu schreiben, ist die Vektorsuche möglicherweise nicht in der Lage, die Syntaxstruktur, das Dateisystemlayout, Codezusammenfassungen oder API-Signaturen abzurufen, die für das Generieren von kohärentem und korrektem Code wichtig sind. Wenn die Aufgabe in der Arbeit mit tabellarischen Daten besteht, kann die Vektorsuche möglicherweise nicht das Schema, die Fremdschlüssel, die gespeicherten Prozeduren oder Berichte abrufen, die für das Abfragen oder Analysieren der Daten hilfreich sind.

Das Zusammenstellen eines Netzwerks von eigenständigen In-Memory-, relationalen und Vektordatenbanken (wie bereits beschrieben) ist keine optimale Lösung für die unterschiedlichen Datentypen. Dieser Ansatz kann für prototypische Agent-Systeme funktionieren. Er erhöht jedoch die Komplexität und verursacht zusätzliche Leistungsengpässe, die die Leistung fortschrittlicher autonomer Agents beeinträchtigen können.

Ein stabiles Speichersystem sollte die folgenden Merkmale aufweisen:

Multimodal

KI-Agent-Speichersysteme sollten Sammlungen bereitstellen, in denen Metadaten, Beziehungen, Entitäten, Zusammenfassungen oder andere Arten von Informationen gespeichert werden, die für Aufgaben und Fachgebiete nützlich sein können. Diese Sammlungen können auf der Struktur und dem Format der Daten basieren, z. B. Dokumente, Tabellen oder Code. Oder sie können auf dem Inhalt und der Bedeutung der Daten basieren, z. B. auf Konzepten, Assoziationen oder Verfahrensschritten.

Speichersysteme sind nicht nur für KI-Agents von Bedeutung. Sie sind auch wichtig für die Menschen, die diese Mittel entwickeln, pflegen und verwenden.

Beispielsweise müssen Menschen die Planungs- und Ausführungsworkflows von Agents möglicherweise in Quasi-Echtzeit überwachen. Während der Überwachung können Menschen möglicherweise steuernd eingreifen oder die Dialoge oder Monologe von Agents inline bearbeiten. Ebenso müssen die Begründung und die Aktionen von Agents möglicherweise von Menschen überwacht werden, um die Gültigkeit des Endergebnisses zu verifizieren.

Die Interaktionen zwischen Mensch und Agent erfolgen wahrscheinlich in natürlicher Sprache oder Programmiersprachen, während das „Denken“, „Lernen“ und „Erinnern“ von Agents durch Einbettungen erfolgt. Diese Unterschiede stellen eine weitere Anforderung an die datenmodalitätsübergreifende Konsistenz der Speichersysteme dar.

Im Betrieb

Speichersysteme sollten Speicherbanken bereitstellen, die für die Interaktion mit dem Benutzer und die Umgebung relevante Informationen speichern. Zu diesen Informationen können möglicherweise Chatverläufe, Benutzereinstellungen, sensorische Daten, getroffene Entscheidungen, gelernte Fakten oder andere operative Daten gehören, die häufig und in großem Umfang aktualisiert werden.

Diese Speicherbanken können den Agents helfen, sich an kurz- und langfristige Informationen zu erinnern, Wiederholungen oder Widersprüche zu vermeiden und die Aufgabenkohärenz zu wahren. Diese Anforderungen müssen auch dann erfüllt sein, wenn die Agents viele nicht zusammenhängende Aufgaben nacheinander ausführen. In komplexeren Anwendungsfällen können Agents möglicherweise auch Pläne mit zahlreichen Verzweigungen unterstützen, die an verschiedenen Punkten zusammenlaufen oder auseinandergehen.

Teilbar, aber auch trennbar

Auf der Makroebene sollten Speichersysteme es mehreren KI-Agents ermöglichen, gemeinsam an einem Problem zu arbeiten oder verschiedene Aspekte des Problems zu bearbeiten, indem sie einen gemeinsam genutzten Speicher bereitstellen, auf den alle Agents zugreifen können. Ein gemeinsam genutzter Speicher kann den Austausch von Informationen und die Koordinierung von Aktionen zwischen den Agents unterstützen.

Gleichzeitig muss das Speichersystem es den Agents ermöglichen, ihre jeweilige Rolle und ihre individuellen Eigenschaften zu wahren, z. B. ihre spezifischen Sammlungen von Prompts und Erinnerungen.

Erstellen eines stabilen KI-Agent-Speichersystems

Die genannten Merkmale erfordern, dass KI-Agent-Speichersysteme hoch skalierbar und schnell sind. Die mühsame Zusammenführung verschiedener In-Memory-, relationaler und Vektordatenbanken (wie oben beschrieben) könnte für KI-gestützte Anwendungen im Anfangsstadium funktionieren. Dieser Ansatz erhöht jedoch die Komplexität und verursacht zusätzliche Leistungsengpässe, die die Leistung fortschrittlicher autonomer Agents beeinträchtigen können.

Anstelle all der eigenständigen Datenbanken kann Azure Cosmos DB als einheitliche Lösung für KI-Agent-Speichersysteme genutzt werden. Dank der Stabilität von Cosmos DB konnte der ChatGPT-Dienst von OpenAI mit hoher Zuverlässigkeit und geringem Wartungsaufwand erfolgreich dynamisch skaliert werden. Unterstützt von einer ARS (Atom Record Sequence)-basierten Engine ist Cosmos DB der weltweit erste global verteilte Dienst für NoSQL-Datenbanken, relationale Datenbanken und Vektordatenbanken, der einen serverlosen Modus bietet. KI-Agents, die auf Azure Cosmos DB basieren, bieten Geschwindigkeit, Skalierbarkeit und Einfachheit.

Geschwindigkeit

Azure Cosmos DB bietet eine Latenzzeit im einstelligen Millisekundenbereich. Dank dieser Fähigkeit eignet es sich für Prozesse, die einen schnellen Datenzugriff und eine schnelle Datenverwaltung erfordern. Zu diesen Prozessen gehören das Zwischenspeichern (sowohl traditionelles als auch semantisches Zwischenspeichern), Transaktionen und operative Vorgänge (Workloads).

Geringe Latenz ist für KI-Agents, die komplexe Begründungen ausführen, Entscheidungen in Echtzeit treffen und sofortige Antworten bereitstellen müssen, von entscheidender Bedeutung. Darüber hinaus bietet der Dienst durch die Verwendung des hochmodernen DiskANN-Algorithmus eine genaue und schnelle Vektorsuche mit einer minimal geringeren Arbeitsspeichernutzung.

Skalieren

Azure Cosmos DB wurde für globale Verteilung und horizontale Skalierbarkeit konzipiert. Sie bietet Unterstützung für E/A in mehreren Regionen und Mehrinstanzenfähigkeit.

Der Dienst trägt dazu bei, dass Speichersysteme nahtlos erweitert werden können und mit den schnell wachsenden Agents und den damit verbundenen Daten Schritt halten können. Die Verfügbarkeitsgarantie in seinem Service-Level-Vertrag (SLA) bedeutet weniger als 5 Minuten Ausfallzeit pro Jahr. Bei reinen Vektordatenbankdiensten hingegen sind Ausfallzeiten von 9 Stunden und mehr zu erwarten. Diese Verfügbarkeit bietet eine solide Grundlage für unternehmenskritische Workloads. Gleichzeitig können die verschiedenen Servicemodelle in Azure Cosmos DB, wie Reservierte Kapazität oder „Serverlos“, dazu beitragen, die Kosten zu senken.

Einfachheit

Azure Cosmos DB kann die Datenverwaltung und -architektur vereinfachen, indem mehrere Datenbankfunktionen in einer einzigen, zusammenhängenden Plattform integriert werden.

Die integrierten Vektordatenbankfunktionen können Einbettungen zusammen mit den entsprechenden Daten in natürlicher Sprache oder Programmiersprachen speichern, indizieren und abfragen. Diese Funktion ermöglicht eine höhere Datenkonsistenz, Skalierung und Leistung.

Dank seiner Flexibilität kann der Cosmos DB-Dienst die verschiedenen Modalitäten und flexiblen Schemata der Metadaten, Beziehungen, Entitäten, Zusammenfassungen, Chatverläufe, Benutzereinstellungen, sensorischen Daten, Entscheidungen, gelernten Fakten oder anderen operativen Daten, die in Agent-Workflows verwendet werden, unterstützen. Die Datenbank indiziert automatisch alle Daten, ohne dass eine Schema- oder Indexverwaltung erforderlich ist, so dass KI-Agents komplexe Abfragen schnell und effizient durchführen können.

Azure Cosmos DB ist vollständig verwaltet, daher entfällt der Mehraufwand für die Datenbankverwaltungsaufgaben wie Skalierung, Patchen und Backups. Ohne diesen Mehraufwand können sich Entwicklerinnen und Entwickler auf das Erstellen und Optimieren der KI-Agents konzentrieren, ohne sich Gedanken über die zugrunde liegende Dateninfrastruktur machen zu müssen.

Erweiterte Funktionen

Azure Cosmos DB enthält erweiterte Funktionen wie den Änderungsfeed, der es ermöglicht, Datenänderungen in Echtzeit nachzuverfolgen und sofort zu reagieren. Diese Funktion ist nützlich für KI-Agents, die umgehend auf neue Informationen reagieren müssen.

Darüber hinaus ermöglicht die integrierte Unterstützung für Multimaster-Schreibvorgänge Hochverfügbarkeit und Resilienz, um den kontinuierlichen Vorgang der KI-Agents auch nach regionalen Ausfällen zu gewährleisten.

Die fünf verfügbaren Konsistenzebenen (von starker bis letztlicher Konsistenz) können je nach Anforderungen des Szenarios auch für verschiedene verteilte Workloads eingesetzt werden.

Tipp

Sie können aus zwei Azure Cosmos DB APIs wählen, um Ihr KI-Agent-Speichersystem aufzubauen:

  • Azure Cosmos DB for NoSQL, das eine Verfügbarkeitsgarantie von 99,999 % bietet und drei Vektorsuchalgorithmen bereitstellt: IVF, HNSW und DiskANN
  • vCore-basierte Azure Cosmos DB for MongoDB, die eine Verfügbarkeitsgarantie von 99,995 % bietet und zwei Vektorsuchalgorithmen bereitstellt: IVF und HNSW (DiskANN ist in Vorbereitung)

Informationen über die Verfügbarkeitsgarantien für diese APIs finden Sie in den Dienst-SLAs.

Implementierungsbeispiel

In diesem Abschnitt wird die Implementierung eines autonomen Agents zum Verarbeiten der Anfragen und Buchungen von Reisenden in der Reiseanwendung einer Kreuzfahrtgesellschaft erläutert.

Chatbots sind ein seit langem bestehendes Konzept. KI-Agents gehen dagegen über einfache menschliche Unterhaltungen hinaus und führen Aufgaben aus, die auf natürlicher Sprache basieren. Diese Aufgaben erfordern traditionell programmierte Logik. Dieser KI-Reise-Agent in diesem Implementierungsbeispiel verwendet das LangChain-Agent-Framework für die Planung, die Verwendung von Tools und die Wahrnehmung des Agents.

Das einheitliche Speichersystem des KI-Reise-Agent verwendet die Vektordatenbank und Dokumentspeicherfunktionen von Azure Cosmos DB, um Anfragen von Reisenden zu bearbeiten und Reisebuchungen zu unterstützen. Die Verwendung von Azure Cosmos DB zu diesem Zweck trägt dazu bei, Geschwindigkeit, Skalierung und Einfachheit sicherzustellen, wie zuvor beschrieben.

Der Beispiel-Agent arbeitet innerhalb eines Python FastAPI-Back-Ends. Er unterstützt Benutzerinteraktionen über eine React-JavaScript-Benutzeroberfläche.

Voraussetzungen

  • Ein Azure-Abonnement. Wenn Sie noch keins haben, können Sie Azure Cosmos DB 30 Tage lang kostenlos testen, ohne ein Azure-Konto anzulegen. Für die kostenlose Testversion ist keine Kreditkarte erforderlich, und nach dem Testzeitraum besteht keine Verpflichtung.
  • Ein Konto für die OpenAI API oder den Azure OpenAI Service
  • Ein vCore-Cluster in Azure Cosmos DB for MongoDB Eine Anleitung zum Erstellen finden Sie in diesem Schnellstart.
  • Eine integrierte Entwicklungsumgebung, z. B. Visual Studio Code
  • Installation von Python 3.11.4 in der Entwicklungsumgebung

Herunterladen des Projekts

Der gesamte Code und alle Beispieldatensätze sind in diesem GitHub-Repository verfügbar. Das Repository enthält die folgenden Ordner:

  • loader: Dieser Ordner enthält Python-Code zum Laden von Beispieldokumenten und Vektoreinbettungen in Azure Cosmos DB.
  • api: Dieser Ordner enthält das Python FastAPI-Projekt zum Hosten des KI-Reise-Agents.
  • web: Dieser Ordner enthält Code für die React-Weboberfläche.

Laden von Reisedokumenten in Azure Cosmos DB

Das GitHub-Repository enthält ein Python-Projekt im Verzeichnis loader. Es ist für das Laden der Beispielreisedokumente in Azure Cosmos DB vorgesehen.

Einrichten der Umgebung

Richten Sie Ihre virtuelle Python-Umgebung im Verzeichnis loader ein, indem Sie den folgenden Befehl ausführen:

    python -m venv venv

Aktivieren Sie Ihre Umgebung, und installieren Sie Abhängigkeiten im Verzeichnis loader:

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

Erstellen Sie eine Datei mit der Erweiterung .env im Verzeichnis loader, um die folgenden Umgebungsvariablen zu speichern:

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

Laden von Dokumenten und Vektoren

Die Python-Datei main.py dient als zentraler Einstiegspunkt zum Laden von Daten in Azure Cosmos DB. Dieser Code verarbeitet die Beispielreisedaten aus dem GitHub-Repository, einschließlich der Informationen zu den Schiffen und Reisezielen. Der Code generiert auch für jedes Schiff und jedes Reiseziel Reisepakete, die die Reisenden über den KI-Agent buchen können. Das Tool CosmosDBLoader ist dafür verantwortlich, Sammlungen, Vektoreinbettungen und Indizes in der Azure Cosmos DB-Instanz zu erstellen.

Hier ist der Inhalt der Datei 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')])

Laden Sie die Dokumente und Vektoren, und erstellen Sie Indizes, indem Sie den folgenden Befehl im Verzeichnis loader ausführen:

    python main.py

Dies ist die Ausgabe von main.py:

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

Erstellen des KI-Reise-Agent mithilfe der Python FastAPI

Der KI-Reise-Agent wird in einer Back-End-API über Python FastAPI gehostet, was die Integration mit der Front-End-Benutzeroberfläche erleichtert. Das API-Projekt verarbeitet Agent-Anforderungen, indem es die LLM-Prompts mit der Datenebene und insbesondere mit den Vektoren und Dokumenten in Azure Cosmos DB abgleicht.

Der Agent nutzt verschiedene Tools, vor allem die auf der API-Dienstebene bereitgestellten Python-Funktionen. Dieser Artikel konzentriert sich auf den Code, der innerhalb des API-Codes für KI-Agents erforderlich ist.

Das API-Projekt im GitHub-Repository ist wie folgt strukturiert:

  • Datenmodellierungskomponenten verwenden die Pydantic-Modelle.
  • Die Komponenten der Webebene sind für die Weiterleitung von Anforderungen und die Verwaltung der Kommunikation zuständig.
  • Die Komponenten der Dienstebene sind für die primäre Geschäftslogik und die Interaktion mit der Datenebene, dem LangChain-Agenten und den Agententools zuständig.
  • Die Komponenten der Datenebene sind für die Interaktion mit der Azure Cosmos DB for MongoDB-Dokumentenspeicherung und der Vektorsuche zuständig.

Einrichten der Umgebung für die API

Wir haben Python Version 3.11.4 zum Entwickeln und Testen der API verwendet.

Richten Sie Ihre virtuelle Python-Umgebung im Verzeichnis api ein:

    python -m venv venv

Aktivieren Sie Ihre Umgebung, und installieren Sie Abhängigkeiten mithilfe der Anforderungsdatei im Verzeichnis api:

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

Erstellen Sie eine Datei mit der Erweiterung .env im Verzeichnis api, um Ihre Umgebungsvariablen zu speichern:

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

Nachdem Sie die Umgebung konfiguriert und Variablen eingerichtet haben, führen Sie den folgenden Befehl aus dem Verzeichnis api aus, um den Server zu initiieren:

    python app.py

Der FastAPI-Server wird standardmäßig über die localhost-Loopback-Adresse 127.0.0.1 auf dem Port 8000 gestartet. Sie können über die folgende localhost-Adresse auf die Swagger-Dokumente zugreifen: http://127.0.0.1:8000/docs

Verwenden einer Sitzung für den KI-Agent-Speicher

Es ist zwingend erforderlich, dass der Reise-Agent innerhalb der laufenden Unterhaltung auf die zuvor bereitgestellten Informationen zurückgreifen kann. Diese Fähigkeit wird häufig als Speicher im Kontext von LLMs bezeichnet.

Um dieses Ziel zu erreichen, verwenden Sie den Chatnachrichtenverlauf, der in der Azure Cosmos DB-Instanz gespeichert wird. Der Verlauf jeder Chatsitzung wird anhand einer Sitzungs-ID gespeichert, um sicherzustellen, dass nur Nachrichten aus der aktuellen Unterhaltungssitzung zugänglich sind. Aus diesem Grund gibt es eine Get Session-Methode in der API. Diese Methode ist eine Platzhaltermethode zum Verwalten von Websitzungen, um die Verwendung des Chatnachrichtenverlaufs zu veranschaulichen.

Klicken Sie auf Ausprobieren für /session/.

Screenshot der Verwendung der Methode „Get Session“ in der Python FastAPI, mit der Schaltfläche zum Ausprobieren. 

{
  "session_id": "0505a645526f4d68a3603ef01efaab19"
}

Für den KI-Agent müssen Sie nur eine Sitzung simulieren. Die gekürzte Methode gibt lediglich eine generierte Sitzungs-ID zum Nachverfolgen des Nachrichtenverlaufs zurück. In einer praktischen Implementierung würde diese Sitzung in Azure Cosmos DB und möglicherweise in React localStorage gespeichert werden.

Hier sind die Inhalte von web/session.py:

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

Starten einer Unterhaltung mit dem KI-Reise-Agent

Verwenden Sie die im vorherigen Schritt abgerufene Sitzungs-ID, um einen neuen Dialog mit dem KI-Agent zu starten und seine Funktionalität zu überprüfen. Für den Test übermitteln Sie den folgenden Ausdruck: „I want to take a relaxing vacation.“

Klicken Sie auf Ausprobieren für /agent/agent_chat.

Screenshot der Verwendung der Agent-Chat-Methode in der Python FastAPI, mit der Schaltfläche zum Ausprobieren.

Verwenden Sie diesen Beispielparameter:

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

Die erste Ausführung führt zu einer Empfehlung für Tranquil Breeze Cruise und Fantasy Seas Adventure Cruise, da der Agent annimmt, das diese der Vektorsuche zufolge die erholsamsten Kreuzfahrten bieten. Diese Dokumente haben die höchste Bewertung für similarity_search_with_score, die in der Datenebene der API (data.mongodb.travel.similarity_search()) aufgerufen wird.

Die Ergebnisse der Ähnlichkeitssuche werden für Debuggingzwecke als Ausgabe der API angezeigt. Dies ist die Ausgabe nach einem Aufruf von data.mongodb.travel.similarity_search():

0.8394561085977978
0.8086545112328692
2

Tipp

Wenn keine Dokumente für die Vektorsuche zurückgegeben werden, ändern Sie ggf. den similarity_search_with_score-Grenzwert oder den Wert des Bewertungsfilters ([doc for doc, score in docs if score >=.78]) in data.mongodb.travel.similarity_search().

Wenn Sie agent_chat zum ersten Mal aufrufen, wird eine neue Sammlung namens history in Azure Cosmos DB erstellt, um die Unterhaltung nach Sitzungen zu speichern. Bei diesem Anruf kann der Agent bei Bedarf auf den gespeicherten Chatnachrichtenverlauf zugreifen. Nachfolgende Ausführungen von agent_chat mit denselben Parametern führen zu unterschiedlichen Ergebnissen, da diese aus dem Speicher stammen.

Einführung in den KI-Agent

Wenn Sie den KI-Agent in die API integrieren, sind die Komponenten für die Websuche für das Initiieren aller Anforderungen verantwortlich. Auf die Komponenten der Websuche folgen der Suchdienst und schließlich die Datenkomponenten.

In diesem speziellen Fall verwenden Sie die MongoDB-Datensuche, die eine Verbindung mit Azure Cosmos DB herstellt. Die Ebenen unterstützen den Austausch von Modellkomponenten, wobei sich der KI-Agent und der Toolcode des KI-Agents auf der Dienstebene befinden. Dieser Ansatz ermöglicht die nahtlose Austauschbarkeit von Datenquellen. Er erweitert auch die Funktionen des KI-Agents mit zusätzlichen, komplexeren Funktionen oder Tools.

Abbildung der FastAPI-Ebenen des KI-Reise-Agent.

Dienstebene

Die Dienstebene bildet den Grundpfeiler der Kerngeschäftslogik. In diesem speziellen Szenario spielt die Dienstebene eine entscheidende Rolle als Repository für den LangChain-Agent-Code. Sie erleichtert die nahtlose Integration von Benutzeraufforderungen mit Azure Cosmos DB-Daten, Unterhaltungsspeicher und Agent-Funktionen für den KI-Agent.

Die Dienstebene verwendet ein Singleton-Mustermodul für die Behandlung von Agent-bezogenen Initialisierungen in der Datei init.py. Hier sind die Inhalte von service/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()

Die Datei init.py initiiert das Laden von Umgebungsvariablen aus einer env-Datei unter Verwendung der Methode load_dotenv(override=False). Anschließend wird eine globale Variable mit dem Namen agent_with_chat_history für den Agent instanziiert. Dieser Agent ist für die Verwendung durch TravelAgent.py vorgesehen.

Die Methode LLM_init() wird während der Modulinitialisierung aufgerufen, um den KI-Agent für die Unterhaltung über die API-Webebene zu konfigurieren. Das OpenAI-chat-Objekt wird mithilfe des GPT-3.5-Modells instanziiert, wobei spezifische Parameter wie Modellname und Temperatur einbezogen werden. Das chat-Objekt, die Toolliste und die Promptvorlage werden kombiniert, um einen AgentExecutor zu generieren, der als der KI-Reise-Agent fungiert.

Der Agent mit Verlauf, agent_with_chat_history, wird durch RunnableWithMessageHistory mit Chatverlauf (MongoDBChatMessageHistory) eingerichtet. Diese Aktion ermöglicht es, einen vollständigen Unterhaltungsverlauf über Azure Cosmos DB aufrechtzuerhalten.

Eingabeaufforderung

Der LLM-Prompt begann zunächst mit der einfachen Aussage „You are a helpful and friendly travel assistant for a cruise company“. Durch Tests wurde jedoch festgestellt, dass Sie konsistentere Ergebnisse erzielen können, indem die folgende Anweisung hinzugefügt wird: „Answer travel questions to the best of your ability, providing only relevant information. To book a cruise, capturing the person's name is essential.“ Die Ergebnisse werden im HTML-Format angezeigt, damit die Darstellung auf der Weboberfläche visuell ansprechender ist.

Agent-Tools

Tools sind Schnittstellen, über die ein Agent mit der Außenwelt interagieren kann, wozu häufig Funktionsaufrufe verwendet werden.

Wenn Sie einen Agent erstellen, müssen Sie verschiedene Tools bereitstellen, die der Agent nutzen kann. Das Decorator-Element @tool ist die einfachste Methode zum Definieren eines benutzerdefinierten Tools.

Standardmäßig verwendet der Decorator den Funktionsnamen als Toolnamen. Sie können ihn jedoch ersetzen, indem Sie eine Zeichenkette als erstes Argument angeben. Der Decorator verwendet den docstring der Funktion als Beschreibung des Tools und erfordert daher die Bereitstellung eines docstrings.

Hier sind die Inhalte von service/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"

Die Datei TravelAgentTools.py definiert drei Tools:

  • vacation_lookup führt eine Vektorsuche gegen die Azure Cosmos DB durch. Es verwendet similarity_search, um relevantes reisebezogenes Material abzurufen.
  • itinerary_lookup ruft die Details und Zeitpläne eines Kreuzfahrtpakets für ein angegebenes Kreuzfahrtschiff ab.
  • book_cruise bucht ein Kreuzfahrtpaket für einen Passagier.

Spezifische Anweisungen („In order to book a cruise I need to know your name.“) können erforderlich sein, damit der Name und die Zimmernummer des Passagiers für die Buchung des Kreuzfahrtpakets erfasst werden, auch wenn Sie solche Anweisungen im LLM-Prompt angegeben haben.

KI-Agent

Das grundlegende Konzept von Agents besteht darin, unter Verwendung eines Sprachmodells eine Abfolge von Aktionen auszuwählen, die ausgeführt werden sollen.

Hier sind die Inhalte von service/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))

Die Datei TravelAgent.py ist einfach, da agent_with_chat_history und die zugehörigen Abhängigkeiten (Tools, Prompts und LLM) in der Datei init.py initialisiert und konfiguriert werden. Diese Datei ruft den Agent anhand der empfangenen Eingaben vom Benutzer und der Sitzungs-ID für den Konversationsspeicher auf. Danach wird PromptResponse (Modell/Prompt) mit der Ausgabe und Antwortzeit des Agents zurückgegeben.

KI-Agent-Integration in die React-Benutzeroberfläche

Nachdem Sie die Daten erfolgreich geladen haben und der KI-Agent über die API erreichbar ist, können Sie die Lösung fertigstellen, indem Sie (mit React) eine Webbenutzeroberfläche für die Reise-Website einrichten. Die Verwendung der Funktionen von React trägt dazu bei, die nahtlose Integration des KI-Agents in eine Reisewebsite zu veranschaulichen. Diese Integration verbessert die Benutzererfahrung mit einem Unterhaltungsreiseassistenten für Anfragen und Buchungen.

Einrichten der Umgebung für React

Installieren Sie Node.js und die Abhängigkeiten, bevor Sie die React-Schnittstelle testen.

Führen Sie den folgenden Befehl im Verzeichnis web aus, um eine Neuinstallation der Projektabhängigkeiten durchzuführen. Die Installation kann einige Zeit in Anspruch nehmen.

    npm ci

Als Nächstes müssen Sie eine Datei mit der Erweiterung .env im Verzeichnis web erstellen, um die Speicherung von Umgebungsvariablen zu unterstützen. Fügen Sie die folgenden Details in die neu erstellte env-Datei ein.

REACT_APP_API_HOST=http://127.0.0.1:8000

Führen Sie dann den folgenden Befehl im Verzeichnis web aus, um die React-Webbenutzeroberfläche zu initiieren:

    npm start

Wenn Sie den obigen Befehl ausführen, wird die React-Webanwendung geöffnet.

Einführung in die React-Weboberfläche

Das Webprojekt des GitHub-Repository ist eine einfache Anwendung, die Benutzerinnen und Benutzern die Interaktion mit dem KI-Agenten erleichtert. Die primären Komponenten, die für die Konversation mit dem Agent erforderlich sind, sind TravelAgent.js und ChatLayout.js. Die Datei Main.js dient als zentrale Landing Page für das Modul oder Benutzer.

Screenshot der React-JavaScript-Weboberfläche.

Main

Die Hauptkomponente dient als zentraler Manager der Anwendung. Sie dient als festgelegter Einstiegspunkt für die Weiterleitung. Sie erzeugt innerhalb der Renderfunktion JSX-Code zum Beschreiben des Layouts der Hauptseite. Dieses Layout umfasst Platzhalterelemente für die Anwendung (z. B. Logos und Links), einen Abschnitt mit der Reise-Agent-Komponente und eine Fußzeile, die einen Beispielhaftungsausschluss für die Art der Anwendung enthält.

Hier ist der Inhalt von 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

Reise-Agent

Die Reise-Agent-Komponente dient einem einfachen Zweck – Benutzereingaben erfassen und Antworten anzeigen. Sie spielt eine wichtige Rolle bei der Verwaltung der Integration in den Back-End-KI-Agent, wobei sie in erster Linie Sitzungen erfasst und Benutzerprompts an den FastAPI-Dienst weiterleitet. Die resultierenden Antworten werden mithilfe der Chat-Layout-Komponente zur Anzeige in einem Array gespeichert.

Hier sind die Inhalte von 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>
  )
}

Wählen Sie Mühelos Reise planen, um den Reiseassistenten zu öffnen.

Chatlayout

Die Chat-Layout-Komponente ist für die Gestaltung des Chats zuständig. Sie verarbeitet die Chatnachrichten systematisch und implementiert die im JSON-message-Objekt angegebene Formatierung.

Hier sind die Inhalte von 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>
  )
}

Benutzerprompts befinden sich auf der rechten Seite und sind blau eingefärbt. Antworten des KI-Reise-Agent befinden sich auf der linken Seite und grün eingefärbt. Wie die folgende Abbildung zeigt, werden die HTML-formatierten Antworten in der Unterhaltung berücksichtigt.

Screenshot eines Chats.

Wenn Ihr KI-Agent für die Produktion bereit ist, können Sie die semantische Zwischenspeicherung verwenden, um die Abfrageleistung um 80 % zu verbessern und die Kosten für LLM-Rückschlüsse und API-Aufrufe zu reduzieren. Informationen zur Implementierung der semantischen Zwischenspeicherung finden Sie in diesem Beitrag im „Stochastic Coder“-Blog.

Abbildung der semantischen Zwischenspeicherung.

Zugehöriger Inhalt