Agents dans les flux de travail

Ce tutoriel montre comment intégrer des agents IA dans des flux de travail à l’aide d’Agent Framework. Vous allez apprendre à créer des flux de travail qui tirent parti de la puissance des agents IA spécialisés pour la création, la révision et d’autres tâches collaboratives.

Ce que vous allez construire

Vous allez créer un flux de travail qui :

Utilise le service d’agent Azure Foundry pour créer des agents intelligents
Implémente un agent de traduction français qui traduit l’entrée en français
Implémente un agent de traduction espagnol qui traduit le français en espagnol
Implémente un agent de traduction en anglais qui traduit l’espagnol en anglais
Connecte des agents dans un pipeline de flux de travail séquentiel
Diffuse des mises à jour en temps réel en tant qu’agents traitent les demandes
Montre la libération appropriée des ressources pour les agents d'Azure Foundry

Concepts couverts

Prerequisites

Sdk .NET 8.0 ou version ultérieure
Point de terminaison et déploiement du service Azure Foundry configurés
Azure CLI installé et authentifié (pour l’authentification des informations d’identification Azure)
Une nouvelle application console

Étape 1 : Installer des packages NuGet

Tout d’abord, installez les packages requis pour votre projet .NET :

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

Étape 2 : Configurer le client Azure Foundry

Configurez le client Azure Foundry avec des variables d’environnement et une authentification :

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

Étape 3 : Créer une méthode de fabrique d’agent

Implémentez une méthode d’assistance pour créer des agents Azure Foundry avec des instructions spécifiques :

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

Étape 4 : Créer des agents Azure Foundry spécialisés

Créez trois agents de traduction à l’aide de la méthode d’assistance :

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

Étape 5 : Générer le flux de travail

Connectez les agents dans un flux de travail séquentiel à l’aide de WorkflowBuilder :

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

Étape 6 : Exécuter avec streaming

Exécutez le flux de travail avec streaming pour observer les mises à jour en temps réel de tous les agents :

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

Étape 7 : Nettoyage des ressources

Nettoyez correctement les agents Azure Foundry après l’utilisation :

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

Fonctionnement

Configuration du client Azure Foundry : utilise PersistentAgentsClient les informations d’identification Azure CLI pour l’authentification
Création d’agent : crée des agents persistants sur Azure Foundry avec des instructions spécifiques pour la traduction
Traitement séquentiel : l’agent français traduit d’abord l’entrée, puis l’agent espagnol, puis l’agent anglais
Modèle de jeton de tour : Les agents mettent en cache les messages et ne les traitent que lorsqu’ils reçoivent un jeton TurnToken
Mises à jour de diffusion en continu : AgentRunUpdateEvent fournit des mises à jour de token en temps réel pendant que les agents génèrent des réponses
Gestion des ressources : nettoyage approprié des agents Azure Foundry à l’aide de l’API Administration

Concepts clés

Service d’agent Azure Foundry : agents IA basés sur le cloud avec des fonctionnalités de raisonnement avancées
PersistentAgentsClient : client pour la création et la gestion d’agents sur Azure Foundry
AgentRunUpdateEvent : mises à jour en continu en temps réel durant l'exécution de l'agent
TurnToken : signal qui déclenche le traitement de l’agent après la mise en cache des messages
Flux de travail séquentiel : agents connectés dans un pipeline où la sortie passe d’un à l’autre

Implémentation complète

Pour obtenir l’implémentation complète de ce flux de travail des agents Azure Foundry, consultez l’exemple De Program.cs FoundryAgent dans le référentiel Agent Framework.

Ce que vous allez construire

Vous allez créer un flux de travail qui :

Utilise le service d’agent Azure AI pour créer des agents intelligents
Implémente un agent rédacteur qui crée du contenu en fonction des instructions
Implémente un agent réviseur qui fournit des commentaires sur le contenu
Connecte des agents dans un pipeline de flux de travail séquentiel
Diffuse des mises à jour en temps réel en tant qu’agents traitent les demandes
Illustre une gestion de contexte asynchrone appropriée pour les clients Azure AI

Concepts couverts

Prerequisites

Python 3.10 ou version ultérieure
Agent Framework installé : pip install agent-framework-azure-ai --pre
Service Azure AI Agent configuré avec des variables d’environnement appropriées
Authentification Azure CLI : az login

Étape 1 : Importer les dépendances requises

Commencez par importer les composants nécessaires pour les agents et flux de travail Azure AI :

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

Étape 2 : Créer Azure AI Agent Factory

Créez une fonction d’assistance pour gérer la création d’un agent Azure AI avec une gestion de contexte asynchrone appropriée :

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

Étape 3 : Créer des agents Azure AI spécialisés

Créez deux agents spécialisés pour la création et la révision du contenu :

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

Étape 4 : Générer le flux de travail

Connectez les agents dans un flux de travail séquentiel à l’aide du générateur Fluent :

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

Étape 5 : Exécuter avec streaming

Exécutez le flux de travail avec streaming pour observer les mises à jour en temps réel des deux agents :

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

Étape 6 : Terminer la fonction principale

Encapsulez tout dans la fonction principale avec une exécution asynchrone appropriée :

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

Fonctionnement

Configuration du client Azure AI : utilisation AzureAIAgentClient avec les informations d’identification Azure CLI pour l’authentification
Modèle d'usine d'agent : crée une fonction d'usine qui gère le cycle de vie asynchrone du contexte pour plusieurs agents
Traitement séquentiel : l’agent Writer génère d’abord du contenu, puis le transmet à l’agent réviseur
Mises à jour de diffusion en continu : AgentRunUpdateEvent fournit des mises à jour de token en temps réel pendant que les agents génèrent des réponses
Gestion du contexte : nettoyage approprié des ressources Azure AI à l’aide de AsyncExitStack

Concepts clés

Service d’agent Azure AI : agents IA basés sur le cloud avec des fonctionnalités de raisonnement avancées
AgentRunUpdateEvent : mises à jour en continu en temps réel durant l'exécution de l'agent
AsyncExitStack : gestion appropriée du contexte asynchrone pour plusieurs ressources
Patron de fabrique d’agent : création d’agents réutilisables avec une configuration client partagée
Flux de travail séquentiel : agents connectés dans un pipeline où la sortie passe d’un à l’autre

Implémentation complète

Pour obtenir l’implémentation de travail complète de ce flux de travail des agents Azure AI, consultez l’exemple azure_ai_agents_streaming.py dans le référentiel Agent Framework.

Étapes suivantes

En savoir plus sur la bifurcation dans les flux de travail

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2025-11-21

Partager via

Agents dans les flux de travail

Ce que vous allez construire

Concepts couverts

Prerequisites

Étape 1 : Installer des packages NuGet

Étape 2 : Configurer le client Azure Foundry

Étape 3 : Créer une méthode de fabrique d’agent

Étape 4 : Créer des agents Azure Foundry spécialisés

Étape 5 : Générer le flux de travail

Étape 6 : Exécuter avec streaming

Étape 7 : Nettoyage des ressources

Fonctionnement

Concepts clés

Implémentation complète

Ce que vous allez construire

Concepts couverts

Prerequisites

Étape 1 : Importer les dépendances requises

Étape 2 : Créer Azure AI Agent Factory

Étape 3 : Créer des agents Azure AI spécialisés

Étape 4 : Générer le flux de travail

Étape 5 : Exécuter avec streaming

Étape 6 : Terminer la fonction principale

Fonctionnement

Concepts clés

Implémentation complète

Étapes suivantes

Commentaires

Ressources supplémentaires