Ügynökök a munkafolyamatokban

Ez az oktatóanyag bemutatja, hogyan integrálhatók az AI-ügynökök munkafolyamatokba az Agent Framework használatával. Megtudhatja, hogyan hozhat létre olyan munkafolyamatokat, amelyek a speciális AI-ügynökök előnyeit használják ki tartalomlétrehozáshoz, áttekintéshez és egyéb együttműködési feladatokhoz.

Mit fog felépíteni?

Létre fog hozni egy munkafolyamatot, amely:

Intelligens ügynökök létrehozása az Azure Foundry Agent Service használatával
Francia fordítóügynököt implementál, amely a bemenetet francia nyelvre fordítja le
Implementál egy spanyol fordítóügynököt, amely franciát fordít spanyolra
Implementál egy angol fordítóügynököt, amely a spanyolt angolra fordítja vissza
Ügynökök csatlakoztatása szekvenciális munkafolyamatban
Valós idejű frissítések streamelése, miközben az ügynökök kérdéseket dolgoznak fel.
Az Azure Foundry-ügynökök megfelelő erőforrás-tisztításának bemutatása

A tárgyalt fogalmak

Előfeltételek

.NET 8.0 SDK vagy újabb
Azure Foundry-projektvégpont és -modell konfigurálva
Az Azure CLI telepítve és hitelesítve (az Azure hitelesítő adatokkal való hitelesítéshez)
Új konzolalkalmazás

1. lépés: NuGet-csomagok telepítése

Először telepítse a szükséges csomagokat a .NET-projekthez:

dotnet add package Azure.AI.Projects --prerelease
dotnet add package Azure.Identity
dotnet add package Microsoft.Agents.AI.Foundry --prerelease
dotnet add package Microsoft.Agents.AI.Workflows --prerelease

2. lépés: Az Azure Foundry-ügyfél beállítása

Az Azure Foundry-ügyfél konfigurálása környezeti változókkal és hitelesítéssel:

using Azure.AI.Projects;
using Azure.AI.Projects.Agents;
using Azure.Identity;
using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Foundry;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;

public static class Program
{
    private static async Task Main()
    {
        // Set up the Azure AI Project client
        var endpoint = Environment.GetEnvironmentVariable("AZURE_AI_PROJECT_ENDPOINT")
            ?? throw new InvalidOperationException("AZURE_AI_PROJECT_ENDPOINT is not set.");
        var deploymentName = Environment.GetEnvironmentVariable("AZURE_AI_MODEL_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
        var aiProjectClient = new AIProjectClient(new Uri(endpoint), new AzureCliCredential());

3. lépés: Az Agent Factory metódus létrehozása

Implementáljon egy segédmetódust az Azure Foundry-ügynökök létrehozásához a következő útmutatással:

    /// <summary>
    /// Creates a translation agent for the specified target language.
    /// </summary>
    /// <param name="targetLanguage">The target language for translation</param>
    /// <param name="aiProjectClient">The AIProjectClient to create the agent</param>
    /// <param name="model">The model to use for the agent</param>
    /// <returns>A ChatClientAgent configured for the specified language</returns>
    private static async Task<ChatClientAgent> GetTranslationAgentAsync(
        string targetLanguage,
        AIProjectClient aiProjectClient,
        string model)
    {
        string agentName = $"{targetLanguage} Translator";
        var version = await aiProjectClient.AgentAdministrationClient.CreateAgentVersionAsync(
            agentName,
            new ProjectsAgentVersionCreationOptions(
                new DeclarativeAgentDefinition(model)
                {
                    Instructions = $"You are a translation assistant that translates the provided text to {targetLanguage}."
                }));

        return aiProjectClient.AsAIAgent(version);
    }
}

4. lépés: Specializált Azure Foundry-ügynökök létrehozása

Hozzon létre három fordítóügynököt a segédmetódus használatával:

        // Create agents
        AIAgent frenchAgent = await GetTranslationAgentAsync("French", aiProjectClient, deploymentName);
        AIAgent spanishAgent = await GetTranslationAgentAsync("Spanish", aiProjectClient, deploymentName);
        AIAgent englishAgent = await GetTranslationAgentAsync("English", aiProjectClient, deploymentName);

5. lépés: A munkafolyamat létrehozása

Csatlakoztassa az ügynököket egy szekvenciális munkafolyamatban a WorkflowBuilder használatával:

        // Build the workflow by adding executors and connecting them
        var workflow = new WorkflowBuilder(frenchAgent)
            .AddEdge(frenchAgent, spanishAgent)
            .AddEdge(spanishAgent, englishAgent)
            .Build();

6. lépés: Végrehajtás streameléssel

Futtassa a munkafolyamatot streameléssel az összes ügynök valós idejű frissítéseinek megfigyeléséhez:

        // Execute the workflow
        await using StreamingRun run = await InProcessExecution.RunStreamingAsync(workflow, new ChatMessage(ChatRole.User, "Hello World!"));

        // Must send the turn token to trigger the agents.
        // The agents are wrapped as executors. When they receive messages,
        // they will cache the messages and only start processing when they receive a TurnToken.
        await run.TrySendMessageAsync(new TurnToken(emitEvents: true));
        await foreach (WorkflowEvent evt in run.WatchStreamAsync())
        {
            if (evt is AgentResponseUpdateEvent executorComplete)
            {
                Console.WriteLine($"{executorComplete.ExecutorId}: {executorComplete.Data}");
            }
        }

7. lépés: Erőforrás-karbantartás

Az Azure Foundry-ügynökök megfelelő tisztítása használat után:

        // Cleanup the agents created for the sample.
        await aiProjectClient.AgentAdministrationClient.DeleteAgentAsync(frenchAgent.Id);
        await aiProjectClient.AgentAdministrationClient.DeleteAgentAsync(spanishAgent.Id);
        await aiProjectClient.AgentAdministrationClient.DeleteAgentAsync(englishAgent.Id);
    }

Hogyan működik?

Azure Foundry-ügyfél beállítása: Azure CLI-hitelesítő adatokkal történő hitelesítés AIProjectClient
Ügynök létrehozása: Verziózott ügynökök létrehozása az Azure Foundry-ben, konkrét utasítások alapján a fordításhoz
Szekvenciális feldolgozás: a francia ügynök először a bemenetet, majd a spanyol ügynököt, majd az angol ügynököt fordítja le
Váltás token minta: Az egységek tárolják az üzeneteket, és csak akkor dolgozzák fel, ha kapnak egy TurnToken
Streamelési frissítések: AgentResponseUpdateEvent valós idejű token frissítéseket biztosít az ügynökök válaszának generálásakor
Erőforrás-kezelés: Az Azure Foundry-ügynökök megfelelő tisztítása a Felügyeleti API használatával

Alapfogalmak

Azure Foundry Agent Service: Felhőalapú AI-ügynökök speciális érvelési képességekkel
AIProjectClient: Ügyfél ügynökök létrehozására és kezelésére az Azure Foundryben
WorkflowEvent: A kimeneti események (type="output") ügynök kimeneti adatait tartalmazzák (AgentResponseUpdate streameléshez, AgentResponse nem streameléshez)
TurnToken: Az ügynökfeldolgozást az üzenet gyorsítótárazása után aktiváló jel
Szekvenciális munkafolyamat: Olyan folyamathoz csatlakoztatott ügynökök, ahol a kimeneti folyamatok egyikről a másikra haladnak

Implementáció befejezése

Az Azure Foundry-ügynökök munkafolyamatának teljes körű megvalósításáért tekintse meg a FoundryAgent Program.cs mintát az Agent Framework-adattárban.

Mit fog felépíteni?

Létre fog hozni egy munkafolyamatot, amely:

A FoundryChatClient használatával hoz létre intelligens ügynököket
Olyan Íróügynököt implementál, amely kérések alapján hoz létre tartalmat
Egy véleményező ügynököt implementál, amely visszajelzést ad a tartalomról
Ügynökök csatlakoztatása szekvenciális munkafolyamatban
Valós idejű frissítések streamelése, miközben az ügynökök kérdéseket dolgoznak fel.

A tárgyalt fogalmak

Előfeltételek

Python 3.10 vagy újabb
Telepített Ügynök-keretrendszer: pip install agent-framework
A megfelelő környezeti változókkal konfigurált Azure OpenAI-válaszok
Azure CLI-hitelesítés: az login

1. lépés: Kötelező függőségek importálása

Először importálja a munkafolyamatokhoz és az Azure OpenAI-válaszügynökökhöz szükséges összetevőket:

import asyncio
import os

from agent_framework import AgentResponseUpdate, WorkflowBuilder
from agent_framework.foundry import FoundryChatClient
from azure.identity import AzureCliCredential

2. lépés: Azure OpenAI-válaszügyfél létrehozása

Hozzon létre egy megosztott ügyfelet, amellyel több ügynököt hozhat létre:

async def main() -> None:
    client = FoundryChatClient(
        project_endpoint=os.environ["FOUNDRY_PROJECT_ENDPOINT"],
        model=os.environ["FOUNDRY_MODEL"],
        credential=AzureCliCredential(),
    )

3. lépés: Specializált ügynökök létrehozása

Hozzon létre két speciális ügynököt a tartalom létrehozásához és áttekintéséhez:

    # Create a Writer agent that generates content
    writer_agent = client.as_agent(
        name="Writer",
        instructions=(
            "You are an excellent content writer. You create new content and edit contents based on the feedback."
        ),
    )

    # Create a Reviewer agent that provides feedback
    reviewer_agent = client.as_agent(
        name="Reviewer",
        instructions=(
            "You are an excellent content reviewer. "
            "Provide actionable feedback to the writer about the provided content. "
            "Provide the feedback in the most concise manner possible."
        ),
    )

4. lépés: A munkafolyamat létrehozása

Kapcsolja össze az ügynököket egy szekvenciális munkafolyamatba az építő segítségével:

        # Build the workflow with agents as executors
        workflow = WorkflowBuilder(start_executor=writer_agent).add_edge(writer_agent, reviewer_agent).build()

5. lépés: Végrehajtás streameléssel

Futtassa a munkafolyamatot streameléssel a két ügynök valós idejű frissítéseinek megfigyeléséhez:

    last_author: str | None = None

    events = workflow.run("Create a slogan for a new electric SUV that is affordable and fun to drive.", stream=True)
    async for event in events:
        if event.type == "output" and isinstance(event.data, AgentResponseUpdate):
            update = event.data
            author = update.author_name
            if author != last_author:
                if last_author is not None:
                    print()
                print(f"{author}: {update.text}", end="", flush=True)
                last_author = author
            else:
                print(update.text, end="", flush=True)

6. lépés: Fő függvény befejezése

A fő függvény minden elemének körbefuttatása megfelelő aszinkron végrehajtással:

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

Hogyan működik?

Ügyfélbeállítás: Azure CLI-hitelesítő adatokkal rendelkezőt FoundryChatClient használ a hitelesítéshez.
Ügynök létrehozása: Író- és véleményezőügynököket hoz létre ugyanabból az ügyfélkonfigurációból.
Szekvenciális feldolgozás: Az íróügynök először létrehozza a tartalmat, majd átadja azt a Véleményező ügynöknek.
Folyamatban lévő frissítések: Az type="output" kimeneti események AgentResponseUpdate adatokkal valós idejű token frissítéseket biztosítanak, amikor az ügynökök válaszokat generálnak.

Alapfogalmak

FoundryChatClient: A munkafolyamat-ügynökök konzisztens konfigurálásához használt megosztott ügyfél.
WorkflowEvent: A kimeneti események (type="output") ügynök kimeneti adatait tartalmazzák (AgentResponseUpdate streameléshez, AgentResponse nem streameléshez).
Szekvenciális munkafolyamat: Olyan folyamathoz csatlakoztatott ügynökök, ahol a kimeneti folyamatok egyikről a másikra haladnak.

Implementáció befejezése

A teljes munka implementációjához tekintse meg azure_ai_agents_streaming.py az Ügynök-keretrendszer adattárában.

Mit fog felépíteni?

Létre fog hozni egy munkafolyamatot, amely:

Azure OpenAI-ügynököket használ munkafolyamat-végrehajtóként
Francia fordítóügynököt implementál
Spanyol fordítóügynököt implementál
Angol fordítóügynököt implementál
Ügynökök csatlakoztatása szekvenciális munkafolyamatban
Valós idejű frissítések streamelése, miközben az ügynökök kérdéseket dolgoznak fel.

A tárgyalt fogalmak

Előfeltételek

Go 1.25-ös vagy újabb verzió
Microsoft Foundry-projektvégpont és modell üzembe helyezése konfigurálva
Azure CLI hitelesítés vagy más Azure hitelesítőadat-forrás

1. lépés: Az Öntödei konfiguráció beállítása

endpoint := os.Getenv("FOUNDRY_PROJECT_ENDPOINT")
model := cmp.Or(os.Getenv("FOUNDRY_MODEL"), "gpt-4o-mini")

token, err := azidentity.NewDefaultAzureCredential(nil)
if err != nil {
    return err
}

Warning

azidentity.NewDefaultAzureCredential a fejlesztéshez kényelmes, de a termelési környezetben gondos megfontolást igényel. Éles környezetben fontolja meg egy konkrét hitelesítő adat, például a azidentity.NewManagedIdentityCredential használatát a késleltetési problémák, a hitelesítő adatok nem szándékos próbálgatása és a visszaesési mechanizmusokból eredő esetleges biztonsági kockázatok elkerülése érdekében.

2. lépés: Ügynök-előállító függvény létrehozása

Ügynökök létrehozása adott fordítási utasításokkal:

newTranslationAgent := func(language string) *agent.Agent {
    return foundryprovider.NewAgent(endpoint, token, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
        Instructions: fmt.Sprintf(
            "Translate the user's text to %s. Return only the translation.",
            language,
        ),
        Config: agent.Config{Name: language + "Agent"},
    })
}

3. lépés: Specializált öntödei ügynökök létrehozása

frenchAgent := newTranslationAgent("French")
spanishAgent := newTranslationAgent("Spanish")
englishAgent := newTranslationAgent("English")

4. lépés: A munkafolyamat létrehozása

Az ügynökök munkafolyamat-végrehajtóként is használhatók, lehetővé téve az AI-alapú munkafolyamat lépéseit.

Kösse össze az egyes ügynököket munkafolyamat-végrehajtóként, majd csatlakoztassa a végrehajtókat élekhez:

import (
    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/workflow/agentworkflow"
    "github.com/microsoft/agent-framework-go/message"
    "github.com/microsoft/agent-framework-go/workflow"
    "github.com/microsoft/agent-framework-go/workflow/inproc"
)

cfg := agentworkflow.Config{DisableForwardIncomingMessages: true}
french := agentworkflow.New(frenchAgent, cfg)
spanish := agentworkflow.New(spanishAgent, cfg)
english := agentworkflow.New(englishAgent, cfg)

wf, err := workflow.NewBuilder(french).
    AddEdge(french, spanish).
    AddEdge(spanish, english).
    WithOutputFrom(english).
    Build()
if err != nil {
    return err
}

5. lépés: Végrehajtás streameléssel

Futtassa a munkafolyamatot, és engedélyezze a frissítési eseményeket a következővel workflow.TurnToken:

run, err := inproc.Default.RunStreaming(ctx, wf, message.NewText("Hello World"))
if err != nil {
    return err
}
defer run.Close(ctx)

emitEvents := true
if err := run.SendMessage(ctx, workflow.TurnToken{EmitEvents: &emitEvents}); err != nil {
    return err
}

for evt, err := range run.WatchStream(ctx) {
    if err != nil {
        return err
    }
    if out, ok := evt.(workflow.OutputEvent); ok {
        if update, ok := out.Output.(*agent.ResponseUpdate); ok {
            fmt.Printf("%s: %s\n", out.ExecutorID, update.String())
        }
    }
}

Hogyan működik?

Ügyfélbeállítás: Azure hitelesítő adatokat használ az OpenAI-ügyféllel.
Ügynöklétrehozás: Speciális ügynököket hoz létre nyelvspecifikus utasításokkal.
Ügynökök hosztolása: A agentworkflow.New használatával minden ügynök munkafolyamat-végrehajtóként rendelhető hozzá.
Szekvenciális feldolgozás: Először a francia végrehajtási folyamat fut le, majd a spanyol, végül az angol.
Fordulójel-minta: A hosztolt ügynökök pufferelik az üzeneteket, és akkor futnak le, amikor kapnak egy workflow.TurnToken.
Folyamatos frissítések: a workflow.OutputEvent értékek tartalmazhatnak *agent.ResponseUpdate kimeneteket a valós idejű előrehaladás jelzésére.

Alapfogalmak

Azure OpenAI-ügynök: Az agent.Agent, amelyet az Azure OpenAI támogatja.
agentworkflow. Új: Átalakít egy ügynököt munkafolyamat-végrehajtóként való használatra.
Munkafolyamat. TurnToken: Jel, amely aktiválja a üzemeltetett ügynököket a pufferelt üzenetek feldolgozásához.
Munkafolyamat kimeneteEvent: Ügynök válaszfrissítéseit és a munkafolyamat végleges kimeneteit hordozza.
Szekvenciális munkafolyamat: Olyan folyamathoz csatlakoztatott ügynökök, ahol a kimeneti folyamatok egyikről a másikra haladnak.

Implementáció befejezése

package main

import (
    "cmp"
    "context"
    "fmt"
    "log"
    "os"

    "github.com/microsoft/agent-framework-go/agent"
    "github.com/microsoft/agent-framework-go/workflow/agentworkflow"
    "github.com/microsoft/agent-framework-go/message"
    "github.com/microsoft/agent-framework-go/workflow"
    "github.com/microsoft/agent-framework-go/workflow/inproc"

    "github.com/Azure/azure-sdk-for-go/sdk/azidentity"
    "github.com/microsoft/agent-framework-go/provider/foundryprovider"
)

func main() {
    ctx := context.Background()
    endpoint := os.Getenv("FOUNDRY_PROJECT_ENDPOINT")
    model := cmp.Or(os.Getenv("FOUNDRY_MODEL"), "gpt-4o-mini")

    credential, err := azidentity.NewDefaultAzureCredential(nil)
    if err != nil {
        log.Fatal(err)
    }

    newTranslationAgent := func(language string) *agent.Agent {
        return foundryprovider.NewAgent(endpoint, credential, foundryprovider.ModelDeployment(model), foundryprovider.AgentConfig{
            Instructions: fmt.Sprintf(
                "Translate the user's text to %s. Return only the translation.",
                language,
            ),
            Config: agent.Config{Name: language + "Agent"},
        })
    }

    cfg := agentworkflow.Config{DisableForwardIncomingMessages: true}
    french := agentworkflow.New(newTranslationAgent("French"), cfg)
    spanish := agentworkflow.New(newTranslationAgent("Spanish"), cfg)
    english := agentworkflow.New(newTranslationAgent("English"), cfg)

    wf, err := workflow.NewBuilder(french).
        AddEdge(french, spanish).
        AddEdge(spanish, english).
        WithOutputFrom(english).
        Build()
    if err != nil {
        log.Fatal(err)
    }

    run, err := inproc.Default.RunStreaming(ctx, wf, message.NewText("Hello World"))
    if err != nil {
        log.Fatal(err)
    }
    defer run.Close(ctx)

    emitEvents := true
    if err := run.SendMessage(ctx, workflow.TurnToken{EmitEvents: &emitEvents}); err != nil {
        log.Fatal(err)
    }

    for evt, err := range run.WatchStream(ctx) {
        if err != nil {
            log.Fatal(err)
        }
        if out, ok := evt.(workflow.OutputEvent); ok {
            if update, ok := out.Output.(*agent.ResponseUpdate); ok {
                fmt.Printf("%s: %s\n", out.ExecutorID, update.String())
            }
        }
    }
}

Warning

Tip

A teljes példáért tekintse meg a munkafolyamatok mintájában szereplő ügynököket .

Következő lépések

Human-in-the-Loop

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-07-10

Ügynökök a munkafolyamatokban

Mit fog felépíteni?

A tárgyalt fogalmak

Előfeltételek

1. lépés: NuGet-csomagok telepítése

2. lépés: Az Azure Foundry-ügyfél beállítása

3. lépés: Az Agent Factory metódus létrehozása

4. lépés: Specializált Azure Foundry-ügynökök létrehozása

5. lépés: A munkafolyamat létrehozása

6. lépés: Végrehajtás streameléssel

7. lépés: Erőforrás-karbantartás

Hogyan működik?

Alapfogalmak

Implementáció befejezése

Mit fog felépíteni?

A tárgyalt fogalmak

Előfeltételek

1. lépés: Kötelező függőségek importálása

2. lépés: Azure OpenAI-válaszügyfél létrehozása

3. lépés: Specializált ügynökök létrehozása

4. lépés: A munkafolyamat létrehozása

5. lépés: Végrehajtás streameléssel

6. lépés: Fő függvény befejezése

Hogyan működik?

Alapfogalmak

Implementáció befejezése

Mit fog felépíteni?

A tárgyalt fogalmak

Előfeltételek

1. lépés: Az Öntödei konfiguráció beállítása

2. lépés: Ügynök-előállító függvény létrehozása

3. lépés: Specializált öntödei ügynökök létrehozása

4. lépés: A munkafolyamat létrehozása

5. lépés: Végrehajtás streameléssel

Hogyan működik?

Alapfogalmak

Implementáció befejezése

Következő lépések

Visszajelzés

További források