# Einführung in KI-Agenten und deren Anwendungsfälle

Willkommen zum Kurs "KI-Agenten für Anfänger"! Dieser Kurs vermittelt Ihnen grundlegendes Wissen und praktische Beispiele für die Arbeit mit KI-Agenten.

Treten Sie der [Azure AI Discord Community](https://discord.gg/kzRShWzttr) bei, um andere Lernende und Entwickler von KI-Agenten kennenzulernen und alle Fragen zu diesem Kurs zu stellen.

Zu Beginn des Kurses verschaffen wir uns zunächst ein besseres Verständnis darüber, was KI-Agenten sind und wie wir sie in den Anwendungen und Arbeitsabläufen, die wir entwickeln, einsetzen können.

## Einführung

Diese Lektion behandelt:

- Was sind KI-Agenten und welche Arten von Agenten gibt es?
- Für welche Anwendungsfälle eignen sich KI-Agenten besonders, und wie können sie uns helfen?
- Was sind die grundlegenden Bausteine beim Entwerfen agentenbasierter Lösungen?

## Lernziele
Nach Abschluss dieser Lektion sollten Sie in der Lage sein:

- Die Konzepte von KI-Agenten zu verstehen und zu erkennen, wie sie sich von anderen KI-Lösungen unterscheiden.
- KI-Agenten effizient einzusetzen.
- Agentenbasierte Lösungen produktiv für Benutzer und Kunden zu entwerfen.

## Definition von KI-Agenten und Typen von KI-Agenten

### Was sind KI-Agenten?

KI-Agenten sind **Systeme**, die es **Großen Sprachmodellen (LLMs)** ermöglichen, **Aktionen auszuführen**, indem sie deren Fähigkeiten erweitern und ihnen **Zugang zu Werkzeugen** und **Wissen** geben.

Lassen Sie uns diese Definition in kleinere Teile zerlegen:

- **System** – Es ist wichtig, Agenten nicht nur als eine einzelne Komponente zu betrachten, sondern als ein System aus vielen Komponenten. Auf der grundlegenden Ebene bestehen die Komponenten eines KI-Agenten aus:
  - **Umgebung** – Der definierte Raum, in dem der KI-Agent arbeitet. Zum Beispiel könnte die Umgebung eines Reisebuchungs-Agenten das Buchungssystem sein, das der Agent verwendet, um Aufgaben zu erledigen.
  - **Sensoren** – Umgebungen enthalten Informationen und geben Rückmeldungen. KI-Agenten nutzen Sensoren, um diese Informationen über den aktuellen Zustand der Umgebung zu sammeln und zu interpretieren. Im Beispiel des Reisebuchungs-Agenten könnte das Buchungssystem Informationen wie Hotelverfügbarkeit oder Flugpreise liefern.
  - **Aktuatoren** – Sobald der KI-Agent den aktuellen Zustand der Umgebung erhält, entscheidet er, welche Aktion für die jeweilige Aufgabe ausgeführt werden soll, um die Umgebung zu verändern. Im Fall des Reisebuchungs-Agenten könnte dies bedeuten, ein verfügbares Zimmer für den Benutzer zu buchen.

![Was sind KI-Agenten?](../../../translated_images/what-are-ai-agents.125520f55950b252a429b04a9f41e0152d4dafa1f1bd9081f4f574631acb759e.de.png?WT.mc_id=academic-105485-koreyst)

**Große Sprachmodelle** – Das Konzept von Agenten existierte bereits vor der Entwicklung von LLMs. Der Vorteil beim Aufbau von KI-Agenten mit LLMs liegt in ihrer Fähigkeit, menschliche Sprache und Daten zu interpretieren. Diese Fähigkeit ermöglicht es LLMs, Umgebungsinformationen zu verstehen und einen Plan zur Veränderung der Umgebung zu definieren.

**Aktionen ausführen** – Außerhalb von KI-Agenten-Systemen sind LLMs darauf beschränkt, Inhalte oder Informationen basierend auf einer Benutzereingabe zu generieren. Innerhalb von KI-Agenten-Systemen können LLMs Aufgaben ausführen, indem sie die Anfrage des Benutzers interpretieren und die in ihrer Umgebung verfügbaren Werkzeuge nutzen.

**Zugang zu Werkzeugen** – Welche Werkzeuge dem LLM zur Verfügung stehen, wird durch 1) die Umgebung, in der es arbeitet, und 2) den Entwickler des KI-Agenten definiert. Im Beispiel des Reisebuchungs-Agenten sind die Werkzeuge des Agenten durch die im Buchungssystem verfügbaren Operationen begrenzt, oder der Entwickler kann den Zugriff des Agenten auf bestimmte Werkzeuge wie Flüge beschränken.

**Wissen** – Neben den Informationen, die von der Umgebung bereitgestellt werden, können KI-Agenten auch Wissen aus anderen Systemen, Diensten, Werkzeugen und sogar anderen Agenten abrufen. Im Beispiel des Reisebuchungs-Agenten könnte dieses Wissen Informationen über die Reisevorlieben des Benutzers aus einer Kundendatenbank umfassen.

### Die verschiedenen Arten von Agenten

Nachdem wir eine allgemeine Definition von KI-Agenten haben, betrachten wir nun einige spezifische Agententypen und wie sie auf einen Reisebuchungs-Agenten angewendet werden könnten.

| **Agententyp**                | **Beschreibung**                                                                                | **Beispiel**                                                                                |
| ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Einfache Reflex-Agenten**   | Führen sofortige Aktionen basierend auf vordefinierten Regeln aus.                                                                     | Der Reiseagent interpretiert den Kontext einer E-Mail und leitet Beschwerden über Reisen an den Kundenservice weiter.                                                                                |
| **Modellbasierte Reflex-Agenten** | Führen Aktionen basierend auf einem Modell der Welt und dessen Veränderungen aus.                                                     | Der Reiseagent priorisiert Routen mit signifikanten Preisänderungen, basierend auf Zugriff auf historische Preisdaten.                                                                                |
| **Zielorientierte Agenten**   | Erstellen Pläne, um bestimmte Ziele zu erreichen, indem sie das Ziel interpretieren und Aktionen bestimmen, um es zu erreichen.         | Der Reiseagent bucht eine Reise, indem er die notwendigen Reisevorkehrungen (Auto, öffentliche Verkehrsmittel, Flüge) vom aktuellen Standort bis zum Zielort ermittelt.                                                        |
| **Nutzenbasierte Agenten**    | Berücksichtigen Präferenzen und wägen numerische Kompromisse ab, um Ziele zu erreichen.                                                | Der Reiseagent maximiert den Nutzen, indem er Bequemlichkeit gegenüber Kosten abwägt, wenn er Reisen bucht.                                                                                |
| **Lernende Agenten**          | Verbessern sich im Laufe der Zeit, indem sie auf Feedback reagieren und ihre Aktionen entsprechend anpassen.                           | Der Reiseagent verbessert sich, indem er Kundenfeedback aus Nach-Reise-Umfragen nutzt, um zukünftige Buchungen anzupassen.                                                                                |
| **Hierarchische Agenten**     | Bestehen aus mehreren Agenten in einem gestuften System, wobei höherstufige Agenten Aufgaben in Unteraufgaben für niedrigerstufige Agenten aufteilen. | Der Reiseagent storniert eine Reise, indem er die Aufgabe in Unteraufgaben aufteilt (z. B. spezifische Buchungen stornieren) und niedrigere Agenten diese ausführen lässt, die wiederum an den höherstufigen Agenten berichten. |
| **Multi-Agenten-Systeme (MAS)** | Agenten erledigen Aufgaben unabhängig, entweder kooperativ oder im Wettbewerb.                                                         | Kooperativ: Mehrere Agenten buchen spezifische Reisedienstleistungen wie Hotels, Flüge und Unterhaltung. Wettbewerbsorientiert: Mehrere Agenten verwalten und konkurrieren um einen gemeinsamen Hotelbuchungskalender, um Kunden in das Hotel einzubuchen.             |

## Wann sollten KI-Agenten eingesetzt werden?

Im vorherigen Abschnitt haben wir das Beispiel eines Reisebuchungs-Agenten genutzt, um zu erklären, wie verschiedene Agententypen in unterschiedlichen Szenarien eingesetzt werden können. Dieses Anwendungsbeispiel wird im gesamten Kurs weiterverwendet.

Schauen wir uns die Arten von Anwendungsfällen an, für die sich KI-Agenten am besten eignen:

![Wann sollten KI-Agenten eingesetzt werden?](../../../translated_images/when-to-use-ai-agents.912b9a02e9e0e2af45a3e24faa4e912e334ec23f21f0cf5cb040b7e899b09cd0.de.png?WT.mc_id=academic-105485-koreyst)

- **Offene Problemstellungen** – Ermöglicht dem LLM, die notwendigen Schritte zur Erledigung einer Aufgabe zu bestimmen, da diese nicht immer fest in einen Arbeitsablauf programmiert werden können.
- **Mehrstufige Prozesse** – Aufgaben, die ein gewisses Maß an Komplexität erfordern, bei denen der KI-Agent Werkzeuge oder Informationen über mehrere Schritte hinweg nutzen muss, anstatt sie in einem einzigen Schritt abzurufen.
- **Verbesserung über Zeit** – Aufgaben, bei denen der Agent durch Feedback aus seiner Umgebung oder von Benutzern im Laufe der Zeit besser werden kann, um einen höheren Nutzen zu bieten.

Weitere Überlegungen zum Einsatz von KI-Agenten behandeln wir in der Lektion "Vertrauenswürdige KI-Agenten entwickeln".

## Grundlagen agentenbasierter Lösungen

### Entwicklung von Agenten

Der erste Schritt bei der Gestaltung eines KI-Agenten-Systems besteht darin, die Werkzeuge, Aktionen und Verhaltensweisen zu definieren. In diesem Kurs konzentrieren wir uns auf die Verwendung des **Azure AI Agent Service**, um unsere Agenten zu definieren. Dieser bietet Funktionen wie:

- Auswahl offener Modelle wie OpenAI, Mistral und Llama
- Nutzung lizenzierter Daten durch Anbieter wie Tripadvisor
- Verwendung standardisierter OpenAPI 3.0-Werkzeuge

### Agentenbasierte Muster

Die Kommunikation mit LLMs erfolgt über Prompts. Aufgrund der halbautonomen Natur von KI-Agenten ist es nicht immer möglich oder notwendig, das LLM manuell nach jeder Veränderung in der Umgebung erneut zu prompten. Wir verwenden **agentenbasierte Muster**, die es uns ermöglichen, das LLM über mehrere Schritte hinweg auf skalierbare Weise zu prompten.

Dieser Kurs ist in einige der derzeit populären agentenbasierten Muster unterteilt.

### Agentenbasierte Frameworks

Agentenbasierte Frameworks ermöglichen es Entwicklern, agentenbasierte Muster durch Code zu implementieren. Diese Frameworks bieten Vorlagen, Plugins und Werkzeuge für eine bessere Zusammenarbeit von KI-Agenten. Diese Vorteile ermöglichen eine bessere Beobachtbarkeit und Fehlerbehebung in KI-Agenten-Systemen.

In diesem Kurs werden wir das forschungsgetriebene AutoGen-Framework sowie das produktionsreife Agent-Framework von Semantic Kernel erkunden.

**Haftungsausschluss**:
Dieses Dokument wurde mit KI-gestützten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir haften nicht für Missverständnisse oder Fehlinterpretationen, die durch die Nutzung dieser Übersetzung entstehen.


```markdown
# Erforsche KI-Agenten-Frameworks

KI-Agenten-Frameworks sind Softwareplattformen, die die Erstellung, Bereitstellung und Verwaltung von KI-Agenten vereinfachen sollen. Diese Frameworks bieten Entwicklern vorgefertigte Komponenten, Abstraktionen und Werkzeuge, die die Entwicklung komplexer KI-Systeme beschleunigen.

Diese Frameworks helfen Entwicklern, sich auf die einzigartigen Aspekte ihrer Anwendungen zu konzentrieren, indem sie standardisierte Ansätze für häufige Herausforderungen in der KI-Agenten-Entwicklung bereitstellen. Sie verbessern die Skalierbarkeit, Zugänglichkeit und Effizienz beim Aufbau von KI-Systemen.

## Einführung

Diese Lektion behandelt:

- Was sind KI-Agenten-Frameworks und was ermöglichen sie Entwicklern?
- Wie können Teams diese Frameworks nutzen, um schnell Prototypen zu erstellen, zu iterieren und die Fähigkeiten meiner Agenten zu verbessern?
- Welche Unterschiede gibt es zwischen den von Microsoft entwickelten Frameworks und Tools ([Autogen](https://aka.ms/ai-agents/autogen) / [Semantic Kernel](https://aka.ms/ai-agents-beginners/semantic-kernel) / [Azure AI Agent Service](https://aka.ms/ai-agents-beginners/ai-agent-service))?
- Kann ich meine bestehenden Azure-Ökosystem-Tools direkt integrieren, oder benötige ich eigenständige Lösungen?
- Was ist der Azure AI Agent Service und wie unterstützt er mich?

## Lernziele

Die Ziele dieser Lektion sind:

- Die Rolle von KI-Agenten-Frameworks in der KI-Entwicklung zu verstehen.
- Wie man KI-Agenten-Frameworks einsetzt, um intelligente Agenten zu entwickeln.
- Die wichtigsten Funktionen, die durch KI-Agenten-Frameworks ermöglicht werden.
- Die Unterschiede zwischen Autogen, Semantic Kernel und Azure AI Agent Service.

## Was sind KI-Agenten-Frameworks und was ermöglichen sie Entwicklern?

Traditionelle KI-Frameworks können dabei helfen, KI in Apps zu integrieren und diese Apps auf folgende Weise zu verbessern:

- **Personalisierung**: KI kann das Nutzerverhalten und die Vorlieben analysieren, um personalisierte Empfehlungen, Inhalte und Erlebnisse zu bieten.
Beispiel: Streaming-Dienste wie Netflix nutzen KI, um Filme und Serien basierend auf der Seh-Historie vorzuschlagen, was die Nutzerbindung und Zufriedenheit erhöht.
- **Automatisierung und Effizienz**: KI kann repetitive Aufgaben automatisieren, Arbeitsabläufe optimieren und die betriebliche Effizienz steigern.
Beispiel: Kundenservice-Apps nutzen KI-gestützte Chatbots, um häufige Anfragen zu bearbeiten, wodurch Antwortzeiten verkürzt und menschliche Mitarbeiter für komplexere Probleme freigestellt werden.
- **Verbesserte Nutzererfahrung**: KI kann die allgemeine Nutzererfahrung verbessern, indem sie intelligente Funktionen wie Spracherkennung, natürliche Sprachverarbeitung und prädiktiven Text bereitstellt.
Beispiel: Virtuelle Assistenten wie Siri und Google Assistant nutzen KI, um Sprachbefehle zu verstehen und darauf zu reagieren, was die Interaktion der Nutzer mit ihren Geräten erleichtert.

### Klingt großartig, oder? Warum brauchen wir dann KI-Agenten-Frameworks?

KI-Agenten-Frameworks gehen über herkömmliche KI-Frameworks hinaus. Sie sind darauf ausgelegt, die Erstellung intelligenter Agenten zu ermöglichen, die mit Nutzern, anderen Agenten und der Umgebung interagieren können, um spezifische Ziele zu erreichen. Diese Agenten können autonomes Verhalten zeigen, Entscheidungen treffen und sich an veränderte Bedingungen anpassen. Werfen wir einen Blick auf einige der wichtigsten Funktionen, die durch KI-Agenten-Frameworks ermöglicht werden:

- **Zusammenarbeit und Koordination von Agenten**: Ermöglicht die Erstellung mehrerer KI-Agenten, die zusammenarbeiten, kommunizieren und koordiniert komplexe Aufgaben lösen können.
- **Automatisierung und Verwaltung von Aufgaben**: Bietet Mechanismen zur Automatisierung mehrstufiger Arbeitsabläufe, zur Aufgabenverteilung und zum dynamischen Aufgabenmanagement zwischen Agenten.
- **Kontextuelles Verständnis und Anpassung**: Rüstet Agenten mit der Fähigkeit aus, Kontext zu verstehen, sich an sich verändernde Umgebungen anzupassen und Entscheidungen auf Basis von Echtzeitinformationen zu treffen.

Zusammenfassend lässt sich sagen, dass Agenten es ermöglichen, mehr zu leisten, Automatisierung auf die nächste Stufe zu heben und intelligentere Systeme zu schaffen, die sich an ihre Umgebung anpassen und aus ihr lernen können.

## Wie kann man die Fähigkeiten eines Agenten schnell prototypisieren, iterieren und verbessern?

Dies ist ein schnelllebiges Feld, aber es gibt einige Gemeinsamkeiten, die die meisten KI-Agenten-Frameworks bieten, um Prototypen schnell zu erstellen und zu iterieren. Dazu gehören modulare Komponenten, kollaborative Werkzeuge und Echtzeitlernen. Schauen wir uns diese genauer an:

- **Modulare Komponenten nutzen**: KI-Frameworks bieten vorgefertigte Komponenten wie Prompts, Parser und Speichermanagement.
- **Kollaborative Werkzeuge einsetzen**: Agenten mit spezifischen Rollen und Aufgaben entwerfen, um kollaborative Arbeitsabläufe zu testen und zu verfeinern.
- **In Echtzeit lernen**: Feedback-Schleifen implementieren, bei denen Agenten aus Interaktionen lernen und ihr Verhalten dynamisch anpassen.

### Modulare Komponenten nutzen

Frameworks wie LangChain und Microsoft Semantic Kernel bieten vorgefertigte Komponenten wie Prompts, Parser und Speichermanagement.

**Wie Teams diese nutzen können**: Teams können diese Komponenten schnell zusammenfügen, um einen funktionalen Prototyp zu erstellen, ohne von Grund auf neu beginnen zu müssen. Dies ermöglicht schnelles Experimentieren und Iterieren.

**Wie es in der Praxis funktioniert**: Sie können einen vorgefertigten Parser verwenden, um Informationen aus Benutzereingaben zu extrahieren, ein Speichermodul zum Speichern und Abrufen von Daten und einen Prompt-Generator, um mit Benutzern zu interagieren – alles ohne diese Komponenten selbst entwickeln zu müssen.

**Beispielcode**. Schauen wir uns ein Beispiel an, wie ein vorgefertigter Parser verwendet werden kann, um Informationen aus Benutzereingaben zu extrahieren:

```python
from langchain import Parser

parser = Parser()
user_input = "Book a flight from New York to London on July 15th"

parsed_data = parser.parse(user_input)

print(parsed_data)
# Output: {'origin': 'New York', 'destination': 'London', 'date': 'July 15th'}
```

In diesem Beispiel sehen Sie, wie ein vorgefertigter Parser verwendet werden kann, um Schlüsselinformationen aus Benutzereingaben zu extrahieren, wie z. B. den Ursprung, das Ziel und das Datum einer Flugbuchungsanfrage. Dieser modulare Ansatz ermöglicht es, sich auf die übergeordnete Logik zu konzentrieren.

### Kollaborative Werkzeuge einsetzen

Frameworks wie CrewAI und Microsoft Autogen erleichtern die Erstellung mehrerer Agenten, die zusammenarbeiten können.

**Wie Teams diese nutzen können**: Teams können Agenten mit spezifischen Rollen und Aufgaben entwerfen, um kollaborative Arbeitsabläufe zu testen und zu verfeinern und die Gesamteffizienz des Systems zu verbessern.

**Wie es in der Praxis funktioniert**: Sie können ein Team von Agenten erstellen, bei dem jeder Agent eine spezialisierte Funktion hat, wie z. B. Datenabruf, Analyse oder Entscheidungsfindung. Diese Agenten können kommunizieren und Informationen austauschen, um ein gemeinsames Ziel zu erreichen, wie z. B. eine Benutzeranfrage zu beantworten oder eine Aufgabe abzuschließen.

**Beispielcode (Autogen)**:

```python
# creating agents, then create a round robin schedule where they can work together, in this case in order

# Data Retrieval Agent
# Data Analysis Agent
# Decision Making Agent

agent_retrieve = AssistantAgent(
    name="dataretrieval",
    model_client=model_client,
    tools=[retrieve_tool],
    system_message="Use tools to solve tasks."
)

agent_analyze = AssistantAgent(
    name="dataanalysis",
    model_client=model_client,
    tools=[analyze_tool],
    system_message="Use tools to solve tasks."
)

# conversation ends when user says "APPROVE"
termination = TextMentionTermination("APPROVE")

user_proxy = UserProxyAgent("user_proxy", input_func=input)

team = RoundRobinGroupChat([agent_retrieve, agent_analyze, user_proxy], termination_condition=termination)

stream = team.run_stream(task="Analyze data", max_turns=10)
# Use asyncio.run(...) when running in a script.
await Console(stream)
```

In diesem Code sehen Sie, wie eine Aufgabe erstellt wird, die mehrere Agenten einbezieht, die zusammenarbeiten, um Daten zu analysieren. Jeder Agent erfüllt eine spezifische Funktion, und die Aufgabe wird durch die Koordination der Agenten ausgeführt, um das gewünschte Ergebnis zu erzielen. Durch die Erstellung dedizierter Agenten mit spezialisierten Rollen können Sie die Effizienz und Leistung von Aufgaben verbessern.

### In Echtzeit lernen

Fortschrittliche Frameworks bieten Funktionen für kontextuelles Echtzeitverstehen und Anpassung.

**Wie Teams diese nutzen können**: Teams können Feedback-Schleifen implementieren, bei denen Agenten aus Interaktionen lernen und ihr Verhalten dynamisch anpassen, was zu einer kontinuierlichen Verbesserung und Verfeinerung der Fähigkeiten führt.

**Wie es in der Praxis funktioniert**: Agenten können Benutzerfeedback, Umweltdaten und Aufgabenergebnisse analysieren, um ihre Wissensbasis zu aktualisieren, Entscheidungsalgorithmen anzupassen und ihre Leistung im Laufe der Zeit zu verbessern. Dieser iterative Lernprozess ermöglicht es Agenten, sich an sich ändernde Bedingungen und Benutzerpräferenzen anzupassen, wodurch die Gesamteffektivität des Systems gesteigert wird.

## Was sind die Unterschiede zwischen den Frameworks Autogen, Semantic Kernel und Azure AI Agent Service?

Es gibt viele Möglichkeiten, diese Frameworks zu vergleichen, aber lassen Sie uns einige der wichtigsten Unterschiede in Bezug auf Design, Fähigkeiten und Zielanwendungen betrachten:

## Autogen

Ein Open-Source-Framework, entwickelt vom AI Frontiers Lab von Microsoft Research. Es konzentriert sich auf ereignisgesteuerte, verteilte *agentische* Anwendungen und ermöglicht mehrere LLMs, SLMs, Tools und fortgeschrittene Multi-Agent-Designmuster.

Autogen basiert auf dem Kernkonzept der Agenten, die autonome Einheiten sind, die ihre Umgebung wahrnehmen, Entscheidungen treffen und Aktionen ausführen können, um bestimmte Ziele zu erreichen. Agenten kommunizieren über asynchrone Nachrichten, was ihnen ermöglicht, unabhängig und parallel zu arbeiten, wodurch die Skalierbarkeit und Reaktionsfähigkeit des Systems verbessert wird.

Agenten basieren auf dem [Aktor-Modell](https://en.wikipedia.org/wiki/Actor_model). Laut Wikipedia ist ein Aktor _die grundlegende Baueinheit für parallele Berechnungen. Als Antwort auf eine empfangene Nachricht kann ein Aktor lokale Entscheidungen treffen, weitere Aktoren erstellen, weitere Nachrichten senden und bestimmen, wie auf die nächste empfangene Nachricht reagiert wird_.

**Anwendungsfälle**: Automatisierung von Code-Generierung, Datenanalyseaufgaben und Entwicklung maßgeschneiderter Agenten für Planungs- und Forschungsfunktionen.

Hier sind einige wichtige Kernkonzepte von Autogen:

- **Agenten**: Ein Agent ist eine Softwareeinheit, die:
  - **Über Nachrichten kommuniziert**, synchron oder asynchron.
  - **Einen eigenen Zustand aufrechterhält**, der durch eingehende Nachrichten geändert werden kann.
  - **Aktionen ausführt** als Reaktion auf empfangene Nachrichten oder Änderungen ihres Zustands.

  Hier ein kurzer Codeausschnitt, wie ein eigener Agent mit Chat-Fähigkeiten erstellt wird:

    ```python
    from autogen_agentchat.agents import AssistantAgent
    from autogen_agentchat.messages import TextMessage
    from autogen_ext.models.openai import OpenAIChatCompletionClient

    class MyAssistant(RoutedAgent):
        def __init__(self, name: str) -> None:
            super().__init__(name)
            model_client = OpenAIChatCompletionClient(model="gpt-4o")
            self._delegate = AssistantAgent(name, model_client=model_client)

        @message_handler
        async def handle_my_message_type(self, message: MyMessageType, ctx: MessageContext) -> None:
            print(f"{self.id.type} received message: {message.content}")
            response = await self._delegate.on_messages(
                [TextMessage(content=message.content, source="user")], ctx.cancellation_token
            )
            print(f"{self.id.type} responded: {response.chat_message.content}")
    ```

    In obigem Code ist `MyAssistant` has been created and inherits from `RoutedAgent`. It has a message handler that prints the content of the message and then sends a response using the `AssistantAgent` delegate. Especially note how we assign to `self._delegate` an instance of `AssistantAgent` ein vorgefertigter Agent, der Chat-Abschlüsse bearbeiten kann.

    Lassen Sie uns Autogen über diesen Agententyp informieren und das Programm starten:

    ```python

    # main.py
    runtime = SingleThreadedAgentRuntime()
    await MyAgent.register(runtime, "my_agent", lambda: MyAgent())

    runtime.start()  # Start processing messages in the background.
    await runtime.send_message(MyMessageType("Hello, World!"), AgentId("my_agent", "default"))
    ```

    Oben wird der Agent mit der Laufzeit registriert und dann eine Nachricht an den Agenten gesendet, was zu folgendem Ergebnis führt:

    ```text
    # Output from the console:
    my_agent received message: Hello, World!
    my_assistant received message: Hello, World!
    my_assistant responded: Hello! How can I assist you today?
    ```

- **Multi-Agenten**: Autogen unterstützt die Erstellung mehrerer Agenten, die zusammenarbeiten können, um komplexe Aufgaben zu lösen. Sie können unterschiedliche Typen von Agenten mit spezialisierten Funktionen und Rollen definieren, z. B. Datenabruf, Analyse, Entscheidungsfindung und Benutzerinteraktion. Sehen wir uns an, wie eine solche Erstellung aussieht:

    ```python
    editor_description = "Editor for planning and reviewing the content."

    # Example of declaring an Agent
    editor_agent_type = await EditorAgent.register(
    runtime,
    editor_topic_type,  # Using topic type as the agent type.
    lambda: EditorAgent(
        description=editor_description,
        group_chat_topic_type=group_chat_topic_type,
        model_client=OpenAIChatCompletionClient(
            model="gpt-4o-2024-08-06",
            # api_key="YOUR_API_KEY",
        ),
        ),
    )

    # remaining declarations shortened for brevity

    # Group chat
    group_chat_manager_type = await GroupChatManager.register(
    runtime,
    "group_chat_manager",
    lambda: GroupChatManager(
        participant_topic_types=[writer_topic_type, illustrator_topic_type, editor_topic_type, user_topic_type],
        model_client=OpenAIChatCompletionClient(
            model="gpt-4o-2024-08-06",
            # api_key="YOUR_API_KEY",
        ),
        participant_descriptions=[
            writer_description,
            illustrator_description,
            editor_description,
            user_description
        ],
        ),
    )
    ```

    Oben wird ein `GroupChatManager` mit der Laufzeit registriert. Dieser Manager ist für die Koordination der Interaktionen zwischen verschiedenen Agententypen wie Autoren, Illustratoren, Redakteuren und Nutzern verantwortlich.

- **Agenten-Laufzeit**: Das Framework bietet eine Laufzeitumgebung, die die Kommunikation zwischen Agenten ermöglicht, ihre Identitäten und Lebenszyklen verwaltet und Sicherheits- sowie Datenschutzgrenzen durchsetzt. Dies bedeutet, dass Sie Ihre Agenten in einer sicheren und kontrollierten Umgebung ausführen können, was eine sichere und effiziente Interaktion gewährleistet. Es gibt zwei interessante Laufzeiten:
  - **Standalone-Laufzeit**: Eine gute Wahl für Einzelprozessanwendungen, bei denen alle Agenten in derselben Programmiersprache implementiert und im selben Prozess ausgeführt werden. Hier ist eine Illustration, wie es funktioniert:

  ![Standalone-Laufzeit](https://microsoft.github.io/autogen/stable/_images/architecture-standalone.svg)
  *Agenten kommunizieren über Nachrichten durch die Laufzeit, und die Laufzeit verwaltet den Lebenszyklus der Agenten.*

  - **Verteilte Agenten-Laufzeit**: Geeignet für Multi-Prozess-Anwendungen, bei denen Agenten in verschiedenen Programmiersprachen implementiert und auf verschiedenen Maschinen ausgeführt werden können. Hier ist eine Illustration, wie es funktioniert:

  ![Verteilte Laufzeit](https://microsoft.github.io/autogen/stable/_images/architecture-distributed.svg)
```

basierend auf Projektzielen. Ideal für das Verständnis natürlicher Sprache und die Generierung von Inhalten. - **Azure AI Agent Service**: Flexible Modelle, unternehmenssichere Mechanismen, Daten-Speichermethoden. Ideal für die sichere, skalierbare und flexible Bereitstellung von KI-Agenten in Unternehmensanwendungen. ## Kann ich meine bestehenden Azure-Ökosystem-Tools direkt integrieren, oder benötige ich eigenständige Lösungen? Die Antwort ist ja, Sie können Ihre bestehenden Azure-Ökosystem-Tools direkt mit dem Azure AI Agent Service integrieren, insbesondere, da dieser nahtlos mit anderen Azure-Diensten zusammenarbeitet. Sie könnten beispielsweise Bing, Azure AI Search und Azure Functions integrieren. Es gibt auch eine tiefe Integration mit Azure AI Foundry. Für Autogen und Semantic Kernel können Sie ebenfalls mit Azure-Diensten integrieren, allerdings kann es erforderlich sein, die Azure-Dienste aus Ihrem Code aufzurufen. Eine weitere Möglichkeit zur Integration besteht darin, die Azure SDKs zu verwenden, um von Ihren Agenten aus mit Azure-Diensten zu interagieren. Außerdem, wie bereits erwähnt, können Sie den Azure AI Agent Service als Orchestrator für Ihre in Autogen oder Semantic Kernel erstellten Agenten verwenden, was einen einfachen Zugang zum Azure-Ökosystem ermöglicht. ## Referenzen - [1] - [Azure Agent Service](https://techcommunity.microsoft.com/blog/azure-ai-services-blog/introducing-azure-ai-agent-service/4298357) - [2] - [Semantic Kernel and Autogen](https://devblogs.microsoft.com/semantic-kernel/microsofts-agentic-ai-frameworks-autogen-and-semantic-kernel/) - [3] - [Semantic Kernel Agent Framework](https://learn.microsoft.com/semantic-kernel/frameworks/agent/?pivots=programming-language-csharp) - [4] - [Azure AI Agent service](https://learn.microsoft.com/azure/ai-services/agents/overview) - [5] - [Using Azure AI Agent Service with AutoGen / Semantic Kernel to build a multi-agent's solution](https://techcommunity.microsoft.com/blog/educatordeveloperblog/using-azure-ai-agent-service-with-autogen--semantic-kernel-to-build-a-multi-agen/4363121)

**Haftungsausschluss**:
Dieses Dokument wurde mit KI-gestützten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, weisen wir darauf hin, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Nutzung dieser Übersetzung entstehen.

10 Lessons to Get Started Building AI Agents


# Prinzipien des Agenten-Designs für KI

## Einführung

Es gibt viele Ansätze, um KI-Agentensysteme zu entwickeln. Da Mehrdeutigkeit in der Gestaltung generativer KI eher ein Merkmal als ein Fehler ist, fällt es Ingenieuren manchmal schwer, überhaupt einen Ausgangspunkt zu finden. Wir haben eine Reihe von nutzerzentrierten UX-Design-Prinzipien entwickelt, um Entwicklern zu helfen, kundenorientierte Agentensysteme zu erstellen, die ihre geschäftlichen Anforderungen erfüllen. Diese Designprinzipien sind keine verbindliche Architektur, sondern ein Ausgangspunkt für Teams, die Agentenerfahrungen definieren und entwickeln.

Im Allgemeinen sollten Agenten:

- Die menschlichen Fähigkeiten erweitern und skalieren (z. B. Brainstorming, Problemlösung, Automatisierung usw.).
- Wissenslücken schließen (z. B. Einblick in Wissensbereiche geben, Übersetzungen, usw.).
- Zusammenarbeit erleichtern und unterstützen, indem sie sich an unsere individuellen Arbeitspräferenzen anpassen.
- Uns zu besseren Versionen unserer selbst machen (z. B. als Lebenscoach/Aufgabenmanager, Unterstützung bei der Entwicklung von Fähigkeiten zur emotionalen Regulierung und Achtsamkeit, Aufbau von Resilienz usw.).

## Dieses Kapitel behandelt

- Was sind die Prinzipien des Agenten-Designs?
- Welche Richtlinien sollten bei der Umsetzung dieser Prinzipien beachtet werden?
- Beispiele für die Anwendung der Designprinzipien

## Lernziele

Nach Abschluss dieses Kapitels wirst du in der Lage sein:

1. Zu erklären, was die Prinzipien des Agenten-Designs sind.
2. Die Richtlinien zur Anwendung der Prinzipien des Agenten-Designs zu erläutern.
3. Zu verstehen, wie man einen Agenten mithilfe der Prinzipien des Agenten-Designs entwickelt.

## Die Prinzipien des Agenten-Designs

![Agenten-Design-Prinzipien](../../../translated_images/agentic-design-principles.9f32a64bb6e2aa5a1bdffb70111aa724058bc248b1a3dd3c6661344015604cff.de.png?WT.mc_id=academic-105485-koreyst)

### Agent (Raum)

Dies ist die Umgebung, in der der Agent agiert. Diese Prinzipien beeinflussen, wie wir Agenten für den Einsatz in physischen und digitalen Welten gestalten.

- **Verbindungen schaffen, nicht zerstören** – Helfen, Menschen mit anderen Menschen, Ereignissen und umsetzbarem Wissen zu verbinden, um Zusammenarbeit und Austausch zu ermöglichen.
  - Agenten helfen, Ereignisse, Wissen und Menschen miteinander zu verknüpfen.
  - Agenten bringen Menschen näher zusammen. Sie sind nicht dafür konzipiert, Menschen zu ersetzen oder zu entwerten.
- **Leicht zugänglich, aber gelegentlich unsichtbar** – Der Agent agiert größtenteils im Hintergrund und meldet sich nur, wenn es relevant und angemessen ist.
  - Der Agent ist für autorisierte Nutzer auf jedem Gerät oder jeder Plattform leicht auffindbar und zugänglich.
  - Der Agent unterstützt multimodale Eingaben und Ausgaben (z. B. Ton, Sprache, Text usw.).
  - Der Agent kann nahtlos zwischen Vorder- und Hintergrund wechseln, je nach Wahrnehmung der Nutzerbedürfnisse.
  - Der Agent kann in unsichtbarer Form agieren, jedoch ist sein Hintergrundprozess und die Zusammenarbeit mit anderen Agenten für den Nutzer transparent und kontrollierbar.

### Agent (Zeit)

Dies beschreibt, wie der Agent über die Zeit hinweg agiert. Diese Prinzipien beeinflussen, wie wir Agenten gestalten, die über Vergangenheit, Gegenwart und Zukunft hinweg interagieren.

- **Vergangenheit**: Reflektion der Geschichte, die sowohl Zustand als auch Kontext umfasst.
  - Der Agent liefert relevantere Ergebnisse durch die Analyse umfangreicher historischer Daten, die über das Ereignis, die Personen oder Zustände hinausgehen.
  - Der Agent schafft Verbindungen aus vergangenen Ereignissen und reflektiert aktiv Erinnerungen, um mit aktuellen Situationen umzugehen.
- **Jetzt**: Mehr anstoßen als benachrichtigen.
  - Der Agent verkörpert einen umfassenden Ansatz zur Interaktion mit Menschen. Wenn ein Ereignis eintritt, geht der Agent über statische Benachrichtigungen oder andere Formalitäten hinaus. Der Agent kann Abläufe vereinfachen oder dynamisch Hinweise generieren, um die Aufmerksamkeit des Nutzers im richtigen Moment zu lenken.
  - Der Agent liefert Informationen basierend auf dem Kontext der Umgebung, sozialen und kulturellen Veränderungen und abgestimmt auf die Absicht des Nutzers.
  - Die Interaktion mit dem Agenten kann schrittweise erfolgen, sich entwickeln und langfristig an Komplexität gewinnen, um den Nutzer zu stärken.
- **Zukunft**: Anpassen und weiterentwickeln.
  - Der Agent passt sich an verschiedene Geräte, Plattformen und Modalitäten an.
  - Der Agent passt sich dem Verhalten des Nutzers, dessen Barrierefreiheitsanforderungen an und ist frei anpassbar.
  - Der Agent wird durch kontinuierliche Nutzerinteraktion geformt und weiterentwickelt.

### Agent (Kern)

Dies sind die Schlüsselelemente im Kern des Designs eines Agenten.

- **Unsicherheit akzeptieren, aber Vertrauen schaffen**.
  - Ein gewisses Maß an Unsicherheit des Agenten wird erwartet. Unsicherheit ist ein Kernelement des Agenten-Designs.
  - Vertrauen und Transparenz sind fundamentale Schichten des Agenten-Designs.
  - Menschen haben die Kontrolle darüber, wann der Agent ein- oder ausgeschaltet ist, und der Status des Agenten ist jederzeit klar ersichtlich.

## Die Richtlinien zur Umsetzung dieser Prinzipien

Wenn du die oben genannten Designprinzipien anwendest, beachte die folgenden Richtlinien:

1. **Transparenz**: Informiere den Nutzer darüber, dass KI beteiligt ist, wie sie funktioniert (einschließlich vergangener Aktionen) und wie Feedback gegeben und das System angepasst werden kann.
2. **Kontrolle**: Gib dem Nutzer die Möglichkeit, das System zu personalisieren, Präferenzen festzulegen und Kontrolle über das System und seine Eigenschaften zu haben (einschließlich der Möglichkeit, Daten zu vergessen).
3. **Konsistenz**: Strebe konsistente, multimodale Erlebnisse über Geräte und Endpunkte hinweg an. Verwende, wo möglich, vertraute UI/UX-Elemente (z. B. Mikrofon-Symbol für Sprachinteraktion) und reduziere die kognitive Belastung des Nutzers so weit wie möglich (z. B. durch prägnante Antworten, visuelle Hilfsmittel und Inhalte wie „Mehr erfahren“).

## Wie man einen Reiseagenten basierend auf diesen Prinzipien und Richtlinien gestaltet

Angenommen, du entwickelst einen Reiseagenten. So könntest du die Designprinzipien und Richtlinien anwenden:

1. **Transparenz** – Informiere den Nutzer darüber, dass der Reiseagent ein KI-gestützter Agent ist. Gib grundlegende Anweisungen, wie man startet (z. B. eine „Hallo“-Nachricht, Beispielaufforderungen). Dokumentiere dies klar auf der Produktseite. Zeige die Liste der Aufforderungen, die ein Nutzer in der Vergangenheit gestellt hat. Mach deutlich, wie Feedback gegeben werden kann (Daumen hoch und runter, Feedback-Button usw.). Erkläre klar, ob der Agent Nutzungs- oder Themenbeschränkungen hat.
2. **Kontrolle** – Stelle sicher, dass klar ist, wie der Nutzer den Agenten nach seiner Erstellung anpassen kann, z. B. mit der Systemaufforderung. Erlaube dem Nutzer, die Ausführlichkeit des Agenten, seinen Schreibstil und Einschränkungen, worüber der Agent nicht sprechen sollte, auszuwählen. Erlaube dem Nutzer, zugehörige Dateien oder Daten, Aufforderungen und frühere Konversationen einzusehen und zu löschen.
3. **Konsistenz** – Stelle sicher, dass die Symbole für Aufforderung teilen, Datei oder Foto hinzufügen und jemanden oder etwas markieren standardisiert und erkennbar sind. Verwende das Büroklammer-Symbol, um Datei-Uploads/Teilen mit dem Agenten anzuzeigen, und ein Bild-Symbol, um den Upload von Grafiken anzuzeigen.

## Zusätzliche Ressourcen
- [Practices for Governing Agentic AI Systems | OpenAI](https://openai.com)
- [The HAX Toolkit Project - Microsoft Research](https://microsoft.com)
- [Responsible AI Toolbox](https://responsibleaitoolbox.ai)
```

**Haftungsausschluss**:
Dieses Dokument wurde mit KI-basierten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, weisen wir darauf hin, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die durch die Nutzung dieser Übersetzung entstehen.


# Entwurfsmuster für die Nutzung von Tools

## Einführung

In dieser Lektion wollen wir folgende Fragen beantworten:

- Was ist das Entwurfsmuster für die Nutzung von Tools?
- Für welche Anwendungsfälle kann es eingesetzt werden?
- Welche Elemente/Bausteine sind notwendig, um das Entwurfsmuster umzusetzen?
- Welche besonderen Überlegungen sind bei der Nutzung des Entwurfsmusters für die Entwicklung vertrauenswürdiger KI-Agenten zu beachten?

## Lernziele

Nach Abschluss dieser Lektion wirst du in der Lage sein:

- Das Entwurfsmuster für die Nutzung von Tools und dessen Zweck zu definieren.
- Anwendungsfälle zu identifizieren, in denen das Entwurfsmuster anwendbar ist.
- Die wichtigsten Elemente zu verstehen, die für die Implementierung des Entwurfsmusters erforderlich sind.
- Überlegungen zur Sicherstellung der Vertrauenswürdigkeit von KI-Agenten, die dieses Entwurfsmuster verwenden, zu erkennen.

## Was ist das Entwurfsmuster für die Nutzung von Tools?

Das **Entwurfsmuster für die Nutzung von Tools** konzentriert sich darauf, LLMs die Fähigkeit zu geben, mit externen Tools zu interagieren, um bestimmte Ziele zu erreichen. Tools sind Code, der von einem Agenten ausgeführt werden kann, um Aktionen durchzuführen. Ein Tool kann eine einfache Funktion wie ein Taschenrechner oder ein API-Aufruf zu einem Drittanbieterdienst wie eine Aktienkursabfrage oder eine Wettervorhersage sein. Im Kontext von KI-Agenten sind Tools so konzipiert, dass sie von Agenten als Antwort auf **modellgenerierte Funktionsaufrufe** ausgeführt werden.

## Für welche Anwendungsfälle kann es eingesetzt werden?

KI-Agenten können Tools nutzen, um komplexe Aufgaben zu erledigen, Informationen abzurufen oder Entscheidungen zu treffen. Das Entwurfsmuster für die Nutzung von Tools wird oft in Szenarien eingesetzt, die eine dynamische Interaktion mit externen Systemen wie Datenbanken, Webdiensten oder Code-Interpretern erfordern. Diese Fähigkeit ist für eine Vielzahl von Anwendungsfällen nützlich, darunter:

- **Dynamische Informationsbeschaffung:** Agenten können externe APIs oder Datenbanken abfragen, um aktuelle Daten abzurufen (z. B. Abfragen einer SQLite-Datenbank für Datenanalysen, Abrufen von Aktienkursen oder Wetterinformationen).
- **Codeausführung und -interpretation:** Agenten können Code oder Skripte ausführen, um mathematische Probleme zu lösen, Berichte zu erstellen oder Simulationen durchzuführen.
- **Workflow-Automatisierung:** Automatisierung von sich wiederholenden oder mehrstufigen Workflows durch die Integration von Tools wie Aufgabenplanern, E-Mail-Diensten oder Datenpipelines.
- **Kundensupport:** Agenten können mit CRM-Systemen, Ticketplattformen oder Wissensdatenbanken interagieren, um Benutzeranfragen zu lösen.
- **Inhaltsgenerierung und -bearbeitung:** Agenten können Tools wie Grammatikprüfer, Textzusammenfasser oder Inhaltsbewertungstools nutzen, um bei der Erstellung von Inhalten zu helfen.

## Welche Elemente/Bausteine sind notwendig, um das Entwurfsmuster für die Nutzung von Tools umzusetzen?

### Funktions-/Toolaufrufe

Der Funktionsaufruf ist der primäre Mechanismus, mit dem wir großen Sprachmodellen (LLMs) die Interaktion mit Tools ermöglichen. Häufig werden die Begriffe „Funktion“ und „Tool“ synonym verwendet, da „Funktionen“ (wiederverwendbare Codeblöcke) die „Tools“ sind, die Agenten verwenden, um Aufgaben auszuführen. Damit der Code einer Funktion aufgerufen werden kann, muss ein LLM die Benutzeranfrage mit der Beschreibung der Funktion vergleichen. Dazu wird ein Schema mit den Beschreibungen aller verfügbaren Funktionen an das LLM gesendet. Das LLM wählt dann die passendste Funktion für die Aufgabe aus und gibt deren Namen und Argumente zurück. Die ausgewählte Funktion wird aufgerufen, ihre Antwort wird an das LLM zurückgesendet, das die Informationen verwendet, um auf die Benutzeranfrage zu antworten.

Um Funktionsaufrufe für Agenten zu implementieren, benötigen Entwickler:

1. Ein LLM-Modell, das Funktionsaufrufe unterstützt
2. Ein Schema, das Funktionsbeschreibungen enthält
3. Den Code für jede beschriebene Funktion

Lass uns das Beispiel der Abfrage der aktuellen Uhrzeit in einer Stadt verwenden, um dies zu veranschaulichen:

- **Initialisierung eines LLMs, das Funktionsaufrufe unterstützt:**

    Nicht alle Modelle unterstützen Funktionsaufrufe, daher ist es wichtig zu überprüfen, ob das von dir verwendete LLM dies tut. [Azure OpenAI](https://learn.microsoft.com/azure/ai-services/openai/how-to/function-calling) unterstützt Funktionsaufrufe. Wir können damit beginnen, den Azure OpenAI-Client zu initialisieren.

    ```python
    # Initialize the Azure OpenAI client
    client = AzureOpenAI(
        azure_endpoint = os.getenv("AZURE_OPENAI_ENDPOINT"),
        api_key=os.getenv("AZURE_OPENAI_API_KEY"),
        api_version="2024-05-01-preview"
    )
    ```

- **Erstellen eines Funktionsschemas:**

    Als Nächstes definieren wir ein JSON-Schema, das den Funktionsnamen, eine Beschreibung der Funktion sowie die Namen und Beschreibungen der Funktionsparameter enthält.
    Dieses Schema übergeben wir dann zusammen mit der Benutzeranfrage an den oben erstellten Client, um die Uhrzeit in San Francisco zu finden. Wichtig ist, dass ein **Toolaufruf** zurückgegeben wird, **nicht** die endgültige Antwort auf die Frage. Wie bereits erwähnt, gibt das LLM den Namen der Funktion zurück, die es für die Aufgabe ausgewählt hat, sowie die Argumente, die an sie übergeben werden.

    ```python
    # Function description for the model to read
    tools = [
        {
            "type": "function",
            "function": {
                "name": "get_current_time",
                "description": "Get the current time in a given location",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "location": {
                            "type": "string",
                            "description": "The city name, e.g. San Francisco",
                        },
                    },
                    "required": ["location"],
                },
            }
        }
    ]
    ```

    ```python

    # Initial user message
    messages = [{"role": "user", "content": "What's the current time in San Francisco"}]

    # First API call: Ask the model to use the function
      response = client.chat.completions.create(
          model=deployment_name,
          messages=messages,
          tools=tools,
          tool_choice="auto",
      )

      # Process the model's response
      response_message = response.choices[0].message
      messages.append(response_message)

      print("Model's response:")

      print(response_message)

    ```

    ```bash
    Model's response:
    ChatCompletionMessage(content=None, role='assistant', function_call=None, tool_calls=[ChatCompletionMessageToolCall(id='call_pOsKdUlqvdyttYB67MOj434b', function=Function(arguments='{"location":"San Francisco"}', name='get_current_time'), type='function')])
    ```

- **Der Funktionscode, der zur Durchführung der Aufgabe erforderlich ist:**

    Nachdem das LLM entschieden hat, welche Funktion ausgeführt werden soll, muss der Code, der die Aufgabe ausführt, implementiert und ausgeführt werden.
    Wir können den Code implementieren, um die aktuelle Uhrzeit in Python abzurufen. Außerdem müssen wir den Code schreiben, um den Namen und die Argumente aus der response_message zu extrahieren, um das endgültige Ergebnis zu erhalten.

    ```python
      def get_current_time(location):
        """Get the current time for a given location"""
        print(f"get_current_time called with location: {location}")
        location_lower = location.lower()

        for key, timezone in TIMEZONE_DATA.items():
            if key in location_lower:
                print(f"Timezone found for {key}")
                current_time = datetime.now(ZoneInfo(timezone)).strftime("%I:%M %p")
                return json.dumps({
                    "location": location,
                    "current_time": current_time
                })

        print(f"No timezone data found for {location_lower}")
        return json.dumps({"location": location, "current_time": "unknown"})
    ```

    ```python
     # Handle function calls
      if response_message.tool_calls:
          for tool_call in response_message.tool_calls:
              if tool_call.function.name == "get_current_time":

                  function_args = json.loads(tool_call.function.arguments)

                  time_response = get_current_time(
                      location=function_args.get("location")
                  )

                  messages.append({
                      "tool_call_id": tool_call.id,
                      "role": "tool",
                      "name": "get_current_time",
                      "content": time_response,
                  })
      else:
          print("No tool calls were made by the model.")

      # Second API call: Get the final response from the model
      final_response = client.chat.completions.create(
          model=deployment_name,
          messages=messages,
      )

      return final_response.choices[0].message.content
     ```

    ```bash
      get_current_time called with location: San Francisco
      Timezone found for san francisco
      The current time in San Francisco is 09:24 AM.
     ```

Der Funktionsaufruf steht im Mittelpunkt der meisten, wenn nicht aller Designs für die Tool-Nutzung von Agenten. Die Implementierung von Grund auf kann jedoch manchmal eine Herausforderung sein.
Wie wir in [Lektion 2](../../../02-explore-agentic-frameworks) gelernt haben, bieten agentische Frameworks uns vorgefertigte Bausteine zur Implementierung der Tool-Nutzung.

### Beispiele für die Nutzung von Tools mit agentischen Frameworks

- ### **[Semantic Kernel](https://learn.microsoft.com/azure/ai-services/agents/overview)**

    Semantic Kernel ist ein Open-Source-KI-Framework für .NET-, Python- und Java-Entwickler, die mit großen Sprachmodellen (LLMs) arbeiten. Es vereinfacht die Nutzung von Funktionsaufrufen, indem es deine Funktionen und deren Parameter automatisch durch einen Prozess namens [Serialisierung](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions) beschreibt. Außerdem übernimmt es die Kommunikation zwischen dem Modell und deinem Code. Ein weiterer Vorteil eines agentischen Frameworks wie Semantic Kernel ist, dass es den Zugriff auf vorgefertigte Tools wie [File Search](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step4_assistant_tool_file_search.py) und [Code Interpreter](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py) ermöglicht.

    Das folgende Diagramm zeigt den Prozess des Funktionsaufrufs mit Semantic Kernel:

    ![Funktionsaufruf](../../../translated_images/functioncalling-diagram.b5493ea5154ad8e3e4940d2e36a49101eec1398948e5d1039942203b4f5a4209.de.png)

    In Semantic Kernel werden Funktionen/Tools als [Plugins](https://learn.microsoft.com/semantic-kernel/concepts/plugins/?pivots=programming-language-python) bezeichnet. Wir können die `get_current_time` function we saw earlier into a plugin by turning it into a class with the function in it. We can also import the `kernel_function`-Dekorator verwenden, der die Beschreibung der Funktion enthält. Wenn du dann einen Kernel mit dem GetCurrentTimePlugin erstellst, serialisiert der Kernel die Funktion und ihre Parameter automatisch und erstellt dabei das Schema, das an das LLM gesendet wird.

    ```python
    from semantic_kernel.functions import kernel_function

    class GetCurrentTimePlugin:
        async def __init__(self, location):
            self.location = location

        @kernel_function(
            description="Get the current time for a given location"
        )
        def get_current_time(location: str = ""):
            ...

    ```

    ```python
    from semantic_kernel import Kernel

    # Create the kernel
    kernel = Kernel()

    # Create the plugin
    get_current_time_plugin = GetCurrentTimePlugin(location)

    # Add the plugin to the kernel
    kernel.add_plugin(get_current_time_plugin)
    ```

- ### **[Azure AI Agent Service](https://learn.microsoft.com/azure/ai-services/agents/overview)**

    Der Azure AI Agent Service ist ein neues agentisches Framework, das Entwicklern dabei helfen soll, hochwertige, erweiterbare KI-Agenten sicher zu erstellen, bereitzustellen und zu skalieren, ohne die zugrunde liegenden Rechen- und Speicherressourcen verwalten zu müssen. Es ist besonders nützlich für Unternehmensanwendungen, da es ein vollständig verwalteter Dienst mit Sicherheit auf Unternehmensniveau ist.

    Im Vergleich zur direkten Entwicklung mit der LLM-API bietet der Azure AI Agent Service einige Vorteile, darunter:
  - Automatische Toolaufrufe – kein Parsen eines Toolaufrufs, Ausführen des Tools und Verarbeiten der Antwort erforderlich; all dies erfolgt nun serverseitig
  - Sicher verwaltete Daten – anstelle der Verwaltung des eigenen Gesprächsstatus kann man sich auf Threads verlassen, um alle benötigten Informationen zu speichern
  - Tools out-of-the-box – Tools, die zur Interaktion mit Datenquellen verwendet werden können, wie Bing, Azure AI Search und Azure Functions.

    Die im Azure AI Agent Service verfügbaren Tools lassen sich in zwei Kategorien unterteilen:

    1. Wissenstools:
        - [Grounding mit Bing Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/bing-grounding?tabs=python&pivots=overview)
        - [File Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/file-search?tabs=python&pivots=overview)
        - [Azure AI Search](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/azure-ai-search?tabs=azurecli%2Cpython&pivots=overview-azure-ai-search)

    2. Aktionstools:
        - [Funktionsaufrufe](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/function-calling?tabs=python&pivots=overview)
        - [Code Interpreter](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/code-interpreter?tabs=python&pivots=overview)
        - [Von OpenAI definierte Tools](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/openapi-spec?tabs=python&pivots=overview)
        - [Azure Functions](https://learn.microsoft.com/azure/ai-services/agents/how-to/tools/azure-functions?pivots=overview)

    Der Agent Service ermöglicht die Nutzung dieser Tools zusammen als `toolset`. It also utilizes `threads` which keep track of the history of messages from a particular conversation.

    Imagine you are a sales agent at a company called Contoso. You want to develop a conversational agent that can answer questions about your sales data.

    The image below illustrates how you could use Azure AI Agent Service to analyze your sales data:

    ![Agentic Service In Action](../../../translated_images/agent-service-in-action.8c2d8aa8e9d91feeb29549b3fde529f8332b243875154d03907616a69198afbc.de.jpg?WT.mc_id=academic-105485-koreyst)

    To use any of these tools with the service we can create a client and define a tool or toolset. To implement this practically we can use the Python code below. The LLM will be able to look at the toolset and decide whether to use the user created function, `fetch_sales_data_using_sqlite_query` oder des vorgefertigten Code Interpreters, abhängig von der Benutzeranfrage.

    ```python
    import os
    from azure.ai.projects import AIProjectClient
    from azure.identity import DefaultAzureCredential
    from fecth_sales_data_functions import fetch_sales_data_using_sqlite_query # fetch_sales_data_using_sqlite_query function which can be found in a fecth_sales_data_functions.py file.
    from azure.ai.projects.models import ToolSet, FunctionTool, CodeInterpreterTool

    project_client = AIProjectClient.from_connection_string(
        credential=DefaultAzureCredential(),
        conn_str=os.environ["PROJECT_CONNECTION_STRING"],
    )

    # Initialize function calling agent with the fetch_sales_data_using_sqlite_query function and adding it to the toolset
    fetch_data_function = FunctionTool(fetch_sales_data_using_sqlite_query)
    toolset = ToolSet()
    toolset.add(fetch_data_function)

    # Initialize Code Interpreter tool and adding it to the toolset.
    code_interpreter = code_interpreter = CodeInterpreterTool()
    toolset = ToolSet()
    toolset.add(code_interpreter)

    agent = project_client.agents.create_agent(
        model="gpt-4o-mini", name="my-agent", instructions="You are helpful agent",
        toolset=toolset
    )
    ```

## Welche besonderen Überlegungen sind bei der Nutzung des Entwurfsmusters für die Entwicklung vertrauenswürdiger KI-Agenten zu beachten?

Ein häufiges Anliegen bei SQL, das dynamisch von LLMs generiert wird, ist die Sicherheit, insbesondere das Risiko von SQL-Injection oder bösartigen Aktionen, wie das Löschen oder Manipulieren der Datenbank. Obwohl diese Bedenken berechtigt sind, können sie effektiv durch die richtige Konfiguration der Datenbankzugriffsrechte gemindert werden. Bei den meisten Datenbanken bedeutet dies, die Datenbank als schreibgeschützt zu konfigurieren. Für Datenbankdienste wie PostgreSQL oder Azure SQL sollte der App eine schreibgeschützte (SELECT) Rolle zugewiesen werden.

Das Ausführen der App in einer sicheren Umgebung erhöht den Schutz weiter. In Unternehmensszenarien werden Daten typischerweise aus operativen Systemen in eine schreibgeschützte Datenbank oder ein Data Warehouse mit einer benutzerfreundlichen Schema extrahiert und transformiert. Dieser Ansatz stellt sicher, dass die Daten sicher sind, für Leistung und Zugänglichkeit optimiert und dass die App eingeschränkten, schreibgeschützten Zugriff hat.

## Zusätzliche Ressourcen

- [Azure AI Agents Service Workshop](https://microsoft.github.io/build-your-first-agent-with-azure-ai-agent-service-workshop/)
- [Contoso Creative Writer Multi-Agent Workshop](https://github.com/Azure-Samples/contoso-creative-writer/tree/main/docs/workshop)
- [Semantic Kernel Function Calling Tutorial](https://learn.microsoft.com/semantic-kernel/concepts/ai-services/chat-completion/function-calling/?pivots=programming-language-python#1-serializing-the-functions)
- [Semantic Kernel Code Interpreter](https://github.com/microsoft/semantic-kernel/blob/main/python/samples/getting_started_with_agents/openai_assistant/step3_assistant_tool_code_interpreter.py)
- [Autogen Tools](https://microsoft.github.io/autogen/dev/user-guide/core-user-guide/components/tools.html)
```

**Haftungsausschluss**:
Dieses Dokument wurde mit KI-gestützten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, weisen wir darauf hin, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir haften nicht für Missverständnisse oder Fehlinterpretationen, die sich aus der Nutzung dieser Übersetzung ergeben.


# Agentic RAG

Diese Lektion bietet einen umfassenden Überblick über Agentic Retrieval-Augmented Generation (Agentic RAG), ein aufstrebendes KI-Paradigma, bei dem große Sprachmodelle (LMs) eigenständig ihre nächsten Schritte planen, während sie Informationen aus externen Quellen abrufen. Im Gegensatz zu statischen Mustern des Abrufens und Lesens umfasst Agentic RAG iterative Aufrufe an das LLM, unterbrochen durch Werkzeug- oder Funktionsaufrufe und strukturierte Ausgaben. Das System bewertet Ergebnisse, verfeinert Abfragen, ruft bei Bedarf zusätzliche Werkzeuge auf und setzt diesen Zyklus fort, bis eine zufriedenstellende Lösung erreicht ist.

## Einführung

Diese Lektion umfasst:

- **Agentic RAG verstehen:** Einblick in das aufkommende Paradigma in der KI, bei dem große Sprachmodelle (LLMs) eigenständig ihre nächsten Schritte planen und Informationen aus externen Datenquellen abrufen.
- **Iterativer Maker-Checker-Ansatz:** Verständnis des iterativen Zyklus von LLM-Aufrufen, unterbrochen durch Werkzeug- oder Funktionsaufrufe und strukturierte Ausgaben, um die Korrektheit zu verbessern und fehlerhafte Abfragen zu behandeln.
- **Praktische Anwendungen erkunden:** Identifikation von Szenarien, in denen Agentic RAG besonders effektiv ist, wie z. B. in korrektheitsorientierten Umgebungen, bei komplexen Datenbankinteraktionen und in erweiterten Workflows.

## Lernziele

Nach Abschluss dieser Lektion wirst du wissen/verstehen, wie man:

- **Agentic RAG versteht:** Einblick in das aufkommende Paradigma in der KI, bei dem große Sprachmodelle (LLMs) eigenständig ihre nächsten Schritte planen und Informationen aus externen Datenquellen abrufen.
- **Iterativer Maker-Checker-Ansatz:** Verstehen des Konzepts eines iterativen Zyklus von LLM-Aufrufen, unterbrochen durch Werkzeug- oder Funktionsaufrufe und strukturierte Ausgaben, um die Korrektheit zu verbessern und fehlerhafte Abfragen zu behandeln.
- **Den Denkprozess übernehmen:** Das System versteht, wie es seinen Denkprozess eigenständig steuert und Entscheidungen darüber trifft, wie es Probleme angeht, ohne auf vordefinierte Pfade angewiesen zu sein.
- **Workflow:** Verstehen, wie ein agentisches Modell eigenständig Markttrendberichte abruft, Wettbewerbsdaten identifiziert, interne Verkaufsmetriken korreliert, Erkenntnisse synthetisiert und die Strategie evaluiert.
- **Iterative Schleifen, Werkzeugintegration und Gedächtnis:** Lernen, wie das System auf einem iterativen Interaktionsmuster basiert, den Zustand und das Gedächtnis über die Schritte hinweg beibehält, um wiederholte Schleifen zu vermeiden und fundierte Entscheidungen zu treffen.
- **Umgang mit Fehlern und Selbstkorrektur:** Erforschung der robusten Selbstkorrekturmechanismen des Systems, einschließlich Iteration und erneuter Abfrage, Nutzung von Diagnosetools und Rückgriff auf menschliche Aufsicht.
- **Grenzen der Eigenständigkeit:** Verständnis der Einschränkungen von Agentic RAG mit Schwerpunkt auf domänenspezifischer Autonomie, Abhängigkeit von Infrastruktur und Einhaltung von Richtlinien.
- **Praktische Anwendungsfälle und Nutzen:** Identifikation von Szenarien, in denen Agentic RAG besonders effektiv ist, wie z. B. in korrektheitsorientierten Umgebungen, bei komplexen Datenbankinteraktionen und in erweiterten Workflows.
- **Governance, Transparenz und Vertrauen:** Lernen, wie wichtig Governance und Transparenz sind, einschließlich erklärbarer Argumentation, Kontrolle von Verzerrungen und menschlicher Aufsicht.

## Was ist Agentic RAG?

Agentic Retrieval-Augmented Generation (Agentic RAG) ist ein aufstrebendes KI-Paradigma, bei dem große Sprachmodelle (LLMs) eigenständig ihre nächsten Schritte planen, während sie Informationen aus externen Quellen abrufen. Im Gegensatz zu statischen Mustern des Abrufens und Lesens umfasst Agentic RAG iterative Aufrufe an das LLM, unterbrochen durch Werkzeug- oder Funktionsaufrufe und strukturierte Ausgaben. Das System bewertet Ergebnisse, verfeinert Abfragen, ruft bei Bedarf zusätzliche Werkzeuge auf und setzt diesen Zyklus fort, bis eine zufriedenstellende Lösung erreicht ist. Dieser iterative "Maker-Checker"-Ansatz verbessert die Korrektheit, behandelt fehlerhafte Abfragen und sorgt für qualitativ hochwertige Ergebnisse.

Das System übernimmt aktiv seinen Denkprozess, indem es fehlgeschlagene Abfragen neu schreibt, verschiedene Abrufmethoden wählt und mehrere Werkzeuge integriert—wie etwa Vektorsuche in Azure AI Search, SQL-Datenbanken oder benutzerdefinierte APIs—bevor es seine Antwort finalisiert. Das unterscheidende Merkmal eines agentischen Systems ist seine Fähigkeit, seinen Denkprozess eigenständig zu steuern. Traditionelle RAG-Implementierungen verlassen sich auf vordefinierte Pfade, während ein agentisches System die Abfolge der Schritte autonom auf Basis der Qualität der gefundenen Informationen bestimmt.

## Definition von Agentic Retrieval-Augmented Generation (Agentic RAG)

Agentic Retrieval-Augmented Generation (Agentic RAG) ist ein aufstrebendes Paradigma in der KI-Entwicklung, bei dem LLMs nicht nur Informationen aus externen Datenquellen abrufen, sondern auch eigenständig ihre nächsten Schritte planen. Im Gegensatz zu statischen Abruf-Lese-Mustern oder sorgfältig geskripteten Prompt-Sequenzen umfasst Agentic RAG einen iterativen Zyklus von LLM-Aufrufen, unterbrochen durch Werkzeug- oder Funktionsaufrufe und strukturierte Ausgaben. Das System bewertet bei jedem Schritt die erzielten Ergebnisse, entscheidet, ob es seine Abfragen verfeinern muss, ruft bei Bedarf zusätzliche Werkzeuge auf und setzt diesen Zyklus fort, bis es eine zufriedenstellende Lösung erreicht.

Dieser iterative "Maker-Checker"-Ansatz ist darauf ausgelegt, die Korrektheit zu verbessern, fehlerhafte Abfragen an strukturierte Datenbanken (z. B. NL2SQL) zu behandeln und ausgewogene, qualitativ hochwertige Ergebnisse sicherzustellen. Anstatt sich ausschließlich auf sorgfältig entwickelte Prompt-Ketten zu verlassen, übernimmt das System aktiv seinen Denkprozess. Es kann fehlgeschlagene Abfragen neu schreiben, verschiedene Abrufmethoden wählen und mehrere Werkzeuge integrieren—wie etwa Vektorsuche in Azure AI Search, SQL-Datenbanken oder benutzerdefinierte APIs—bevor es seine Antwort finalisiert. Dies macht komplexe Orchestrierungsrahmen überflüssig. Stattdessen kann eine relativ einfache Schleife aus „LLM-Aufruf → Werkzeugnutzung → LLM-Aufruf → …“ zu ausgefeilten und fundierten Ergebnissen führen.

![Agentic RAG Core Loop](../../../05-agentic-rag/images/agentic-rag-core-loop.png)

## Den Denkprozess übernehmen

Das unterscheidende Merkmal, das ein System "agentisch" macht, ist seine Fähigkeit, seinen Denkprozess eigenständig zu steuern. Traditionelle RAG-Implementierungen hängen oft davon ab, dass Menschen einen Pfad für das Modell vordefinieren: eine Denkweise, die festlegt, was wann abgerufen werden soll. Ein wirklich agentisches System hingegen entscheidet intern, wie es das Problem angeht. Es führt nicht einfach ein Skript aus, sondern bestimmt autonom die Abfolge der Schritte auf Basis der Qualität der gefundenen Informationen.

Zum Beispiel: Wenn das System aufgefordert wird, eine Produktstartstrategie zu erstellen, verlässt es sich nicht nur auf einen Prompt, der den gesamten Forschungs- und Entscheidungsworkflow vorgibt. Stattdessen entscheidet das agentische Modell eigenständig:

1. Aktuelle Markttrendberichte mit Bing Web Grounding abzurufen.
2. Relevante Wettbewerbsdaten mit Azure AI Search zu identifizieren.
3. Historische interne Verkaufsmetriken mit Azure SQL Database zu korrelieren.
4. Die Erkenntnisse zu einer kohärenten Strategie zu synthetisieren, orchestriert über Azure OpenAI Service.
5. Die Strategie auf Lücken oder Inkonsistenzen zu überprüfen und gegebenenfalls eine weitere Abrufrunde einzuleiten.

All diese Schritte—Abfragen verfeinern, Quellen auswählen, iterieren, bis eine zufriedenstellende Antwort erreicht ist—werden vom Modell entschieden, nicht von einem Menschen vorgegeben.

## Iterative Schleifen, Werkzeugintegration und Gedächtnis

![Tool Integration Architecture](../../../05-agentic-rag/images/tool-integration.png)

Ein agentisches System basiert auf einem iterativen Interaktionsmuster:

- **Erster Aufruf:** Das Ziel des Nutzers (auch User Prompt genannt) wird dem LLM präsentiert.
- **Werkzeugaufruf:** Wenn das Modell feststellt, dass Informationen fehlen oder Anweisungen unklar sind, wählt es ein Werkzeug oder eine Abrufmethode—wie eine Abfrage an eine Vektordatenbank (z. B. Azure AI Search Hybrid Search über private Daten) oder einen strukturierten SQL-Aufruf—um mehr Kontext zu sammeln.
- **Bewertung & Verfeinerung:** Nach Überprüfung der zurückgegebenen Daten entscheidet das Modell, ob die Informationen ausreichen. Falls nicht, verfeinert es die Abfrage, versucht ein anderes Werkzeug oder passt seinen Ansatz an.
- **Wiederholen, bis zufriedenstellend:** Dieser Zyklus wird fortgesetzt, bis das Modell feststellt, dass es genügend Klarheit und Beweise hat, um eine fundierte Antwort zu liefern.
- **Gedächtnis & Zustand:** Da das System den Zustand und das Gedächtnis über die Schritte hinweg beibehält, kann es sich an vorherige Versuche und deren Ergebnisse erinnern, wiederholte Schleifen vermeiden und fundiertere Entscheidungen treffen, während es voranschreitet.

Im Laufe der Zeit entsteht so ein Gefühl des fortschreitenden Verständnisses, das es dem Modell ermöglicht, komplexe, mehrstufige Aufgaben zu bewältigen, ohne dass ein Mensch ständig eingreifen oder den Prompt umformen muss.

## Umgang mit Fehlern und Selbstkorrektur

Die Eigenständigkeit von Agentic RAG umfasst auch robuste Selbstkorrekturmechanismen. Wenn das System auf Sackgassen stößt—wie das Abrufen irrelevanter Dokumente oder das Auftreten fehlerhafter Abfragen—kann es:

- **Iterieren und erneut abfragen:** Anstatt minderwertige Antworten zurückzugeben, versucht das Modell neue Suchstrategien, schreibt Datenbankabfragen um oder prüft alternative Datensätze.
- **Diagnosetools nutzen:** Das System kann zusätzliche Funktionen aufrufen, die ihm helfen, seine Denkschritte zu debuggen oder die Korrektheit der abgerufenen Daten zu bestätigen. Tools wie Azure AI Tracing sind entscheidend, um eine robuste Beobachtbarkeit und Überwachung zu ermöglichen.
- **Auf menschliche Aufsicht zurückgreifen:** In hochkritischen oder wiederholt scheiternden Szenarien könnte das Modell Unsicherheit signalisieren und menschliche Anleitung anfordern. Sobald der Mensch korrigierendes Feedback gibt, kann das Modell diese Lektion für die Zukunft übernehmen.

Dieser iterative und dynamische Ansatz ermöglicht es dem Modell, sich kontinuierlich zu verbessern und sicherzustellen, dass es nicht nur ein Einweg-System ist, sondern eines, das aus seinen Fehlern innerhalb einer Sitzung lernt.

![Self Correction Mechanism](../../../05-agentic-rag/images/self-correction.png)

## Grenzen der Eigenständigkeit

Trotz seiner Eigenständigkeit innerhalb einer Aufgabe ist Agentic RAG nicht mit einer allgemeinen künstlichen Intelligenz (Artificial General Intelligence) gleichzusetzen. Seine "agentischen" Fähigkeiten sind auf die von menschlichen Entwicklern bereitgestellten Werkzeuge, Datenquellen und Richtlinien beschränkt. Es kann keine eigenen Werkzeuge erfinden oder über die gesetzten Domänengrenzen hinausgehen. Stattdessen glänzt es darin, die vorhandenen Ressourcen dynamisch zu orchestrieren.

Wichtige Unterschiede zu fortgeschritteneren KI-Formen umfassen:

1. **Domänenspezifische Autonomie:** Agentic RAG-Systeme konzentrieren sich darauf, benutzerdefinierte Ziele innerhalb einer bekannten Domäne zu erreichen, indem sie Strategien wie Abfrageumformung oder Werkzeugauswahl anwenden, um Ergebnisse zu verbessern.
2. **Infrastrukturabhängigkeit:** Die Fähigkeiten des Systems hängen von den von Entwicklern integrierten Werkzeugen und Daten ab. Es kann diese Grenzen ohne menschliches Eingreifen nicht überschreiten.
3. **Einhaltung von Richtlinien:** Ethische Richtlinien, Compliance-Regeln und Geschäftspolitiken bleiben von großer Bedeutung. Die Freiheit des Agenten ist immer durch Sicherheitsmaßnahmen und Überwachungsmechanismen eingeschränkt (hoffentlich?).

## Praktische Anwendungsfälle und Nutzen

Agentic RAG glänzt in Szenarien, die iterative Verfeinerung und Präzision erfordern:

1. **Korrektheitsorientierte Umgebungen:** In Bereichen wie Compliance-Prüfungen, regulatorischer Analyse oder juristischer Recherche kann das agentische Modell Fakten wiederholt überprüfen, mehrere Quellen konsultieren und Abfragen umschreiben, bis es eine gründlich geprüfte Antwort liefert.
2. **Komplexe Datenbankinteraktionen:** Bei der Arbeit mit strukturierten Daten, bei denen Abfragen häufig scheitern oder angepasst werden müssen, kann das System eigenständig seine Abfragen mithilfe von Azure SQL oder Microsoft Fabric OneLake verfeinern, um sicherzustellen, dass die endgültige Abfrage mit der Benutzerabsicht übereinstimmt.
3. **Erweiterte Workflows:** Länger laufende Sitzungen können sich weiterentwickeln, wenn neue Informationen auftauchen. Agentic RAG kann kontinuierlich neue Daten integrieren und Strategien anpassen, während es mehr über den Problemraum lernt.

## Governance, Transparenz und Vertrauen

Da diese Systeme eigenständiger in ihrer Argumentation werden, sind Governance und Transparenz von entscheidender Bedeutung:

- **Erklärbare Argumentation:** Das Modell kann eine Prüfspur der getätigten Abfragen, der konsultierten Quellen und der Argumentationsschritte bereitstellen, die zu seiner Schlussfolgerung geführt haben. Tools wie Azure AI Content Safety und Azure AI Tracing / GenAIOps können helfen, Transparenz zu gewährleisten und Risiken zu minimieren.
- **Kontrolle von Verzerrungen und ausgewogene Abrufe:** Entwickler können Abrufstrategien anpassen, um sicherzustellen, dass ausgewogene, repräsentative Datenquellen berücksichtigt werden, und regelmäßig Ausgaben überprüfen, um Verzerrungen oder unausgewogene Muster zu erkennen, unter Verwendung benutzerdefinierter Modelle für fortgeschrittene Datenwissenschaftsorganisationen mit Azure Machine Learning.
- **Menschliche Aufsicht und Compliance:** Für sensible Aufgaben bleibt die menschliche Überprüfung unerlässlich. Agentic RAG ersetzt nicht das menschliche Urteilsvermögen bei kritischen Entscheidungen—es ergänzt es, indem es gründlicher geprüfte Optionen liefert.

Werkzeuge, die einen klaren Aktionsverlauf aufzeichnen, sind unerlässlich. Ohne sie kann das Debuggen eines mehrstufigen Prozesses sehr schwierig sein. Siehe folgendes Beispiel von Literal AI (Unternehmen hinter Chainlit) für einen Agent-Lauf:

![AgentRunExample](../../../05-agentic-rag/images/AgentRunExample.png)

![AgentRunExample2](../../../05-agentic-rag/images/AgentRunExample2.png)

## Fazit

Agentic RAG stellt eine natürliche Weiterentwicklung in der Art und Weise dar, wie KI-Systeme komplexe, datenintensive Aufgaben bewältigen. Durch die Einführung eines iterativen Interaktionsmusters, die autonome Auswahl von Werkzeugen und die Verfeinerung von Abfragen, bis ein qualitativ hochwertiges Ergebnis erzielt wird, geht das System über statisches Prompt-Following hinaus und wird zu einem anpassungsfähigen, kontextbewussten Entscheidungsträger. Obwohl es weiterhin durch menschlich definierte Infrastrukturen und ethische Richtlinien begrenzt ist, ermöglichen diese agentischen Fähigkeiten reichhaltigere, dynamischere und letztlich nützlichere KI-Interaktionen sowohl für Unternehmen als auch für Endbenutzer.

## Zusätzliche Ressourcen

- Implementierung von Retrieval Augmented Generation (RAG) mit Azure OpenAI Service: Erfahre, wie du deine eigenen Daten mit dem Azure OpenAI Service nutzen kannst. [Dieses Microsoft Learn-Modul bietet eine umfassende Anleitung zur Implementierung von RAG](https://learn.microsoft.com/training/modules/use-own-data-azure-openai)
- Evaluation generativer KI-Anwendungen mit Azure AI Foundry: Dieser Artikel behandelt die Bewertung und den Vergleich von Modellen anhand öffentlich verfügbarer Datensätze, einschließlich [Agentic AI-Anwendungen und RAG-Architekturen](https://learn.microsoft.com/azure/ai-studio/concepts/evaluation-approach-gen-ai)
- [Was ist Agentic RAG | Weaviate](https://weaviate.io/blog/what-is-agentic-rag)
- [Agentic RAG: Ein vollständiger Leitfaden zu Agent-Based Retrieval Augmented Generation – News von Generation RAG](https://ragaboutit.com/agentic-rag-a-complete-guide-to-agent-based-retrieval-augmented-generation/)
- [Agentic RAG: Steigere dein RAG mit Abfrageumformung und Selbstabfrage! Hugging Face Open-Source AI Cookbook](https://huggingface.co/learn/cookbook/agent_rag)
- [Agentische Ebenen zu RAG hinzufügen](https://youtu.be/aQ4yQXeB1Ss?si=2HUqBzHoeB5tR04U)
- [Die Zukunft von Wissensassistenten: Jerry Liu](https://www.youtube.com/watch?v=zeAyuLc_f3Q&t=244s)
- [Wie man Agentic RAG-Systeme baut](https://www.youtube.com/watch?v=AOSjiXP1jmQ)
- [Verwendung des Azure AI Foundry Agent Service zur Skalierung deiner KI-Agenten](https://ignite.microsoft.com/sessions/BRK102?source=sessions)

### Wissenschaftliche Arbeiten

- [2303.17651 Self-Refine: Iterative Refinement with Self-Feedback](https://arxiv.org/abs/2303.17651)
- [2303.11366 Reflexion: Language Agents with Verbal Reinforcement Learning](https://arxiv.org/abs/2303.11366)
- [2305.11738 CRITIC: Large Language Models Can Self-Correct with Tool-Interactive Critiquing](https://arxiv.org/abs/2305.11738)
```

**Haftungsausschluss**:
Dieses Dokument wurde mit KI-basierten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, beachten Sie bitte, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die durch die Nutzung dieser Übersetzung entstehen.


```markdown
# Vertrauenswürdige KI-Agenten entwickeln

## Einführung

In dieser Lektion werden folgende Themen behandelt:

- Wie man sichere und effektive KI-Agenten erstellt und bereitstellt.
- Wichtige Sicherheitsaspekte bei der Entwicklung von KI-Agenten.
- Wie man Datenschutz und Privatsphäre der Nutzer bei der Entwicklung von KI-Agenten sicherstellt.

## Lernziele

Nach Abschluss dieser Lektion wirst du in der Lage sein:

- Risiken bei der Erstellung von KI-Agenten zu erkennen und zu mindern.
- Sicherheitsmaßnahmen zu implementieren, um sicherzustellen, dass Daten und Zugriffe ordnungsgemäß verwaltet werden.
- KI-Agenten zu erstellen, die den Datenschutz wahren und eine qualitativ hochwertige Nutzererfahrung bieten.

## Sicherheit

Beginnen wir mit dem Aufbau sicherer agentenbasierter Anwendungen. Sicherheit bedeutet, dass der KI-Agent wie vorgesehen funktioniert. Als Entwickler von agentenbasierten Anwendungen haben wir Methoden und Werkzeuge, um die Sicherheit zu maximieren:

### Aufbau eines Meta-Prompting-Systems

Wenn du jemals eine KI-Anwendung mit großen Sprachmodellen (LLMs) entwickelt hast, weißt du, wie wichtig es ist, ein robustes System-Prompt oder eine Systemnachricht zu entwerfen. Diese Prompts legen die Meta-Regeln, Anweisungen und Richtlinien fest, wie das LLM mit dem Nutzer und den Daten interagieren soll.

Für KI-Agenten ist das System-Prompt noch wichtiger, da die KI-Agenten hochspezifische Anweisungen benötigen, um die Aufgaben zu erfüllen, die wir für sie entworfen haben.

Um skalierbare System-Prompts zu erstellen, können wir ein Meta-Prompting-System verwenden, um einen oder mehrere Agenten in unserer Anwendung zu erstellen:

![Aufbau eines Meta-Prompting-Systems](../../../translated_images/building-a-metaprompting-system.aa7d6de2100b0ef48c3e1926dab6903026b22fc9d27fc4327162fbbb9caf960f.de.png)

#### Schritt 1: Erstelle ein Meta- oder Template-Prompt

Das Meta-Prompt wird von einem LLM verwendet, um die System-Prompts für die Agenten zu generieren, die wir erstellen. Wir entwerfen es als Vorlage, damit wir bei Bedarf effizient mehrere Agenten erstellen können.

Hier ist ein Beispiel für ein Meta-Prompt, das wir dem LLM geben würden:

```plaintext
You are an expert at creating AI agent assitants.
You will be provided a company name, role, responsibilites and other
information that you will use to provide a system prompt for.
To create the system prompt, be descriptive as possible and provide a structure that a system using an LLM can better understand the role and responsibilites of the AI assistant.
```

#### Schritt 2: Erstelle ein Basis-Prompt

Der nächste Schritt besteht darin, ein Basis-Prompt zu erstellen, das den KI-Agenten beschreibt. Du solltest die Rolle des Agenten, die Aufgaben, die er erledigen soll, und andere Verantwortlichkeiten des Agenten einbeziehen.

Hier ist ein Beispiel:

```plaintext
You are a travel agent for Contoso Travel with that is great at booking flights for customers. To help customers you can perform the following tasks: lookup available flights, book flights, ask for preferences in seating and times for flights, cancel any previously booked flights and alert customers on any delays or cancellations of flights.
```

#### Schritt 3: Basis-Prompt dem LLM bereitstellen

Nun können wir dieses Prompt optimieren, indem wir das Meta-Prompt als System-Prompt und unser Basis-Prompt verwenden.

Das Ergebnis ist ein besser gestaltetes Prompt, das unsere KI-Agenten besser leitet:

```markdown
**Company Name:** Contoso Travel
**Role:** Travel Agent Assistant

**Objective:**
You are an AI-powered travel agent assistant for Contoso Travel, specializing in booking flights and providing exceptional customer service. Your main goal is to assist customers in finding, booking, and managing their flights, all while ensuring that their preferences and needs are met efficiently.

**Key Responsibilities:**

1. **Flight Lookup:**

    - Assist customers in searching for available flights based on their specified destination, dates, and any other relevant preferences.
    - Provide a list of options, including flight times, airlines, layovers, and pricing.
2. **Flight Booking:**

    - Facilitate the booking of flights for customers, ensuring that all details are correctly entered into the system.
    - Confirm bookings and provide customers with their itinerary, including confirmation numbers and any other pertinent information.
3. **Customer Preference Inquiry:**

    - Actively ask customers for their preferences regarding seating (e.g., aisle, window, extra legroom) and preferred times for flights (e.g., morning, afternoon, evening).
    - Record these preferences for future reference and tailor suggestions accordingly.
4. **Flight Cancellation:**

    - Assist customers in canceling previously booked flights if needed, following company policies and procedures.
    - Notify customers of any necessary refunds or additional steps that may be required for cancellations.
5. **Flight Monitoring:**

    - Monitor the status of booked flights and alert customers in real-time about any delays, cancellations, or changes to their flight schedule.
    - Provide updates through preferred communication channels (e.g., email, SMS) as needed.

**Tone and Style:**

- Maintain a friendly, professional, and approachable demeanor in all interactions with customers.
- Ensure that all communication is clear, informative, and tailored to the customer's specific needs and inquiries.

**User Interaction Instructions:**

- Respond to customer queries promptly and accurately.
- Use a conversational style while ensuring professionalism.
- Prioritize customer satisfaction by being attentive, empathetic, and proactive in all assistance provided.

**Additional Notes:**

- Stay updated on any changes to airline policies, travel restrictions, and other relevant information that could impact flight bookings and customer experience.
- Use clear and concise language to explain options and processes, avoiding jargon where possible for better customer understanding.

This AI assistant is designed to streamline the flight booking process for customers of Contoso Travel, ensuring that all their travel needs are met efficiently and effectively.

```

#### Schritt 4: Iterieren und Verbessern

Der Wert dieses Meta-Prompting-Systems liegt darin, die Erstellung von Prompts für mehrere Agenten zu vereinfachen und die Prompts im Laufe der Zeit zu verbessern. Es ist selten, dass ein Prompt beim ersten Mal für den gesamten Anwendungsfall funktioniert. Kleine Anpassungen und Verbesserungen vorzunehmen, indem man das Basis-Prompt ändert und es durch das System laufen lässt, ermöglicht es, Ergebnisse zu vergleichen und zu bewerten.

## Bedrohungen verstehen

Um vertrauenswürdige KI-Agenten zu entwickeln, ist es wichtig, die Risiken und Bedrohungen für deinen KI-Agenten zu verstehen und zu mindern. Schauen wir uns einige der verschiedenen Bedrohungen für KI-Agenten an und wie du besser planen und dich darauf vorbereiten kannst.

![Bedrohungen verstehen](../../../translated_images/understanding-threats.f8fbe6fe11e025b3085fc91e82d975937ad1d672260a2aeed40458aa41798d0e.de.png)

### Aufgaben und Anweisungen

**Beschreibung:** Angreifer versuchen, die Anweisungen oder Ziele des KI-Agenten durch Eingaben oder Manipulationen zu ändern.

**Abwehrmaßnahmen**: Führe Validierungsprüfungen und Eingabefilter durch, um potenziell gefährliche Prompts zu erkennen, bevor sie vom KI-Agenten verarbeitet werden. Da diese Angriffe in der Regel häufige Interaktionen mit dem Agenten erfordern, ist die Begrenzung der Anzahl der Gesprächsrunden eine weitere Möglichkeit, diese Angriffe zu verhindern.

### Zugriff auf kritische Systeme

**Beschreibung**: Wenn ein KI-Agent Zugriff auf Systeme und Dienste hat, die sensible Daten speichern, können Angreifer die Kommunikation zwischen dem Agenten und diesen Diensten kompromittieren. Dies können direkte Angriffe oder indirekte Versuche sein, Informationen über diese Systeme durch den Agenten zu erlangen.

**Abwehrmaßnahmen**: KI-Agenten sollten nur bei Bedarf Zugriff auf Systeme haben, um solche Angriffe zu verhindern. Die Kommunikation zwischen Agent und System sollte ebenfalls sicher sein. Die Implementierung von Authentifizierung und Zugriffskontrollen ist eine weitere Möglichkeit, diese Informationen zu schützen.

### Überlastung von Ressourcen und Diensten

**Beschreibung:** KI-Agenten können auf verschiedene Tools und Dienste zugreifen, um Aufgaben zu erledigen. Angreifer können diese Fähigkeit nutzen, um diese Dienste durch eine hohe Anzahl von Anfragen über den KI-Agenten anzugreifen, was zu Systemausfällen oder hohen Kosten führen kann.

**Abwehrmaßnahmen:** Implementiere Richtlinien, um die Anzahl der Anfragen, die ein KI-Agent an einen Dienst senden kann, zu begrenzen. Die Begrenzung der Anzahl der Gesprächsrunden und Anfragen an deinen KI-Agenten ist eine weitere Möglichkeit, solche Angriffe zu verhindern.

### Manipulation der Wissensbasis

**Beschreibung:** Dieser Angriff zielt nicht direkt auf den KI-Agenten ab, sondern auf die Wissensbasis und andere Dienste, die der KI-Agent nutzen wird. Dies könnte die Korruption von Daten oder Informationen beinhalten, die der KI-Agent zur Erfüllung einer Aufgabe verwendet, was zu voreingenommenen oder unbeabsichtigten Antworten für den Nutzer führen kann.

**Abwehrmaßnahmen:** Führe regelmäßige Überprüfungen der Daten durch, die der KI-Agent in seinen Arbeitsabläufen verwenden wird. Stelle sicher, dass der Zugriff auf diese Daten sicher ist und nur von vertrauenswürdigen Personen geändert werden kann, um solche Angriffe zu vermeiden.

### Kaskadierende Fehler

**Beschreibung:** KI-Agenten greifen auf verschiedene Tools und Dienste zu, um Aufgaben zu erledigen. Fehler, die durch Angreifer verursacht werden, können zu Ausfällen anderer Systeme führen, mit denen der KI-Agent verbunden ist, wodurch der Angriff weiter verbreitet und schwerer zu beheben wird.

**Abwehrmaßnahmen**: Eine Möglichkeit, dies zu vermeiden, besteht darin, den KI-Agenten in einer begrenzten Umgebung wie einem Docker-Container auszuführen, um direkte Systemangriffe zu verhindern. Das Erstellen von Fallback-Mechanismen und Wiederholungslogik, wenn bestimmte Systeme mit einem Fehler reagieren, ist eine weitere Möglichkeit, größere Systemausfälle zu verhindern.

## Mensch in der Schleife (Human-in-the-Loop)

Eine weitere effektive Methode, um vertrauenswürdige KI-Agentensysteme zu entwickeln, ist die Nutzung eines Human-in-the-Loop-Ansatzes. Dies schafft einen Ablauf, bei dem Nutzer während der Ausführung Feedback an die Agenten geben können. Nutzer agieren im Wesentlichen als Agent in einem Multi-Agenten-System und können den laufenden Prozess genehmigen oder abbrechen.

![Mensch in der Schleife](../../../translated_images/human-in-the-loop.e9edbe8f6d42041b4213421410823250aa750fe8bdba5601d69ed46f3ff6489d.de.png)

Hier ist ein Code-Snippet, das AutoGen verwendet, um zu zeigen, wie dieses Konzept implementiert wird:

```python

# Create the agents.
model_client = OpenAIChatCompletionClient(model="gpt-4o-mini")
assistant = AssistantAgent("assistant", model_client=model_client)
user_proxy = UserProxyAgent("user_proxy", input_func=input)  # Use input() to get user input from console.

# Create the termination condition which will end the conversation when the user says "APPROVE".
termination = TextMentionTermination("APPROVE")

# Create the team.
team = RoundRobinGroupChat([assistant, user_proxy], termination_condition=termination)

# Run the conversation and stream to the console.
stream = team.run_stream(task="Write a 4-line poem about the ocean.")
# Use asyncio.run(...) when running in a script.
await Console(stream)

```
```

**Haftungsausschluss**:
Dieses Dokument wurde mit KI-gestützten maschinellen Übersetzungsdiensten übersetzt. Obwohl wir uns um Genauigkeit bemühen, weisen wir darauf hin, dass automatisierte Übersetzungen Fehler oder Ungenauigkeiten enthalten können. Das Originaldokument in seiner ursprünglichen Sprache sollte als maßgebliche Quelle betrachtet werden. Für kritische Informationen wird eine professionelle menschliche Übersetzung empfohlen. Wir übernehmen keine Haftung für Missverständnisse oder Fehlinterpretationen, die aus der Nutzung dieser Übersetzung resultieren.