ai-agents-for-beginners

Exploring AI Agent Frameworks

(Klicken Sie auf das obige Bild, um das Video 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 rationalisieren.

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

Einleitung

Diese Lektion behandelt

Lernziele

Die Ziele dieser Lektion sind es, Ihnen zu helfen zu verstehen

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

Herkömmliche KI-Frameworks können Ihnen helfen, KI in Ihre Apps zu integrieren und diese Apps auf folgende Weise zu verbessern

Das klingt alles großartig, warum brauchen wir also das KI-Agenten-Framework?

KI-Agenten-Frameworks stellen mehr als nur KI-Frameworks dar. Sie sind darauf ausgelegt, die Erstellung von intelligenten Agenten zu ermöglichen, die mit Benutzern, anderen Agenten und der 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. Schauen wir uns einige wichtige Fähigkeiten an, die durch KI-Agenten-Frameworks ermöglicht werden.

Zusammenfassend lässt sich sagen, dass Agenten Ihnen ermöglichen, mehr zu tun, die Automatisierung auf die nächste Stufe zu heben und intelligentere Systeme zu erstellen, die sich an ihre Umgebung anpassen und daraus lernen können.

Wie kann man schnell Prototypen erstellen, iterieren und die Fähigkeiten des Agenten verbessern?

Dies ist eine sich schnell entwickelnde Landschaft, aber es gibt einige Dinge, die bei den meisten KI-Agenten-Frameworks üblich sind und Ihnen helfen können, schnell Prototypen zu erstellen und zu iterieren, nämlich Modulkomponenten, Kollaborationstools und Echtzeitlernen. Lassen Sie uns diese genauer betrachten.

Modulare Komponenten verwenden

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

Wie Teams diese nutzen können: Teams können diese Komponenten schnell zusammenstellen, um einen funktionsfähigen Prototypen zu erstellen, ohne bei Null anfangen zu müssen, was schnelle Experimente und Iterationen ermöglicht.

So funktioniert es in der Praxis: 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 zur Interaktion mit Benutzern, alles ohne diese Komponenten von Grund auf neu erstellen zu müssen.

Beispielcode. Sehen wir uns Beispiele an, wie Sie mit Semantic Kernel Python und .Net einen vorgefertigten KI-Konnektor verwenden können, der Auto-Funktionsaufrufe verwendet, 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}");
    }
}

Aus diesem Beispiel ist ersichtlich, 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.

Kollaborationstools nutzen

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 ihnen zu ermöglichen, kollaborative Arbeitsabläufe zu testen und zu verfeinern und die Gesamteffizienz des Systems zu verbessern.

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

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 Aufgabeneffizienz und -leistung verbessern.

In Echtzeit lernen

Fortgeschrittene Frameworks bieten Funktionen für Echtzeit-Kontextverständnis und -Anpassung.

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

So funktioniert es in der Praxis: Agenten können Benutzerfeedback, Umgebungsdaten und Aufgabenergebnisse analysieren, um ihre Wissensbasis zu aktualisieren, Entscheidungsfindungsalgorithmen anzupassen und die Leistung im Laufe der Zeit zu verbessern. Dieser iterative Lernprozess ermöglicht es Agenten, sich an veränderte Bedingungen und Benutzervorlieben anzupassen und die Gesamteffektivität des Systems zu verbessern.

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 schauen wir uns einige wichtige Unterschiede in Bezug auf ihr Design, ihre Fähigkeiten und ihre Zielanwendungsfälle an.

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 die Nutzung mehrerer LLMs und SLMs, Tools und fortschrittlicher Multi-Agenten-Designmuster.

AutoGen basiert auf dem Kernkonzept von Agenten, die autonome Entitäten 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 und die Skalierbarkeit und Reaktionsfähigkeit des Systems zu verbessern.

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

Anwendungsfälle: Automatisierung der Code-Generierung, Datenanalyseaufgaben und Erstellung benutzerdefinierter Agenten für Planungs- und Forschungsfunktionen.

Hier sind einige wichtige Kernkonzepte von AutoGen

Semantic Kernel + Agent Framework

Semantic Kernel ist ein unternehmenstaugliches KI-Orchestrierungs-SDK. Es besteht aus KI- und Speicherkonnektoren sowie einem Agenten-Framework.

Lassen Sie uns zuerst einige Kernkomponenten behandeln.

Das ist also das Grundlegende des Semantic Kernel-Frameworks, wie sieht es mit dem Agenten-Framework aus?

Azure KI Agent-Dienst

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 z. B. dem direkten Aufrufen von Open-Source-LLMs wie Llama 3, Mistral und Cohere.

Azure AI Agent Service bietet stärkere Unternehmenssicherheitsmechanismen und Datenspeichermethoden, wodurch er sich für Unternehmensanwendungen eignet.

Er funktioniert "out-of-the-box" mit Multi-Agenten-Orchestrierungs-Frameworks wie AutoGen und Semantic Kernel.

Dieser Dienst befindet sich derzeit in der Public Preview 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, dass es viel Überschneidung zwischen diesen Frameworks gibt, aber es gibt einige wichtige Unterschiede in Bezug auf ihr Design, ihre Fähigkeiten und ihre Zielanwendungsfälle.

Immer noch unsicher, welches Sie wählen sollen?

Anwendungsfälle

Lassen Sie uns sehen, ob wir Ihnen helfen können, indem wir einige gängige Anwendungsfälle durchgehen.

F: Ich experimentiere, lerne und erstelle Proof-of-Concept-Agentenanwendungen und möchte in der Lage sein, schnell zu bauen und zu experimentieren.

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

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

A: AutoGen ist speziell für ereignisgesteuerte, verteilte agentische Anwendungen konzipiert und eignet sich daher gut für die Automatisierung von Code-Generierungs- und Datenanalyseaufgaben. Es bietet die notwendigen Werkzeuge und Fähigkeiten, um komplexe Multi-Agenten-Systeme effizient zu erstellen.

F: Klingt, als ob Azure AI Agent Service hier auch funktionieren könnte, er hat Werkzeuge für Code-Generierung und mehr?

A: Ja, 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. Er erleichtert den Aufbau Ihrer Agenten im Foundry-Portal und deren Bereitstellung in großem Maßstab.

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

A: Eine großartige Wahl ist es, Ihre Anwendung zunächst in Semantic Kernel zu erstellen und dann Azure AI Agent Service zur Bereitstellung Ihres Agenten zu verwenden. Dieser Ansatz ermöglicht es Ihnen, Ihre Agenten einfach zu persistieren und gleichzeitig die Leistung von Semantic Kernel für den Aufbau von Multi-Agenten-Systemen zu nutzen. Darüber hinaus verfügt Semantic Kernel über einen Konnektor in AutoGen, was die gemeinsame Nutzung beider Frameworks erleichtert.

Fassen wir die wichtigsten Unterschiede in einer Tabelle zusammen.

Framework Fokus Kernkonzepte Anwendungsfälle
AutoGen Ereignisgesteuerte, verteilte agentische Anwendungen Agenten, Personas, Funktionen, Daten Code-Generierung, Datenanalyseaufgaben
Semantischer Kernel Verständnis und Generierung von menschenähnlichen Textinhalten Agenten, modulare Komponenten, Kollaboration Natürliches Sprachverständnis, Inhaltsgenerierung
Azure KI Agent-Dienst Flexible Modelle, Unternehmenssicherheit, Code-Generierung, Tool-Aufrufe Modularität, Kollaboration, Prozessorchestrierung 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 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 sich auch in Azure-Dienste integrieren, aber es kann erforderlich sein, dass Sie die Azure-Dienste aus Ihrem Code aufrufen. Eine weitere Möglichkeit der Integration ist die Verwendung der Azure SDKs, um von Ihren Agenten aus mit Azure-Diensten zu interagieren. Darüber hinaus können Sie, wie erwähnt, Azure AI Agent Service als Orchestrator für Ihre in AutoGen oder Semantic Kernel erstellten Agenten verwenden, was einen einfachen Zugriff auf das 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 für Agenten

Nächste Lektion

Verständnis von agentischen Entwurfsmustern

Diese Seite ist Open Source. Verbessern Sie diese Seite.