Agenci w przepływach pracy

Co będziesz budować

Utworzysz przepływ pracy, który:

• Używa usługi Azure Foundry Agent Service do tworzenia inteligentnych agentów
• Implementuje francuskiego agenta tłumaczenia, który tłumaczy dane wejściowe na język francuski
• Implementuje hiszpańskiego agenta tłumaczenia, który tłumaczy język francuski na hiszpański
• Implementuje angielskiego agenta tłumaczenia, który tłumaczy język hiszpański z powrotem na angielski
• Łączy agentów w sekwencyjnej ścieżce pracy.
• Przesyła strumieniowo aktualizacje w czasie rzeczywistym, gdy agenci przetwarzają żądania
• Demonstruje prawidłowe czyszczenie zasobów dla agentów usługi Azure Foundry

Omówione pojęcia

• Agenci w przepływach pracy
• Bezpośrednie krawędzie
• Konstruktor przepływu pracy

Wymagania wstępne

• Pakiet .NET 8.0 SDK lub nowszy
• Skonfigurowano punkt końcowy usługi Azure Foundry i wdrożenie
• Zainstalowany i uwierzytelniony interfejs wiersza polecenia platformy Azure(na potrzeby uwierzytelniania poświadczeń platformy Azure)
• Nowa aplikacja konsolowa

Krok 1. Instalowanie pakietów NuGet

Najpierw zainstaluj wymagane pakiety dla projektu .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

Krok 2. Konfigurowanie klienta usługi Azure Foundry

Skonfiguruj klienta usługi Azure Foundry przy użyciu zmiennych środowiskowych i uwierzytelniania:

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

Krok 3. Tworzenie metody fabryki agentów

Zaimplementuj metodę pomocnika, aby utworzyć agentów usługi Azure Foundry z określonymi instrukcjami:

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

Krok 4. Tworzenie wyspecjalizowanych agentów usługi Azure Foundry

Utwórz trzech agentów tłumaczenia przy użyciu metody pomocniczej:

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

Krok 5. Tworzenie przepływu pracy

Połącz agentów w przepływie pracy sekwencyjnej przy użyciu programu WorkflowBuilder:

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

Krok 6: Wykonywanie z użyciem przesyłania strumieniowego

Uruchom przepływ pracy z funkcją strumieniowania, aby śledzić aktualizacje w czasie rzeczywistym od wszystkich agentów.

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

Krok 7. Oczyszczanie zasobów

Prawidłowo wyczyść agentów usługi Azure Foundry po użyciu:

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

Jak to działa

1. Azure Foundry Client Setup: używa PersistentAgentsClient z poświadczeniami Azure CLI do uwierzytelniania
2. Tworzenie agentów: tworzy trwałych agentów w usłudze Azure Foundry zgodnie z określonymi instrukcjami dotyczącymi tłumaczenia.
3. Przetwarzanie sekwencyjne: francuski agent tłumaczy najpierw dane wejściowe, a następnie hiszpański agent, a następnie angielski agent
4. Wzorzec tokenu 'Turn': agenci buforują komunikaty i przetwarzają dopiero po otrzymaniu TurnToken
5. Aktualizacje strumieniowe: AgentRunUpdateEvent zapewniają aktualizacje tokenów w czasie rzeczywistym, gdy agenci generują odpowiedzi
6. Zarządzanie zasobami: prawidłowe czyszczenie agentów usługi Azure Foundry przy użyciu interfejsu API administracyjnego

Kluczowe pojęcia

• Usługa agenta usługi Azure Foundry: agenci sztucznej inteligencji opartej na chmurze z zaawansowanymi możliwościami rozumowania
• PersistentAgentsClient: klient do tworzenia agentów i zarządzania nimi w usłudze Azure Foundry
• AgentRunUpdateEvent: aktualizacje strumieniowe w czasie rzeczywistym podczas działania agenta
• TurnToken: sygnał wyzwalający przetwarzanie agenta po buforowaniu komunikatów
• Sekwencyjny przepływ pracy: agenty połączeni w potoku, w którym dane wyjściowe przepływają od jednego do kolejnego

Kompletna implementacja

Aby uzyskać pełną działającą implementację tego przepływu pracy agentów usługi Azure Foundry, zobacz przykład foundryAgent Program.cs w repozytorium Platformy agentów.

Co będziesz budować

Utworzysz przepływ pracy, który:

• Tworzenie inteligentnych agentów przy użyciu usługi Azure AI Agent Service
• Implementuje agenta piszącego, który tworzy zawartość na podstawie poleceń
• Implementuje agenta recenzenta, który przekazuje opinię na temat zawartości
• Łączy agentów w sekwencyjnej ścieżce pracy.
• Przesyła strumieniowo aktualizacje w czasie rzeczywistym, gdy agenci przetwarzają żądania
• Demonstruje właściwe zarządzanie kontekstem asynchronicznego dla klientów usługi Azure AI

Omówione pojęcia

• Agenci w przepływach pracy
• Bezpośrednie krawędzie
• Konstruktor przepływu pracy

Wymagania wstępne

• Środowisko Python w wersji 3.10 lub nowszej
• Zainstalowano program Agent Framework: pip install agent-framework-azure-ai --pre
• Usługa agenta sztucznej inteligencji platformy Azure skonfigurowana z odpowiednimi zmiennymi środowiskowymi
• Uwierzytelnianie Azure CLI: az login

Krok 1. Importowanie wymaganych zależności

Zacznij od zaimportowania niezbędnych składników dla agentów i przepływów pracy usługi 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

Krok 2. Tworzenie fabryki agentów sztucznej inteligencji platformy Azure

Utwórz funkcję pomocnika do zarządzania tworzeniem agenta sztucznej inteligencji platformy Azure przy użyciu odpowiedniej obsługi kontekstu asynchronicznego:

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

Krok 3. Tworzenie wyspecjalizowanych agentów sztucznej inteligencji platformy Azure

Utwórz dwóch wyspecjalizowanych agentów do tworzenia i przeglądu zawartości.

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

Krok 4. Kompilowanie przepływu pracy

Połącz agentów w sekwencyjnym przepływie pracy przy użyciu płynnego konstruktora:

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

Krok 5: Wykonanie z użyciem transmisji strumieniowej

Uruchom przepływ pracy z przesyłaniem strumieniowym, aby obserwować aktualizacje w czasie rzeczywistym od obu agentów:

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

Krok 6: Ukończ funkcję Main

Zawijaj wszystko w funkcji main przy użyciu prawidłowego wykonywania asynchronicznego:

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

Jak to działa

1. Konfiguracja klienta usługi Azure AI: Używa AzureAIAgentClient razem z poświadczeniami interfejsu wiersza polecenia platformy Azure do uwierzytelniania
2. Wzorzec fabryki agentów: tworzy funkcję fabryki, która zarządza cyklem życia kontekstu asynchronicznego dla wielu agentów
3. Przetwarzanie sekwencyjne: agent modułu zapisywania najpierw generuje zawartość, a następnie przekazuje ją do agenta recenzenta
4. Aktualizacje strumieniowe: AgentRunUpdateEvent zapewniają aktualizacje tokenów w czasie rzeczywistym, gdy agenci generują odpowiedzi
5. Zarządzanie kontekstem: prawidłowe czyszczenie zasobów sztucznej inteligencji platformy Azure przy użyciu AsyncExitStack

Kluczowe pojęcia

• Usługa agenta sztucznej inteligencji platformy Azure: agenci sztucznej inteligencji oparte na chmurze z zaawansowanymi możliwościami rozumowania
• AgentRunUpdateEvent: aktualizacje strumieniowe w czasie rzeczywistym podczas działania agenta
• AsyncExitStack: właściwe zarządzanie kontekstem asynchronicznym dla zarządzania wieloma zasobami
• Wzorzec fabryki agentów: tworzenie agenta wielokrotnego użytku z konfiguracją udostępnionego klienta
• Sekwencyjny przepływ pracy: agenty połączeni w potoku, w którym dane wyjściowe przepływają od jednego do kolejnego

Kompletna implementacja

Aby uzyskać pełną działającą implementację tego przepływu pracy agentów sztucznej inteligencji platformy Azure, zobacz przykład azure_ai_agents_streaming.py w repozytorium Platformy agentów.