Agenter i arbetsflöden

Vad du kommer att bygga

Du skapar ett arbetsflöde som:

• Använder Azure Foundry Agent Service för att skapa intelligenta agenter
• Implementerar en fransk översättningsagent som översätter indata till franska
• Implementerar en spansk översättningsagent som översätter franska till spanska
• Implementerar en engelsk översättningsagent som översätter spanska tillbaka till engelska
• Ansluter agenter i en pipeline för sekventiellt arbetsflöde
• Strömmar realtidsuppdateringar när agenter bearbetar begäranden
• Visar korrekt resursrensning för Azure Foundry-agenter

Begrepp som omfattas

• Agenter i arbetsflöden
• Direkta kanter
• Arbetsflödesverktyget

Förutsättningar

• .NET 8.0 SDK eller senare
• En Azure Foundry-projektslutpunkt och modell konfigurerad
• Azure CLI installerat och autentiserat (för autentisering med Azure-autentiseringsuppgifter)
• Ett nytt konsolprogram

Steg 1: Installera NuGet-paket

Installera först de nödvändiga paketen för .NET-projektet:

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

Steg 2: Konfigurera Azure Foundry-klienten

Konfigurera Azure Foundry-klienten med miljövariabler och autentisering:

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

Steg 3: Skapa agentfabriksmetod

Implementera en hjälpmetod för att skapa Azure Foundry-agenter med specifika instruktioner:

    /// <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);
    }
}

Steg 4: Skapa specialiserade Azure Foundry-agenter

Skapa tre översättningsagenter med hjälpmetoden:

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

Steg 5: Skapa arbetsflödet

Anslut agenterna i ett sekventiellt arbetsflöde med hjälp av WorkflowBuilder:

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

Steg 6: Kör med direktuppspelning

Kör arbetsflödet med direktuppspelning för att observera realtidsuppdateringar från alla agenter:

        // 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}");
            }
        }

Steg 7: Resursrensning

Rensa Azure Foundry-agenterna korrekt efter användning:

        // 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);
    }

Så här fungerar det

1. Konfiguration av Azure Foundry-klient: Använder PersistentAgentsClient med Azure CLI-autentiseringsuppgifter för autentisering
2. Skapande av agent: Skapar beständiga agenter på Azure Foundry med specifika instruktioner för översättning
3. Sekventiell bearbetning: Fransk agent översätter indata först, sedan spansk agent och sedan engelsk agent
4. Vänd tokenmönster: Agenter cachelagrar meddelanden och bearbetar endast när de tar emot en TurnToken
5. Direktuppspelningsuppdateringar: AgentResponseUpdateEvent tillhandahåller tokenuppdateringar i realtid när agenter genererar svar
6. Resurshantering: Korrekt rensning av Azure Foundry-agenter med hjälp av administrations-API:et

Viktiga begrepp

• Azure Foundry Agent Service: Molnbaserade AI-agenter med avancerade resonemangsfunktioner
• PersistentAgentsClient: Klient för att skapa och hantera agenter på Azure Foundry
• WorkflowEvent: Utdatahändelser (type="output") innehåller agentutdata (AgentResponseUpdate för direktuppspelning, AgentResponse för icke-direktuppspelning)
• TurnToken: Signal som utlöser agentbearbetning efter cachelagring av meddelanden
• Sekventiellt arbetsflöde: Agenter som är anslutna i en pipeline där utdata flödar från en till en annan

Fullständig implementering

Den fullständiga implementeringen av det här Arbetsflödet för Azure Foundry-agenter finns i FoundryAgent-Program.cs exempel på Agent Framework-lagringsplatsen.

Vad du kommer att bygga

Du skapar ett arbetsflöde som:

• Använder AzureOpenAIResponsesClient för att skapa intelligenta agenter
• Implementerar en Writer-agent som skapar innehåll baserat på frågor
• Implementerar en granskaragent som ger feedback om innehållet
• Ansluter agenter i en pipeline för sekventiellt arbetsflöde
• Strömmar realtidsuppdateringar när agenter bearbetar begäranden

Begrepp som omfattas

• Agenter i arbetsflöden
• Direkta kanter
• Arbetsflödesverktyget

Förutsättningar

• Python 3.10 eller senare
• Agent Framework har installerats: pip install agent-framework --pre
• Azure OpenAI-svar konfigurerade med rätt miljövariabler
• Azure CLI-autentisering: az login

Steg 1: Importera nödvändiga beroenden

Börja med att importera nödvändiga komponenter för arbetsflöden och Azure OpenAI-svarsagenter:

import asyncio
import os

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

Steg 2: Skapa Azure OpenAI-svarsklient

Skapa en delad klient som du kan använda för att skapa flera agenter:

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(),
    )

Steg 3: Skapa specialiserade agenter

Skapa två specialiserade agenter för att skapa och granska innehåll:

    # 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."
        ),
    )

Steg 4: Skapa arbetsflödet

Anslut agenterna i ett sekventiellt arbetsflöde med hjälp av byggverktyget:

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

Steg 5: Kör med direktuppspelning

Kör arbetsflödet med direktuppspelning för att observera realtidsuppdateringar från båda agenterna:

    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)

Steg 6: Slutför huvudfunktionen

Inneslut allt i huvudfunktionen med korrekt asynkron körning.

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

Så här fungerar det

1. Klientinstallation: Använder en AzureOpenAIResponsesClient med Azure CLI-autentiseringsuppgifter för autentisering.
2. Skapande av agent: Skapar skrivare och granskare från samma klientkonfiguration.
3. Sekventiell bearbetning: Skrivagenten genererar först innehåll och skickar det sedan till granskaragenten.
4. Direktuppspelningsuppdateringar: Utdatahändelser (type="output") med AgentResponseUpdate data ger uppdateringar av token i realtid när agenter genererar svar.

Viktiga begrepp

• AzureOpenAIResponsesClient: Delad klient som används för att skapa arbetsflödesagenter med konsekvent konfiguration.
• WorkflowEvent: Utdatahändelser (type="output") innehåller agentutdata (AgentResponseUpdate för direktuppspelning, AgentResponse för icke-direktuppspelning).
• Sekventiellt arbetsflöde: Agenter som är anslutna i en pipeline där utdata flödar från en till en annan.

Fullständig implementering

Den fullständiga arbetsimplementeringen finns i azure_ai_agents_streaming.py på Agent Framework-lagringsplatsen.