Agentes em fluxos de trabalho

Este tutorial demonstra como integrar agentes de IA em fluxos de trabalho usando o Agent Framework. Você aprenderá a criar fluxos de trabalho que aproveitam o poder de agentes de IA especializados para criação, revisão e outras tarefas colaborativas de conteúdo.

O que você vai construir

Você criará um fluxo de trabalho que:

Usa o Azure Foundry Agent Service para criar agentes inteligentes
Implementa um agente de tradução francês que traduz a entrada para o francês
Implementa um agente de tradução espanhol que traduz francês para espanhol
Implementa um agente de tradução em inglês que traduz espanhol de volta para inglês
Conecta agentes em um pipeline de fluxo de trabalho sequencial
Transmite atualizações em tempo real à medida que os agentes processam solicitações
Demonstra a limpeza adequada de recursos para agentes do Azure Foundry

Conceitos abordados

Pré-requisitos

SDK do .NET 8.0 ou posterior
Configuração do ponto de extremidade e implantação do serviço Azure Foundry
CLI do Azure instalada e autenticada (para autenticação de credenciais do Azure)
Um novo aplicativo de console

Etapa 1: Instalar pacotes NuGet

Primeiro, instale os pacotes necessários para seu projeto .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

Etapa 2: Configurar o Azure Foundry Client

Configure o cliente do Azure Foundry com variáveis de ambiente e autenticação:

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

Passo 3: Método de Criar Fábrica de Agentes

Implemente um método auxiliar para criar agentes do Azure Foundry com instruções específicas:

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

Passo 4: Criar Agentes Especializados Azure Foundry

Crie três agentes de tradução usando o método auxiliar:

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

Etapa 5: Criar o fluxo de trabalho

Conecte os agentes em um fluxo de trabalho sequencial usando o WorkflowBuilder:

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

Etapa 6: Executar com streaming

Execute o fluxo de trabalho com streaming para observar atualizações em tempo real de todos os agentes:

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

Etapa 7: Limpeza de recursos

Limpe corretamente os agentes do Azure Foundry após o uso:

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

Como funciona

Configuração do Cliente do Azure Foundry: Usa PersistentAgentsClient com credenciais da CLI do Azure para autenticação
Criação de agentes: cria agentes persistentes no Azure Foundry com instruções específicas para tradução
Processamento sequencial: o agente francês traduz primeiro a entrada, depois o agente espanhol e, em seguida, o agente inglês
Padrão de token: os agentes armazenam mensagens em cache e só processam quando recebem um TurnToken
Streaming Updates: AgentRunUpdateEvent fornece atualizações de token em tempo real à medida que os agentes geram respostas
Gerenciamento de recursos: limpeza adequada dos agentes do Azure Foundry usando a API de administração

Conceitos-chave

Azure Foundry Agent Service: agentes de IA baseados em nuvem com recursos avançados de raciocínio
PersistentAgentsClient: Cliente para criar e gerenciar agentes no Azure Foundry
AgentRunUpdateEvent: atualizações de streaming em tempo real durante a execução do agente
TurnToken: Sinal que aciona o processamento do agente após o cache de mensagens
Fluxo de trabalho sequencial: agentes conectados em um pipeline onde a saída flui de um para o próximo

Implementação Completa

Para obter a implementação de trabalho completa deste fluxo de trabalho de agentes do Azure Foundry, consulte o exemplo de Program.cs do FoundryAgent no repositório do Agent Framework.

O que você vai construir

Você criará um fluxo de trabalho que:

Usa o Azure AI Agent Service para criar agentes inteligentes
Implementa um agente do Writer que cria conteúdo com base em prompts
Implementa um agente revisor que fornece comentários sobre o conteúdo
Conecta agentes em um pipeline de fluxo de trabalho sequencial
Transmite atualizações em tempo real à medida que os agentes processam solicitações
Demonstra o gerenciamento de contexto assíncrono adequado para clientes de IA do Azure

Conceitos abordados

Pré-requisitos

Python 3.10 ou posterior
Agent Framework instalado: pip install agent-framework-azure-ai --pre
Azure AI Agent Service configurado com variáveis de ambiente adequadas
Autenticação da CLI do Azure: az login

Etapa 1: Importar dependências necessárias

Comece importando os componentes necessários para agentes e fluxos de trabalho de IA do Azure:

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

Etapa 2: Criar o Azure AI Agent Factory

Crie uma função auxiliar para gerenciar a criação do agente de IA do Azure com manipulação de contexto assíncrona adequada:

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

Etapa 3: Criar agentes especializados de IA do Azure

Crie dois agentes especializados para criação e revisão de conteúdo:

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

Etapa 4: Criar o fluxo de trabalho

Conecte os agentes em um fluxo de trabalho sequencial usando o construtor fluente:

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

Etapa 5: Executar com streaming

Execute o fluxo de trabalho com streaming para observar atualizações em tempo real de ambos os agentes:

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

Passo 6: Completar a função principal

Encapsule tudo na função principal com execução assíncrona correta.

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

Como funciona

Configuração do Cliente do Azure AI: Usa AzureAIAgentClient com credenciais da CLI do Azure para autenticação
Padrão de fábrica do agente: cria uma função de fábrica que gerencia o ciclo de vida do contexto assíncrono para vários agentes
Processamento sequencial: o agente do Writer gera o conteúdo primeiro e, em seguida, o passa para o agente do Revisor
Streaming Updates: AgentRunUpdateEvent fornece atualizações de token em tempo real à medida que os agentes geram respostas
Gerenciamento de contexto: limpeza adequada dos recursos de IA do Azure usando AsyncExitStack

Conceitos-chave

Azure AI Agent Service: agentes de IA baseados em nuvem com recursos avançados de raciocínio
AgentRunUpdateEvent: atualizações de streaming em tempo real durante a execução do agente
AsyncExitStack: Gerenciamento de contexto assíncrono adequado para vários recursos
Padrão de fábrica do agente: criação de agente reutilizável com configuração de cliente compartilhada
Fluxo de trabalho sequencial: agentes conectados em um pipeline onde a saída flui de um para o próximo

Implementação Completa

Para obter a implementação de trabalho completa deste fluxo de trabalho de agentes de IA do Azure, consulte o exemplo de azure_ai_agents_streaming.py no repositório do Agent Framework.

Próximas Etapas

Saiba mais sobre ramificações em fluxos de trabalho

Feedback

Esta página foi útil?

Last updated on 2025-11-21

Partilhar via

Agentes em fluxos de trabalho

O que você vai construir

Conceitos abordados

Pré-requisitos

Etapa 1: Instalar pacotes NuGet

Etapa 2: Configurar o Azure Foundry Client

Passo 3: Método de Criar Fábrica de Agentes

Passo 4: Criar Agentes Especializados Azure Foundry

Etapa 5: Criar o fluxo de trabalho

Etapa 6: Executar com streaming

Etapa 7: Limpeza de recursos

Como funciona

Conceitos-chave

Implementação Completa

O que você vai construir

Conceitos abordados

Pré-requisitos

Etapa 1: Importar dependências necessárias

Etapa 2: Criar o Azure AI Agent Factory

Etapa 3: Criar agentes especializados de IA do Azure

Etapa 4: Criar o fluxo de trabalho

Etapa 5: Executar com streaming

Passo 6: Completar a função principal

Como funciona

Conceitos-chave

Implementação Completa

Próximas Etapas

Feedback

Recursos adicionais