Agenter i arbetsflöden

Den här självstudien visar hur du integrerar AI-agenter i arbetsflöden med hjälp av Agent Framework. Du lär dig att skapa arbetsflöden som utnyttjar kraften hos specialiserade AI-agenter för att skapa, granska och andra samarbetsuppgifter.

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
• Azure Foundry-tjänstslutpunkt och distribution 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 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());

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, model);
        AIAgent spanishAgent = await GetTranslationAgentAsync("Spanish", persistentAgentsClient, model);
        AIAgent englishAgent = await GetTranslationAgentAsync("English", persistentAgentsClient, model);

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

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: AgentRunUpdateEvent 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
• AgentRunUpdateEvent: Strömmande uppdateringar i realtid under agentkörning
• 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 Azure AI Agent Service 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
• Visar korrekt asynkron kontexthantering för Azure AI-klienter

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-azure-ai --pre
• Azure AI Agent Service konfigurerad 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 Azure AI-agenter och arbetsflöden:

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

Steg 2: Skapa Azure AI Agent Factory

Skapa en hjälpfunktion för att hantera skapande av Azure AI-agent med korrekt asynkron kontexthantering:

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

Steg 3: Skapa specialiserade Azure AI-agenter

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

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

Steg 4: Skapa arbetsflödet

Anslut agenterna i ett sekventiellt arbetsflöde med hjälp av fluent-byggaren:

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

Steg 5: Kör med direktuppspelning

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

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

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. Konfiguration av Azure AI-klient: Använder AzureAIAgentClient med Azure CLI-autentiseringsuppgifter för autentisering
2. Agentfabriksmönster: Skapar en fabriksfunktion som hanterar asynkron kontextlivscykel för flera agenter
3. Sekventiell bearbetning: Skrivaragenten genererar först innehåll och skickar det sedan till granskaragenten
4. Direktuppspelningsuppdateringar: AgentRunUpdateEvent tillhandahåller tokenuppdateringar i realtid när agenter genererar svar
5. Kontexthantering: Korrekt rensning av Azure AI-resurser med hjälp av AsyncExitStack

Viktiga begrepp

• Azure AI Agent Service: Molnbaserade AI-agenter med avancerade resonemangsfunktioner
• AgentRunUpdateEvent: Strömmande uppdateringar i realtid under agentkörning
• AsyncExitStack: Korrekt asynkron kontexthantering för flera resurser
• Agentfabriksmönster: Skapande av återanvändbar agent med delad klientkonfiguration
• 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 AI-agenter finns i azure_ai_agents_streaming.py exempel på Agent Framework-lagringsplatsen.

Nästa steg

Lär dig mer om förgrening i arbetsflöden