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

Waarschuwing

DefaultAzureCredential is handig voor ontwikkeling, maar vereist zorgvuldige overwegingen in de productieomgeving. Overweeg in productie een specifieke referentie te gebruiken (bijvoorbeeld ManagedIdentityCredential) om latentieproblemen, onbedoelde referentieprobing en potentiële beveiligingsrisico's van terugvalmechanismen te voorkomen.

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 AgentResponseUpdateEvent 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: AgentResponseUpdateEvent 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
WorkflowEvent: uitvoergebeurtenissen (type="output") bevatten uitvoergegevens van agents (AgentResponseUpdate voor streaming, AgentResponse voor niet-streaming)
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 AgentResponseUpdate, WorkflowBuilder
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.as_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 opbouwfunctie:

        # Build the workflow with agents as executors
        workflow = WorkflowBuilder(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 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()

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
Streamingupdates: uitvoergebeurtenissen (type="output") met AgentResponseUpdate gegevens bieden realtime tokenbijwerkingen 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
WorkflowEvent: uitvoergebeurtenissen (type="output") bevatten uitvoergegevens van agents (AgentResponseUpdate voor streaming, AgentResponse voor niet-streaming)
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

Human-in-the-Loop

Feedback

Is deze pagina nuttig?

Last updated on 2026-02-13

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