Een eenvoudige opeenvolgende werkstroom maken

In deze zelfstudie ziet u hoe u een eenvoudige opeenvolgende werkstroom maakt met behulp van Agent Framework-werkstromen.

Sequentiële werkstromen vormen de basis van het bouwen van complexe AI-agentsystemen. Deze zelfstudie laat zien hoe u een eenvoudige werkstroom in twee stappen maakt waarin elke stap gegevens verwerkt en doorgeeft aan de volgende stap.

Overzicht

In deze zelfstudie maakt u een werkstroom met twee uitvoerders:

Hoofdletterexecutor : invoertekst converteren naar hoofdletters
Reverse Text Executor - Hiermee wordt de tekst omgekeerd en wordt het uiteindelijke resultaat uitgevoerd

De werkstroom demonstreert kernconcepten zoals:

Een aangepaste uitvoerder maken met één handler
Een aangepaste uitvoerder maken op basis van een functie
Gebruiken WorkflowBuilder om uitvoerders te verbinden met randen
Gegevens verwerken via opeenvolgende stappen
Uitvoering van werkstroom observeren via gebeurtenissen

Behandelde concepten

Vereiste voorwaarden

.NET 8.0 SDK of hoger
Er zijn geen externe AI-services vereist voor dit basisvoorbeeld
Een nieuwe consoletoepassing

Stapsgewijze implementatie

In de volgende secties ziet u hoe u de opeenvolgende werkstroom stap voor stap bouwt.

Stap 1: NuGet-pakketten installeren

Installeer eerst de vereiste pakketten voor uw .NET-project:

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

Stap 2: de Hoofdletteruitvoerder definiëren

Definieer een uitvoerprogramma waarmee tekst wordt geconverteerd naar hoofdletters:

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

Belangrijkste punten:

Een functie maken die een tekenreeks gebruikt en de hoofdletterversie retourneert
Gebruiken BindExecutor() om een uitvoerder te maken op basis van de functie

Stap 3: De uitvoerfunctie voor omgekeerde tekst definiëren

Definieer een uitvoerprogramma waarmee de tekst wordt omgekeerd:

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

Belangrijkste punten:

Een klasse maken die wordt overgenomen van Executor<TInput, TOutput>
Implementeren HandleAsync() om de invoer te verwerken en de uitvoer te retourneren

Stap 4: De werkstroom bouwen en verbinden

Verbind de uitvoerders met behulp van WorkflowBuilder:

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

Belangrijkste punten:

WorkflowBuilder constructor ontvangt de start-executor
AddEdge() maakt een gerichte verbinding van hoofdletters naar omgekeerd
WithOutputFrom() geeft aan welke uitvoerders werkstroomuitvoer produceren
Build() maakt de onveranderbare werkstroom

Stap 5: De werkstroom uitvoeren

Voer de werkstroom uit en bekijk de resultaten:

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

Stap 6: Inzicht krijgen in de uitvoer van de werkstroom

Wanneer u de werkstroom uitvoert, ziet u uitvoer zoals:

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

De invoer 'Hallo, wereld!' wordt eerst geconverteerd naar hoofdletters ('HALLO, WERELD!') en vervolgens omgekeerd ('! DLROW ,OLLEH").

Belangrijke concepten uitgelegd

Uitvoerdersinterface

Uitvoerders van functies:

Gebruiken BindExecutor() om een uitvoerder te maken op basis van een functie

Uitvoerders implementeren Executor<TInput, TOutput>:

TInput: Het type gegevens dat deze uitvoerder accepteert
TOutput: Het type gegevens dat deze uitvoerder produceert
HandleAsync: de methode die de invoer verwerkt en de uitvoer retourneert

.NET Workflow Builder-patroon

De WorkflowBuilder biedt een fluent API voor het maken van werkstromen:

Constructor: neemt de startuitvoerer
AddEdge(): Hiermee worden gerichte verbindingen tussen uitvoerders gemaakt
WithOutputFrom(): hiermee geeft u op welke uitvoerders werkstroomuitvoer produceren
Build(): Hiermee maakt u de uiteindelijke onveranderbare werkstroom

.NET-gebeurtenistypen

Tijdens de uitvoering kunt u deze gebeurtenistypen bekijken:

ExecutorCompletedEvent - Wanneer een uitvoerder klaar is met de verwerking

Volledig .NET-voorbeeld

Zie het 01_ExecutorsAndEdges voorbeeld in de agentframeworkopslagplaats voor de volledige, kant-en-klare implementatie.

Dit voorbeeld omvat:

Volledige implementatie met alle gebruiksinstructies en klassestructuur
Aanvullende opmerkingen waarin de werkstroomconcepten worden uitgelegd
De installatie en configuratie van het project voltooien

Overzicht

In deze zelfstudie maakt u een werkstroom met twee uitvoerders:

Hoofdletterexecutor : invoertekst converteren naar hoofdletters
Reverse Text Executor - Hiermee wordt de tekst omgekeerd en wordt het uiteindelijke resultaat uitgevoerd

De werkstroom demonstreert kernconcepten zoals:

@executor De decorator gebruiken om werkstroomknooppunten te maken
Uitvoerders verbinden met WorkflowBuilder
Gegevens doorgeven tussen stappen met ctx.send_message()
Uiteindelijke uitvoer opleveren met ctx.yield_output()
Streaminggebeurtenissen voor realtime waarneembaarheid

Behandelde concepten

Vereiste voorwaarden

Python 3.10 of hoger
Python-pakket van Agent Framework Core geïnstalleerd: pip install agent-framework-core --pre
Er zijn geen externe AI-services vereist voor dit basisvoorbeeld

Stapsgewijze implementatie

In de volgende secties ziet u hoe u de opeenvolgende werkstroom stap voor stap bouwt.

Stap 1: Vereiste modules importeren

Importeer eerst de benodigde modules uit Agent Framework:

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

Stap 2: De eerste uitvoerder maken

Maak een uitvoerder die tekst converteert naar hoofdletters door een uitvoerder te implementeren met een handlermethode:

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)

Belangrijkste punten:

De @executor decorator registreert deze functie als een werkstroomknooppunt
WorkflowContext[str] geeft aan dat deze uitvoerder een tekenreeks downstream verzendt door de eerste typeparameter op te geven
ctx.send_message() geeft gegevens door aan de volgende stap

Stap 3: De tweede uitvoerder maken

Maak een executor die de tekst omkeert en de uiteindelijke uitvoer oplevert van een methode die is gedecoreerd met @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)

Belangrijkste punten:

WorkflowContext[Never, str] geeft aan dat dit een terminalexecutor is die geen berichten verzendt door op te Never geven als de eerste typeparameter, maar werkstroomuitvoer produceert door op te str geven als de tweede parameter
ctx.yield_output() geeft het uiteindelijke werkstroomresultaat
De workflow wordt voltooid wanneer deze inactief wordt.

Stap 4: De werkstroom bouwen

Verbind de uitvoerders met behulp van WorkflowBuilder:

upper_case = UpperCase(id="upper_case_executor")

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

Belangrijkste punten:

add_edge() maakt gerichte verbindingen tussen uitvoerders
set_start_executor() definieert het toegangspunt
build() voltooit de workflow

Stap 5: De werkstroom uitvoeren met streaming

Voer de werkstroom uit en bekijk gebeurtenissen in realtime:

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

Stap 6: De uitvoer begrijpen

Wanneer u de werkstroom uitvoert, ziet u gebeurtenissen zoals:

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

Belangrijke concepten uitgelegd

Werkstroomcontexttypen

Het WorkflowContext algemene type definieert welke gegevens tussen uitvoerders stromen:

WorkflowContext[str] - Hiermee wordt een tekenreeks naar de volgende uitvoerder verzonden
WorkflowContext[Never, str] - Terminaluitvoerder die werkstroomuitvoer van het type tekststring oplevert

Gebeurtenistypen

Tijdens het streamen ziet u deze gebeurtenistypen:

ExecutorInvokedEvent - Wanneer een uitvoerder begint met verwerken
ExecutorCompletedEvent - Wanneer een uitvoerder klaar is met de verwerking
WorkflowOutputEvent - Bevat het uiteindelijke werkstroomresultaat

Python Workflow Builder patroon

De WorkflowBuilder biedt een fluent API voor het maken van werkstromen:

add_edge(): Hiermee worden gerichte verbindingen tussen uitvoerders gemaakt
set_start_executor(): definieert het invoerpunt van de werkstroom
build(): Hiermee wordt een onveranderbaar werkstroomobject voltooid en geretourneerd

Volledig voorbeeld

Zie het voorbeeld in de agentframework-opslagplaats voor de volledige, kant-en-klare implementatie.

Dit voorbeeld omvat:

Volledige implementatie met alle import- en documentatie
Aanvullende opmerkingen waarin de werkstroomconcepten worden uitgelegd
Voorbeelduitvoer met de verwachte resultaten

Volgende stappen

Meer informatie over het maken van een eenvoudige gelijktijdige werkstroom

Feedback

Is deze pagina nuttig?

Last updated on 2025-11-21

Delen via

Een eenvoudige opeenvolgende werkstroom maken

Overzicht

Behandelde concepten

Vereiste voorwaarden

Stapsgewijze implementatie

Stap 1: NuGet-pakketten installeren

Stap 2: de Hoofdletteruitvoerder definiëren

Stap 3: De uitvoerfunctie voor omgekeerde tekst definiëren

Stap 4: De werkstroom bouwen en verbinden

Stap 5: De werkstroom uitvoeren

Stap 6: Inzicht krijgen in de uitvoer van de werkstroom

Belangrijke concepten uitgelegd

Uitvoerdersinterface

.NET Workflow Builder-patroon

.NET-gebeurtenistypen

Volledig .NET-voorbeeld

Overzicht

Behandelde concepten

Vereiste voorwaarden

Stapsgewijze implementatie

Stap 1: Vereiste modules importeren

Stap 2: De eerste uitvoerder maken

Stap 3: De tweede uitvoerder maken

Stap 4: De werkstroom bouwen

Stap 5: De werkstroom uitvoeren met streaming

Stap 6: De uitvoer begrijpen

Belangrijke concepten uitgelegd

Werkstroomcontexttypen

Gebeurtenistypen

Python Workflow Builder patroon

Volledig voorbeeld

Volgende stappen

Feedback

Aanvullende resources