Megosztás:

Microsoft Agent Framework Munkafolyamat-vezérlések – Szekvenciális

A szekvenciális szervezés során az ügynökök egy folyamatba vannak rendezve. Minden ügynök egymás után dolgozza fel a feladatot, és átadja a kimenetét a sorozat következő ügynökének. Ez olyan munkafolyamatokhoz ideális, ahol minden lépés az előzőre épül, például dokumentum-felülvizsgálatra, adatfeldolgozási folyamatokra vagy többfázisú érvelésre.

Szekvenciális orchestráció

Fontos

A korábbi ügynökök teljes beszélgetési előzményeit a sorozat következő ügynöke továbbítja. Minden ügynök láthatja az összes korábbi üzenetet, ami lehetővé teszi a környezettudatos feldolgozást.

Tudnivalók

  • Ügynökök szekvenciális folyamatláncának létrehozása
  • Ügynökök láncba kapcsolása, ahol mindegyik az előző kimenetre épül
  • Ügynökök és egyéni végrehajtók keverése speciális feladatokhoz
  • A beszélgetés áramlásának nyomon követése a csatornán keresztül

Az ügynökök definiálása

A szekvenciális vezénylés során az ügynökök egy folyamatba vannak rendezve, amelyben minden ügynök feldolgozza a feladatot, és átadja a kimenetet a következő ügynöknek a sorrendben.

Az Azure OpenAI-ügyfél beállítása

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using Microsoft.Agents.AI;

// 1) Set up the Azure OpenAI client
var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ??
    throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
var client = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsIChatClient();

Figyelmeztetés

DefaultAzureCredential a fejlesztéshez kényelmes, de a termelési környezetben gondos megfontolást igényel. Éles környezetben fontolja meg egy adott hitelesítő adat (pl. ManagedIdentityCredential) használatát a késési problémák elkerülése, a hitelesítő adatok nem szándékos próbálgatásának és a tartalék mechanizmusokból eredő esetleges biztonsági kockázatok elkerülése érdekében.

Speciális ügynökök létrehozása, amelyek sorrendben fognak működni:

// 2) Helper method to create translation agents
static ChatClientAgent GetTranslationAgent(string targetLanguage, IChatClient chatClient) =>
    new(chatClient,
        $"You are a translation assistant who only responds in {targetLanguage}. Respond to any " +
        $"input by outputting the name of the input language and then translating the input to {targetLanguage}.");

// Create translation agents for sequential processing
var translationAgents = (from lang in (string[])["French", "Spanish", "English"]
                         select GetTranslationAgent(lang, client));

Az szekvenciális orchestráció beállítása

Hozza létre a munkafolyamatot a következővel AgentWorkflowBuilder:

// 3) Build sequential workflow
var workflow = AgentWorkflowBuilder.BuildSequential(translationAgents);

A szekvenciális munkafolyamat futtatása

Hajtsa végre a munkafolyamatot, és dolgozza fel az eseményeket:

// 4) Run the workflow
var messages = new List<ChatMessage> { new(ChatRole.User, "Hello, world!") };

StreamingRun run = await InProcessExecution.StreamAsync(workflow, messages);
await run.TrySendMessageAsync(new TurnToken(emitEvents: true));

List<ChatMessage> result = new();
await foreach (WorkflowEvent evt in run.WatchStreamAsync().ConfigureAwait(false))
{
    if (evt is AgentResponseUpdateEvent e)
    {
        Console.WriteLine($"{e.ExecutorId}: {e.Data}");
    }
    else if (evt is WorkflowOutputEvent outputEvt)
    {
        result = (List<ChatMessage>)outputEvt.Data!;
        break;
    }
}

// Display final result
foreach (var message in result)
{
    Console.WriteLine($"{message.Role}: {message.Content}");
}

Mintakimenet

French_Translation: User: Hello, world!
French_Translation: Assistant: English detected. Bonjour, le monde !
Spanish_Translation: Assistant: French detected. ¡Hola, mundo!
English_Translation: Assistant: Spanish detected. Hello, world!

Alapfogalmak

  • Szekvenciális feldolgozás: Minden ügynök az előző ügynök kimenetét dolgozza fel sorrendben
  • AgentWorkflowBuilder.BuildSequential(): Folyamat-munkafolyamatot hoz létre ügynökök gyűjteményéből
  • ChatClientAgent: Egy csevegőügyfél által támogatott ügynököt jelöl, konkrét útmutatással
  • StreamingRun: Valós idejű végrehajtást biztosít az eseménystreamelési képességekkel
  • Eseménykezelés: Az ügynök előrehaladásának AgentResponseUpdateEvent és befejezésének monitorozása WorkflowOutputEvent

A szekvenciális vezénylés során minden ügynök egymás után dolgozza fel a feladatot, és a kimenet egyikről a másikra halad. Először definiálja az ügynököket egy kétfázisú folyamathoz:

from agent_framework.azure import AzureChatClient
from azure.identity import AzureCliCredential

# 1) Create agents using AzureChatClient
chat_client = AzureChatClient(credential=AzureCliCredential())

writer = chat_client.as_agent(
    instructions=(
        "You are a concise copywriter. Provide a single, punchy marketing sentence based on the prompt."
    ),
    name="writer",
)

reviewer = chat_client.as_agent(
    instructions=(
        "You are a thoughtful reviewer. Give brief feedback on the previous assistant message."
    ),
    name="reviewer",
)

Az szekvenciális orchestráció beállítása

Az SequentialBuilder osztály létrehoz egy folyamatot, amelyben az ügynökök sorrendben dolgozzák fel a feladatokat. Minden ügynök látja a teljes beszélgetési előzményeket, és hozzáadja a válaszukat:

from agent_framework.orchestrations import SequentialBuilder

# 2) Build sequential workflow: writer -> reviewer
workflow = SequentialBuilder(participants=[writer, reviewer]).build()

A szekvenciális munkafolyamat futtatása

Hajtsa végre a munkafolyamatot, és gyűjtse össze az egyes ügynökök közreműködését megjelenítő utolsó beszélgetést:

from agent_framework import Message, WorkflowEvent

# 3) Run and print final conversation
output_evt: WorkflowEvent | None = None
async for event in workflow.run_stream("Write a tagline for a budget-friendly eBike."):
    if event.type == "output":
        output_evt = event

if output_evt:
    print("===== Final Conversation =====")
    messages: list[Message] | Any = output_evt.data
    for i, msg in enumerate(messages, start=1):
        name = msg.author_name or ("assistant" if msg.role == "assistant" else "user")
        print(f"{'-' * 60}\n{i:02d} [{name}]\n{msg.text}")

Mintakimenet

===== Final Conversation =====
------------------------------------------------------------
01 [user]
Write a tagline for a budget-friendly eBike.
------------------------------------------------------------
02 [writer]
Ride farther, spend less—your affordable eBike adventure starts here.
------------------------------------------------------------
03 [reviewer]
This tagline clearly communicates affordability and the benefit of extended travel, making it
appealing to budget-conscious consumers. It has a friendly and motivating tone, though it could
be slightly shorter for more punch. Overall, a strong and effective suggestion!

Speciális: Ügynökök összekeverése testreszabott végrehajtókkal

A szekvenciális vezénylés támogatja az ügynökök és az egyéni végrehajtók speciális feldolgozásra való keverését. Ez akkor hasznos, ha olyan egyéni logikára van szüksége, amely nem igényel LLM-et:

Egyéni végrehajtó definiálása

from agent_framework import Executor, WorkflowContext, handler
from agent_framework import Message

class Summarizer(Executor):
    """Simple summarizer: consumes full conversation and appends an assistant summary."""

    @handler
    async def summarize(
        self,
        conversation: list[Message],
        ctx: WorkflowContext[list[Message]]
    ) -> None:
        users = sum(1 for m in conversation if m.role == "user")
        assistants = sum(1 for m in conversation if m.role == "assistant")
        summary = Message(
            role="assistant",
            contents=[f"Summary -> users:{users} assistants:{assistants}"]
        )
        await ctx.send_message(list(conversation) + [summary])

Vegyes szekvenciális munkafolyamat létrehozása

# Create a content agent
content = chat_client.as_agent(
    instructions="Produce a concise paragraph answering the user's request.",
    name="content",
)

# Build sequential workflow: content -> summarizer
summarizer = Summarizer(id="summarizer")
workflow = SequentialBuilder(participants=[content, summarizer]).build()

Mintakimenet egyéni végrehajtóval

------------------------------------------------------------
01 [user]
Explain the benefits of budget eBikes for commuters.
------------------------------------------------------------
02 [content]
Budget eBikes offer commuters an affordable, eco-friendly alternative to cars and public transport.
Their electric assistance reduces physical strain and allows riders to cover longer distances quickly,
minimizing travel time and fatigue. Budget models are low-cost to maintain and operate, making them accessible
for a wider range of people. Additionally, eBikes help reduce traffic congestion and carbon emissions,
supporting greener urban environments. Overall, budget eBikes provide cost-effective, efficient, and
sustainable transportation for daily commuting needs.
------------------------------------------------------------
03 [assistant]
Summary -> users:1 assistants:1

Alapfogalmak

  • Megosztott környezet: Minden résztvevő megkapja a teljes beszélgetési előzményt, beleértve az összes korábbi üzenetet is
  • Rendelési ügyek: Az ügynökök szigorúan a listában megadott sorrendben hajtanak végre participants()
  • Rugalmas résztvevők: Az ügynököket és az egyéni végrehajtókat tetszőleges sorrendben keverheti
  • Beszélgetési folyamat: Minden ügynök/végrehajtó hozzáfűzi a beszélgetést, és teljes párbeszédet hoz létre

Következő lépések

Egyidejű vezénylés

  • Last updated on