ai-agents-for-beginners

Multi-Agent Design

(Klicken Sie auf das obige Bild, um das Video dieser Lektion anzusehen)

Metakognition in KI-Agenten

Einleitung

Willkommen zur Lektion über Metakognition in KI-Agenten! Dieses Kapitel richtet sich an Anfänger, die neugierig darauf sind, wie KI-Agenten über ihre eigenen Denkprozesse nachdenken können. Am Ende dieser Lektion werden Sie die wichtigsten Konzepte verstehen und mit praktischen Beispielen ausgestattet sein, um Metakognition im Design von KI-Agenten anzuwenden.

Lernziele

Nach Abschluss dieser Lektion werden Sie in der Lage sein:

  1. Die Implikationen von Schleifen für logisches Denken in Agentendefinitionen zu verstehen.
  2. Planungs- und Auswertungstechniken zu nutzen, um sich selbst korrigierenden Agenten zu helfen.
  3. Eigene Agenten zu erstellen, die in der Lage sind, Code zu manipulieren, um Aufgaben zu erledigen.

Einführung in die Metakognition

Metakognition bezieht sich auf übergeordnete kognitive Prozesse, die das Denken über das eigene Denken beinhalten. Für KI-Agenten bedeutet dies, ihre Aktionen auf der Grundlage von Selbstwahrnehmung und vergangenen Erfahrungen bewerten und anpassen zu können. Metakognition oder „Denken über das Denken“ ist ein wichtiges Konzept bei der Entwicklung von agentenbasierten KI-Systemen. Es beinhaltet, dass KI-Systeme sich ihrer eigenen internen Prozesse bewusst sind und in der Lage sind, ihr Verhalten zu überwachen, zu regulieren und entsprechend anzupassen. Ähnlich wie wir, wenn wir die Situation einschätzen oder uns einem Problem widmen. Diese Selbstwahrnehmung kann KI-Systemen helfen, bessere Entscheidungen zu treffen, Fehler zu identifizieren und ihre Leistung im Laufe der Zeit zu verbessern – wieder mit Bezug auf den Turing-Test und die Debatte, ob die KI die Weltherrschaft übernehmen wird.

Im Kontext von agentenbasierten KI-Systemen kann Metakognition zur Bewältigung mehrerer Herausforderungen beitragen, wie z. B.:

Was ist Metakognition?

Metakognition, oder „Denken über das Denken“, ist ein übergeordneter kognitiver Prozess, der Selbstwahrnehmung und Selbstregulierung der eigenen kognitiven Prozesse beinhaltet. Im Bereich der KI befähigt Metakognition Agenten, ihre Strategien und Aktionen zu bewerten und anzupassen, was zu verbesserten Fähigkeiten zur Problemlösung und Entscheidungsfindung führt. Durch das Verständnis von Metakognition können Sie KI-Agenten entwerfen, die nicht nur intelligenter, sondern auch anpassungsfähiger und effizienter sind. Bei echter Metakognition würde man sehen, wie die KI explizit über ihr eigenes Denken nachdenkt.

Beispiel: „Ich habe günstigere Flüge priorisiert, weil... Ich könnte Direktflüge verpassen, also lasse ich sie noch einmal prüfen.“ Verfolgung, wie oder warum es eine bestimmte Route gewählt hat.

Bedeutung der Metakognition in KI-Agenten

Metakognition spielt aus mehreren Gründen eine entscheidende Rolle beim Design von KI-Agenten:

Importance of Metacognition

Komponenten eines KI-Agenten

Bevor wir uns mit metakognitiven Prozessen befassen, ist es wichtig, die grundlegenden Komponenten eines KI-Agenten zu verstehen. Ein KI-Agent besteht typischerweise aus:

Diese Komponenten arbeiten zusammen, um eine „Expertise-Einheit“ zu schaffen, die spezifische Aufgaben ausführen kann.

Beispiel: Stellen Sie sich einen Reiseberater vor, einen Agentendienst, der nicht nur Ihren Urlaub plant, sondern auch seinen Weg basierend auf Echtzeitdaten und vergangenen Kundenerlebnissen anpasst.

Beispiel: Metakognition in einem Reiseberater-Service

Stellen Sie sich vor, Sie entwerfen einen KI-gestützten Reiseberater-Service. Dieser Agent, „Reiseberater“, unterstützt Benutzer bei der Planung ihrer Urlaube. Um Metakognition zu integrieren, muss der Reiseberater seine Aktionen basierend auf Selbstwahrnehmung und vergangenen Erfahrungen bewerten und anpassen. So könnte Metakognition eine Rolle spielen:

Aktuelle Aufgabe

Die aktuelle Aufgabe ist es, einem Benutzer bei der Planung einer Reise nach Paris zu helfen.

Schritte zur Erledigung der Aufgabe

  1. Benutzerpräferenzen sammeln: Fragen Sie den Benutzer nach seinen Reisedaten, seinem Budget, seinen Interessen (z. B. Museen, Küche, Shopping) und besonderen Anforderungen.
  2. Informationen abrufen: Suchen Sie nach Flugoptionen, Unterkünften, Attraktionen und Restaurants, die den Präferenzen des Benutzers entsprechen.
  3. Empfehlungen generieren: Bieten Sie eine personalisierte Reiseroute mit Flugdetails, Hotelbuchungen und vorgeschlagenen Aktivitäten an.
  4. Anpassung basierend auf Feedback: Bitten Sie den Benutzer um Feedback zu den Empfehlungen und nehmen Sie die notwendigen Anpassungen vor.

Benötigte Ressourcen

Erfahrung und Selbstreflexion

Der Reiseberater nutzt Metakognition, um seine Leistung zu bewerten und aus vergangenen Erfahrungen zu lernen. Zum Beispiel:

  1. Analyse des Benutzerfeedbacks: Der Reiseberater prüft das Benutzerfeedback, um festzustellen, welche Empfehlungen gut ankamen und welche nicht. Er passt seine zukünftigen Vorschläge entsprechend an.
  2. Anpassungsfähigkeit: Wenn ein Benutzer zuvor eine Abneigung gegen überfüllte Orte erwähnt hat, wird der Reiseberater in Zukunft die Empfehlung beliebter Touristenattraktionen zu Stoßzeiten vermeiden.
  3. Fehlerkorrektur: Wenn der Reiseberater in der Vergangenheit einen Buchungsfehler gemacht hat, z. B. ein ausgebuchtes Hotel vorgeschlagen hat, lernt er, die Verfügbarkeit rigoroser zu prüfen, bevor er Empfehlungen ausspricht.

Praktisches Entwicklerbeispiel

Hier ist ein vereinfachtes Beispiel, wie der Code des Reiseberaters bei der Integration von Metakognition aussehen könnte.

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # Search for flights, hotels, and attractions based on preferences
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # Analyze feedback and adjust future recommendations
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

Warum Metakognition wichtig ist

Durch die Integration von Metakognition kann der Reiseberater personalisiertere und genauere Reiseempfehlungen anbieten und so das Gesamterlebnis des Benutzers verbessern.

2. Planung in Agenten

Planung ist eine kritische Komponente des Verhaltens von KI-Agenten. Sie beinhaltet die Festlegung der Schritte, die zur Erreichung eines Ziels erforderlich sind, unter Berücksichtigung des aktuellen Zustands, der Ressourcen und möglicher Hindernisse.

Elemente der Planung

Beispiel: Hier sind die Schritte, die der Reiseberater unternehmen muss, um einen Benutzer bei der effektiven Planung seiner Reise zu unterstützen.

Schritte für den Reiseberater

  1. Benutzerpräferenzen sammeln
    • Fragen Sie den Benutzer nach Details zu Reisedaten, Budget, Interessen und besonderen Anforderungen.
    • Beispiele: „Wann planen Sie zu reisen?“ „Was ist Ihre Budgetspanne?“ „Welche Aktivitäten genießen Sie im Urlaub?“
  2. Informationen abrufen
    • Suchen Sie nach relevanten Reiseoptionen basierend auf den Benutzerpräferenzen.
    • Flüge: Suchen Sie nach verfügbaren Flügen innerhalb des Budgets und der bevorzugten Reisedaten des Benutzers.
    • Unterkünfte: Finden Sie Hotels oder Mietobjekte, die den Präferenzen des Benutzers in Bezug auf Lage, Preis und Ausstattung entsprechen.
    • Attraktionen und Restaurants: Identifizieren Sie beliebte Attraktionen, Aktivitäten und Essensmöglichkeiten, die mit den Interessen des Benutzers übereinstimmen.
  3. Empfehlungen generieren
    • Fassen Sie die abgerufenen Informationen zu einer personalisierten Reiseroute zusammen.
    • Stellen Sie Details wie Flugoptionen, Hotelbuchungen und vorgeschlagene Aktivitäten bereit und stellen Sie sicher, dass die Empfehlungen auf die Präferenzen des Benutzers zugeschnitten sind.
  4. Reiseroute dem Benutzer präsentieren
    • Teilen Sie die vorgeschlagene Reiseroute zur Überprüfung mit dem Benutzer.
    • Beispiel: „Hier ist eine vorgeschlagene Reiseroute für Ihre Reise nach Paris. Sie beinhaltet Flugdetails, Hotelbuchungen und eine Liste empfohlener Aktivitäten und Restaurants. Lassen Sie mich Ihre Gedanken wissen!“
  5. Feedback sammeln
    • Bitten Sie den Benutzer um Feedback zur vorgeschlagenen Reiseroute.
    • Beispiele: „Gefallen Ihnen die Flugoptionen?“ „Ist das Hotel für Ihre Bedürfnisse geeignet?“ „Gibt es Aktivitäten, die Sie hinzufügen oder entfernen möchten?“
  6. Anpassung basierend auf Feedback
    • Modifizieren Sie die Reiseroute basierend auf dem Feedback des Benutzers.
    • Nehmen Sie notwendige Änderungen an Flug-, Unterkunfts- und Aktivitätsempfehlungen vor, um den Präferenzen des Benutzers besser zu entsprechen.
  7. Endgültige Bestätigung
    • Präsentieren Sie die aktualisierte Reiseroute dem Benutzer zur endgültigen Bestätigung.
    • Beispiel: „Ich habe die Anpassungen basierend auf Ihrem Feedback vorgenommen. Hier ist die aktualisierte Reiseroute. Sieht alles gut für Sie aus?“
  8. Buchungen und Reservierungen bestätigen
    • Sobald der Benutzer die Reiseroute genehmigt hat, fahren Sie mit der Buchung von Flügen, Unterkünften und allen vorab geplanten Aktivitäten fort.
    • Senden Sie die Bestätigungsdetails an den Benutzer.
  9. Laufende Unterstützung bieten
    • Bleiben Sie verfügbar, um den Benutzer vor und während seiner Reise bei Änderungen oder zusätzlichen Anfragen zu unterstützen.
    • Beispiel: „Wenn Sie während Ihrer Reise weitere Unterstützung benötigen, können Sie sich jederzeit an mich wenden!“

Beispiel-Interaktion

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# Example usage within a booing request
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

3. Korrektives RAG-System

Zuerst beginnen wir mit dem Verständnis des Unterschieds zwischen einem RAG-Tool und einer präventiven Kontextladung.

RAG vs Context Loading

Retrieval-Augmented Generation (RAG)

RAG kombiniert ein Retrievalsystem mit einem generativen Modell. Wenn eine Anfrage gestellt wird, ruft das Retrievalsystem relevante Dokumente oder Daten aus einer externen Quelle ab, und diese abgerufenen Informationen werden verwendet, um die Eingabe für das generative Modell zu erweitern. Dies hilft dem Modell, genauere und kontextbezogenere Antworten zu generieren.

In einem RAG-System ruft der Agent relevante Informationen aus einer Wissensdatenbank ab und nutzt diese, um angemessene Antworten oder Aktionen zu generieren.

Korrektiver RAG-Ansatz

Der Korrektive RAG-Ansatz konzentriert sich auf die Verwendung von RAG-Techniken zur Korrektur von Fehlern und zur Verbesserung der Genauigkeit von KI-Agenten. Dies beinhaltet:

  1. Prompting-Technik: Verwendung spezifischer Prompts, um den Agenten bei der Abfrage relevanter Informationen anzuleiten.
  2. Werkzeug: Implementierung von Algorithmen und Mechanismen, die es dem Agenten ermöglichen, die Relevanz der abgerufenen Informationen zu bewerten und genaue Antworten zu generieren.
  3. Bewertung: Kontinuierliche Bewertung der Leistung des Agenten und Vornahme von Anpassungen zur Verbesserung seiner Genauigkeit und Effizienz.

Beispiel: Korrektives RAG in einem Suchagenten

Betrachten Sie einen Suchagenten, der Informationen aus dem Internet abruft, um Benutzeranfragen zu beantworten. Der Korrektive RAG-Ansatz könnte Folgendes beinhalten:

  1. Prompting-Technik: Formulierung von Suchanfragen basierend auf der Eingabe des Benutzers.
  2. Werkzeug: Verwendung von Natural-Language-Processing- und Machine-Learning-Algorithmen zur Rangfolge und Filterung von Suchergebnissen.
  3. Bewertung: Analyse des Benutzerfeedbacks zur Identifizierung und Korrektur von Ungenauigkeiten in den abgerufenen Informationen.

Korrektives RAG im Reiseberater

Korrektives RAG (Retrieval-Augmented Generation) verbessert die Fähigkeit einer KI, Informationen abzurufen und zu generieren, während Ungenauigkeiten korrigiert werden. Lassen Sie uns sehen, wie der Reiseberater den Korrektive RAG-Ansatz nutzen kann, um genauere und relevantere Reiseempfehlungen anzubieten.

Dies beinhaltet:

Schritte zur Implementierung von Korrektivem RAG im Reiseberater

  1. Erste Benutzerinteraktion
    • Der Reiseberater sammelt anfängliche Präferenzen vom Benutzer, wie z. B. Reiseziel, Reisedaten, Budget und Interessen.

    • Beispiel

      preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
  2. Abruf von Informationen
    • Der Reiseberater ruft Informationen zu Flügen, Unterkünften, Attraktionen und Restaurants basierend auf den Benutzerpräferenzen ab.

    • Beispiel

      flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
  3. Generierung erster Empfehlungen
    • Der Reiseberater nutzt die abgerufenen Informationen, um eine personalisierte Reiseroute zu erstellen.

    • Beispiel

      itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
  4. Sammeln von Benutzerfeedback
    • Der Reiseberater bittet den Benutzer um Feedback zu den ersten Empfehlungen.

    • Beispiel

      feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
  5. Korrektiver RAG-Prozess
    • Prompting-Technik: Der Reiseberater formuliert neue Suchanfragen basierend auf dem Benutzerfeedback.

      • Beispiel

        if "disliked" in feedback:
    preferences["avoid"] = feedback["disliked"]
    • Werkzeug: Der Reiseberater verwendet Algorithmen, um neue Suchergebnisse zu rangieren und zu filtern, wobei die Relevanz basierend auf dem Benutzerfeedback hervorgehoben wird.

      • Beispiel

        new_attractions = search_attractions(preferences)
new_itinerary = create_itinerary(flights, hotels, new_attractions)
print("Updated Itinerary:", new_itinerary)
    • Bewertung: Der Reiseberater bewertet kontinuierlich die Relevanz und Genauigkeit seiner Empfehlungen, indem er das Benutzerfeedback analysiert und notwendige Anpassungen vornimmt.

      • Beispiel

        def adjust_preferences(preferences, feedback):
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

preferences = adjust_preferences(preferences, feedback)

Praktisches Beispiel

Hier ist ein vereinfachtes Python-Codebeispiel, das den Korrektive RAG-Ansatz im Reiseberater integriert.

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# Example usage
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

Präventive Kontextladung

Präventive Kontextladung beinhaltet das Laden relevanter Kontext- oder Hintergrundinformationen in das Modell, bevor eine Anfrage verarbeitet wird. Das bedeutet, dass das Modell von Anfang an Zugriff auf diese Informationen hat, was ihm helfen kann, informiertere Antworten zu generieren, ohne während des Prozesses zusätzliche Daten abrufen zu müssen.

Hier ist ein vereinfachtes Beispiel, wie eine präventive Kontextladung für eine Reiseberater-Anwendung in Python aussehen könnte.

class TravelAgent:
    def __init__(self):
        # Pre-load popular destinations and their information
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # Fetch destination information from pre-loaded context
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# Example usage
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

Erklärung

  1. Initialisierung (Methode __init__): Die Klasse TravelAgent lädt vorab ein Wörterbuch mit Informationen über beliebte Reiseziele wie Paris, Tokio, New York und Sydney. Dieses Wörterbuch enthält Details wie Land, Währung, Sprache und Hauptattraktionen für jedes Reiseziel.

  2. Informationen abrufen (Methode get_destination_info): Wenn ein Benutzer eine Anfrage zu einem bestimmten Reiseziel stellt, ruft die Methode get_destination_info die relevanten Informationen aus dem vorab geladenen Kontextwörterbuch ab.

Durch das Vorladen des Kontexts kann die Reiseberater-Anwendung schnell auf Benutzeranfragen reagieren, ohne diese Informationen in Echtzeit aus einer externen Quelle abrufen zu müssen. Dies macht die Anwendung effizienter und reaktionsschneller.

Der Plan mit einem Ziel bootstrappen, bevor iteriert wird

Das Bootstrappen eines Plans mit einem Ziel bedeutet, mit einem klaren Ziel oder Ergebnis vor Augen zu beginnen. Durch die Festlegung dieses Ziels im Voraus kann das Modell es als Leitprinzip während des gesamten iterativen Prozesses verwenden. Dies trägt dazu bei, dass jede Iteration dem Erreichen des gewünschten Ergebnisses näher kommt, wodurch der Prozess effizienter und fokussierter wird.

Hier ist ein Beispiel, wie Sie einen Reiseplan mit einem Ziel bootstrappen können, bevor Sie für einen Reiseberater in Python iterieren.

Szenario

Ein Reiseberater möchte für einen Kunden eine maßgeschneiderte Urlaubsplanung erstellen. Das Ziel ist es, eine Reiseroute zu erstellen, die die Kundenzufriedenheit basierend auf seinen Präferenzen und seinem Budget maximiert.

Schritte

  1. Definieren Sie die Präferenzen und das Budget des Kunden.
  2. Bootstrappen Sie den anfänglichen Plan basierend auf diesen Präferenzen.
  3. Iterieren Sie, um den Plan zu verfeinern und die Kundenzufriedenheit zu optimieren.

Python-Code

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# Example usage
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)

Code-Erklärung

  1. Initialisierung (Methode __init__): Die Klasse TravelAgent wird mit einer Liste potenzieller Reiseziele initialisiert, von denen jedes Attribute wie Name, Kosten und Aktivitätstyp aufweist.

  2. Bootstrappen des Plans (Methode bootstrap_plan): Diese Methode erstellt einen anfänglichen Reiseplan basierend auf den Präferenzen und dem Budget des Kunden. Sie durchläuft die Liste der Reiseziele und fügt sie dem Plan hinzu, wenn sie den Präferenzen des Kunden entsprechen und im Budget liegen.

  3. Abgleichen von Präferenzen (Methode match_preferences): Diese Methode prüft, ob ein Reiseziel mit den Präferenzen des Kunden übereinstimmt.

  4. Iterieren des Plans (Methode iterate_plan): Diese Methode verfeinert den anfänglichen Plan, indem sie versucht, jedes Reiseziel im Plan durch eine bessere Übereinstimmung zu ersetzen, unter Berücksichtigung der Präferenzen und Budgetbeschränkungen des Kunden.

  5. Kostenberechnung (Methode calculate_cost): Diese Methode berechnet die Gesamtkosten des aktuellen Plans, einschließlich eines potenziellen neuen Reiseziels.

Beispielhafte Verwendung

Durch das Bootstrappen des Plans mit einem klaren Ziel (z. B. Maximierung der Kundenzufriedenheit) und Iterationen zur Verfeinerung des Plans kann der Reiseberater eine maßgeschneiderte und optimierte Reiseroute für den Kunden erstellen. Dieser Ansatz stellt sicher, dass der Reiseplan von Anfang an mit den Präferenzen und dem Budget des Kunden übereinstimmt und sich mit jeder Iteration verbessert.

LLM für Re-Ranking und Scoring nutzen

Große Sprachmodelle (LLMs) können für Re-Ranking und Scoring verwendet werden, indem sie die Relevanz und Qualität abgerufener Dokumente oder generierter Antworten bewerten. So funktioniert es:

Retrieval: Der anfängliche Retrieval-Schritt ruft eine Reihe von Kandidatendokumenten oder Antworten basierend auf der Anfrage ab.

Re-Ranking: Das LLM bewertet diese Kandidaten und stuft sie basierend auf ihrer Relevanz und Qualität neu ein. Dieser Schritt stellt sicher, dass die relevantesten und qualitativ hochwertigsten Informationen zuerst präsentiert werden.

Scoring: Das LLM weist jedem Kandidaten Punktzahlen zu, die seine Relevanz und Qualität widerspiegeln. Dies hilft bei der Auswahl der besten Antwort oder des besten Dokuments für den Benutzer.

Durch die Nutzung von LLMs für Re-Ranking und Scoring kann das System genauere und kontextbezogenere Informationen liefern und so das Gesamterlebnis des Benutzers verbessern.

Hier ist ein Beispiel dafür, wie ein Reiseberater ein Large Language Model (LLM) für das Re-Ranking und Scoring von Reisezielen basierend auf Benutzerpräferenzen in Python verwenden könnte.

Szenario – Reise basierend auf Präferenzen

Ein Reiseberater möchte einem Kunden die besten Reiseziele basierend auf seinen Präferenzen empfehlen. Das LLM hilft beim Re-Ranking und Scoring der Reiseziele, um sicherzustellen, dass die relevantesten Optionen präsentiert werden.

Schritte

  1. Sammeln Sie Benutzereinstellungen.
  2. Rufen Sie eine Liste potenzieller Reiseziele ab.
  3. Verwenden Sie das LLM, um die Reiseziele basierend auf den Benutzereinstellungen neu einzustufen und zu bewerten.

Hier erfahren Sie, wie Sie das vorherige Beispiel zur Verwendung von Azure OpenAI Services aktualisieren können.

Anforderungen

  1. Sie benötigen ein Azure-Abonnement.
  2. Erstellen Sie eine Azure OpenAI-Ressource und rufen Sie Ihren API-Schlüssel ab.

Beispiel Python-Code

import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # Generate a prompt for the Azure OpenAI
        prompt = self.generate_prompt(preferences)
        
        # Define headers and payload for the request
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # Call the Azure OpenAI API to get the re-ranked and scored destinations
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # Extract and return the recommendations
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# Example usage
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)

Code-Erklärung – Preference Booker

  1. Initialisierung: Die Klasse TravelAgent wird mit einer Liste potenzieller Reiseziele initialisiert, von denen jedes Attribute wie Name und Beschreibung aufweist.

  2. Empfehlungen erhalten (Methode get_recommendations): Diese Methode generiert einen Prompt für den Azure OpenAI-Dienst basierend auf den Benutzereinstellungen und führt eine HTTP POST-Anfrage an die Azure OpenAI-API aus, um neu eingestufte und bewertete Reiseziele zu erhalten.

  3. Prompt generieren (Methode generate_prompt): Diese Methode erstellt einen Prompt für Azure OpenAI, einschließlich der Benutzereinstellungen und der Liste der Reiseziele. Der Prompt leitet das Modell an, die Reiseziele basierend auf den bereitgestellten Präferenzen neu einzustufen und zu bewerten.

  4. API-Aufruf: Die Bibliothek requests wird verwendet, um eine HTTP POST-Anfrage an den Azure OpenAI-API-Endpunkt zu senden. Die Antwort enthält die neu eingestuften und bewerteten Reiseziele.

  5. Beispielhafte Verwendung: Der Reiseberater sammelt Benutzereinstellungen (z. B. Interesse an Sightseeing und vielfältiger Kultur) und nutzt den Azure OpenAI-Dienst, um neu eingestufte und bewertete Empfehlungen für Reiseziele zu erhalten.

Stellen Sie sicher, dass Sie your_azure_openai_api_key durch Ihren tatsächlichen Azure OpenAI API-Schlüssel und https://your-endpoint.com/... durch die tatsächliche Endpunkt-URL Ihrer Azure OpenAI-Bereitstellung ersetzen.

Durch die Nutzung des LLM für Re-Ranking und Scoring kann der Reiseberater den Kunden personalisiertere und relevantere Reiseempfehlungen anbieten und so deren Gesamterlebnis verbessern.

RAG: Prompting-Technik vs. Werkzeug

Retrieval-Augmented Generation (RAG) kann sowohl eine Prompting-Technik als auch ein Werkzeug bei der Entwicklung von KI-Agenten sein. Das Verständnis des Unterschieds zwischen beidem kann Ihnen helfen, RAG effektiver in Ihren Projekten einzusetzen.

RAG als Prompting-Technik

Was ist es?

Wie es funktioniert

  1. Prompts formulieren: Erstellen Sie gut strukturierte Prompts oder Anfragen basierend auf der anstehenden Aufgabe oder der Eingabe des Benutzers.
  2. Informationen abrufen: Nutzen Sie die Prompts, um relevante Daten aus einer vordefinierten Wissensbasis oder einem Datensatz zu suchen.
  3. Antwort generieren: Kombinieren Sie die abgerufenen Informationen mit generativen KI-Modellen, um eine umfassende und kohärente Antwort zu produzieren.

Beispiel im Reiseberater:

RAG als Werkzeug

Was ist es?

Wie es funktioniert

  1. Integration: Betten Sie RAG in die Architektur des KI-Agenten ein, sodass er die Abruf- und Generierungsaufgaben automatisch verwalten kann.
  2. Automatisierung: Das Werkzeug verwaltet den gesamten Prozess, vom Empfang der Benutzereingabe bis zur Generierung der endgültigen Antwort, ohne dass für jeden Schritt explizite Prompts erforderlich sind.
  3. Effizienz: Verbessert die Leistung des Agenten durch Optimierung des Abruf- und Generierungsprozesses, was schnellere und genauere Antworten ermöglicht.

Beispiel im Reiseberater:

Vergleich

Aspekt Prompting-Technik Werkzeug
Manuell vs. Automatisch Manuelle Formulierung von Prompts für jede Anfrage. Automatisierter Prozess für Abruf und Generierung.
Kontrolle Bietet mehr Kontrolle über den Abrufprozess. Optimiert und automatisiert Abruf und Generierung.
Flexibilität Ermöglicht benutzerdefinierte Prompts basierend auf spezifischen Bedürfnissen. Effizienter für groß angelegte Implementierungen.
Komplexität Erfordert die Erstellung und Anpassung von Prompts. Einfacher in die Architektur eines KI-Agenten zu integrieren.

Praktische Beispiele

Beispiel für eine Prompting-Technik

def search_museums_in_paris():
    prompt = "Find top museums in Paris"
    search_results = search_web(prompt)
    return search_results

museums = search_museums_in_paris()
print("Top Museums in Paris:", museums)

Beispiel für ein Werkzeug

class Travel_Agent:
    def __init__(self):
        self.rag_tool = RAGTool()

    def get_museums_in_paris(self):
        user_input = "I want to visit museums in Paris."
        response = self.rag_tool.retrieve_and_generate(user_input)
        return response

travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Top Museums in Paris:", museums)

Bewertung der Relevanz

Die Bewertung der Relevanz ist ein entscheidender Aspekt der Leistung von KI-Agenten. Sie stellt sicher, dass die vom Agenten abgerufenen und generierten Informationen für den Benutzer angemessen, genau und nützlich sind. Lassen Sie uns untersuchen, wie die Relevanz in KI-Agenten bewertet wird, einschließlich praktischer Beispiele und Techniken.

Schlüsselkonzepte bei der Bewertung der Relevanz

  1. Kontextbewusstsein:
    • Der Agent muss den Kontext der Benutzeranfrage verstehen, um relevante Informationen abzurufen und zu generieren.
    • Beispiel: Wenn ein Benutzer nach „besten Restaurants in Paris“ fragt, sollte der Agent die Präferenzen des Benutzers berücksichtigen, wie z. B. Küchenart und Budget.
  2. Genauigkeit:
    • Die vom Agenten bereitgestellten Informationen sollten sachlich korrekt und aktuell sein.
    • Beispiel: Empfehlung von aktuell geöffneten Restaurants mit guten Bewertungen anstelle von veralteten oder geschlossenen Optionen.
  3. Benutzerabsicht:
    • Der Agent sollte die Absicht des Benutzers hinter der Anfrage ableiten, um die relevantesten Informationen bereitzustellen.
    • Beispiel: Wenn ein Benutzer nach „preiswerten Hotels“ fragt, sollte der Agent günstige Optionen priorisieren.
  4. Feedback-Schleife:
    • Das kontinuierliche Sammeln und Analysieren von Benutzerfeedback hilft dem Agenten, seinen Prozess zur Bewertung der Relevanz zu verfeinern.
    • Beispiel: Einbeziehung von Benutzerbewertungen und Feedback zu früheren Empfehlungen zur Verbesserung zukünftiger Antworten.

Praktische Techniken zur Bewertung der Relevanz

  1. Relevanzbewertung:
    • Weisen Sie jedem abgerufenen Element einen Relevanzscore zu, basierend darauf, wie gut es mit der Anfrage und den Präferenzen des Benutzers übereinstimmt.

    • Beispiel

      def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score
  2. Filtern und Rangieren:
    • Filtern Sie irrelevante Elemente heraus und ordnen Sie die verbleibenden Elemente basierend auf ihren Relevanzscores ein.

    • Beispiel

      def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # Return top 10 relevant items
  3. Natural Language Processing (NLP):
    • Verwenden Sie NLP-Techniken, um die Benutzeranfrage zu verstehen und relevante Informationen abzurufen.

    • Beispiel

      def process_query(query):
    # Use NLP to extract key information from the user's query
    processed_query = nlp(query)
    return processed_query
  4. Benutzerfeedback-Integration:
    • Sammeln Sie Benutzerfeedback zu den bereitgestellten Empfehlungen und nutzen Sie es, um zukünftige Relevanzbewertungen anzupassen.

    • Beispiel

      def adjust_based_on_feedback(feedback, items):
    for item in items:
        if item['name'] in feedback['liked']:
            item['relevance'] += 1
        if item['name'] in feedback['disliked']:
            item['relevance'] -= 1
    return items

Beispiel: Bewertung der Relevanz im Reiseberater

Hier ist ein praktisches Beispiel dafür, wie der Reiseberater die Relevanz von Reiseempfehlungen bewerten kann.

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
        itinerary = create_itinerary(flights, ranked_hotels, attractions)
        return itinerary

    def filter_and_rank(self, items, query):
        ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
        return ranked_items[:10]  # Return top 10 relevant items

    def relevance_score(self, item, query):
        score = 0
        if item['category'] in query['interests']:
            score += 1
        if item['price'] <= query['budget']:
            score += 1
        if item['location'] == query['destination']:
            score += 1
        return score

    def adjust_based_on_feedback(self, feedback, items):
        for item in items:
            if item['name'] in feedback['liked']:
                item['relevance'] += 1
            if item['name'] in feedback['disliked']:
                item['relevance'] -= 1
        return items

# Example usage
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

Suchen mit Absicht

Suchen mit Absicht bedeutet, den zugrunde liegenden Zweck oder das Ziel hinter einer Benutzeranfrage zu verstehen und zu interpretieren, um die relevantesten und nützlichsten Informationen abzurufen und zu generieren. Dieser Ansatz geht über die reine Keyword-Übereinstimmung hinaus und konzentriert sich auf das Erfassen der tatsächlichen Bedürfnisse und des Kontexts des Benutzers.

Schlüsselkonzepte beim Suchen mit Absicht

  1. Verstehen der Benutzerabsicht:
    • Benutzerabsichten können in drei Haupttypen eingeteilt werden: informativ, navigierend und transaktional.
      • Informative Absicht: Der Benutzer sucht nach Informationen zu einem Thema (z. B. „Was sind die besten Museen in Paris?“).
      • Navigational Absicht: Der Benutzer möchte zu einer bestimmten Website oder Seite navigieren (z. B. „Offizielle Website des Louvre-Museums“).
      • Transaktionale Absicht: Der Benutzer beabsichtigt, eine Transaktion durchzuführen, z. B. einen Flug zu buchen oder einen Kauf zu tätigen (z. B. „Flug nach Paris buchen“).
  2. Kontextbewusstsein:
    • Die Analyse des Kontexts der Benutzeranfrage hilft bei der genauen Identifizierung ihrer Absicht. Dies beinhaltet die Berücksichtigung früherer Interaktionen, Benutzereinstellungen und der spezifischen Details der aktuellen Anfrage.
  3. Natural Language Processing (NLP):
    • NLP-Techniken werden eingesetzt, um die von Benutzern bereitgestellten natürlichsprachlichen Anfragen zu verstehen und zu interpretieren. Dies beinhaltet Aufgaben wie Entitätenerkennung, Sentimentanalyse und Anfrage-Parsing.
  4. Personalisierung:
    • Die Personalisierung von Suchergebnissen basierend auf der Historie, den Präferenzen und dem Feedback des Benutzers verbessert die Relevanz der abgerufenen Informationen.

Praktisches Beispiel: Suchen mit Absicht im Reiseberater

Nehmen wir Travel Agent als Beispiel, um zu sehen, wie Suchen mit Absicht implementiert werden kann.

  1. Benutzerpräferenzen sammeln

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Verstehen der Benutzerabsicht

    def identify_intent(query):
    if "book" in query or "purchase" in query:
        return "transactional"
    elif "website" in query or "official" in query:
        return "navigational"
    else:
        return "informational"

  3. Kontextbewusstsein

    def analyze_context(query, user_history):
    # Combine current query with user history to understand context
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

  4. Ergebnisse suchen und personalisieren

    def search_with_intent(query, preferences, user_history):
    intent = identify_intent(query)
    context = analyze_context(query, user_history)
    if intent == "informational":
        search_results = search_information(query, preferences)
    elif intent == "navigational":
        search_results = search_navigation(query)
    elif intent == "transactional":
        search_results = search_transaction(query, preferences)
    personalized_results = personalize_results(search_results, user_history)
    return personalized_results

def search_information(query, preferences):
    # Example search logic for informational intent
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # Example search logic for navigational intent
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # Example search logic for transactional intent
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # Example personalization logic
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # Return top 10 personalized results

  5. Beispielhafte Verwendung

    travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
user_history = ["Louvre Museum website", "Book flight to Paris"]
query = "best museums in Paris"
results = search_with_intent(query, preferences, user_history)
print("Search Results:", results)

4. Code als Werkzeug generieren

Code-generierende Agenten nutzen KI-Modelle, um Code zu schreiben und auszuführen, komplexe Probleme zu lösen und Aufgaben zu automatisieren.

Code-generierende Agenten

Code-generierende Agenten nutzen generative KI-Modelle, um Code zu schreiben und auszuführen. Diese Agenten können komplexe Probleme lösen, Aufgaben automatisieren und wertvolle Einblicke liefern, indem sie Code in verschiedenen Programmiersprachen generieren und ausführen.

Praktische Anwendungen

  1. Automatisierte Code-Generierung: Generieren Sie Code-Schnipsel für bestimmte Aufgaben, wie z. B. Datenanalyse, Web-Scraping oder maschinelles Lernen.
  2. SQL als RAG: Verwenden Sie SQL-Abfragen, um Daten aus Datenbanken abzurufen und zu manipulieren.
  3. Problemlösung: Erstellen und Ausführen von Code zur Lösung spezifischer Probleme, wie z. B. Optimierung von Algorithmen oder Datenanalyse.

Beispiel: Code-generierender Agent für Datenanalyse

Stellen Sie sich vor, Sie entwerfen einen Code-generierenden Agenten. Hier ist, wie er funktionieren könnte.

  1. Aufgabe: Analysieren Sie einen Datensatz, um Trends und Muster zu identifizieren.
  2. Schritte:
    • Laden Sie den Datensatz in ein Datenanalysewerkzeug.
    • Generieren Sie SQL-Abfragen, um die Daten zu filtern und zu aggregieren.
    • Führen Sie die Abfragen aus und rufen Sie die Ergebnisse ab.
    • Nutzen Sie die Ergebnisse, um Visualisierungen und Erkenntnisse zu generieren.
  3. Benötigte Ressourcen: Zugriff auf den Datensatz, Datenanalysewerkzeuge und SQL-Fähigkeiten.
  4. Erfahrung: Nutzen Sie vergangene Analyseergebnisse, um die Genauigkeit und Relevanz zukünftiger Analysen zu verbessern.

Beispiel: Code-generierende Agent für Reisebüro

In diesem Beispiel entwerfen wir einen Code-generierenden Agenten, das Reisebüro, um Benutzer bei der Reiseplanung zu unterstützen, indem es Code generiert und ausführt. Dieser Agent kann Aufgaben wie das Abrufen von Reiseoptionen, das Filtern von Ergebnissen und das Zusammenstellen einer Reiseroute mithilfe generativer KI übernehmen.

Übersicht des Code-generierenden Agenten

  1. Sammeln von Benutzereinstellungen: Sammelt Benutzereingaben wie Reiseziel, Reisedaten, Budget und Interessen.
  2. Generieren von Code zum Abrufen von Daten: Generiert Code-Schnipsel zum Abrufen von Daten über Flüge, Hotels und Attraktionen.
  3. Ausführen von generiertem Code: Führt den generierten Code aus, um Echtzeitinformationen abzurufen.
  4. Generieren von Reiseroute: Fasst die abgerufenen Daten in einem personalisierten Reiseplan zusammen.
  5. Anpassung basierend auf Feedback: Empfängt Benutzerfeedback und generiert bei Bedarf Code neu, um die Ergebnisse zu verfeinern.

Schrittweise Implementierung

  1. Benutzerpräferenzen sammeln

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Generieren von Code zum Abrufen von Daten

    def generate_code_to_fetch_data(preferences):
    # Example: Generate code to search for flights based on user preferences
    code = f"""
    def search_flights():
        import requests
        response = requests.get('https://api.example.com/flights', params={preferences})
        return response.json()
    """
    return code

def generate_code_to_fetch_hotels(preferences):
    # Example: Generate code to search for hotels
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

  3. Ausführen von generiertem Code

    def execute_code(code):
    # Execute the generated code using exec
    exec(code)
    result = locals()
    return result

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
   
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
   
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)

print("Flight Options:", flights)
print("Hotel Options:", hotels)

  4. Generieren von Reiseroute

    def generate_itinerary(flights, hotels, attractions):
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

attractions = search_attractions(preferences)
itinerary = generate_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

  5. Anpassung basierend auf Feedback

    def adjust_based_on_feedback(feedback, preferences):
    # Adjust preferences based on user feedback
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
   
# Regenerate and execute code with updated preferences
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
   
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
   
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

Umweltbewusstsein und Schlussfolgerungen nutzen

Basierend auf dem Schema der Tabelle kann der Abfragegenerierungsprozess durch die Nutzung von Umweltbewusstsein und Schlussfolgerungen tatsächlich verbessert werden.

Hier ist ein Beispiel dafür, wie dies geschehen kann

  1. Verständnis des Schemas: Das System versteht das Schema der Tabelle und nutzt diese Informationen, um die Abfragegenerierung zu verankern.
  2. Anpassung basierend auf Feedback: Das System passt Benutzereinstellungen basierend auf Feedback an und leitet daraus ab, welche Felder im Schema aktualisiert werden müssen.
  3. Generieren und Ausführen von Abfragen: Das System generiert und führt Abfragen aus, um aktualisierte Flug- und Hoteldaten basierend auf den neuen Präferenzen abzurufen.

Hier ist ein aktualisiertes Python-Codebeispiel, das diese Konzepte integriert

def adjust_based_on_feedback(feedback, preferences, schema):
    # Adjust preferences based on user feedback
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # Reasoning based on schema to adjust other related preferences
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # Custom logic to adjust preferences based on schema and feedback
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # Generate code to fetch flight data based on updated preferences
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # Generate code to fetch hotel data based on updated preferences
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # Simulate execution of code and return mock data
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # Generate itinerary based on flights, hotels, and attractions
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# Example schema
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# Example usage
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# Regenerate and execute code with updated preferences
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

Erklärung – Buchung basierend auf Feedback

  1. Schema-Bewusstsein: Das Wörterbuch schema definiert, wie Präferenzen basierend auf Feedback angepasst werden sollen. Es enthält Felder wie favorites und avoid mit entsprechenden Anpassungen.
  2. Anpassen von Präferenzen (Methode adjust_based_on_feedback): Diese Methode passt Präferenzen basierend auf Benutzerfeedback und dem Schema an.
  3. Umweltbasierte Anpassungen (Methode adjust_based_on_environment): Diese Methode passt die Anpassungen basierend auf dem Schema und dem Feedback an.
  4. Generieren und Ausführen von Abfragen: Das System generiert Code zum Abrufen aktualisierter Flug- und Hoteldaten basierend auf den angepassten Präferenzen und simuliert die Ausführung dieser Abfragen.
  5. Generieren von Reiseroute: Das System erstellt eine aktualisierte Reiseroute basierend auf den neuen Flug-, Hotel- und Attraktionsdaten.

Indem das System umweltbewusst gemacht und basierend auf dem Schema Schlussfolgerungen gezogen werden, kann es genauere und relevantere Abfragen generieren, was zu besseren Reiseempfehlungen und einer personalisierteren Benutzererfahrung führt.

Verwendung von SQL als Retrieval-Augmented Generation (RAG)-Technik

SQL (Structured Query Language) ist ein leistungsstarkes Werkzeug für die Interaktion mit Datenbanken. Wenn es als Teil eines Retrieval-Augmented Generation (RAG)-Ansatzes verwendet wird, kann SQL relevante Daten aus Datenbanken abrufen, um Antworten oder Aktionen in KI-Agenten zu informieren und zu generieren. Lassen Sie uns untersuchen, wie SQL als RAG-Technik im Kontext des Reisebüros verwendet werden kann.

Schlüsselkonzepte

  1. Datenbankinteraktion:
    • SQL wird verwendet, um Datenbanken abzufragen, relevante Informationen abzurufen und Daten zu manipulieren.
    • Beispiel: Abrufen von Flugdetails, Hotelinformationen und Attraktionen aus einer Reisedatenbank.
  2. Integration mit RAG:
    • SQL-Abfragen werden basierend auf Benutzereingaben und Präferenzen generiert.
    • Die abgerufenen Daten werden dann verwendet, um personalisierte Empfehlungen oder Aktionen zu generieren.
  3. Dynamische Abfragegenerierung:
    • Der KI-Agent generiert dynamische SQL-Abfragen basierend auf dem Kontext und den Benutzerbedürfnissen.
    • Beispiel: Anpassen von SQL-Abfragen zum Filtern von Ergebnissen basierend auf Budget, Daten und Interessen.

Anwendungen

Beispiel: Ein Datenanalyse-Agent

  1. Aufgabe: Analyse eines Datensatzes zur Ermittlung von Trends.
  2. Schritte:
    • Laden des Datensatzes.
    • Generieren von SQL-Abfragen zum Filtern von Daten.
    • Ausführen von Abfragen und Abrufen von Ergebnissen.
    • Generieren von Visualisierungen und Einblicken.
  3. Ressourcen: Zugriff auf Datensätze, SQL-Funktionen.
  4. Erfahrung: Nutzen Sie vergangene Ergebnisse, um zukünftige Analysen zu verbessern.

Praktisches Beispiel: Verwendung von SQL im Reisebüro

  1. Benutzerpräferenzen sammeln

    class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

  2. Generieren von SQL-Abfragen

    def generate_sql_query(table, preferences):
    query = f"SELECT * FROM {table} WHERE "
    conditions = []
    for key, value in preferences.items():
        conditions.append(f"{key}='{value}'")
    query += " AND ".join(conditions)
    return query

  3. Ausführen von SQL-Abfragen

    import sqlite3

def execute_sql_query(query, database="travel.db"):
    connection = sqlite3.connect(database)
    cursor = connection.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    connection.close()
    return results

  4. Generieren von Empfehlungen

    def generate_recommendations(preferences):
    flight_query = generate_sql_query("flights", preferences)
    hotel_query = generate_sql_query("hotels", preferences)
    attraction_query = generate_sql_query("attractions", preferences)
       
    flights = execute_sql_query(flight_query)
    hotels = execute_sql_query(hotel_query)
    attractions = execute_sql_query(attraction_query)
       
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = generate_recommendations(preferences)
print("Suggested Itinerary:", itinerary)

Beispiel-SQL-Abfragen

  1. Flugabfrage

    SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

  2. Hotelabfrage

    SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

  3. Attraktionsabfrage

    SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

Durch die Nutzung von SQL als Teil der Retrieval-Augmented Generation (RAG)-Technik können KI-Agenten wie das Reisebüro dynamisch relevante Daten abrufen und nutzen, um genaue und personalisierte Empfehlungen zu geben.

Beispiel für Metakognition

Um eine Implementierung von Metakognition zu demonstrieren, erstellen wir einen einfachen Agenten, der über seinen Entscheidungsprozess reflektiert, während er ein Problem löst. In diesem Beispiel bauen wir ein System, bei dem ein Agent versucht, die Wahl eines Hotels zu optimieren, dann aber seine eigene Argumentation bewertet und seine Strategie anpasst, wenn er Fehler macht oder suboptimale Entscheidungen trifft.

Wir simulieren dies anhand eines einfachen Beispiels, bei dem der Agent Hotels basierend auf einer Kombination aus Preis und Qualität auswählt, aber er wird über seine Entscheidungen „reflektieren“ und sich entsprechend anpassen.

Wie dies Metakognition illustriert

  1. Erste Entscheidung: Der Agent wählt das günstigste Hotel aus, ohne die Auswirkung auf die Qualität zu berücksichtigen.
  2. Reflexion und Bewertung: Nach der ersten Wahl prüft der Agent anhand von Benutzerfeedback, ob das Hotel eine „schlechte“ Wahl ist. Wenn er feststellt, dass die Qualität des Hotels zu niedrig war, reflektiert er seine Argumentation.
  3. Anpassung der Strategie: Der Agent passt seine Strategie basierend auf seiner Reflexion an und wechselt von „günstigster“ zu „höchster_qualität“, wodurch sein Entscheidungsprozess in zukünftigen Iterationen verbessert wird.

Hier ist ein Beispiel

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # Stores the hotels chosen previously
        self.corrected_choices = []  # Stores the corrected choices
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # Available strategies

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # Let's assume we have some user feedback that tells us whether the last choice was good or not
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # Adjust strategy if the previous choice was unsatisfactory
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# Simulate a list of hotels (price and quality)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# Create an agent
agent = HotelRecommendationAgent()

# Step 1: The agent recommends a hotel using the "cheapest" strategy
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# Step 2: The agent reflects on the choice and adjusts strategy if necessary
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# Step 3: The agent recommends again, this time using the adjusted strategy
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

Metakognitive Fähigkeiten von Agenten

Der Schlüssel hier ist die Fähigkeit des Agenten,

Dies ist eine einfache Form der Metakognition, bei der das System in der Lage ist, seinen Denkprozess basierend auf internem Feedback anzupassen.

Fazit

Metakognition ist ein mächtiges Werkzeug, das die Fähigkeiten von KI-Agenten erheblich verbessern kann. Durch die Einbeziehung metakognitiver Prozesse können Sie Agenten entwickeln, die intelligenter, anpassungsfähiger und effizienter sind. Nutzen Sie die zusätzlichen Ressourcen, um die faszinierende Welt der Metakognition in KI-Agenten weiter zu erkunden.

Haben Sie weitere Fragen zum Metacognition-Designmuster?

Treten Sie dem Azure AI Foundry Discord bei, um andere Lernende zu treffen, Sprechstunden zu besuchen und Ihre Fragen zu KI-Agenten beantwortet zu bekommen.

Vorherige Lektion

Multi-Agenten-Entwurfsmuster

Nächste Lektion

KI-Agenten in Produktion

Diese Seite ist Open Source. Verbessern Sie diese Seite.