ai-agents-for-beginners

Erforschung von AI-Agenten-Frameworks

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

Erforsche AI-Agenten-Frameworks

AI-Agenten-Frameworks sind Softwareplattformen, die entwickelt wurden, um die Erstellung, Bereitstellung und Verwaltung von AI-Agenten zu vereinfachen. Diese Frameworks bieten Entwicklern vorgefertigte Komponenten, Abstraktionen und Tools, die die Entwicklung komplexer AI-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 AI-Agenten bereitstellen. Sie verbessern die Skalierbarkeit, Zugänglichkeit und Effizienz beim Aufbau von AI-Systemen.

Einführung

Diese Lektion behandelt:

Lernziele

Die Ziele dieser Lektion sind:

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

Traditionelle AI-Frameworks können Ihnen helfen, AI in Ihre Apps zu integrieren und diese Apps auf folgende Weise zu verbessern:

Das klingt alles großartig, aber warum brauchen wir dann AI-Agenten-Frameworks?

AI-Agenten-Frameworks gehen über traditionelle AI-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. Schauen wir uns einige der wichtigsten Fähigkeiten an, die durch AI-Agenten-Frameworks ermöglicht werden:

Zusammenfassend ermöglichen Agenten, mehr zu erreichen, die 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 sich schnell entwickelndes Feld, aber es gibt einige gemeinsame Elemente in den meisten AI-Agenten-Frameworks, die Ihnen helfen können, schnell Prototypen zu erstellen und zu iterieren, 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 AI-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 – alles, ohne diese Komponenten selbst erstellen zu müssen.

Beispielcode. Schauen wir uns Beispiele an, wie Sie einen vorgefertigten AI-Connector mit Semantic Kernel Python und .Net verwenden können, der automatische Funktionsaufrufe nutzt, um auf Benutzereingaben zu reagieren:

# 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, ist, wie Sie einen vorgefertigten Parser nutzen können, um wichtige Informationen aus Benutzereingaben zu extrahieren, wie z. B. 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 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 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, die mehrere Agenten umfasst, 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 spezialisierter Agenten mit spezifischen Rollen können Sie die Effizienz und Leistung von Aufgaben verbessern.

Lernen in Echtzeit

Fortschrittliche Frameworks bieten Fähigkeiten 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 ihre Leistung im Laufe der Zeit zu verbessern. Dieser iterative Lernprozess ermöglicht es Agenten, sich an veränderte Bedingungen und Benutzerpräferenzen anzupassen, was die Gesamteffektivität des Systems erhöht.

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 ihr Design, ihre Fähigkeiten und ihre Zielanwendungsfälle betrachten:

AutoGen

AutoGen ist ein Open-Source-Framework, das vom AI Frontiers Lab von Microsoft Research entwickelt wurde. Es konzentriert sich auf ereignisgesteuerte, verteilte agentische Anwendungen und ermöglicht mehrere LLMs und SLMs, Tools und fortschrittliche 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 spezifische Ziele zu erreichen. Agenten kommunizieren über asynchrone Nachrichten, was es ihnen ermöglicht, unabhängig und parallel zu arbeiten, wodurch die Skalierbarkeit und Reaktionsfähigkeit des Systems verbessert wird.

Agenten basieren auf dem Actor-Modell. Laut Wikipedia ist ein Actor der grundlegende Baustein der nebenläufigen Berechnung. Als Antwort auf eine empfangene Nachricht kann ein Actor: lokale Entscheidungen treffen, weitere Actors erstellen, weitere Nachrichten senden und bestimmen, wie auf die nächste empfangene Nachricht reagiert werden soll.

Anwendungsfälle: Automatisierung von Code-Generierung, Datenanalysetätigkeiten und Erstellung benutzerdefinierter Agenten für Planungs- und Forschungsfunktionen.

Hier sind einige wichtige Kernkonzepte von AutoGen:

Semantic Kernel + Agenten-Framework

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

Lassen Sie uns zunächst einige Kernkomponenten behandeln:

Diese Fakten werden dann in der Speichersammlung SummarizedAzureDocs gespeichert. Dies ist ein sehr vereinfachtes Beispiel, aber Sie können sehen, wie Informationen im Speicher abgelegt werden können, damit das LLM sie nutzen kann.

Das sind die Grundlagen des Semantic Kernel Frameworks, aber was ist mit dem Agent Framework?

Azure AI Agent Service

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

Der Azure AI Agent Service bietet stärkere Sicherheitsmechanismen für Unternehmen und Methoden zur Datenspeicherung, was ihn für Unternehmensanwendungen geeignet macht.

Er funktioniert sofort mit Multi-Agent-Orchestrierungs-Frameworks wie AutoGen und Semantic Kernel.

Dieser Service befindet sich derzeit in der Public Preview und unterstützt Python und C# für die Entwicklung 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

Der Azure AI Agent Service hat die folgenden Kernkonzepte:

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

Was sind die Unterschiede 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

Schauen wir, ob wir Ihnen helfen können, 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 Agentenanwendungen konzentriert und fortschrittliche Multi-Agent-Designmuster unterstützt.

F: Was macht AutoGen für diesen Anwendungsfall besser geeignet als Semantic Kernel und Azure AI Agent Service?

A: AutoGen wurde speziell für ereignisgesteuerte, verteilte Agentenanwendungen entwickelt und eignet sich daher hervorragend für die Automatisierung von Codegenerierungs- und Datenanalysetätigkeiten. Es bietet die notwendigen Tools und Fähigkeiten, um komplexe Multi-Agent-Systeme effizient zu erstellen.

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

A: Ja, der Azure AI Agent Service ist ein Plattformdienst für Agenten und bietet integrierte Funktionen für mehrere Modelle, Azure AI Search, Bing Search und Azure Functions. Es macht es einfach, Ihre Agenten im Foundry-Portal zu erstellen und in großem Maßstab bereitzustellen.

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 den Azure AI Agent Service zu verwenden, um Ihren Agenten bereitzustellen. Dieser Ansatz ermöglicht es Ihnen, Ihre Agenten einfach zu speichern und gleichzeitig die Möglichkeit zu nutzen, Multi-Agent-Systeme in Semantic Kernel zu erstellen. Darüber hinaus verfügt Semantic Kernel über einen Connector in AutoGen, was die gemeinsame Nutzung beider Frameworks erleichtert.

Lassen Sie uns die wichtigsten Unterschiede in einer Tabelle zusammenfassen:

Framework Fokus Kernkonzepte Anwendungsfälle
AutoGen Ereignisgesteuerte, verteilte Agentenanwendungen Agenten, Personas, Funktionen, Daten Codegenerierung, Datenanalysetätigkeiten
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 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 weil er so konzipiert wurde, dass er 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 der Azure AI Foundry.

Für AutoGen und Semantic Kernel können Sie ebenfalls mit Azure-Diensten integrieren, aber es kann 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. Wie bereits erwähnt, können Sie den Azure AI Agent Service auch als Orchestrator für Ihre in AutoGen oder Semantic Kernel erstellten Agenten verwenden, was einen einfachen Zugriff auf das Azure-Ökosystem ermöglicht.

Beispielcodes

Haben Sie weitere Fragen zu KI-Agenten-Frameworks?

Treten Sie dem Azure AI Foundry Discord bei, um andere Lernende zu treffen, an Sprechstunden teilzunehmen 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, 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 sich aus der Nutzung dieser Übersetzung ergeben.

This site is open source. Improve this page.