Agenten in Workflows

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

• Agents in Workflows
• Direkte Kanten
• Workflow-Generator

Voraussetzungen

• .NET 8.0 SDK oder höher
• Ein Azure Foundry-Projektendpunkt und -Modell 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 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 OpenAI client
        var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
            ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set.");
        var deploymentName = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYMENT_NAME") ?? "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, deploymentName);
        AIAgent spanishAgent = await GetTranslationAgentAsync("Spanish", persistentAgentsClient, deploymentName);
        AIAgent englishAgent = await GetTranslationAgentAsync("English", persistentAgentsClient, deploymentName);

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.RunStreamingAsync(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())
        {
            if (evt is AgentResponseUpdateEvent 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

1. Einrichten des Azure Foundry-Clients: Verwendet PersistentAgentsClient mit Azure CLI-Anmeldeinformationen für die Authentifizierung
2. Erstellung von Agenten: Erstellt persistente Agenten in Azure Foundry mit exakten Übersetzungsanweisungen
3. Sequenzielle Verarbeitung: Der französische Agent übersetzt zuerst Eingaben, dann spanischer Agent und dann englischer Agent
4. Token-Umschaltmuster: Agents speichern Nachrichten zwischenspeichern und verarbeiten sie nur, wenn sie ein TurnToken erhalten.
5. Streamingupdates: AgentResponseUpdateEvent Stellt Echtzeittokenupdates bereit, wenn Agents Antworten generieren
6. 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
• WorkflowEvent: Ausgabeereignisse (type="output") enthalten Agentausgabedaten (AgentResponseUpdate für Streaming, AgentResponse für Nicht-Streaming)
• 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 AzureOpenAIResponsesClient, um intelligente Agenten zu erstellen
• 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

Behandelte Konzepte

• Agents in Workflows
• Direkte Kanten
• Workflow-Generator

Voraussetzungen

• Python 3.10 oder höher
• Agent Framework installiert: pip install agent-framework --pre
• Azure OpenAI-Antworten, die mit ordnungsgemäßen Umgebungsvariablen konfiguriert sind
• Azure CLI-Authentifizierung: az login

Schritt 1: Importieren erforderlicher Abhängigkeiten

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

import asyncio
import os

from agent_framework import AgentResponseUpdate, WorkflowBuilder
from agent_framework.azure import AzureOpenAIResponsesClient
from azure.identity import AzureCliCredential

Schritt 2: Erstellen des Azure OpenAI-Antwortclients

Erstellen Sie einen freigegebenen Client, den Sie zum Erstellen mehrerer Agents verwenden können:

async def main() -> None:
    client = AzureOpenAIResponsesClient(
        project_endpoint=os.environ["AZURE_AI_PROJECT_ENDPOINT"],
        deployment_name=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
        credential=AzureCliCredential(),
    )

Schritt 3: Erstellen von spezialisierten Agents

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

    # Create a Writer agent that generates content
    writer_agent = client.as_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_agent = client.as_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 Generators:

        # Build the workflow with agents as executors
        workflow = WorkflowBuilder(start_executor=writer_agent).add_edge(writer_agent, reviewer_agent).build()

Schritt 5: Ausführen mit Streaming

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

    last_author: str | None = None

    events = workflow.run("Create a slogan for a new electric SUV that is affordable and fun to drive.", stream=True)
    async for event in events:
        if event.type == "output" and isinstance(event.data, AgentResponseUpdate):
            update = event.data
            author = update.author_name
            if author != last_author:
                if last_author is not None:
                    print()
                print(f"{author}: {update.text}", end="", flush=True)
                last_author = author
            else:
                print(update.text, end="", flush=True)

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

1. Clientsetup: Verwendet eine AzureOpenAIResponsesClient mit Azure CLI-Anmeldeinformationen für die Authentifizierung.
2. Agent Creation: Erstellt Writer- und Reviewer-Agents aus derselben Clientkonfiguration.
3. Sequenzielle Verarbeitung: Writer-Agent generiert zuerst Inhalt und übergibt ihn dann an den Prüfer-Agent.
4. Streamingupdates: Ausgabeereignisse (type="output") mit AgentResponseUpdate Daten stellen Echtzeittokenupdates bereit, wenn Agents Antworten generieren.

Wichtige Konzepte

• AzureOpenAIResponsesClient: Freigegebener Client, der zum Erstellen von Workflow-Agents mit konsistenter Konfiguration verwendet wird.
• WorkflowEvent: Ausgabeereignisse (type="output") enthalten Agentenausgabedaten (AgentResponseUpdate für Streaming, AgentResponse für Nicht-Streaming).
• Sequenzieller Workflow: Agenten, die in einer Pipeline verbunden sind, in der die Ausgabe von einem Agenten zum nächsten fließt.

Vollständige Implementierung

Die vollständige Arbeitsimplementierung finden Sie unter azure_ai_agents_streaming.py im Agent Framework-Repository.