Skapa ett enkelt sekventiellt arbetsflöde

Den här självstudien visar hur du skapar ett enkelt sekventiellt arbetsflöde med hjälp av Agent Framework-arbetsflöden.

Sekventiella arbetsflöden är grunden för att skapa komplexa AI-agentsystem. Den här självstudien visar hur du skapar ett enkelt tvåstegsarbetsflöde där varje steg bearbetar data och skickar dem till nästa steg.

Översikt

I den här självstudien skapar du ett arbetsflöde med två utförare:

Versalomvandlare – Konverterar indatatext till versaler
Omvänd textexekutor – återställer texten och matar ut slutresultatet

Arbetsflödet visar grundläggande begrepp som:

Skapa en anpassad exekutor med en hanterare
Skapa en anpassad exekverare från en funktion
Använda WorkflowBuilder för att ansluta exekverare till kanter
Bearbeta data genom sekventiella steg
Övervaka arbetsflödesutförande via händelser

Begrepp som omfattas

Förutsättningar

.NET 8.0 SDK eller senare
Inga externa AI-tjänster krävs för det här grundläggande exemplet
Ett nytt konsolprogram

Stegvis implementering

Följande avsnitt visar hur du skapar det sekventiella arbetsflödet steg för steg.

Steg 1: Installera NuGet-paket

Installera först de nödvändiga paketen för .NET-projektet:

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

Steg 2: Definiera versalhanteraren

Definiera en komponent som konverterar text till versaler:

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

Viktiga punkter:

Skapa en funktion som tar en sträng och returnerar den i versaler
Använd BindExecutor() för att skapa en körfunktion från funktionen

Steg 3: Definiera den omvända textexekutor

Definiera en executor som vänder texten.

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

Viktiga punkter:

Skapa en klass som ärver från Executor<TInput, TOutput>
Implementera HandleAsync() för att bearbeta indata och returnera utdata

Steg 4: Skapa och ansluta arbetsflödet

Anslut exekverarna med WorkflowBuilder:

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

Viktiga punkter:

WorkflowBuilder konstruktorn tar startexekutorn
AddEdge() skapar en riktad anslutning från Uppercase till Reverse
WithOutputFrom() anger vilka köre som skapar arbetsflödesutdata
Build() skapar det oföränderliga arbetsflödet

Steg 5: Kör arbetsflödet

Kör arbetsflödet och observera resultatet:

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

Steg 6: Förstå arbetsflödets utdata

När du kör arbetsflödet visas utdata som:

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

Indatan "Hello, World!" konverteras först till stora bokstäver ("HELLO, WORLD!"), och vänds sedan till omvänd ordning ("!DLROW ,OLLEH").

Viktiga begrepp förklaras

Körgränssnitt

Exekverare från funktioner:

Använd BindExecutor() för att skapa en exekverare av en funktion

Utförare implementerar Executor<TInput, TOutput>:

TInput: Typen av data som den här exekveraren accepterar
TOutput: Den typ av data som denna exekverare producerar
HandleAsync: Metoden som bearbetar indata och returnerar utdata

Mönster för .NET Workflow Builder

Tillhandahåller WorkflowBuilder ett flytande API för att konstruera arbetsflöden:

Konstruktor: Tar startexekutor
AddEdge(): Skapar riktade anslutningar mellan utförare
WithOutputFrom(): Anger vilka utförare som skapar arbetsflödesutdata
Build(): Skapar det slutliga oföränderliga arbetsflödet

.NET-händelsetyper

Under exekvering kan du observera följande händelsetyper:

ExecutorCompletedEvent – När exekveraren är klar med bearbetningen

Slutför .NET-exempel

Den fullständiga, färdiga implementeringen finns i 01_ExecutorsAndEdges-exemplet på Agent Framework-lagringsplatsen.

Det här exemplet omfattar:

Fullständig implementering med alla använda instruktioner och klassstruktur
Ytterligare kommentarer som förklarar arbetsflödesbegreppen
Slutför projektets installation och konfiguration

Översikt

I den här självstudien skapar du ett arbetsflöde med två utförare:

Versalkonverterare – Konverterar indatatext till versaler
Omvänd textexekutor – återställer texten och matar ut slutresultatet

Arbetsflödet visar grundläggande begrepp som:

Använda dekoratören @executor för att skapa arbetsflödesnoder
Ansluta exekutorer med WorkflowBuilder
Skicka data mellan steg med ctx.send_message()
Ger slutliga utdata med ctx.yield_output()
Direktuppspelningshändelser för realtidsobservabilitet

Begrepp som omfattas

Förutsättningar

Python 3.10 eller senare
Agent Framework Core Python-paketet installerat: pip install agent-framework-core --pre
Inga externa AI-tjänster krävs för det här grundläggande exemplet

Stegvis implementering

Följande avsnitt visar hur du skapar det sekventiella arbetsflödet steg för steg.

Steg 1: Importera nödvändiga moduler

Importera först nödvändiga moduler från Agent Framework:

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

Steg 2: Skapa den första exekutorn

Skapa en exekverare som konverterar text till versaler genom att implementera en exekverare som använder en hanteringsmetod.

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)

Viktiga punkter:

Dekoratören @executor registrerar den här funktionen som en arbetsflödesnod
WorkflowContext[str] anger att den här exekutorn skickar en sträng nedströms genom att specificera den första typparametern
ctx.send_message() skickar data till nästa steg

Steg 3: Skapa den andra utföraren

Skapa en köre som vänder texten och ger slututdata från en metod som är dekorerad med @executor:

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

Viktiga punkter:

WorkflowContext[Never, str] anger att det här är en terminalexekutor som inte skickar några meddelanden genom att Never ange som den första typparametern men som skapar arbetsflödesutdata genom att str ange som den andra parametern
ctx.yield_output() ger det slutliga arbetsflödesresultatet
Arbetsflödet slutförs när det blir inaktivt

Steg 4: Skapa arbetsflödet

Anslut exekverarna med WorkflowBuilder:

upper_case = UpperCase(id="upper_case_executor")

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

Viktiga punkter:

add_edge() skapar riktade anslutningar mellan exekutorer
set_start_executor() definierar startpunkten
build() slutför arbetsflödet

Steg 5: Kör arbetsflödet med direktuppspelning

Kör arbetsflödet och observera händelser i realtid:

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

Steg 6: Förstå utdata

När du kör arbetsflödet visas händelser som:

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

Viktiga begrepp förklaras

Kontexttyper för arbetsflöde

Den WorkflowContext allmänna typen definierar vilka dataflöden mellan utförare:

WorkflowContext[str] - Skickar en sträng till nästa exekutör
WorkflowContext[Never, str] – Terminalexekutor som ger arbetsflödesutdata av typsträng

Händelsetyper

Vid strömning kommer du att se följande typer av händelser:

ExecutorInvokedEvent – När en exekverare börjar hantera
ExecutorCompletedEvent – När exekveraren är klar med bearbetningen
WorkflowOutputEvent – Innehåller det slutliga arbetsflödesresultatet

Mönster för Python Workflow Builder

Tillhandahåller WorkflowBuilder ett flytande API för att konstruera arbetsflöden:

add_edge(): Skapar riktade anslutningar mellan utförare
set_start_executor(): Definierar arbetsflödets startpunkt
build(): Slutför och returnerar ett oföränderligt arbetsflödesobjekt

Fullständigt exempel

Den fullständiga, färdiga implementeringen finns i exemplet på Agent Framework-lagringsplatsen.

Det här exemplet omfattar:

Fullständig implementering med all import och dokumentation
Ytterligare kommentarer som förklarar arbetsflödesbegreppen
Exempelutdata som visar förväntade resultat

Nästa steg

Lär dig mer om att skapa ett enkelt samtidigt arbetsflöde

Feedback

Var den här sidan hjälpsam?

Last updated on 2025-11-21

Dela via

Skapa ett enkelt sekventiellt arbetsflöde

Översikt

Begrepp som omfattas

Förutsättningar

Stegvis implementering

Steg 1: Installera NuGet-paket

Steg 2: Definiera versalhanteraren

Steg 3: Definiera den omvända textexekutor

Steg 4: Skapa och ansluta arbetsflödet

Steg 5: Kör arbetsflödet

Steg 6: Förstå arbetsflödets utdata

Viktiga begrepp förklaras

Körgränssnitt

Mönster för .NET Workflow Builder

.NET-händelsetyper

Slutför .NET-exempel

Översikt

Begrepp som omfattas

Förutsättningar

Stegvis implementering

Steg 1: Importera nödvändiga moduler

Steg 2: Skapa den första exekutorn

Steg 3: Skapa den andra utföraren

Steg 4: Skapa arbetsflödet

Steg 5: Kör arbetsflödet med direktuppspelning

Steg 6: Förstå utdata

Viktiga begrepp förklaras

Kontexttyper för arbetsflöde

Händelsetyper

Mönster för Python Workflow Builder

Fullständigt exempel

Nästa steg

Feedback

Ytterligare resurser