Freigeben über

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

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 DefaultAzureCredential());

Warnung

DefaultAzureCredential ist praktisch für die Entwicklung, erfordert aber sorgfältige Überlegungen in der Produktion. Berücksichtigen Sie in der Produktion die Verwendung bestimmter Anmeldeinformationen (z. B. ManagedIdentityCredential), um Latenzprobleme, unbeabsichtigte Abfragen von Anmeldeinformationen und potenzielle Sicherheitsrisiken durch Ausweichmechanismen zu vermeiden.

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 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 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 AgentResponseUpdate, WorkflowBuilder
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.as_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 Generators:

        # Build the workflow with agents as executors
        workflow = WorkflowBuilder(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 event.type == "output" and isinstance(event.data, AgentResponseUpdate):
                # 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 event.type == "output":
                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

  1. Azure AI-Client-Setup: Verwendet AzureAIAgentClient mit Azure CLI-Anmeldeinformationen zur Authentifizierung
  2. Agent Factory Pattern: Erstellt eine Fabrikfunktion, die den asynchronen Kontextlebenszyklus für mehrere Agenten verwaltet.
  3. Sequenzielle Verarbeitung: Writer-Agent generiert zuerst Inhalt und übergibt ihn dann an den Prüfer-Agent.
  4. Streaming-Updates: Ausgabeereignisse (type="output") mit AgentResponseUpdate Daten stellen Echtzeittokenupdates bereit, während Agenten Antworten generieren.
  5. Kontextverwaltung: Ordnungsgemäße Bereinigung von Azure AI-Ressourcen mithilfe von AsyncExitStack

Wichtige Konzepte

  • Azure AI Agent Service: Cloudbasierte KI-Agenten mit erweiterten Schlussfolgerungsfähigkeiten
  • WorkflowEvent: Ausgabeereignisse (type="output") enthalten Agentausgabedaten (AgentResponseUpdate für Streaming, AgentResponse für Nicht-Streaming)
  • 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

Human-in-the-Loop

  • Last updated on