Agenten in Workflows

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

• Agents in werkprocessen
• Directe randen
• Opbouwfunctie voor werkstromen

Vereiste voorwaarden

• .NET 8.0 SDK of hoger
• Een Azure Foundry-projecteindpunt en -model 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 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());

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

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

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

1. Installatie van Azure Foundry-client: Maakt gebruik van PersistentAgentsClient met Azure CLI-referenties voor authenticatie
2. Agent maken: permanente agents maken in Azure Foundry met specifieke instructies voor vertaling
3. Sequentiële verwerking: Franse agent vertaalt eerst invoer, vervolgens Spaanse agent, vervolgens Engelse agent
4. Turn Token Pattern: Agents cachen berichten en verwerken ze alleen wanneer zij een token ontvangen TurnToken
5. Streaming updates: AgentResponseUpdateEvent biedt realtime token updates als agents antwoorden genereren
6. 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:

• Gebruikt AzureOpenAIResponsesClient 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

Besproken concepten

• Agents in werkprocessen
• Directe randen
• Opbouwfunctie voor werkstromen

Vereiste voorwaarden

• Python 3.10 of hoger
• Agent Framework geïnstalleerd: pip install agent-framework --pre
• Azure OpenAI-antwoorden geconfigureerd met de juiste omgevingsvariabelen
• Azure CLI-verificatie: az login

Stap 1: Vereiste afhankelijkheden importeren

Begin met het importeren van de benodigde onderdelen voor werkstromen en Azure OpenAI-antwoordenagents:

import asyncio
import os

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

Stap 2: Een Azure OpenAI-antwoordclient maken

Maak één gedeelde client die u kunt gebruiken om meerdere agents samen te stellen:

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

Stap 3: Gespecialiseerde agents maken

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

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

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_agent).add_edge(writer_agent, reviewer_agent).build()

Stap 5: Uitvoeren met streaming

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

    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)

Stap 6: Hoofdfunctie voltooien

Verpakt alles in de hoofdfunctie met de juiste asynchrone uitvoering:

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

Hoe het werkt

1. Clientinstallatie: gebruikt één AzureOpenAIResponsesClient met Azure CLI-referenties voor authenticatie.
2. Agent maken: hiermee maakt u schrijf- en revisoragents op basis van dezelfde clientconfiguratie.
3. Sequentiële verwerking: de schrijveragent genereert eerst inhoud en geeft deze vervolgens door aan de revisoragent.
4. Streaming-updates: uitvoergebeurtenissen (type="output") met AgentResponseUpdate gegevens bieden realtime token-updates terwijl agenten antwoorden genereren.

Sleutelbegrippen

• AzureOpenAIResponsesClient: gedeelde client die wordt gebruikt voor het maken van werkstroomagents met consistente configuratie.
• WorkflowEvent: uitvoergebeurtenissen (type="output") bevatten uitvoergegevens van agents (AgentResponseUpdate voor streaming, AgentResponse voor niet-streaming).
• Sequentiële werkstroom: agents die zijn verbonden in een pijplijn, waarbij uitvoer van het ene naar het andere stroomt.

Implementatie voltooien

Zie azure_ai_agents_streaming.py in de agentframeworkopslagplaats voor de volledige werkimplementatie.