ai-agents-for-beginners

Erkundung von KI-Agenten-Frameworks

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

KI-Agenten-Frameworks erkunden

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

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 Entwicklung von KI-Agenten bereitstellen. Sie verbessern die Skalierbarkeit, Zugänglichkeit und Effizienz beim Aufbau von KI-Systemen.

Einführung

Diese Lektion behandelt:

Lernziele

Die Ziele dieser Lektion sind:

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

Traditionelle KI-Frameworks können helfen, KI in Ihre Apps zu integrieren und diese Apps in den folgenden Bereichen zu verbessern:

Das klingt alles großartig, oder? Warum brauchen wir dann ein KI-Agenten-Framework?

KI-Agenten-Frameworks gehen über traditionelle KI-Frameworks hinaus. Sie sind darauf ausgelegt, die Erstellung intelligenter Agenten zu ermöglichen, die mit Benutzern, anderen Agenten und ihrer Umgebung interagieren können, um bestimmte Ziele zu erreichen. Diese Agenten können autonomes Verhalten zeigen, Entscheidungen treffen und sich an veränderte Bedingungen anpassen. Hier sind einige der wichtigsten Funktionen, die durch KI-Agenten-Frameworks ermöglicht werden:

Zusammengefasst ermöglichen Agenten mehr Automatisierung, schaffen intelligentere Systeme, die sich anpassen und aus ihrer Umgebung lernen können.

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

Dies ist ein sich schnell entwickelndes Gebiet, aber es gibt einige gemeinsame Merkmale der meisten KI-Agenten-Frameworks, die beim schnellen Prototyping und Iterieren helfen können, nämlich modulare Komponenten, kollaborative Tools und Echtzeitlernen. Schauen wir uns diese genauer an:

Verwendung modularer Komponenten

SDKs wie Microsoft Semantic Kernel und LangChain bieten vorgefertigte Komponenten wie KI-Connectoren, Prompt-Vorlagen und Speicherverwaltung.

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

Wie es in der Praxis funktioniert: Sie können einen vorgefertigten Parser verwenden, um Informationen aus Benutzereingaben zu extrahieren, ein Speichermodul, um Daten zu speichern und abzurufen, und einen Prompt-Generator, um mit Benutzern zu interagieren, ohne diese Komponenten selbst erstellen zu müssen.

Beispielcode. Schauen wir uns Beispiele an, wie Sie einen vorgefertigten KI-Connector mit Semantic Kernel Python und .Net verwenden können, der automatische Funktionsaufrufe nutzt, damit das Modell auf Benutzereingaben reagiert:

# Semantic Kernel Python Example

import asyncio
from typing import Annotated

from semantic_kernel.connectors.ai import FunctionChoiceBehavior
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion, AzureChatPromptExecutionSettings
from semantic_kernel.contents import ChatHistory
from semantic_kernel.functions import kernel_function
from semantic_kernel.kernel import Kernel

# Define a ChatHistory object to hold the conversation's context
chat_history = ChatHistory()
chat_history.add_user_message("I'd like to go to New York on January 1, 2025")


# Define a sample plugin that contains the function to book travel
class BookTravelPlugin:
    """A Sample Book Travel Plugin"""

    @kernel_function(name="book_flight", description="Book travel given location and date")
    async def book_flight(
        self, date: Annotated[str, "The date of travel"], location: Annotated[str, "The location to travel to"]
    ) -> str:
        return f"Travel was booked to {location} on {date}"

# Create the Kernel
kernel = Kernel()

# Add the sample plugin to the Kernel object
kernel.add_plugin(BookTravelPlugin(), plugin_name="book_travel")

# Define the Azure OpenAI AI Connector
chat_service = AzureChatCompletion(
    deployment_name="YOUR_DEPLOYMENT_NAME", 
    api_key="YOUR_API_KEY", 
    endpoint="https://<your-resource>.azure.openai.com/",
)

# Define the request settings to configure the model with auto-function calling
request_settings = AzureChatPromptExecutionSettings(function_choice_behavior=FunctionChoiceBehavior.Auto())


async def main():
    # Make the request to the model for the given chat history and request settings
    # The Kernel contains the sample that the model will request to invoke
    response = await chat_service.get_chat_message_content(
        chat_history=chat_history, settings=request_settings, kernel=kernel
    )
    assert response is not None

    """
    Note: In the auto function calling process, the model determines it can invoke the 
    `BookTravelPlugin` using the `book_flight` function, supplying the necessary arguments. 
    
    For example:

    "tool_calls": [
        {
            "id": "call_abc123",
            "type": "function",
            "function": {
                "name": "BookTravelPlugin-book_flight",
                "arguments": "{'location': 'New York', 'date': '2025-01-01'}"
            }
        }
    ]

    Since the location and date arguments are required (as defined by the kernel function), if the 
    model lacks either, it will prompt the user to provide them. For instance:

    User: Book me a flight to New York.
    Model: Sure, I'd love to help you book a flight. Could you please specify the date?
    User: I want to travel on January 1, 2025.
    Model: Your flight to New York on January 1, 2025, has been successfully booked. Safe travels!
    """

    print(f"`{response}`")
    # Example AI Model Response: `Your flight to New York on January 1, 2025, has been successfully booked. Safe travels! ✈️🗽`

    # Add the model's response to our chat history context
    chat_history.add_assistant_message(response.content)


if __name__ == "__main__":
    asyncio.run(main())

// Semantic Kernel C# example

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using System.ComponentModel;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;

ChatHistory chatHistory = [];
chatHistory.AddUserMessage("I'd like to go to New York on January 1, 2025");

var kernelBuilder = Kernel.CreateBuilder();
kernelBuilder.AddAzureOpenAIChatCompletion(
    deploymentName: "NAME_OF_YOUR_DEPLOYMENT",
    apiKey: "YOUR_API_KEY",
    endpoint: "YOUR_AZURE_ENDPOINT"
);
kernelBuilder.Plugins.AddFromType<BookTravelPlugin>("BookTravel"); 
var kernel = kernelBuilder.Build();

var settings = new AzureOpenAIPromptExecutionSettings()
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

var chatCompletion = kernel.GetRequiredService<IChatCompletionService>();

var response = await chatCompletion.GetChatMessageContentAsync(chatHistory, settings, kernel);

/*
Behind the scenes, the model recognizes the tool to call, what arguments it already has (location) and (date)
{

"tool_calls": [
    {
        "id": "call_abc123",
        "type": "function",
        "function": {
            "name": "BookTravelPlugin-book_flight",
            "arguments": "{'location': 'New York', 'date': '2025-01-01'}"
        }
    }
]
*/

Console.WriteLine(response.Content);
chatHistory.AddMessage(response!.Role, response!.Content!);

// Example AI Model Response: Your flight to New York on January 1, 2025, has been successfully booked. Safe travels! ✈️🗽

// Define a plugin that contains the function to book travel
public class BookTravelPlugin
{
    [KernelFunction("book_flight")]
    [Description("Book travel given location and date")]
    public async Task<string> BookFlight(DateTime date, string location)
    {
        return await Task.FromResult( $"Travel was booked to {location} on {date}");
    }
}

Was Sie in diesem Beispiel sehen können, ist, wie Sie einen vorgefertigten Parser nutzen können, um wichtige Informationen aus Benutzereingaben zu extrahieren, wie den Ursprung, das Ziel und das Datum einer Flugbuchungsanfrage. Dieser modulare Ansatz ermöglicht es Ihnen, sich auf die übergeordnete Logik zu konzentrieren.

Nutzung kollaborativer Tools

Frameworks wie CrewAI, Microsoft AutoGen und Semantic Kernel 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 Datenabruf, Analyse oder Entscheidungsfindung. Diese Agenten können kommunizieren und Informationen austauschen, um ein gemeinsames Ziel zu erreichen, wie eine Benutzeranfrage zu beantworten oder eine Aufgabe zu erledigen.

Beispielcode (AutoGen):

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

Was Sie im vorherigen Code sehen, ist, wie Sie eine Aufgabe erstellen können, bei der mehrere Agenten zusammenarbeiten, um Daten zu analysieren. Jeder Agent führt eine spezifische Funktion aus, 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 der Aufgabe verbessern.

Lernen in Echtzeit

Fortgeschrittene Frameworks bieten Funktionen für kontextuelles Verständnis und Anpassung in Echtzeit.

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 kontinuierlicher 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 die Leistung im Laufe der Zeit zu verbessern. Dieser iterative Lernprozess ermöglicht es Agenten, sich an veränderte Bedingungen und Benutzerpräferenzen anzupassen, wodurch die Gesamteffektivität des Systems verbessert 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 wichtige Unterschiede in Bezug auf Design, Funktionen und Zielanwendungen betrachten:

AutoGen

AutoGen ist ein Open-Source-Framework, das von Microsoft Research’s AI Frontiers Lab entwickelt wurde. Es konzentriert sich auf ereignisgesteuerte, verteilte agentische Anwendungen und ermöglicht mehrere LLMs und SLMs, Tools und fortgeschrittene Multi-Agent-Designmuster.

AutoGen basiert auf dem Kernkonzept von Agenten, die autonome Einheiten sind, die ihre Umgebung wahrnehmen, Entscheidungen treffen und Maßnahmen ergreifen können, um bestimmte Ziele zu erreichen. Agenten kommunizieren über asynchrone Nachrichten, wodurch sie unabhängig und parallel arbeiten können, was die Skalierbarkeit und Reaktionsfähigkeit des Systems verbessert.

Laut Wikipedia ist ein Akteur die grundlegende Baueinheit der nebenläufigen Berechnung. Als Antwort auf eine empfangene Nachricht kann ein Akteur: lokale Entscheidungen treffen, weitere Akteure erstellen, weitere Nachrichten senden und bestimmen, wie auf die nächste empfangene Nachricht reagiert wird.

Anwendungsfälle: Automatisierung von Codegenerierung, Datenanalysetasks und Erstellung benutzerdefinierter Agenten für Planungs- und Forschungsfunktionen.

Hier sind einige wichtige Kernkonzepte von AutoGen:

Semantic Kernel + Agent Framework

Semantic Kernel ist ein unternehmensbereites KI-Orchestrierungs-SDK. Es besteht aus KI- und Speicher-Connectoren sowie einem Agenten-Framework.

Lassen Sie uns zunächst einige Kernkomponenten behandeln:

Azure AI Agent Service ist eine neuere Ergänzung, die auf der Microsoft Ignite 2024 vorgestellt wurde. Sie ermöglicht die Entwicklung und Bereitstellung von KI-Agenten mit flexibleren Modellen, wie dem direkten Aufruf von Open-Source-LLMs wie Llama 3, Mistral und Cohere.

Azure AI Agent Service bietet stärkere Sicherheitsmechanismen für Unternehmen und Methoden zur Datenspeicherung, wodurch sie sich für Unternehmensanwendungen eignet.

Die Service funktioniert direkt mit Multi-Agent-Orchestrierungs-Frameworks wie AutoGen und Semantic Kernel.

Dieser Service befindet sich derzeit in der öffentlichen Vorschau und unterstützt Python und C# für die Erstellung von Agenten.

Mit Semantic Kernel Python können wir einen Azure AI Agent mit einem benutzerdefinierten Plugin erstellen:

import asyncio
from typing import Annotated

from azure.identity.aio import DefaultAzureCredential

from semantic_kernel.agents import AzureAIAgent, AzureAIAgentSettings, AzureAIAgentThread
from semantic_kernel.contents import ChatMessageContent
from semantic_kernel.contents import AuthorRole
from semantic_kernel.functions import kernel_function


# Define a sample plugin for the sample
class MenuPlugin:
    """A sample Menu Plugin used for the concept sample."""

    @kernel_function(description="Provides a list of specials from the menu.")
    def get_specials(self) -> Annotated[str, "Returns the specials from the menu."]:
        return """
        Special Soup: Clam Chowder
        Special Salad: Cobb Salad
        Special Drink: Chai Tea
        """

    @kernel_function(description="Provides the price of the requested menu item.")
    def get_item_price(
        self, menu_item: Annotated[str, "The name of the menu item."]
    ) -> Annotated[str, "Returns the price of the menu item."]:
        return "$9.99"


async def main() -> None:
    ai_agent_settings = AzureAIAgentSettings.create()

    async with (
        DefaultAzureCredential() as creds,
        AzureAIAgent.create_client(
            credential=creds,
            conn_str=ai_agent_settings.project_connection_string.get_secret_value(),
        ) as client,
    ):
        # Create agent definition
        agent_definition = await client.agents.create_agent(
            model=ai_agent_settings.model_deployment_name,
            name="Host",
            instructions="Answer questions about the menu.",
        )

        # Create the AzureAI Agent using the defined client and agent definition
        agent = AzureAIAgent(
            client=client,
            definition=agent_definition,
            plugins=[MenuPlugin()],
        )

        # Create a thread to hold the conversation
        # If no thread is provided, a new thread will be
        # created and returned with the initial response
        thread: AzureAIAgentThread | None = None

        user_inputs = [
            "Hello",
            "What is the special soup?",
            "How much does that cost?",
            "Thank you",
        ]

        try:
            for user_input in user_inputs:
                print(f"# User: '{user_input}'")
                # Invoke the agent for the specified thread
                response = await agent.get_response(
                    messages=user_input,
                    thread_id=thread,
                )
                print(f"# {response.name}: {response.content}")
                thread = response.thread
        finally:
            await thread.delete() if thread else None
            await client.agents.delete_agent(agent.id)


if __name__ == "__main__":
    asyncio.run(main())

Kernkonzepte

Azure AI Agent Service hat die folgenden Kernkonzepte:

Anwendungsfälle: Azure AI Agent Service ist für Unternehmensanwendungen konzipiert, die eine sichere, skalierbare und flexible Bereitstellung von KI-Agenten erfordern.

Was ist der Unterschied zwischen diesen Frameworks?

Es scheint, als gäbe es viele Überschneidungen zwischen diesen Frameworks, aber es gibt einige wesentliche Unterschiede in Bezug auf Design, Fähigkeiten und Zielanwendungsfälle:

Immer noch unsicher, welches Sie wählen sollen?

Anwendungsfälle

Lassen Sie uns versuchen, Ihnen zu helfen, indem wir einige häufige Anwendungsfälle durchgehen:

F: Ich experimentiere, lerne und baue Proof-of-Concept-Agentenanwendungen und möchte schnell bauen und experimentieren können.

A: AutoGen wäre eine gute Wahl für dieses Szenario, da es sich auf ereignisgesteuerte, verteilte Anwendungen mit Agenten konzentriert und fortschrittliche Multi-Agent-Designmuster unterstützt.

F: Was macht AutoGen zu einer besseren Wahl als Semantic Kernel und Azure AI Agent Service für diesen Anwendungsfall?

A: AutoGen ist speziell für ereignisgesteuerte, verteilte Anwendungen mit Agenten konzipiert und eignet sich daher gut für die Automatisierung von Codegenerierungs- und Datenanalysetasks. Es bietet die notwendigen Tools und Fähigkeiten, um komplexe Multi-Agent-Systeme effizient zu erstellen.

F: Klingt, als könnte Azure AI Agent Service hier auch funktionieren, es hat Tools für die Codegenerierung und mehr?

A: Ja, Azure AI Agent Service ist eine Plattform für Agenten und bietet integrierte Funktionen für mehrere Modelle, Azure AI Search, Bing Search und Azure Functions. Es erleichtert das Erstellen Ihrer Agenten im Foundry-Portal und deren Bereitstellung im großen Maßstab.

F: Ich bin immer noch verwirrt, geben Sie mir einfach eine Option.

A: Eine großartige Wahl ist es, Ihre Anwendung zuerst in Semantic Kernel zu erstellen und dann Azure AI Agent Service zu verwenden, um Ihren Agenten bereitzustellen. Dieser Ansatz ermöglicht es Ihnen, Ihre Agenten einfach zu speichern, während Sie die Möglichkeit nutzen, Multi-Agent-Systeme in Semantic Kernel zu erstellen. Darüber hinaus verfügt Semantic Kernel über einen Connector in AutoGen, der die gemeinsame Nutzung beider Frameworks erleichtert.

Lassen Sie uns die wichtigsten Unterschiede in einer Tabelle zusammenfassen:

Framework Fokus Kernkonzepte Anwendungsfälle
AutoGen Ereignisgesteuerte, verteilte Anwendungen mit Agenten Agenten, Personas, Funktionen, Daten Codegenerierung, Datenanalysetasks
Semantic Kernel Verständnis und Generierung menschenähnlicher Textinhalte Agenten, modulare Komponenten, Zusammenarbeit Sprachverständnis, Inhaltserstellung
Azure AI Agent Service Flexible Modelle, Unternehmenssicherheit, Codegenerierung, Tool-Aufrufe Modularität, Zusammenarbeit, Prozess-Orchestrierung Sichere, skalierbare und flexible Bereitstellung von KI-Agenten

Was ist der ideale Anwendungsfall für jedes dieser Frameworks?

Kann ich meine vorhandenen Azure-Ökosystem-Tools direkt integrieren oder benötige ich eigenständige Lösungen?

Die Antwort ist ja, Sie können Ihre vorhandenen Azure-Ökosystem-Tools direkt mit Azure AI Agent Service integrieren, insbesondere weil es so konzipiert wurde, dass es nahtlos mit anderen Azure-Diensten funktioniert. 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, aber es könnte erforderlich sein, die Azure-Dienste aus Ihrem Code aufzurufen. Eine andere Möglichkeit zur Integration besteht darin, die Azure SDKs zu verwenden, um von Ihren Agenten aus mit Azure-Diensten zu interagieren. Wie bereits erwähnt, können Sie Azure AI Agent Service auch als Orchestrator für Ihre in AutoGen oder Semantic Kernel erstellten Agenten verwenden, was einen einfachen Zugang zum Azure-Ökosystem ermöglicht.

Haben Sie weitere Fragen zu KI-Agenten-Frameworks?

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.

Referenzen

Vorherige Lektion

Einführung in KI-Agenten und Anwendungsfälle

Nächste Lektion

Verständnis von agentischen Designmustern

Haftungsausschluss:
Dieses Dokument wurde mit dem KI-Übersetzungsdienst Co-op Translator ü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 sich aus der Nutzung dieser Übersetzung ergeben.

This site is open source. Improve this page.