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
Um endpoint e modelo de projeto Azure Foundry configurados
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 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());

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

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

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: AgentResponseUpdateEvent 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
WorkflowEvent: Os eventos de saída (type="output") contêm dados de saída do agente (AgentResponseUpdate para streaming, AgentResponse para não-streaming)
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 AzureOpenAIResponsesClient 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

Conceitos abordados

Pré-requisitos

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

Etapa 1: Importar dependências necessárias

Comece por importar os componentes necessários para fluxos de trabalho e agentes Azure OpenAI Responses:

import asyncio
import os

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

Passo 2: Criar o Cliente de Respostas Azure OpenAI

Crie um cliente partilhado que possa usar para construir múltiplos agentes:

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

Passo 3: Criar Agentes Especializados

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

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

Etapa 4: Criar o fluxo de trabalho

Ligue os agentes num fluxo de trabalho sequencial usando o construtor:

        # Build the workflow with agents as executors
        workflow = WorkflowBuilder(start_executor=writer_agent).add_edge(writer_agent, reviewer_agent).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_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)

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: Usa um AzureOpenAIResponsesClient com credenciais de CLI Azure para autenticação.
Criação de Agentes: Cria agentes Escritor e Revisor a partir da mesma configuração de cliente.
Processamento Sequencial: O agente escritor gera primeiro o conteúdo e depois passa-o ao agente revisor.
Atualizações de Streaming: Os eventos de saída (type="output") com dados de AgentResponseUpdate fornecem atualizações de tokens em tempo real enquanto os agentes geram respostas.

Conceitos-chave

AzureOpenAIRrespondersesClient: Cliente partilhado usado para criar agentes de workflow com configuração consistente.
WorkflowEvent: Os eventos de saída (type="output") contêm dados de saída do agente (AgentResponseUpdate para streaming, AgentResponse para não streaming).
Fluxo de Trabalho Sequencial: Agentes ligados num pipeline onde a saída flui de um para o outro.

Implementação Completa

Para a implementação funcional completa, veja azure_ai_agents_streaming.py no repositório Agent Framework.

Próximas Etapas

Humano no Ciclo de Decisão

Comentários

Esta página foi útil?

Last updated on 2026-03-12

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

Passo 2: Criar o Cliente de Respostas Azure OpenAI

Passo 3: Criar Agentes Especializados

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

Comentários

Recursos adicionais