Agenten in Workflows

In diesem Lernprogramm wird veranschaulicht, wie KI-Agents mithilfe von Agent Framework in Workflows integriert werden. Sie lernen, Workflows zu erstellen, die die Leistungsfähigkeit spezialisierter KI-Agents für die Erstellung, Überprüfung und andere gemeinsame Aufgaben nutzen.

Was Sie erstellen werden

Sie erstellen einen Workflow, der:

Verwendet den Azure Foundry Agent Service zum Erstellen intelligenter Agents
Implementiert einen französischen Übersetzungsagenten, der Eingaben in Französisch übersetzt.
Implementiert einen spanischen Übersetzungsagenten, der Französisch in Spanisch übersetzt
Implementiert einen englischsprachigen Übersetzungs-Agent, der Spanisch zurück ins Englische übersetzt
Verbindet Agents in einer sequenziellen Workflowpipeline
Echtzeitaktualisierungen streamen, während Agenten Anfragen verarbeiten
Veranschaulicht die ordnungsgemäße Ressourcenbereinigung für Azure Foundry-Agents.

Behandelte Konzepte

Voraussetzungen

.NET 8.0 SDK oder höher
Azure Foundry-Dienstendpunkt und -Bereitstellung konfiguriert
Installierte und authentifizierte Azure CLI (für die Azure-Anmeldeinformationsauthentifizierung)
Eine neue Konsolenanwendung

Schritt 1: Installieren von NuGet-Paketen

Installieren Sie zunächst die erforderlichen Pakete für Ihr .NET-Projekt:

dotnet add package Azure.AI.Agents.Persistent --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Agents.AI.AzureAI --prerelease
dotnet add package Microsoft.Agents.AI.Workflows --prerelease

Schritt 2: Einrichten des Azure Foundry-Clients

Konfigurieren Sie den Azure Foundry-Client mit Umgebungsvariablen und Authentifizierung:

using System;
using System.Threading.Tasks;
using Azure.AI.Agents.Persistent;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;

public static class Program
{
    private static async Task Main()
    {
        // Set up the Azure Foundry client
        var endpoint = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_ENDPOINT") ?? throw new Exception("AZURE_FOUNDRY_PROJECT_ENDPOINT is not set.");
        var model = Environment.GetEnvironmentVariable("AZURE_FOUNDRY_PROJECT_MODEL_ID") ?? "gpt-4o-mini";
        var persistentAgentsClient = new PersistentAgentsClient(endpoint, new AzureCliCredential());

Schritt 3: Erstellen der Agent Factory-Methode

Implementieren Sie eine Hilfsmethode zum Erstellen von Azure Foundry-Agents mit bestimmten Anweisungen:

    /// <summary>
    /// Creates a translation agent for the specified target language.
    /// </summary>
    /// <param name="targetLanguage">The target language for translation</param>
    /// <param name="persistentAgentsClient">The PersistentAgentsClient to create the agent</param>
    /// <param name="model">The model to use for the agent</param>
    /// <returns>A ChatClientAgent configured for the specified language</returns>
    private static async Task<ChatClientAgent> GetTranslationAgentAsync(
        string targetLanguage,
        PersistentAgentsClient persistentAgentsClient,
        string model)
    {
        var agentMetadata = await persistentAgentsClient.Administration.CreateAgentAsync(
            model: model,
            name: $"{targetLanguage} Translator",
            instructions: $"You are a translation assistant that translates the provided text to {targetLanguage}.");

        return await persistentAgentsClient.GetAIAgentAsync(agentMetadata.Value.Id);
    }
}

Schritt 4: Erstellen von spezialisierten Azure Foundry Agents

Erstellen Sie drei Übersetzungs-Agents mithilfe der Hilfsmethode:

        // Create agents
        AIAgent frenchAgent = await GetTranslationAgentAsync("French", persistentAgentsClient, model);
        AIAgent spanishAgent = await GetTranslationAgentAsync("Spanish", persistentAgentsClient, model);
        AIAgent englishAgent = await GetTranslationAgentAsync("English", persistentAgentsClient, model);

Schritt 5: Erstellen des Workflows

Verbinden Sie die Agents in einem sequenziellen Workflow mithilfe von WorkflowBuilder:

        // Build the workflow by adding executors and connecting them
        var workflow = new WorkflowBuilder(frenchAgent)
            .AddEdge(frenchAgent, spanishAgent)
            .AddEdge(spanishAgent, englishAgent)
            .Build();

Schritt 6: Ausführen mit Streaming

Führen Sie den Workflow mit Streaming aus, um Echtzeitupdates von allen Agents zu beobachten:

        // Execute the workflow
        await using StreamingRun run = await InProcessExecution.StreamAsync(workflow, new ChatMessage(ChatRole.User, "Hello World!"));

        // Must send the turn token to trigger the agents.
        // The agents are wrapped as executors. When they receive messages,
        // they will cache the messages and only start processing when they receive a TurnToken.
        await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
        await foreach (WorkflowEvent evt in run.WatchStreamAsync().ConfigureAwait(false))
        {
            if (evt is AgentRunUpdateEvent executorComplete)
            {
                Console.WriteLine($"{executorComplete.ExecutorId}: {executorComplete.Data}");
            }
        }

Schritt 7: Ressourcenbereinigung

Bereinigen Sie die Azure Foundry-Agents nach der Verwendung ordnungsgemäß:

        // Cleanup the agents created for the sample.
        await persistentAgentsClient.Administration.DeleteAgentAsync(frenchAgent.Id);
        await persistentAgentsClient.Administration.DeleteAgentAsync(spanishAgent.Id);
        await persistentAgentsClient.Administration.DeleteAgentAsync(englishAgent.Id);
    }

Funktionsweise

Einrichten des Azure Foundry-Clients: Verwendet PersistentAgentsClient mit Azure CLI-Anmeldeinformationen für die Authentifizierung
Erstellung von Agenten: Erstellt persistente Agenten in Azure Foundry mit exakten Übersetzungsanweisungen
Sequenzielle Verarbeitung: Der französische Agent übersetzt zuerst Eingaben, dann spanischer Agent und dann englischer Agent
Token-Umschaltmuster: Agents speichern Nachrichten zwischenspeichern und verarbeiten sie nur, wenn sie ein TurnToken erhalten.
Streamingupdates: AgentRunUpdateEvent Stellt Echtzeittokenupdates bereit, wenn Agents Antworten generieren
Ressourcenverwaltung: Ordnungsgemäße Bereinigung von Azure Foundry-Agents mithilfe der Verwaltungs-API

Wichtige Konzepte

Azure Foundry Agent Service: Cloudbasierte KI-Agenten mit erweiterten Denkfähigkeiten
PersistentAgentsClient: Client zum Erstellen und Verwalten von Agents in Azure Foundry
AgentRunUpdateEvent: Echtzeit-Streamingupdates während der Agentausführung
TurnToken: Signal, das die Agentverarbeitung nach dem Zwischenspeichern von Nachrichten auslöst
Sequenzieller Workflow: Agents, die in einer Pipeline verbunden sind, wobei die Ausgabe von einem Agenten zum nächsten fließt

Vollständige Implementierung

Die vollständige Arbeitsimplementierung dieses Azure Foundry Agents-Workflows finden Sie im FoundryAgent-Program.cs Beispiel im Agent Framework-Repository.

Was Sie erstellen werden

Sie erstellen einen Workflow, der:

Verwendet azure AI Agent Service zum Erstellen intelligenter Agents
Implementiert einen Writer-Agent, der Inhalte basierend auf Aufforderungen erstellt.
Implementiert einen Prüfer-Agent, der Feedback zu den Inhalten bereitstellt
Verbindet Agents in einer sequenziellen Workflowpipeline
Echtzeitaktualisierungen streamen, während Agenten Anfragen verarbeiten
Veranschaulicht die richtige asynchrone Kontextverwaltung für Azure AI-Clients

Behandelte Konzepte

Voraussetzungen

Python 3.10 oder höher
Agent Framework installiert: pip install agent-framework-azure-ai --pre
Azure AI-Agent-Dienst mit ordnungsgemäßen Umgebungsvariablen konfiguriert
Azure CLI-Authentifizierung: az login

Schritt 1: Importieren erforderlicher Abhängigkeiten

Importieren Sie zunächst die erforderlichen Komponenten für Azure AI-Agents und -Workflows:

import asyncio
from collections.abc import Awaitable, Callable
from contextlib import AsyncExitStack
from typing import Any

from agent_framework import AgentRunUpdateEvent, WorkflowBuilder, WorkflowOutputEvent
from agent_framework.azure import AzureAIAgentClient
from azure.identity.aio import AzureCliCredential

Schritt 2: Erstellen der Azure AI Agent Factory

Erstellen Sie eine Hilfsfunktion zur Verwaltung der Erstellung von Azure AI-Agenten mit korrekter asynchroner Kontextbehandlung.

async def create_azure_ai_agent() -> tuple[Callable[..., Awaitable[Any]], Callable[[], Awaitable[None]]]:
    """Helper method to create an Azure AI agent factory and a close function.

    This makes sure the async context managers are properly handled.
    """
    stack = AsyncExitStack()
    cred = await stack.enter_async_context(AzureCliCredential())

    client = await stack.enter_async_context(AzureAIAgentClient(async_credential=cred))

    async def agent(**kwargs: Any) -> Any:
        return await stack.enter_async_context(client.create_agent(**kwargs))

    async def close() -> None:
        await stack.aclose()

    return agent, close

Schritt 3: Erstellen spezialisierter Azure KI-Agenten

Erstellen Sie zwei spezialisierte Agents für die Inhaltserstellung und -überprüfung:

async def main() -> None:
    agent, close = await create_azure_ai_agent()
    try:
        # Create a Writer agent that generates content
        writer = await agent(
            name="Writer",
            instructions=(
                "You are an excellent content writer. You create new content and edit contents based on the feedback."
            ),
        )

        # Create a Reviewer agent that provides feedback
        reviewer = await agent(
            name="Reviewer",
            instructions=(
                "You are an excellent content reviewer. "
                "Provide actionable feedback to the writer about the provided content. "
                "Provide the feedback in the most concise manner possible."
            ),
        )

Schritt 4: Erstellen des Workflows

Verbinden Sie die Agents in einem sequenziellen Workflow mithilfe des Fluent Builders:

        # Build the workflow with agents as executors
        workflow = WorkflowBuilder().set_start_executor(writer).add_edge(writer, reviewer).build()

Schritt 5: Ausführen mit Streaming

Führen Sie den Workflow mit Streaming aus, um Echtzeitupdates von beiden Agents zu beobachten:

        last_executor_id: str | None = None

        events = workflow.run_stream("Create a slogan for a new electric SUV that is affordable and fun to drive.")
        async for event in events:
            if isinstance(event, AgentRunUpdateEvent):
                # Handle streaming updates from agents
                eid = event.executor_id
                if eid != last_executor_id:
                    if last_executor_id is not None:
                        print()
                    print(f"{eid}:", end=" ", flush=True)
                    last_executor_id = eid
                print(event.data, end="", flush=True)
            elif isinstance(event, WorkflowOutputEvent):
                print("\n===== Final output =====")
                print(event.data)
    finally:
        await close()

Schritt 6: Ausführen der Hauptfunktion

Umschließen Sie alles in der Hauptfunktion mit der richtigen asynchronen Ausführung:

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

Funktionsweise

Azure AI-Client-Setup: Verwendet AzureAIAgentClient mit Azure CLI-Anmeldeinformationen zur Authentifizierung
Agent Factory Pattern: Erstellt eine Fabrikfunktion, die den asynchronen Kontextlebenszyklus für mehrere Agenten verwaltet.
Sequenzielle Verarbeitung: Writer-Agent generiert zuerst Inhalt und übergibt ihn dann an den Prüfer-Agent.
Streamingupdates: AgentRunUpdateEvent Stellt Echtzeittokenupdates bereit, wenn Agents Antworten generieren
Kontextverwaltung: Ordnungsgemäße Bereinigung von Azure AI-Ressourcen mithilfe von AsyncExitStack

Wichtige Konzepte

Azure AI Agent Service: Cloudbasierte KI-Agenten mit erweiterten Schlussfolgerungsfähigkeiten
AgentRunUpdateEvent: Echtzeit-Streamingupdates während der Agentausführung
AsyncExitStack: Richtige asynchrone Kontextverwaltung für mehrere Ressourcen
Agent Factory Pattern: Wiederverwendbare Agenterstellung mit freigegebener Clientkonfiguration
Sequenzieller Workflow: Agents, die in einer Pipeline verbunden sind, wobei die Ausgabe von einem Agenten zum nächsten fließt

Vollständige Implementierung

Die vollständige Arbeitsimplementierung dieses Azure AI-Agents-Workflows finden Sie im azure_ai_agents_streaming.py Beispiel im Agent Framework-Repository.

Nächste Schritte

Erfahren Sie mehr über das Verzweigen in Workflows

Feedback

War diese Seite hilfreich?

Last updated on 2025-11-21

Freigeben über

Agenten in Workflows

Was Sie erstellen werden

Behandelte Konzepte

Voraussetzungen

Schritt 1: Installieren von NuGet-Paketen

Schritt 2: Einrichten des Azure Foundry-Clients

Schritt 3: Erstellen der Agent Factory-Methode

Schritt 4: Erstellen von spezialisierten Azure Foundry Agents

Schritt 5: Erstellen des Workflows

Schritt 6: Ausführen mit Streaming

Schritt 7: Ressourcenbereinigung

Funktionsweise

Wichtige Konzepte

Vollständige Implementierung

Was Sie erstellen werden

Behandelte Konzepte

Voraussetzungen

Schritt 1: Importieren erforderlicher Abhängigkeiten

Schritt 2: Erstellen der Azure AI Agent Factory

Schritt 3: Erstellen spezialisierter Azure KI-Agenten

Schritt 4: Erstellen des Workflows

Schritt 5: Ausführen mit Streaming

Schritt 6: Ausführen der Hauptfunktion

Funktionsweise

Wichtige Konzepte

Vollständige Implementierung

Nächste Schritte

Feedback

Zusätzliche Ressourcen