Végrehajtók

A végrehajtók a munkafolyamat üzeneteinek feldolgozásának alapvető építőelemei. Ezek önálló feldolgozási egységek, amelyek gépelt üzeneteket fogadnak, műveleteket hajtanak végre, és kimeneti üzeneteket vagy eseményeket képesek létrehozni.

Áttekintés

Minden végrehajtó egyedi azonosítóval rendelkezik, és képes kezelni bizonyos üzenettípusokat. A végrehajtók lehetnek:

• Egyéni logikai összetevők – adatok feldolgozása, API-k meghívása vagy üzenetek átalakítása
• AI-ügynökök – a válaszok létrehozásához használjon LLM-eket (lásd : Ügynökök a munkafolyamatokban)

Fontos

A végrehajtó üzenetkezelők C#-ban való definiálásának ajánlott módja az, hogy az attribútumot olyan metódusokra alkalmazzuk, amelyek egy Executor-ből származó partial osztályon belül találhatók. Ez fordítási idejű forráslétrehozást használ a kezelőregisztrációhoz, jobb teljesítményt, fordítási idő érvényesítést és natív AOT-kompatibilitást biztosít.

Egyszerű végrehajtói struktúra

A végrehajtók az Executor alaposztályból származnak, és az [MessageHandler] attribútum használatával deklarálják a kezelő metódusokat. Az osztályt meg kell jelölni partial a forráslétrehozás engedélyezéséhez.

using Microsoft.Agents.AI.Workflows;

internal sealed partial class UppercaseExecutor() : Executor("UppercaseExecutor")
{
    [MessageHandler]
    private ValueTask<string> HandleAsync(string message, IWorkflowContext context)
    {
        string result = message.ToUpperInvariant();
        return ValueTask.FromResult(result); // Return value is automatically sent to connected executors
    }
}

Manuálisan is küldhet üzeneteket érték visszaadása nélkül:

internal sealed partial class UppercaseExecutor() : Executor("UppercaseExecutor")
{
    [MessageHandler]
    private async ValueTask HandleAsync(string message, IWorkflowContext context)
    {
        string result = message.ToUpperInvariant();
        await context.SendMessageAsync(result); // Manually send messages to connected executors
    }
}

Több bemeneti típus

Több bemeneti típus kezelése több [MessageHandler] metódus definiálásával:

internal sealed partial class SampleExecutor() : Executor("SampleExecutor")
{
    [MessageHandler]
    private ValueTask<string> HandleStringAsync(string message, IWorkflowContext context)
    {
        return ValueTask.FromResult(message.ToUpperInvariant());
    }

    [MessageHandler]
    private ValueTask<int> HandleIntAsync(int message, IWorkflowContext context)
    {
        return ValueTask.FromResult(message * 2);
    }
}

Funkcióalapú végrehajtók

Hozzon létre egy végrehajtót egy függvényből a bővítménymetódus BindExecutor használatával:

Func<string, string> uppercaseFunc = s => s.ToUpperInvariant();
var uppercase = uppercaseFunc.BindExecutor("UppercaseExecutor");

Egyszerű végrehajtói struktúra

A végrehajtók az Executor alaposztálytól öröklődnek. Minden végrehajtó a @handler dekoratőrrel ellátott metódusokat használja. A kezelőknek megfelelő típusú széljegyzetekkel kell rendelkezniük a feldolgozott üzenettípusok megadásához.

from agent_framework import (
    Executor,
    WorkflowContext,
    handler,
)

class UpperCase(Executor):

    @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."""
        await ctx.send_message(text.upper())

Function-Based Végrehajtók

Hozzon létre egy végrehajtót egy függvényből a @executor dekorátor használatával:

from agent_framework import (
    WorkflowContext,
    executor,
)

@executor(id="upper_case_executor")
async def upper_case(text: str, ctx: WorkflowContext[str]) -> None:
    """Convert the input to uppercase and forward it to the next node."""
    await ctx.send_message(text.upper())

Több bemeneti típus

Több bemeneti típus kezelése több kezelő definiálásával:

class SampleExecutor(Executor):

    @handler
    async def to_upper_case(self, text: str, ctx: WorkflowContext[str]) -> None:
        await ctx.send_message(text.upper())

    @handler
    async def double_integer(self, number: int, ctx: WorkflowContext[int]) -> None:
        await ctx.send_message(number * 2)

Explicit típusparaméterek

A széljegyzetek típusának alternatívaként a dekorátorparamétereken keresztül explicit módon adhatja meg a típusokat:

Fontos

Explicit típusparaméterek használatakor minden típust meg kell adnia a dekorátoron keresztül – az explicit paraméterek nem keverhetők össze típusjegyzetekkel. A input paraméter megadása kötelező, output és workflow_output nem kötelező.

class ExplicitTypesExecutor(Executor):

    @handler(input=str, output=str)
    async def to_upper_case(self, text, ctx) -> None:
        await ctx.send_message(text.upper())

    @handler(input=str | int, output=str)
    async def handle_mixed(self, message, ctx) -> None:
        await ctx.send_message(str(message).upper())

    @handler(input=str, output=int, workflow_output=bool)
    async def process_with_workflow_output(self, message, ctx) -> None:
        await ctx.send_message(len(message))
        await ctx.yield_output(True)

A WorkflowContext objektum

A WorkflowContext módszereket kínál a munkafolyamat végrehajtása közbeni interakcióhoz.

• send_message — üzenetek küldése csatlakoztatott végrehajtóknak
• yield_output — a hívónak visszaadott/streamelt munkafolyamat-kimenetek létrehozása

class OutputExecutor(Executor):

    @handler
    async def handle(self, message: str, ctx: WorkflowContext[Never, str]) -> None:
        await ctx.yield_output("Hello, World!")

Ha egy kezelő nem küld üzeneteket, és nem ad kimenetet, nincs szükség típusparaméterre:

class LogExecutor(Executor):

    @handler
    async def handle(self, message: str, ctx: WorkflowContext) -> None:
        print("Doing some work...")

Következő lépések

edges