Agenten in Workflows

In deze zelfstudie ziet u hoe u AI-agents integreert in werkstromen met behulp van Agent Framework. Je leert werkstromen te creëren die van de kracht van gespecialiseerde AI-agents gebruikmaken voor het maken van content, beoordelen en andere samenwerkingstaken.

Wat je gaat bouwen

U maakt een werkstroom die:

Maakt gebruik van Azure Foundry Agent Service om intelligente agents te maken
Implementeert een Franse vertaalagent die invoer vertaalt naar het Frans
Implementeert een Spaanse vertaalagent die Frans naar spaans vertaalt
Implementeert een Engelse vertaalagent die Spaans weer vertaalt naar het Engels
Verbindt agents met elkaar in een sequentiële werkstroompijpleiding
Streamt realtime updates als agents aanvragen verwerken
Demonstreert het juiste opschonen van resources voor Azure Foundry-agents

Besproken concepten

Vereiste voorwaarden

.NET 8.0 SDK of hoger
Azure Foundry-service-eindpunt en -implementatie geconfigureerd
Azure CLI geïnstalleerd en geverifieerd (voor Azure-referentieverificatie)
Een nieuwe consoletoepassing

Stap 1: NuGet-pakketten installeren

Installeer eerst de vereiste pakketten voor uw .NET-project:

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

Stap 2: Azure Foundry-client instellen

Configureer de Azure Foundry-client met omgevingsvariabelen en -verificatie:

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

Stap 3: Agent Factory-methode maken

Implementeer een helpermethode voor het maken van Azure Foundry-agents met specifieke instructies:

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

Stap 4: Gespecialiseerde Azure Foundry-agents maken

Maak drie vertaalagenten met behulp van de helpermethode:

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

Stap 5: De werkstroom bouwen

Verbind de agents in een sequentiële werkstroom met behulp van WorkflowBuilder:

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

Stap 6: Uitvoeren met streaming

Voer de werkstroom uit met streaming om realtime updates van alle agents te bekijken:

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

Stap 7: Opschonen van bronnen

Schoon de Azure Foundry-agents na gebruik correct op:

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

Hoe het werkt

Installatie van Azure Foundry-client: Maakt gebruik van PersistentAgentsClient met Azure CLI-referenties voor authenticatie
Agent maken: permanente agents maken in Azure Foundry met specifieke instructies voor vertaling
Sequentiële verwerking: Franse agent vertaalt eerst invoer, vervolgens Spaanse agent, vervolgens Engelse agent
Turn Token Pattern: Agents cachen berichten en verwerken ze alleen wanneer zij een token ontvangen TurnToken
Streaming updates: AgentRunUpdateEvent biedt realtime token updates als agents antwoorden genereren
Resourcebeheer: Juiste opschoning van Azure Foundry-agents met behulp van de Beheer-API

Sleutelbegrippen

Azure Foundry Agent Service: AI-agents in de cloud met geavanceerde redeneringsmogelijkheden
PersistentAgentsClient: Client voor het maken en beheren van agents in Azure Foundry
AgentRunUpdateEvent: realtime streaming-updates tijdens de uitvoering van de agent
TurnToken: Signaal dat agentverwerking activeert na berichtcaching
Sequentiële werkstroom: agents die zijn verbonden in een pijplijn, waarbij uitvoer van de ene naar de volgende stroomt

Implementatie voltooien

Voor de volledige werkende implementatie van deze Azure Foundry-agents workflow, zie het FoundryAgent-Program.cs voorbeeld in de agentframework-repository.

Wat je gaat bouwen

U maakt een werkstroom die:

Maakt gebruik van Azure AI Agent Service om intelligente agents te maken
Hiermee wordt een Writer-agent geïmplementeerd waarmee inhoud wordt gemaakt op basis van prompts
Implementeert een revisoragent die feedback geeft over de inhoud
Verbindt agents met elkaar in een sequentiële werkstroompijpleiding
Streamt realtime updates als agents aanvragen verwerken
Demonstreert het juiste asynchrone contextbeheer voor Azure AI-clients

Besproken concepten

Vereiste voorwaarden

Python 3.10 of hoger
Agent Framework geïnstalleerd: pip install agent-framework-azure-ai --pre
Azure AI Agent Service geconfigureerd met de juiste omgevingsvariabelen
Azure CLI-verificatie: az login

Stap 1: Vereiste afhankelijkheden importeren

Begin met het importeren van de benodigde onderdelen voor Azure AI-agents en -werkstromen:

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

Stap 2: Azure AI Agent Factory maken

Maak een helperfunctie voor het beheren van het maken van Azure AI-agents met de juiste asynchrone contextafhandeling:

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

Stap 3: Gespecialiseerde Azure AI-agents maken

Maak twee gespecialiseerde agents voor het maken en controleren van inhoud:

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

Stap 4: De werkstroom bouwen

Verbind de agents in een sequentiële werkstroom met behulp van de Fluent Builder:

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

Stap 5: Uitvoeren met streaming

Voer de werkstroom uit met streaming om realtime updates van beide agents te bekijken:

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

Stap 6: Hoofdfunctie voltooien

Verpakt alles in de hoofdfunctie met de juiste asynchrone uitvoering:

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

Hoe het werkt

Azure AI-clientinstallatie: maakt gebruik van AzureAIAgentClient met Azure CLI-referenties voor authenticatie
Agent Factory-patroon: Hiermee maakt u een factory-functie die de levenscyclus van asynchrone context voor meerdere agents beheert
Sequentiële verwerking: Writer-agent genereert eerst inhoud en geeft deze vervolgens door aan de revisoragent
Streaming updates: AgentRunUpdateEvent biedt realtime token updates als agents antwoorden genereren
Contextbeheer: Juiste opschoning van Azure AI-resources met behulp van AsyncExitStack

Sleutelbegrippen

Azure AI Agent-service: AI-agents in de cloud met geavanceerde redeneringsmogelijkheden
AgentRunUpdateEvent: realtime streaming-updates tijdens de uitvoering van de agent
AsyncExitStack: Correcte asynchrone contextbeheer voor meerdere resources
Agent Factory-patroon: Herbruikbare agent maken met gedeelde clientconfiguratie
Sequentiële werkstroom: agents die zijn verbonden in een pijplijn, waarbij uitvoer van de ene naar de volgende stroomt

Implementatie voltooien

Zie het azure_ai_agents_streaming.py voorbeeld in de opslagplaats van Agent Framework voor de volledige werkende implementatie van deze Werkstroom voor Azure AI-agents.

Volgende stappen

Meer informatie over vertakkingen in werkstromen

Feedback

Is deze pagina nuttig?

Last updated on 2025-12-08

Delen via

Agenten in Workflows

Wat je gaat bouwen

Besproken concepten

Vereiste voorwaarden

Stap 1: NuGet-pakketten installeren

Stap 2: Azure Foundry-client instellen

Stap 3: Agent Factory-methode maken

Stap 4: Gespecialiseerde Azure Foundry-agents maken

Stap 5: De werkstroom bouwen

Stap 6: Uitvoeren met streaming

Stap 7: Opschonen van bronnen

Hoe het werkt

Sleutelbegrippen

Implementatie voltooien

Wat je gaat bouwen

Besproken concepten

Vereiste voorwaarden

Stap 1: Vereiste afhankelijkheden importeren

Stap 2: Azure AI Agent Factory maken

Stap 3: Gespecialiseerde Azure AI-agents maken

Stap 4: De werkstroom bouwen

Stap 5: Uitvoeren met streaming

Stap 6: Hoofdfunctie voltooien

Hoe het werkt

Sleutelbegrippen

Implementatie voltooien

Volgende stappen

Feedback

Aanvullende resources