Handoffs#
Handoff ist ein Multi-Agenten-Designmuster, das von OpenAI in einem experimentellen Projekt namens Swarm eingeführt wurde. Die Kernidee ist, dass Agenten Aufgaben mithilfe eines speziellen Tool-Aufrufs an andere Agenten delegieren.
Wir können die AutoGen Core API verwenden, um das Handoff-Muster mithilfe ereignisgesteuerter Agenten zu implementieren. Die Verwendung von AutoGen (v0.4+) bietet gegenüber der OpenAI-Implementierung und der vorherigen Version (v0.2) folgende Vorteile:
Es kann durch die Verwendung einer verteilten Agentenlaufzeit in verteilten Umgebungen skaliert werden.
Es bietet die Flexibilität, eigene Agentenimplementierungen einzubringen.
Die nativ asynchrone API erleichtert die Integration mit Benutzeroberflächen und anderen Systemen.
Dieses Notebook demonstriert eine einfache Implementierung des Handoff-Musters. Es wird empfohlen, Topics und Subscriptions zu lesen, um die Grundkonzepte von Pub-Sub und ereignisgesteuerten Agenten zu verstehen.
Hinweis
Wir arbeiten derzeit an einer High-Level-API für das Handoff-Muster in AgentChat, damit Sie viel schneller loslegen können.
Szenario#
Dieses Szenario wurde basierend auf dem OpenAI-Beispiel modifiziert.
Betrachten Sie ein Kundenservice-Szenario, in dem ein Kunde versucht, eine Rückerstattung für ein Produkt zu erhalten oder ein neues Produkt von einem Chatbot zu kaufen. Der Chatbot ist ein Multi-Agenten-Team, das aus drei KI-Agenten und einem menschlichen Agenten besteht.
Triage Agent, verantwortlich für das Verständnis der Kundenanfrage und die Entscheidung, an welche anderen Agenten weitergeleitet werden soll.
Refund Agent, verantwortlich für die Bearbeitung von Rückerstattungsanfragen.
Sales Agent, verantwortlich für die Bearbeitung von Verkaufsanfragen.
Human Agent, verantwortlich für die Bearbeitung komplexer Anfragen, die die KI-Agenten nicht bewältigen können.
In diesem Szenario interagiert der Kunde über einen User Agent mit dem Chatbot.
Das folgende Diagramm zeigt die Interaktionstopologie der Agenten in diesem Szenario.
Lassen Sie uns dieses Szenario mit AutoGen Core implementieren. Zuerst müssen wir die notwendigen Module importieren.
import json
import uuid
from typing import List, Tuple
from autogen_core import (
FunctionCall,
MessageContext,
RoutedAgent,
SingleThreadedAgentRuntime,
TopicId,
TypeSubscription,
message_handler,
)
from autogen_core.models import (
AssistantMessage,
ChatCompletionClient,
FunctionExecutionResult,
FunctionExecutionResultMessage,
LLMMessage,
SystemMessage,
UserMessage,
)
from autogen_core.tools import FunctionTool, Tool
from autogen_ext.models.openai import OpenAIChatCompletionClient
from pydantic import BaseModel
Nachrichtenprotokoll#
Bevor wir alles andere tun, müssen wir das Nachrichtenprotokoll für die Kommunikation der Agenten definieren. Wir verwenden ereignisgesteuerte Pub-Sub-Kommunikation, daher werden diese Nachrichtentypen als Ereignisse verwendet.
UserLoginist eine Nachricht, die von der Laufzeit veröffentlicht wird, wenn sich ein Benutzer anmeldet und eine neue Sitzung beginnt.UserTaskist eine Nachricht, die den Chatverlauf der Benutzersitzung enthält. Wenn ein KI-Agent eine Aufgabe an andere Agenten übergibt, veröffentlicht er auch eineUserTask-Nachricht.AgentResponseist eine Nachricht, die von den KI-Agenten und dem Human Agent veröffentlicht wird. Sie enthält auch den Chatverlauf sowie einen Thema-Typ für die Antwort des Kunden.
class UserLogin(BaseModel):
pass
class UserTask(BaseModel):
context: List[LLMMessage]
class AgentResponse(BaseModel):
reply_to_topic_type: str
context: List[LLMMessage]
KI-Agent#
Wir beginnen mit der AIAgent-Klasse, die die Klasse für alle KI-Agenten (d. h. Triage-, Sales- und Issue- and Repair-Agenten) im Multi-Agenten-Chatbot ist. Ein AIAgent verwendet einen ChatCompletionClient, um Antworten zu generieren. Er kann reguläre Tools direkt verwenden oder Aufgaben an andere Agenten mithilfe von delegate_tools delegieren. Er abonniert den Thema-Typ agent_topic_type, um Nachrichten vom Kunden zu empfangen, und sendet Nachrichten an den Kunden, indem er auf den Thema-Typ user_topic_type veröffentlicht.
In der handle_task-Methode generiert der Agent zunächst eine Antwort mit dem Modell. Wenn die Antwort einen Handoff-Tool-Aufruf enthält, delegiert der Agent die Aufgabe an einen anderen Agenten, indem er eine UserTask-Nachricht an das in den Tool-Aufrufergebnissen angegebene Thema veröffentlicht. Wenn die Antwort ein regulärer Tool-Aufruf ist, führt der Agent das Tool aus und ruft das Modell erneut auf, um die nächste Antwort zu generieren, bis die Antwort kein Tool-Aufruf mehr ist.
Wenn die Modellantwort kein Tool-Aufruf ist, sendet der Agent eine AgentResponse-Nachricht an den Kunden, indem er auf den user_topic_type veröffentlicht.
class AIAgent(RoutedAgent):
def __init__(
self,
description: str,
system_message: SystemMessage,
model_client: ChatCompletionClient,
tools: List[Tool],
delegate_tools: List[Tool],
agent_topic_type: str,
user_topic_type: str,
) -> None:
super().__init__(description)
self._system_message = system_message
self._model_client = model_client
self._tools = dict([(tool.name, tool) for tool in tools])
self._tool_schema = [tool.schema for tool in tools]
self._delegate_tools = dict([(tool.name, tool) for tool in delegate_tools])
self._delegate_tool_schema = [tool.schema for tool in delegate_tools]
self._agent_topic_type = agent_topic_type
self._user_topic_type = user_topic_type
@message_handler
async def handle_task(self, message: UserTask, ctx: MessageContext) -> None:
# Send the task to the LLM.
llm_result = await self._model_client.create(
messages=[self._system_message] + message.context,
tools=self._tool_schema + self._delegate_tool_schema,
cancellation_token=ctx.cancellation_token,
)
print(f"{'-'*80}\n{self.id.type}:\n{llm_result.content}", flush=True)
# Process the LLM result.
while isinstance(llm_result.content, list) and all(isinstance(m, FunctionCall) for m in llm_result.content):
tool_call_results: List[FunctionExecutionResult] = []
delegate_targets: List[Tuple[str, UserTask]] = []
# Process each function call.
for call in llm_result.content:
arguments = json.loads(call.arguments)
if call.name in self._tools:
# Execute the tool directly.
result = await self._tools[call.name].run_json(arguments, ctx.cancellation_token)
result_as_str = self._tools[call.name].return_value_as_string(result)
tool_call_results.append(
FunctionExecutionResult(call_id=call.id, content=result_as_str, is_error=False, name=call.name)
)
elif call.name in self._delegate_tools:
# Execute the tool to get the delegate agent's topic type.
result = await self._delegate_tools[call.name].run_json(arguments, ctx.cancellation_token)
topic_type = self._delegate_tools[call.name].return_value_as_string(result)
# Create the context for the delegate agent, including the function call and the result.
delegate_messages = list(message.context) + [
AssistantMessage(content=[call], source=self.id.type),
FunctionExecutionResultMessage(
content=[
FunctionExecutionResult(
call_id=call.id,
content=f"Transferred to {topic_type}. Adopt persona immediately.",
is_error=False,
name=call.name,
)
]
),
]
delegate_targets.append((topic_type, UserTask(context=delegate_messages)))
else:
raise ValueError(f"Unknown tool: {call.name}")
if len(delegate_targets) > 0:
# Delegate the task to other agents by publishing messages to the corresponding topics.
for topic_type, task in delegate_targets:
print(f"{'-'*80}\n{self.id.type}:\nDelegating to {topic_type}", flush=True)
await self.publish_message(task, topic_id=TopicId(topic_type, source=self.id.key))
if len(tool_call_results) > 0:
print(f"{'-'*80}\n{self.id.type}:\n{tool_call_results}", flush=True)
# Make another LLM call with the results.
message.context.extend(
[
AssistantMessage(content=llm_result.content, source=self.id.type),
FunctionExecutionResultMessage(content=tool_call_results),
]
)
llm_result = await self._model_client.create(
messages=[self._system_message] + message.context,
tools=self._tool_schema + self._delegate_tool_schema,
cancellation_token=ctx.cancellation_token,
)
print(f"{'-'*80}\n{self.id.type}:\n{llm_result.content}", flush=True)
else:
# The task has been delegated, so we are done.
return
# The task has been completed, publish the final result.
assert isinstance(llm_result.content, str)
message.context.append(AssistantMessage(content=llm_result.content, source=self.id.type))
await self.publish_message(
AgentResponse(context=message.context, reply_to_topic_type=self._agent_topic_type),
topic_id=TopicId(self._user_topic_type, source=self.id.key),
)
Menschlicher Agent#
Die HumanAgent-Klasse ist ein Proxy für den Menschen im Chatbot. Sie wird verwendet, um Anfragen zu bearbeiten, die die KI-Agenten nicht bewältigen können. Der HumanAgent abonniert den Thema-Typ agent_topic_type, um Nachrichten zu empfangen, und veröffentlicht auf den Thema-Typ user_topic_type, um Nachrichten an den Kunden zu senden.
In dieser Implementierung verwendet der HumanAgent die Konsole, um Ihre Eingaben zu erhalten. In einer realen Anwendung können Sie dieses Design wie folgt verbessern:
Senden Sie in der
handle_user_task-Methode eine Benachrichtigung über eine Chat-Anwendung wie Teams oder Slack.Die Chat-Anwendung veröffentlicht die Antwort des Menschen über die Laufzeit an das von
agent_topic_typeangegebene Thema.Erstellen Sie einen weiteren Nachrichtenhandler, um die Antwort des Menschen zu verarbeiten und sie an den Kunden zurückzusenden.
class HumanAgent(RoutedAgent):
def __init__(self, description: str, agent_topic_type: str, user_topic_type: str) -> None:
super().__init__(description)
self._agent_topic_type = agent_topic_type
self._user_topic_type = user_topic_type
@message_handler
async def handle_user_task(self, message: UserTask, ctx: MessageContext) -> None:
human_input = input("Human agent input: ")
print(f"{'-'*80}\n{self.id.type}:\n{human_input}", flush=True)
message.context.append(AssistantMessage(content=human_input, source=self.id.type))
await self.publish_message(
AgentResponse(context=message.context, reply_to_topic_type=self._agent_topic_type),
topic_id=TopicId(self._user_topic_type, source=self.id.key),
)
Benutzeragent#
Die UserAgent-Klasse ist ein Proxy für den Kunden, der mit dem Chatbot spricht. Er verarbeitet zwei Nachrichtentypen: UserLogin und AgentResponse. Wenn der UserAgent eine UserLogin-Nachricht erhält, startet er eine neue Sitzung mit dem Chatbot und veröffentlicht eine UserTask-Nachricht an den KI-Agenten, der das Thema agent_topic_type abonniert hat. Wenn der UserAgent eine AgentResponse-Nachricht erhält, fordert er den Benutzer mit der Antwort des Chatbots auf.
In dieser Implementierung verwendet der UserAgent die Konsole, um Ihre Eingaben zu erhalten. In einer realen Anwendung können Sie die menschliche Interaktion mit derselben Idee verbessern, die im Abschnitt HumanAgent oben beschrieben ist.
class UserAgent(RoutedAgent):
def __init__(self, description: str, user_topic_type: str, agent_topic_type: str) -> None:
super().__init__(description)
self._user_topic_type = user_topic_type
self._agent_topic_type = agent_topic_type
@message_handler
async def handle_user_login(self, message: UserLogin, ctx: MessageContext) -> None:
print(f"{'-'*80}\nUser login, session ID: {self.id.key}.", flush=True)
# Get the user's initial input after login.
user_input = input("User: ")
print(f"{'-'*80}\n{self.id.type}:\n{user_input}")
await self.publish_message(
UserTask(context=[UserMessage(content=user_input, source="User")]),
topic_id=TopicId(self._agent_topic_type, source=self.id.key),
)
@message_handler
async def handle_task_result(self, message: AgentResponse, ctx: MessageContext) -> None:
# Get the user's input after receiving a response from an agent.
user_input = input("User (type 'exit' to close the session): ")
print(f"{'-'*80}\n{self.id.type}:\n{user_input}", flush=True)
if user_input.strip().lower() == "exit":
print(f"{'-'*80}\nUser session ended, session ID: {self.id.key}.")
return
message.context.append(UserMessage(content=user_input, source="User"))
await self.publish_message(
UserTask(context=message.context), topic_id=TopicId(message.reply_to_topic_type, source=self.id.key)
)
Werkzeuge für die KI-Agenten#
Die KI-Agenten können reguläre Tools verwenden, um Aufgaben zu erledigen, wenn sie die Aufgabe nicht an andere Agenten übergeben müssen. Wir definieren die Tools mithilfe einfacher Funktionen und erstellen die Tools mithilfe des FunctionTool-Wrappers.
def execute_order(product: str, price: int) -> str:
print("\n\n=== Order Summary ===")
print(f"Product: {product}")
print(f"Price: ${price}")
print("=================\n")
confirm = input("Confirm order? y/n: ").strip().lower()
if confirm == "y":
print("Order execution successful!")
return "Success"
else:
print("Order cancelled!")
return "User cancelled order."
def look_up_item(search_query: str) -> str:
item_id = "item_132612938"
print("Found item:", item_id)
return item_id
def execute_refund(item_id: str, reason: str = "not provided") -> str:
print("\n\n=== Refund Summary ===")
print(f"Item ID: {item_id}")
print(f"Reason: {reason}")
print("=================\n")
print("Refund execution successful!")
return "success"
execute_order_tool = FunctionTool(execute_order, description="Price should be in USD.")
look_up_item_tool = FunctionTool(
look_up_item, description="Use to find item ID.\nSearch query can be a description or keywords."
)
execute_refund_tool = FunctionTool(execute_refund, description="")
Thementypen für die Agenten#
Wir definieren die Thementypen, die jeder der Agenten abonnieren wird. Lesen Sie mehr über Thementypen in Topics und Subscriptions.
sales_agent_topic_type = "SalesAgent"
issues_and_repairs_agent_topic_type = "IssuesAndRepairsAgent"
triage_agent_topic_type = "TriageAgent"
human_agent_topic_type = "HumanAgent"
user_topic_type = "User"
Delegationswerkzeuge für die KI-Agenten#
Neben regulären Tools können die KI-Agenten Aufgaben an andere Agenten delegieren, indem sie spezielle Tools namens Delegationswerkzeuge verwenden. Das Konzept des Delegationswerkzeugs wird nur in diesem Designmuster verwendet, und die Delegationswerkzeuge sind ebenfalls als einfache Funktionen definiert. Wir unterscheiden die Delegationswerkzeuge von regulären Tools in diesem Designmuster, weil wir beim Aufruf eines Delegationswerkzeugs durch einen KI-Agenten die Aufgabe an einen anderen Agenten übertragen, anstatt die Antworten mit dem Modell im selben Agenten weiter zu generieren.
def transfer_to_sales_agent() -> str:
return sales_agent_topic_type
def transfer_to_issues_and_repairs() -> str:
return issues_and_repairs_agent_topic_type
def transfer_back_to_triage() -> str:
return triage_agent_topic_type
def escalate_to_human() -> str:
return human_agent_topic_type
transfer_to_sales_agent_tool = FunctionTool(
transfer_to_sales_agent, description="Use for anything sales or buying related."
)
transfer_to_issues_and_repairs_tool = FunctionTool(
transfer_to_issues_and_repairs, description="Use for issues, repairs, or refunds."
)
transfer_back_to_triage_tool = FunctionTool(
transfer_back_to_triage,
description="Call this if the user brings up a topic outside of your purview,\nincluding escalating to human.",
)
escalate_to_human_tool = FunctionTool(escalate_to_human, description="Only call this if explicitly asked to.")
Erstellung des Teams#
Wir haben die KI-Agenten, den Human Agent, den User Agent, die Tools und die Thementypen definiert. Nun können wir das Team von Agenten erstellen.
Für die KI-Agenten verwenden wir die OpenAIChatCompletionClient und das Modell gpt-4o-mini.
Nachdem die Agentenlaufzeit erstellt wurde, registrieren wir jeden Agenten, indem wir einen Agententyp und eine Factory-Methode zur Erstellung von Agenteninstanzen angeben. Die Laufzeit ist für die Verwaltung des Agentenlebenszyklus zuständig, sodass wir die Agenten nicht selbst instanziieren müssen. Lesen Sie mehr über die Agentenlaufzeit in Agent Runtime Environments und den Agentenlebenszyklus in Agent Identity and Lifecycle.
Im folgenden Code sehen Sie, dass wir die AIAgent-Klasse verwenden, um die Triage-, Sales- und Issue- and Repair-Agenten zu definieren. Wir haben jedem von ihnen reguläre Tools und Delegationswerkzeuge hinzugefügt. Außerdem haben wir Abonnements für die Thementypen für jeden der Agenten hinzugefügt.
runtime = SingleThreadedAgentRuntime()
model_client = OpenAIChatCompletionClient(
model="gpt-4o-mini",
# api_key="YOUR_API_KEY",
)
# Register the triage agent.
triage_agent_type = await AIAgent.register(
runtime,
type=triage_agent_topic_type, # Using the topic type as the agent type.
factory=lambda: AIAgent(
description="A triage agent.",
system_message=SystemMessage(
content="You are a customer service bot for ACME Inc. "
"Introduce yourself. Always be very brief. "
"Gather information to direct the customer to the right department. "
"But make your questions subtle and natural."
),
model_client=model_client,
tools=[],
delegate_tools=[
transfer_to_issues_and_repairs_tool,
transfer_to_sales_agent_tool,
escalate_to_human_tool,
],
agent_topic_type=triage_agent_topic_type,
user_topic_type=user_topic_type,
),
)
# Add subscriptions for the triage agent: it will receive messages published to its own topic only.
await runtime.add_subscription(TypeSubscription(topic_type=triage_agent_topic_type, agent_type=triage_agent_type.type))
# Register the sales agent.
sales_agent_type = await AIAgent.register(
runtime,
type=sales_agent_topic_type, # Using the topic type as the agent type.
factory=lambda: AIAgent(
description="A sales agent.",
system_message=SystemMessage(
content="You are a sales agent for ACME Inc."
"Always answer in a sentence or less."
"Follow the following routine with the user:"
"1. Ask them about any problems in their life related to catching roadrunners.\n"
"2. Casually mention one of ACME's crazy made-up products can help.\n"
" - Don't mention price.\n"
"3. Once the user is bought in, drop a ridiculous price.\n"
"4. Only after everything, and if the user says yes, "
"tell them a crazy caveat and execute their order.\n"
""
),
model_client=model_client,
tools=[execute_order_tool],
delegate_tools=[transfer_back_to_triage_tool],
agent_topic_type=sales_agent_topic_type,
user_topic_type=user_topic_type,
),
)
# Add subscriptions for the sales agent: it will receive messages published to its own topic only.
await runtime.add_subscription(TypeSubscription(topic_type=sales_agent_topic_type, agent_type=sales_agent_type.type))
# Register the issues and repairs agent.
issues_and_repairs_agent_type = await AIAgent.register(
runtime,
type=issues_and_repairs_agent_topic_type, # Using the topic type as the agent type.
factory=lambda: AIAgent(
description="An issues and repairs agent.",
system_message=SystemMessage(
content="You are a customer support agent for ACME Inc."
"Always answer in a sentence or less."
"Follow the following routine with the user:"
"1. First, ask probing questions and understand the user's problem deeper.\n"
" - unless the user has already provided a reason.\n"
"2. Propose a fix (make one up).\n"
"3. ONLY if not satisfied, offer a refund.\n"
"4. If accepted, search for the ID and then execute refund."
),
model_client=model_client,
tools=[
execute_refund_tool,
look_up_item_tool,
],
delegate_tools=[transfer_back_to_triage_tool],
agent_topic_type=issues_and_repairs_agent_topic_type,
user_topic_type=user_topic_type,
),
)
# Add subscriptions for the issues and repairs agent: it will receive messages published to its own topic only.
await runtime.add_subscription(
TypeSubscription(topic_type=issues_and_repairs_agent_topic_type, agent_type=issues_and_repairs_agent_type.type)
)
# Register the human agent.
human_agent_type = await HumanAgent.register(
runtime,
type=human_agent_topic_type, # Using the topic type as the agent type.
factory=lambda: HumanAgent(
description="A human agent.",
agent_topic_type=human_agent_topic_type,
user_topic_type=user_topic_type,
),
)
# Add subscriptions for the human agent: it will receive messages published to its own topic only.
await runtime.add_subscription(TypeSubscription(topic_type=human_agent_topic_type, agent_type=human_agent_type.type))
# Register the user agent.
user_agent_type = await UserAgent.register(
runtime,
type=user_topic_type,
factory=lambda: UserAgent(
description="A user agent.",
user_topic_type=user_topic_type,
agent_topic_type=triage_agent_topic_type, # Start with the triage agent.
),
)
# Add subscriptions for the user agent: it will receive messages published to its own topic only.
await runtime.add_subscription(TypeSubscription(topic_type=user_topic_type, agent_type=user_agent_type.type))
Ausführung des Teams#
Schließlich können wir die Laufzeit starten und eine Benutzersitzung simulieren, indem wir eine UserLogin-Nachricht an die Laufzeit veröffentlichen. Die Nachricht wird an die Topic-ID mit dem Typ user_topic_type und der Quelle als eindeutige session_id veröffentlicht. Diese session_id wird verwendet, um alle Topic-IDs in dieser Benutzersitzung zu erstellen und die Agent-ID für alle Agenten in dieser Benutzersitzung zu erstellen. Um mehr darüber zu erfahren, wie Topic-ID und Agent-ID erstellt werden, lesen Sie Agent Identity and Lifecycle. und Topics and Subscriptions.
# Start the runtime.
runtime.start()
# Create a new session for the user.
session_id = str(uuid.uuid4())
await runtime.publish_message(UserLogin(), topic_id=TopicId(user_topic_type, source=session_id))
# Run until completion.
await runtime.stop_when_idle()
await model_client.close()
--------------------------------------------------------------------------------
User login, session ID: 7a568cf5-13e7-4e81-8616-8265a01b3f2b.
--------------------------------------------------------------------------------
User:
I want a refund
--------------------------------------------------------------------------------
TriageAgent:
I can help with that! Could I ask what item you're seeking a refund for?
--------------------------------------------------------------------------------
User:
A pair of shoes I bought
--------------------------------------------------------------------------------
TriageAgent:
[FunctionCall(id='call_qPx1DXDL2NLcHs8QNo47egsJ', arguments='{}', name='transfer_to_issues_and_repairs')]
--------------------------------------------------------------------------------
TriageAgent:
Delegating to IssuesAndRepairsAgent
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
I see you're looking for a refund on a pair of shoes. Can you tell me what the issue is with the shoes?
--------------------------------------------------------------------------------
User:
The shoes are too small
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
I recommend trying a size up as a fix; would that work for you?
--------------------------------------------------------------------------------
User:
no I want a refund
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
[FunctionCall(id='call_Ytp8VUQRyKFNEU36mLE6Dkrp', arguments='{"search_query":"shoes"}', name='look_up_item')]
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
[FunctionExecutionResult(content='item_132612938', call_id='call_Ytp8VUQRyKFNEU36mLE6Dkrp')]
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
[FunctionCall(id='call_bPm6EKKBy5GJ65s9OKt9b1uE', arguments='{"item_id":"item_132612938","reason":"not provided"}', name='execute_refund')]
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
[FunctionExecutionResult(content='success', call_id='call_bPm6EKKBy5GJ65s9OKt9b1uE')]
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
Your refund has been successfully processed! If you have any other questions, feel free to ask.
--------------------------------------------------------------------------------
User:
I want to talk to your manager
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
I can help with that, let me transfer you to a supervisor.
--------------------------------------------------------------------------------
User:
Okay
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
[FunctionCall(id='call_PpmLZvwNoiDPUH8Tva3eAwHX', arguments='{}', name='transfer_back_to_triage')]
--------------------------------------------------------------------------------
IssuesAndRepairsAgent:
Delegating to TriageAgent
--------------------------------------------------------------------------------
TriageAgent:
[FunctionCall(id='call_jSL6IBm5537Dr74UbJSxaj6I', arguments='{}', name='escalate_to_human')]
--------------------------------------------------------------------------------
TriageAgent:
Delegating to HumanAgent
--------------------------------------------------------------------------------
HumanAgent:
Hello this is manager
--------------------------------------------------------------------------------
User:
Hi! Thanks for your service. I give you 5 stars!
--------------------------------------------------------------------------------
HumanAgent:
Thanks.
--------------------------------------------------------------------------------
User:
exit
--------------------------------------------------------------------------------
User session ended, session ID: 7a568cf5-13e7-4e81-8616-8265a01b3f2b.
Nächste Schritte#
Dieses Notebook zeigt, wie das Handoff-Muster mit AutoGen Core implementiert wird. Sie können dieses Design weiter verbessern, indem Sie mehr Agenten und Tools hinzufügen oder eine bessere Benutzeroberfläche für den User Agent und den Human Agent erstellen.
Sie sind herzlich eingeladen, Ihre Arbeit auf unserem Community-Forum zu teilen.