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

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

Varning

DefaultAzureCredential är praktiskt för utveckling men kräver noggrant övervägande i produktion. I produktion bör du överväga att använda en specifik autentiseringsuppgift (t.ex. ManagedIdentityCredential) för att undvika problem med svarstid, oavsiktlig avsökning av autentiseringsuppgifter och potentiella säkerhetsrisker från reservmekanismer.

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

Konfiguration av Azure Foundry-klient: Använder PersistentAgentsClient med Azure CLI-autentiseringsuppgifter för autentisering
Skapande av agent: Skapar beständiga agenter på Azure Foundry med specifika instruktioner för översättning
Sekventiell bearbetning: Fransk agent översätter indata först, sedan spansk agent och sedan engelsk agent
Vänd tokenmönster: Agenter cachelagrar meddelanden och bearbetar endast när de tar emot en TurnToken
Direktuppspelningsuppdateringar: AgentResponseUpdateEvent tillhandahåller tokenuppdateringar i realtid när agenter genererar svar
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
Visar ett valfritt mönster för delad session för agenter som skapats från samma klient

Begrepp som omfattas

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 = 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 = 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).add_edge(writer, reviewer).build()

Valfritt: Dela en session mellan `AzureOpenAIResponsesClient` agenter

Som standard använder varje agentexekutor sitt eget sessionstillstånd. För agenter som skapats från samma AzureOpenAIResponsesClient kan du koppla en delad session explicit:

- Basic familiarity with agents, workflows, and executors in the agent framework.
"""


@executor(id="intercept_agent_response")
async def intercept_agent_response(
    agent_response: AgentExecutorResponse, ctx: WorkflowContext[AgentExecutorRequest]
) -> None:
    """This executor intercepts the agent response and sends a request without messages.

    This essentially prevents duplication of messages in the shared thread. Without this
        deployment_name=os.environ["AZURE_AI_MODEL_DEPLOYMENT_NAME"],
        credential=AzureCliCredential(),
    )

    # set the same context provider (same default source_id) for both agents to share the thread
    writer = client.as_agent(
        instructions=("You are a concise copywriter. Provide a single, punchy marketing sentence based on the prompt."),
        name="writer",
        context_providers=[InMemoryHistoryProvider()],
    )

    reviewer = client.as_agent(
        instructions=("You are a thoughtful reviewer. Give brief feedback on the previous assistant message."),
        name="reviewer",
        context_providers=[InMemoryHistoryProvider()],
    )

    # Create the shared session
    shared_session = writer.create_session()
    writer_executor = AgentExecutor(writer, session=shared_session)
    reviewer_executor = AgentExecutor(reviewer, session=shared_session)

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("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):
            # 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)

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

Klientinstallation: Använder en AzureOpenAIResponsesClient med Azure CLI-autentiseringsuppgifter för autentisering.
Skapande av agent: Skapar skrivare och granskare från samma klientkonfiguration.
Sekventiell bearbetning: Skrivagenten genererar först innehåll och skickar det sedan till granskaragenten.
Direktuppspelningsuppdateringar: Utdatahändelser (type="output") med AgentResponseUpdate data ger uppdateringar av token i realtid när agenter genererar svar.
Delade sessioner (valfritt): En delad session kan kopplas när båda agenterna skapas från samma AzureOpenAIResponsesClient.

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.
Mönster för delad session: Valfri konfiguration för delat minne/tråd mellan valda agenter i ett arbetsflöde.

Fullständig implementering

Fullständiga implementeringar finns i azure_ai_agents_streaming.py och azure_ai_agents_with_shared_session.py på Agent Framework-lagringsplatsen.

Nästa steg

Human-in-the-Loop

Feedback

Var den här sidan hjälpsam?

Last updated on 2026-02-20

Dela via

Agenter i arbetsflöden

Vad du kommer att bygga

Begrepp som omfattas

Förutsättningar

Steg 1: Installera NuGet-paket

Steg 2: Konfigurera Azure Foundry-klienten

Steg 3: Skapa agentfabriksmetod

Steg 4: Skapa specialiserade Azure Foundry-agenter

Steg 5: Skapa arbetsflödet

Steg 6: Kör med direktuppspelning

Steg 7: Resursrensning

Så här fungerar det

Viktiga begrepp

Fullständig implementering

Vad du kommer att bygga

Begrepp som omfattas

Förutsättningar

Steg 1: Importera nödvändiga beroenden

Steg 2: Skapa Azure OpenAI-svarsklient

Steg 3: Skapa specialiserade agenter

Steg 4: Skapa arbetsflödet

Valfritt: Dela en session mellan AzureOpenAIResponsesClient agenter

Steg 5: Kör med direktuppspelning

Steg 6: Slutför huvudfunktionen

Så här fungerar det

Viktiga begrepp

Fullständig implementering

Nästa steg

Feedback

Ytterligare resurser

Valfritt: Dela en session mellan `AzureOpenAIResponsesClient` agenter