Vytvoření jednoduchého sekvenčního pracovního postupu

Tento kurz ukazuje, jak vytvořit jednoduchý sekvenční pracovní postup pomocí pracovních postupů rozhraní Agent Framework.

Sekvenční pracovní postupy jsou základem vytváření složitých systémů agentů AI. V tomto kurzu se dozvíte, jak vytvořit jednoduchý dvoustupňový pracovní postup, ve kterém každý krok zpracovává data a předává je dalšímu kroku.

Přehled

V tomto kurzu vytvoříte pracovní postup se dvěma exekutory:

Exekutor velkými písmeny – převede vstupní text na velká písmena.
Reverse Text Executor - Převrací text a výstupem je konečný výsledek

Pracovní postup ukazuje základní koncepty, jako jsou:

Vytvoření vlastního vykonavatele s jednou obslužnou rutinou
Vytvoření vlastního exekutoru z funkce
Použití WorkflowBuilder ke spojení výkonných jednotek s hranami
Zpracování dat prostřednictvím sekvenčních kroků
Sledování provádění pracovního postupu prostřednictvím událostí

Pokryté koncepty

Požadavky

Sada .NET 8.0 SDK nebo novější
Pro tento základní příklad nejsou vyžadovány žádné externí služby AI.
Nová konzolová aplikace

Podrobná implementace

Následující části ukazují, jak krok za krokem sestavit sekvenční pracovní postup.

Krok 1: Instalace balíčků NuGet

Nejprve nainstalujte požadované balíčky pro váš projekt .NET:

dotnet add package Microsoft.Agents.AI.Workflows --prerelease

Krok 2: Definování vykonavatele pro převod na velká písmena

Definujte exekutor, který převede text na velká písmena:

using System;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.Agents.AI.Workflows;

/// <summary>
/// First executor: converts input text to uppercase.
/// </summary>
Func<string, string> uppercaseFunc = s => s.ToUpperInvariant();
var uppercase = uppercaseFunc.BindExecutor("UppercaseExecutor");

Klíčové body:

Vytvořte funkci, která přijímá řetězec a vrací jeho verzi ve velkých písmenech.
Použijte BindExecutor() k vytvoření exekutoru z funkce.

Krok 3: Definování exekutoru reverzního textu

Definujte spouštěč, který reverzuje text.

/// <summary>
/// Second executor: reverses the input text and completes the workflow.
/// </summary>
internal sealed class ReverseTextExecutor() : Executor<string, string>("ReverseTextExecutor")
{
    public override ValueTask<string> HandleAsync(string input, IWorkflowContext context, CancellationToken cancellationToken = default)
    {
        // Reverse the input text
        return ValueTask.FromResult(new string(input.Reverse().ToArray()));
    }
}

ReverseTextExecutor reverse = new();

Klíčové body:

Vytvoření třídy, která dědí z Executor<TInput, TOutput>
Implementace HandleAsync() pro zpracování vstupu a vrácení výstupu

Krok 4: Sestavení a připojení pracovního postupu

Připojte exekutory pomocí WorkflowBuilder:

// Build the workflow by connecting executors sequentially
WorkflowBuilder builder = new(uppercase);
builder.AddEdge(uppercase, reverse).WithOutputFrom(reverse);
var workflow = builder.Build();

Klíčové body:

WorkflowBuilder konstruktor přijímá počátečního vykonavatele.
AddEdge() vytvoří směrované spojení od funkce Uppercase k funkci Reverse.
WithOutputFrom() určuje, které exekutory vytvářejí výstupy pracovního postupu.
Build() vytvoří neměnný pracovní postup.

Krok 5: Provedení pracovního postupu

Spusťte pracovní postup a sledujte výsledky:

// Execute the workflow with input data
await using Run run = await InProcessExecution.RunAsync(workflow, "Hello, World!");
foreach (WorkflowEvent evt in run.NewEvents)
{
    switch (evt)
    {
        case ExecutorCompletedEvent executorComplete:
            Console.WriteLine($"{executorComplete.ExecutorId}: {executorComplete.Data}");
            break;
    }
}

Krok 6: Porozumění výstupu pracovních procesů

Při spuštění pracovního postupu uvidíte výstup jako:

UppercaseExecutor: HELLO, WORLD!
ReverseTextExecutor: !DLROW ,OLLEH

Vstup "Hello, World!" se nejprve převede na velká písmena ("HELLO, WORLD!") a pak se obrátí ("!DLROW ,OLLEH").

Vysvětlení klíčových konceptů

Rozhraní exekutoru

Spouštěče z funkcí:

Pomocí BindExecutor() vytvoříte vykonavatel z funkce.

Exekutory implementují Executor<TInput, TOutput>:

TInput: Typ dat, která tento exekutor přijímá
TOutput: Typ dat, která tento exekutor vytvoří
HandleAsync: Metoda, která zpracovává vstup a vrací výstup

Model tvůrce pracovních postupů .NET

Poskytuje WorkflowBuilder plynulé rozhraní API pro sestavování pracovních postupů.

Konstruktor: Přebírá spouštěcí exekutor
AddEdge(): Vytvoří směrovaná připojení mezi exekutory.
WithOutputFrom(): Určuje, které exekutory vytvářejí výstupy pracovního postupu.
Build(): Vytvoří konečný neměnný pracovní postup.

Typy událostí .NET

Během provádění můžete sledovat tyto typy událostí:

ExecutorCompletedEvent – Po dokončení zpracování vykonavatele

Kompletní příklad .NET

Úplnou implementaci připravenou ke spuštění najdete v ukázce 01_ExecutorsAndEdges v úložišti Agent Framework.

Tato ukázka zahrnuje:

Úplná implementace se všemi příkazy using a strukturou tříd
Další komentáře vysvětlující koncepty pracovního postupu
Dokončení nastavení a konfigurace projektu

Přehled

V tomto kurzu vytvoříte pracovní postup se dvěma exekutory:

Výkonný převod na velká písmena – převede vstupní text na velká písmena.
Reverse Text Executor - Převrací text a výstupem je konečný výsledek

Pracovní postup ukazuje základní koncepty, jako jsou:

Dva způsoby definování jednotky práce (uzel exekutoru):
1. Vlastní třída, která je podtřídou Executor s asynchronní metodou označená @handler
2. Samostatná asynchronní funkce označená @executor
Připojení zpracovatelů pomocí WorkflowBuilder
Předávání dat mezi kroky pomocí ctx.send_message()
Výsledek konečného výstupu s využitím ctx.yield_output()
Streamování událostí pro okamžitou pozorovatelnost

Pokryté koncepty

Požadavky

Python 3.10 nebo novější
Nainstalovaný balíček Agent Framework Core Python: pip install agent-framework-core --pre
Pro tento základní příklad nejsou vyžadovány žádné externí služby AI.

Podrobná implementace

Následující části ukazují, jak krok za krokem sestavit sekvenční pracovní postup.

Krok 1: Import požadovaných modulů

Nejprve naimportujte potřebné moduly z agenta Framework:

import asyncio
from typing_extensions import Never
from agent_framework import WorkflowBuilder, WorkflowContext, WorkflowOutputEvent, executor

Krok 2: Vytvoření prvního exekutoru

Vytvořte executor, který převede text na velká písmena tím, že implementujete executor s metodou handleru.

class UpperCase(Executor):
    def __init__(self, id: str):
        super().__init__(id=id)

    @handler
    async def to_upper_case(self, text: str, ctx: WorkflowContext[str]) -> None:
        """Convert the input to uppercase and forward it to the next node.

        Note: The WorkflowContext is parameterized with the type this handler will
        emit. Here WorkflowContext[str] means downstream nodes should expect str.
        """
        result = text.upper()

        # Send the result to the next executor in the workflow.
        await ctx.send_message(result)

Klíčové body:

Vytvoření podtřídy pomocí Executor vám umožňuje v případě potřeby definovat pojmenovaný uzel s háky životního cyklu.
Dekorátor @handler označuje asynchronní metodu, která vykonává úkol.
Podpis obslužné rutiny se řídí kontraktem:
- Prvním parametrem je zadaný vstup pro tento uzel (tady: text: str)
- Druhý parametr je WorkflowContext[T_Out], kde T_Out je typ dat, který tento uzel bude generovat prostřednictvím ctx.send_message() (zde: str)
V rámci obslužné rutiny obvykle vypočítáte výsledek a přesměrujete ho do podřízených uzlů pomocí ctx.send_message(result)

Krok 3: Vytvoření druhého exekutoru

Pro jednoduché kroky můžete vynechat tvoření podtříd a definovat asynchronní funkci se stejným vzorem podpisu (typed input + WorkflowContext), na kterou použijete dekorátor @executor. Tím se vytvoří plně funkční uzel, který se dá připojit k toku:

@executor(id="reverse_text_executor")
async def reverse_text(text: str, ctx: WorkflowContext[Never, str]) -> None:
    """Reverse the input and yield the workflow output."""
    result = text[::-1]

    # Yield the final output for this workflow run
    await ctx.yield_output(result)

Klíčové body:

Dekorátor @executor transformuje samostatnou asynchronní funkci na uzel pracovního postupu.
Parametrizuje se WorkflowContext dvěma typy:
- T_Out = Never: Tento uzel neodesílá zprávy podřízeným uzlům.
- T_W_Out = str: Tento uzel poskytuje výstup pracovního postupu typu. str
Terminálové uzly poskytují výstupy, které používají ctx.yield_output() k poskytování výsledků pracovního postupu.
Pracovní postup se dokončí, když se stane nečinným (není žádná další práce)

Krok 4: Sestavení pracovního postupu

Připojte exekutory pomocí WorkflowBuilder:

upper_case = UpperCase(id="upper_case_executor")

workflow = (
    WorkflowBuilder()
    .add_edge(upper_case, reverse_text)
    .set_start_executor(upper_case)
    .build()
)

Klíčové body:

add_edge() vytvoří směrovaná připojení mezi exekutory.
set_start_executor() definuje vstupní bod.
build() finalizuje pracovní postup.

Krok 5: Spuštění pracovního postupu se streamováním

Spusťte pracovní postup a sledujte události v reálném čase:

async def main():
    # Run the workflow and stream events
    async for event in workflow.run_stream("hello world"):
        print(f"Event: {event}")
        if isinstance(event, WorkflowOutputEvent):
            print(f"Workflow completed with result: {event.data}")

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

Krok 6: Vysvětlení výstupu

Při spuštění pracovního postupu se zobrazí události jako:

Event: ExecutorInvokedEvent(executor_id=upper_case_executor)
Event: ExecutorCompletedEvent(executor_id=upper_case_executor)
Event: ExecutorInvokedEvent(executor_id=reverse_text_executor)
Event: ExecutorCompletedEvent(executor_id=reverse_text_executor)
Event: WorkflowOutputEvent(data='DLROW OLLEH', source_executor_id=reverse_text_executor)
Workflow completed with result: DLROW OLLEH

Vysvětlení klíčových konceptů

Dva způsoby definování exekutorů

Vlastní třída (podtřídy Executor):: Nejlepší v případě, že potřebujete háky životního cyklu nebo složitý stav. Definujte asynchronní metodu s dekorátorem @handler.
Založený na funkcích (@executor dekorátor): Nejvhodnější řešení pro jednoduché kroky. Definujte samostatnou asynchronní funkci se stejným vzorem podpisu.

Oba přístupy používají stejný podpis obslužné rutiny:

První parametr: zadaný vstup do tohoto uzlu
Druhý parametr: a WorkflowContext[T_Out, T_W_Out]

Typy kontextu pracovního postupu

Obecný WorkflowContext typ definuje toky dat mezi exekutory:

WorkflowContext[T_Out] - Používá se pro uzly, které odesílají zprávy typu T_Out do podřízených uzlů prostřednictvím ctx.send_message()
WorkflowContext[T_Out, T_W_Out] - Používá se pro uzly, které také poskytují výstup pracovního postupu typu T_W_Out prostřednictvím ctx.yield_output()
WorkflowContext bez parametrů typu je ekvivalentní WorkflowContext[Never, Never], což znamená, že tento uzel neodesílá zprávy do podřízených uzlů ani nevyvolá výstup pracovního postupu.

Typy událostí

Během provádění streamování budete sledovat tyto typy událostí:

ExecutorInvokedEvent – Když exekutor začne zpracovávat
ExecutorCompletedEvent – Po dokončení zpracování vykonavatele
WorkflowOutputEvent – Obsahuje konečný výsledek pracovního postupu.

Model Tvůrce pracovních postupů Pythonu

Poskytuje WorkflowBuilder plynulé rozhraní API pro sestavování pracovních postupů.

add_edge(): Vytvoří směrovaná připojení mezi exekutory.
set_start_executor(): Definuje vstupní bod pracovního postupu.
build(): Finalizuje a vrací neměnný objekt pracovního postupu.

Kompletní příklad

Úplnou implementaci připravenou ke spuštění najdete v ukázce v úložišti Agent Framework.

Tato ukázka zahrnuje:

Úplná implementace se všemi importy a dokumentací
Další komentáře vysvětlující koncepty pracovního postupu
Ukázkový výstup zobrazující očekávané výsledky

Další kroky

Informace o vytvoření jednoduchého souběžného pracovního postupu

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-01-13

Sdílet prostřednictvím

Vytvoření jednoduchého sekvenčního pracovního postupu

Přehled

Pokryté koncepty

Požadavky

Podrobná implementace

Krok 1: Instalace balíčků NuGet

Krok 2: Definování vykonavatele pro převod na velká písmena

Krok 3: Definování exekutoru reverzního textu

Krok 4: Sestavení a připojení pracovního postupu

Krok 5: Provedení pracovního postupu

Krok 6: Porozumění výstupu pracovních procesů

Vysvětlení klíčových konceptů

Rozhraní exekutoru

Model tvůrce pracovních postupů .NET

Typy událostí .NET

Kompletní příklad .NET

Přehled

Pokryté koncepty

Požadavky

Podrobná implementace

Krok 1: Import požadovaných modulů

Krok 2: Vytvoření prvního exekutoru

Krok 3: Vytvoření druhého exekutoru

Krok 4: Sestavení pracovního postupu

Krok 5: Spuštění pracovního postupu se streamováním

Krok 6: Vysvětlení výstupu

Vysvětlení klíčových konceptů

Dva způsoby definování exekutorů

Typy kontextu pracovního postupu

Typy událostí

Model Tvůrce pracovních postupů Pythonu

Kompletní příklad

Další kroky

Váš názor

Další materiály