Freigeben über

Microsoft Agent Framework-Workflows-Orchestrierungen – Übergabe

Die Handoff-Orchestrierung ermöglicht Agenten, die Steuerung basierend auf dem Kontext oder der Benutzeranforderung untereinander zu übertragen. Jeder Agent kann die Unterhaltung einem anderen Agenten mit der entsprechenden Expertise "übergeben", um sicherzustellen, dass der richtige Agent jeden Teil der Aufgabe verarbeitet. Dies ist besonders hilfreich bei Kundensupport, Expertensystemen oder szenarien, die eine dynamische Delegierung erfordern.

Intern wird die Handoff-Orchestrierung mithilfe einer Mesh-Topologie implementiert, in der Agenten direkt ohne einen Orchestrator verbunden sind. Jeder Agent kann entscheiden, wann die Unterhaltung basierend auf vordefinierten Regeln oder dem Inhalt der Nachrichten übergeben werden soll.

Handoff-Orchestrierung

Hinweis

Die Handoff-Orchestrierung unterstützt nur Agent, und die Agenten müssen die Ausführung lokaler Tools unterstützen.

Unterschiede zwischen Übergabe und Agent-als-Tools

Während das Modell Agenten-als-Werkzeuge oft als Multi-Agenten-Muster gesehen wird und auf den ersten Blick ähnlich zu einem Handover erscheinen mag, bestehen grundlegende Unterschiede zwischen den beiden:

  • Steuerfluss: Bei der Hand-off-Orchestrierung wird die Steuerung explizit zwischen Agenten basierend auf definierten Regeln übergeben. Jeder Agent kann sich entscheiden, die gesamte Aufgabe an einen anderen Agenten zu übergeben. Es gibt keine zentrale Autorität, die den Workflow verwaltet. Im Gegensatz dazu umfasst agent-as-tools einen primären Agent, der Subaufgaben an andere Agents delegiert, und sobald der Agent die Unteraufgabe abgeschlossen hat, kehrt die Steuerung an den primären Agent zurück.
  • Aufgabenbesitz: Bei der Übergabe übernimmt der Agent, der die Übergabe empfängt, die vollständige Verantwortung für die Aufgabe. Im Agent-as-Tools behält der primäre Agent die Gesamtverantwortung für die Aufgabe bei, während andere Agents als Tools behandelt werden, um bestimmte Teilvorgänge zu unterstützen.
  • Kontextverwaltung: Bei der Orchestrierung der Übergabe wird die Unterhaltung vollständig an einen anderen Agenten übergeben. Der empfangende Agent hat den vollständigen Kontext dessen, was bisher getan wurde. In Agent-as-Tools verwaltet der primäre Agent den Gesamtkontext und stellt ggf. nur relevante Informationen für die Tool-Agents bereit.

Sie lernen Folgendes

  • So erstellen Sie spezielle Agents für unterschiedliche Domänen
  • So konfigurieren Sie Weiterleitungsregeln zwischen Agenten
  • So erstellen Sie interaktive Workflows mit dynamischem Agent-Routing
  • Umgang mit mehrstufigen Gesprächen bei Agentenwechsel
  • So implementieren Sie die Genehmigung von Tools für sensible Vorgänge (HITL)
  • Verwendung von Checkpointing für dauerhafte Handoff-Workflows

Bei der Orchestrierung der Übergaben können Agenten die Steuerung basierend auf dem Kontext aneinander übertragen, was dynamisches Routing und spezialisiertes Fachwissen ermöglicht.

Einrichten des Azure OpenAI-Clients

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Azure.AI.OpenAI;
using Azure.Identity;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using Microsoft.Agents.AI;

// 1) Set up the Azure OpenAI client
var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT") ??
    throw new InvalidOperationException("AZURE_OPENAI_ENDPOINT is not set.");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT_NAME") ?? "gpt-4o-mini";
var client = new AzureOpenAIClient(new Uri(endpoint), new DefaultAzureCredential())
    .GetChatClient(deploymentName)
    .AsIChatClient();

Warnung

DefaultAzureCredential ist praktisch für die Entwicklung, erfordert aber sorgfältige Überlegungen in der Produktion. Berücksichtigen Sie in der Produktion die Verwendung bestimmter Anmeldeinformationen (z. B. ManagedIdentityCredential), um Latenzprobleme, unbeabsichtigte Abfragen von Anmeldeinformationen und potenzielle Sicherheitsrisiken durch Ausweichmechanismen zu vermeiden.

Definieren Sie Ihre spezialisierten Agenten

Erstellen Sie domänenspezifische Agenten und einen Triage-Agenten für das Routing.

// 2) Create specialized agents
ChatClientAgent historyTutor = new(client,
    "You provide assistance with historical queries. Explain important events and context clearly. Only respond about history.",
    "history_tutor",
    "Specialist agent for historical questions");

ChatClientAgent mathTutor = new(client,
    "You provide help with math problems. Explain your reasoning at each step and include examples. Only respond about math.",
    "math_tutor",
    "Specialist agent for math questions");

ChatClientAgent triageAgent = new(client,
    "You determine which agent to use based on the user's homework question. ALWAYS handoff to another agent.",
    "triage_agent",
    "Routes messages to the appropriate specialist agent");

Konfigurieren von Handoff-Regeln

Definieren Sie, welche Agents an welche anderen Agents übergeben werden können:

// 3) Build handoff workflow with routing rules
var workflow = AgentWorkflowBuilder.StartHandoffWith(triageAgent)
    .WithHandoffs(triageAgent, [mathTutor, historyTutor]) // Triage can route to either specialist
    .WithHandoff(mathTutor, triageAgent)                  // Math tutor can return to triage
    .WithHandoff(historyTutor, triageAgent)               // History tutor can return to triage
    .Build();

Interaktiver Übergabeworkflow ausführen

Bearbeitung mehrstufiger Unterhaltungen mit dynamischem Agentenwechsel:

// 4) Process multi-turn conversations
List<ChatMessage> messages = new();

while (true)
{
    Console.Write("Q: ");
    string userInput = Console.ReadLine()!;
    messages.Add(new(ChatRole.User, userInput));

    // Execute workflow and process events
    StreamingRun run = await InProcessExecution.StreamAsync(workflow, messages);
    await run.TrySendMessageAsync(new TurnToken(emitEvents: true));

    List<ChatMessage> newMessages = new();
    await foreach (WorkflowEvent evt in run.WatchStreamAsync().ConfigureAwait(false))
    {
        if (evt is AgentResponseUpdateEvent e)
        {
            Console.WriteLine($"{e.ExecutorId}: {e.Data}");
        }
        else if (evt is WorkflowOutputEvent outputEvt)
        {
            newMessages = (List<ChatMessage>)outputEvt.Data!;
            break;
        }
    }

    // Add new messages to conversation history
    messages.AddRange(newMessages.Skip(messages.Count));
}

Beispielinteraktion

Q: What is the derivative of x^2?
triage_agent: This is a math question. I'll hand this off to the math tutor.
math_tutor: The derivative of x^2 is 2x. Using the power rule, we bring down the exponent (2) and multiply it by the coefficient (1), then reduce the exponent by 1: d/dx(x^2) = 2x^(2-1) = 2x.

Q: Tell me about World War 2
triage_agent: This is a history question. I'll hand this off to the history tutor.
history_tutor: World War 2 was a global conflict from 1939 to 1945. It began when Germany invaded Poland and involved most of the world's nations. Key events included the Holocaust, Pearl Harbor attack, D-Day invasion, and ended with atomic bombs on Japan.

Q: Can you help me with calculus integration?
triage_agent: This is another math question. I'll route this to the math tutor.
math_tutor: I'd be happy to help with calculus integration! Integration is the reverse of differentiation. The basic power rule for integration is: ∫x^n dx = x^(n+1)/(n+1) + C, where C is the constant of integration.

Definieren einiger Tools für die Demonstration

@tool
def process_refund(order_number: Annotated[str, "Order number to process refund for"]) -> str:
    """Simulated function to process a refund for a given order number."""
    return f"Refund processed successfully for order {order_number}."

@tool
def check_order_status(order_number: Annotated[str, "Order number to check status for"]) -> str:
    """Simulated function to check the status of a given order number."""
    return f"Order {order_number} is currently being processed and will ship in 2 business days."

@tool
def process_return(order_number: Annotated[str, "Order number to process return for"]) -> str:
    """Simulated function to process a return for a given order number."""
    return f"Return initiated successfully for order {order_number}. You will receive return instructions via email."

Einrichten des Chatclients

from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential

# Initialize the Azure OpenAI chat client
chat_client = AzureOpenAIChatClient(credential=AzureCliCredential())

Definieren Sie Ihre spezialisierten Agenten

Erstellen Sie domänenspezifische Agenten mit einem Koordinator für Routing.

# Create triage/coordinator agent
triage_agent = chat_client.as_agent(
    instructions=(
        "You are frontline support triage. Route customer issues to the appropriate specialist agents "
        "based on the problem described."
    ),
    description="Triage agent that handles general inquiries.",
    name="triage_agent",
)

# Refund specialist: Handles refund requests
refund_agent = chat_client.as_agent(
    instructions="You process refund requests.",
    description="Agent that handles refund requests.",
    name="refund_agent",
    # In a real application, an agent can have multiple tools; here we keep it simple
    tools=[process_refund],
)

# Order/shipping specialist: Resolves delivery issues
order_agent = chat_client.as_agent(
    instructions="You handle order and shipping inquiries.",
    description="Agent that handles order tracking and shipping issues.",
    name="order_agent",
    # In a real application, an agent can have multiple tools; here we keep it simple
    tools=[check_order_status],
)

# Return specialist: Handles return requests
return_agent = chat_client.as_agent(
    instructions="You manage product return requests.",
    description="Agent that handles return processing.",
    name="return_agent",
    # In a real application, an agent can have multiple tools; here we keep it simple
    tools=[process_return],
)

Konfigurieren von Handoff-Regeln

Erstellen Sie den Übergabeworkflow mithilfe von HandoffBuilder:

from agent_framework.orchestrations import HandoffBuilder

# Build the handoff workflow
workflow = (
    HandoffBuilder(
        name="customer_support_handoff",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
        termination_condition=lambda conversation: len(conversation) > 0 and "welcome" in conversation[-1].text.lower(),
    )
    .with_start_agent(triage_agent) # Triage receives initial user input
    .build()
)

Standardmäßig können alle Agenten einander übergeben werden. Für erweitertes Routing können Sie Handoffs konfigurieren:

workflow = (
    HandoffBuilder(
        name="customer_support_handoff",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
        termination_condition=lambda conversation: len(conversation) > 0 and "welcome" in conversation[-1].text.lower(),
    )
    .with_start_agent(triage_agent) # Triage receives initial user input
    # Triage cannot route directly to refund agent
    .add_handoff(triage_agent, [order_agent, return_agent])
    # Only the return agent can handoff to refund agent - users wanting refunds after returns
    .add_handoff(return_agent, [refund_agent])
    # All specialists can handoff back to triage for further routing
    .add_handoff(order_agent, [triage_agent])
    .add_handoff(return_agent, [triage_agent])
    .add_handoff(refund_agent, [triage_agent])
    .build()
)

Hinweis

Auch bei benutzerdefinierten Übergaberegeln sind alle Agents weiterhin in einer Gittertopologie verbunden. Dies liegt daran, dass Agents den Kontext miteinander teilen müssen, um den Unterhaltungsverlauf aufrechtzuerhalten (weitere Details finden Sie unter "Kontextsynchronisierung "). Die Übergaberegeln regeln nur, welche Agenten die Unterhaltung als nächstes übernehmen können.

Ausführen der Handoff-Agent-Interaktion

Im Gegensatz zu anderen Orchestrierungen ist Handoff interaktiv, da sich ein Agent nicht nach jeder Wendung für eine Übergabe entscheidet. Wenn ein Agent die Unterhaltung nicht abgibt, ist eine manuelle Eingabe erforderlich, um das Gespräch fortzusetzen. Informationen zum Umgehen dieser Anforderung finden Sie im autonomen Modus . Nachdem ein Agent reagiert, geht die Kontrolle entweder an den Orchestrator oder an den nächsten Agenten bei anderen Orchestrierungen.

Wenn sich ein Agent in einem Übergabeworkflow entscheidet, nicht zu übergeben (eine Übergabe wird durch einen speziellen Toolaufruf ausgelöst), gibt der Workflow ein WorkflowEvent mit type="request_info" und eine HandoffAgentUserRequest-Nutzlast aus, die die neuesten Nachrichten des Agenten enthält. Der Benutzer muss auf diese Anforderung antworten, um den Workflow fortzusetzen.

from agent_framework import WorkflowEvent
from agent_framework.orchestrations import HandoffAgentUserRequest

# Start workflow with initial user message
events = [event async for event in workflow.run_stream("I need help with my order")]

# Process events and collect pending input requests
pending_requests = []
for event in events:
    if event.type == "request_info" and isinstance(event.data, HandoffAgentUserRequest):
        pending_requests.append(event)
        request_data = event.data
        print(f"Agent {event.executor_id} is awaiting your input")
        # The request contains the most recent messages generated by the
        # agent requesting input
        for msg in request_data.agent_response.messages[-3:]:
            print(f"{msg.author_name}: {msg.text}")

# Interactive loop: respond to requests
while pending_requests:
    user_input = input("You: ")

    # Send responses to all pending requests
    responses = {req.request_id: HandoffAgentUserRequest.create_response(user_input) for req in pending_requests}
    # You can also send a `HandoffAgentUserRequest.terminate()` to end the workflow early
    events = [event async for event in workflow.run(responses=responses)]

    # Process new events
    pending_requests = []
    for event in events:
        # Check for new input requests

Autonomer Modus

Die Handoff-Orchestrierung wurde für interaktive Szenarien entwickelt, in denen menschliche Eingaben erforderlich sind, wenn ein Agent sich entscheidet, die Übergabe nicht durchzuführen. Als experimentelles Feature können Sie jedoch den "autonomen Modus" aktivieren, damit der Workflow ohne menschliche Eingriffe fortgesetzt werden kann. Wenn sich ein Agent in diesem Modus entscheidet, nicht zu übergeben, sendet der Workflow automatisch eine Standardantwort (z. B. User did not respond. Continue assisting autonomously.) an den Agenten, sodass er die Unterhaltung fortsetzen kann.

Tipp

Warum ist Handoff-Orchestrierung inhärent interaktiv? Im Gegensatz zu anderen Orchestrierungen, bei denen nach der Antwort eines Agenten nur ein einziger Weg, nämlich zum Orchestrator oder zum nächsten Agenten, zurückführt, hat der Agent bei einer Handoff-Orchestrierung die Möglichkeit, entweder an einen anderen Agenten weiterzuleiten oder den Benutzer selbst weiterhin zu unterstützen. Und da Übergaben durch Werkzeugaufrufe erreicht werden, wenn ein Agent kein Übergabewerkzeug aufruft, sondern stattdessen eine Antwort generiert, weiß der Workflow nicht, was als Nächstes zu tun ist und bittet stattdessen den Benutzer wieder um weitere Eingaben. Es ist auch nicht möglich, zu erzwingen, dass ein Agent immer übergibt, indem er das Übergabetool aufruft, da der Agent sonst keine sinnvollen Antworten generieren kann.

Der autonome Modus wird durch das Aufrufen von with_autonomous_mode() auf der HandoffBuilder aktiviert. Dadurch wird der Workflow so konfiguriert, dass er automatisch auf Eingabeanforderungen mit einer Standardnachricht reagiert, sodass der Agent fortfahren kann, ohne auf menschliche Eingaben zu warten.

workflow = (
    HandoffBuilder(
        name="autonomous_customer_support",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
    )
    .with_start_agent(triage_agent)
    .with_autonomous_mode()
    .build()
)

Sie können den autonomen Modus auch nur für eine Teilmenge von Agents aktivieren, indem Sie eine Liste von Agentinstanzen an with_autonomous_mode()übergeben.

workflow = (
    HandoffBuilder(
        name="partially_autonomous_support",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
    )
    .with_start_agent(triage_agent)
    .with_autonomous_mode(agents=[triage_agent])  # Only triage_agent runs autonomously
    .build()
)

Sie können die Standardantwortnachricht anpassen.

workflow = (
    HandoffBuilder(
        name="custom_autonomous_support",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
    )
    .with_start_agent(triage_agent)
    .with_autonomous_mode(
        agents=[triage_agent],
        prompts={triage_agent.name: "Continue with your best judgment as the user is unavailable."},
    )
    .build()
)

Sie können die Anzahl der Drehungen anpassen, die ein Agent autonom ausführen kann, bevor menschliche Eingaben erforderlich sind. Dadurch kann verhindert werden, dass der Workflow unbegrenzt ohne Benutzerbeteiligung ausgeführt wird.

workflow = (
    HandoffBuilder(
        name="limited_autonomous_support",
        participants=[triage_agent, refund_agent, order_agent, return_agent],
    )
    .with_start_agent(triage_agent)
    .with_autonomous_mode(
        agents=[triage_agent],
        turn_limits={triage_agent.name: 3},  # Max 3 autonomous turns
    )
    .build()
)

Erweitert: Werkzeuggenehmigung in Handoff-Workflows

Handoff-Workflows können Agenten mit Tools enthalten, die vor der Ausführung eine menschliche Genehmigung erfordern. Dies ist nützlich für sensible Vorgänge wie die Verarbeitung von Rückerstattungen, das Tätigen von Einkäufen oder das Ausführen von unwiderruflichen Aktionen.

Definieren von Tools mit Genehmigung erforderlich

from typing import Annotated
from agent_framework import tool

@tool(approval_mode="always_require")
def process_refund(order_number: Annotated[str, "Order number to process refund for"]) -> str:
    """Simulated function to process a refund for a given order number."""
    return f"Refund processed successfully for order {order_number}."

Erstellen Sie Agenten mit Tools, die eine Genehmigung erfordern

from agent_framework import Agent
from agent_framework.azure import AzureOpenAIChatClient
from azure.identity import AzureCliCredential

client = AzureOpenAIChatClient(credential=AzureCliCredential())

triage_agent = chat_client.as_agent(
    instructions=(
        "You are frontline support triage. Route customer issues to the appropriate specialist agents "
        "based on the problem described."
    ),
    description="Triage agent that handles general inquiries.",
    name="triage_agent",
)

refund_agent = chat_client.as_agent(
    instructions="You process refund requests.",
    description="Agent that handles refund requests.",
    name="refund_agent",
    tools=[process_refund],
)

order_agent = chat_client.as_agent(
    instructions="You handle order and shipping inquiries.",
    description="Agent that handles order tracking and shipping issues.",
    name="order_agent",
    tools=[check_order_status],
)

Behandeln von Benutzereingabe- und Toolgenehmigungsanforderungen

from agent_framework import (
    FunctionApprovalRequestContent,
    WorkflowEvent,
)
from agent_framework.orchestrations import HandoffBuilder, HandoffAgentUserRequest

workflow = (
    HandoffBuilder(
        name="support_with_approvals",
        participants=[triage_agent, refund_agent, order_agent],
    )
    .with_start_agent(triage_agent)
    .build()
)

pending_requests: list[WorkflowEvent] = []

# Start workflow
async for event in workflow.run_stream("My order 12345 arrived damaged. I need a refund."):
    if event.type == "request_info":
        pending_requests.append(event)

# Process pending requests - could be user input OR tool approval
while pending_requests:
    responses: dict[str, object] = {}

    for request in pending_requests:
        if isinstance(request.data, HandoffAgentUserRequest):
            # Agent needs user input
            print(f"Agent {request.executor_id} asks:")
            for msg in request.data.agent_response.messages[-2:]:
                print(f"  {msg.author_name}: {msg.text}")

            user_input = input("You: ")
            responses[request.request_id] = HandoffAgentUserRequest.create_response(user_input)

        elif isinstance(request.data, FunctionApprovalRequestContent):
            # Agent wants to call a tool that requires approval
            func_call = request.data.function_call
            args = func_call.parse_arguments() or {}

            print(f"\nTool approval requested: {func_call.name}")
            print(f"Arguments: {args}")

            approval = input("Approve? (y/n): ").strip().lower() == "y"
            responses[request.request_id] = request.data.create_response(approved=approval)

    # Send all responses and collect new requests
    pending_requests = []
    async for event in workflow.run(responses=responses):
        if event.type == "request_info":
            pending_requests.append(event)
        elif event.type == "output":
            print("\nWorkflow completed!")

Mit Prüfpunkting für dauerhafte Workflows

Verwenden Sie für lang andauernde Workflows, bei denen die Toolgenehmigung Stunden oder Tage später erfolgen kann, Checkpointing:

from agent_framework import FileCheckpointStorage

storage = FileCheckpointStorage(storage_path="./checkpoints")

workflow = (
    HandoffBuilder(
        name="durable_support",
        participants=[triage_agent, refund_agent, order_agent],
        checkpoint_storage=storage,
    )
    .with_start_agent(triage_agent)
    .build()
)

# Initial run - workflow pauses when approval is needed
pending_requests = []
async for event in workflow.run_stream("I need a refund for order 12345"):
    if event.type == "request_info":
        pending_requests.append(event)

# Process can exit here - checkpoint is saved automatically

# Later: Resume from checkpoint and provide approval
checkpoints = await storage.list_checkpoints()
latest = sorted(checkpoints, key=lambda c: c.timestamp, reverse=True)[0]

# Step 1: Restore checkpoint to reload pending requests
restored_requests = []
async for event in workflow.run_stream(checkpoint_id=latest.checkpoint_id):
    if event.type == "request_info":
        restored_requests.append(event)

# Step 2: Send responses
responses = {}
for req in restored_requests:
    if isinstance(req.data, FunctionApprovalRequestContent):
        responses[req.request_id] = req.data.create_response(approved=True)
    elif isinstance(req.data, HandoffAgentUserRequest):
        responses[req.request_id] = HandoffAgentUserRequest.create_response("Yes, please process the refund.")

async for event in workflow.run(responses=responses):
    if event.type == "output":
        print("Refund workflow completed!")

Beispielinteraktion

User: I need help with my order

triage_agent: I'd be happy to help you with your order. Could you please provide more details about the issue?

User: My order 1234 arrived damaged

triage_agent: I'm sorry to hear that your order arrived damaged. I will connect you with a specialist.

support_agent: I'm sorry about the damaged order. To assist you better, could you please:
- Describe the damage
- Would you prefer a replacement or refund?

User: I'd like a refund

triage_agent: I'll connect you with the refund specialist.

refund_agent: I'll process your refund for order 1234. Here's what will happen next:
1. Verification of the damaged items
2. Refund request submission
3. Return instructions if needed
4. Refund processing within 5-10 business days

Could you provide photos of the damage to expedite the process?

Kontextsynchronisierung

Agenten im Agent-Framework nutzen Agentsitzungen (AgentSession) zur Verwaltung des Kontexts. In einer Handoff-Orchestrierung teilen die Agenten nicht dieselbe Sitzungsinstanz. Die Teilnehmer sind dafür verantwortlich, die Kontextkonsistenz sicherzustellen. Um dies zu erreichen, sollen die Teilnehmer ihre Antworten oder Benutzereingaben an alle anderen im Workflow übertragen, sobald sie eine Antwort generieren, um sicherzustellen, dass alle Teilnehmer den neuesten Kontext für ihren nächsten Zug haben.

Handoffkontextsynchronisierung

Hinweis

Toolbezogene Inhalte, einschließlich Übergabetoolaufrufe, werden nicht an andere Agents übertragen. Nur Benutzer- und Agentnachrichten werden für alle Teilnehmer synchronisiert.

Tipp

Agents verwenden nicht dieselbe Sitzungsinstanz, da unterschiedliche Agenttypen möglicherweise unterschiedliche Implementierungen der AgentSession Abstraktion aufweisen. Die gemeinsame Nutzung derselben Sitzungsinstanz kann zu Inkonsistenzen führen, wie jeder Agent Kontext verarbeitet und pflegt.

Nach dem Senden der Antwort überprüft der Teilnehmer dann, ob die Unterhaltung an einen anderen Agent übergeben werden muss. Wenn ja, sendet sie eine Anforderung an den ausgewählten Agent, um die Unterhaltung zu übernehmen. Andernfalls fordert sie benutzereingaben an oder setzt sich basierend auf der Workflowkonfiguration autonom fort.

Wichtige Konzepte

  • Dynamisches Routing: Agents können entscheiden, welcher Agent die nächste Interaktion basierend auf dem Kontext verarbeiten soll.
  • AgentWorkflowBuilder.StartHandoffWith(): Definiert den ersten Agent, der den Workflow startet.
  • WithHandoff() und WithHandoffs(): Konfiguriert Übergaberegeln zwischen bestimmten Agenten
  • Kontexterhaltung: Die vollständige Gesprächshistorie wird über alle Übertragungen hinweg beibehalten.
  • Multi-Turn-Support: Unterstützt fortlaufende Gespräche mit einem nahtlosen Wechsel zwischen Agenten
  • Spezialisierte Expertise: Jeder Agent konzentriert sich auf seine Domäne, während er durch Handoffs zusammenarbeitet
  • Dynamisches Routing: Agents können entscheiden, welcher Agent die nächste Interaktion basierend auf dem Kontext verarbeiten soll.
  • HandoffBuilder: Erstellt Workflows mit automatischer Handofftoolregistrierung
  • with_start_agent(): Definiert, welcher Agent zuerst Benutzereingaben empfängt.
  • add_handoff(): Konfiguriert bestimmte Übergabebeziehungen zwischen Agents
  • Kontexterhaltung: Die vollständige Gesprächshistorie wird über alle Übertragungen hinweg beibehalten.
  • Anforderungs-/Antwortzyklus: Workflow fordert Benutzereingaben an, verarbeitet Antworten und setzt fort, bis die Beendigungsbedingung erfüllt ist.
  • Toolgenehmigung: Verwendung @tool(approval_mode="always_require") für vertrauliche Vorgänge, die eine menschliche Genehmigung benötigen
  • FunctionApprovalRequestContent: Wird ausgegeben, wenn ein Agent ein Tool aufruft, das eine Genehmigung erfordert; verwenden create_response(approved=...) , um zu antworten
  • Checkpointing: Wird with_checkpointing() für dauerhafte Workflows verwendet, die über Prozessneustarts hinweg anhalten und fortsetzen können
  • Spezialisierte Expertise: Jeder Agent konzentriert sich auf seine Domäne, während er durch Handoffs zusammenarbeitet

Nächste Schritte

Gruppenchat-Orchestrierung

  • Last updated on