Remarque
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Dans les applications réelles, la gestion correcte de l’état est essentielle lors de la gestion de plusieurs tâches ou requêtes. Sans isolation appropriée, l’état partagé entre différentes exécutions de flux de travail peut entraîner un comportement inattendu, une altération des données et des conditions de concurrence. Cet article explique comment garantir l’isolation de l’état dans les flux de travail de Microsoft Agent Framework, en fournissant des aperçus sur les meilleures pratiques et les pièges courants.
Générateurs de flux de travail mutables et flux de travail immuables
Les flux de travail sont créés par les générateurs de flux de travail. Les générateurs de flux de travail sont généralement considérés comme mutables, où l’on peut ajouter, modifier l’exécuteur de démarrage ou d’autres configurations une fois le générateur créé ou même après la création d’un flux de travail. En revanche, les flux de travail sont immuables lorsqu’un flux de travail est généré, il ne peut pas être modifié (aucune API publique pour modifier un flux de travail).
Cette distinction est importante, car elle affecte la façon dont l’état est géré dans différentes exécutions de flux de travail. Il n’est pas recommandé de réutiliser une instance de flux de travail unique pour plusieurs tâches ou requêtes, car cela peut entraîner un partage d’état inattendu. Au lieu de cela, il est recommandé de créer une instance de flux de travail à partir du générateur pour chaque tâche ou demande pour garantir une isolation d’état appropriée et la sécurité des threads.
Garantir l’isolation de l’état dans les générateurs de flux de travail
Lorsqu’une instance d’exécuteur est transmise directement à un générateur de flux de travail, cette instance d’exécuteur est partagée entre toutes les instances de flux de travail créées à partir du générateur. Cela peut entraîner des problèmes si l’instance d’exécuteur contient un état qui ne doit pas être partagé entre plusieurs exécutions de flux de travail. Pour garantir une isolation d’état appropriée et la sécurité des threads, il est recommandé d’utiliser des fonctions de fabrique qui créent une instance d’exécuteur pour chaque instance de flux de travail.
À venir...
Exemple non thread-safe :
executor_a = CustomExecutorA()
executor_b = CustomExecutorB()
workflow_builder = WorkflowBuilder()
# executor_a and executor_b are passed directly to the workflow builder
workflow_builder.add_edge(executor_a, executor_b)
workflow_builder.set_start_executor(executor_b)
# All workflow instances created from the builder will share the same executor instances
workflow_a = workflow_builder.build()
workflow_b = workflow_builder.build()
Exemple de sécurité des threads :
workflow_builder = WorkflowBuilder()
# Register executor factory functions with the workflow builder
workflow_builder.register_executor(factory_func=CustomExecutorA, name="executor_a")
workflow_builder.register_executor(factory_func=CustomExecutorB, name="executor_b")
# Add edges using registered factory function names
workflow_builder.add_edge("executor_a", "executor_b")
workflow_builder.set_start_executor("executor_b")
# Each workflow instance created from the builder will have its own executor instances
workflow_a = workflow_builder.build()
workflow_b = workflow_builder.build()
Conseil / Astuce
Pour garantir une isolation d’état appropriée et la sécurité des threads, assurez-vous également que les instances d’exécuteur créées par les fonctions de fabrique ne partagent pas l’état mutable.
Gestion de l’état de l’agent
Le contexte de l’agent est géré via des threads d’agent. Par défaut, chaque agent d’un workflow obtient son propre thread, sauf si l’agent est géré par un exécuteur personnalisé. Pour plus d’informations, reportez-vous à Travailler avec les agents.
Les threads d’agent sont conservés entre les exécutions de flux de travail. Cela signifie que si un agent est appelé lors de la première exécution d’un flux de travail, le contenu généré par l’agent sera disponible dans les exécutions suivantes de la même instance de flux de travail. Bien que cela puisse être utile pour maintenir la continuité au sein d’une seule tâche, il peut également entraîner un partage d’état inattendu si la même instance de flux de travail est réutilisée pour différentes tâches ou demandes. Pour vous assurer que l'état de l'agent est isolé pour chaque tâche, utilisez les fonctions de fabrique d'agents dans votre générateur de flux de travail pour créer une nouvelle instance de flux de travail pour chaque tâche ou requête.
À venir...
Exemple non sécurisé pour les threads :
writer_agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent(
instructions=(
"You are an excellent content writer. You create new content and edit contents based on the feedback."
),
name="writer_agent",
)
reviewer_agent = AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent(
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."
),
name="reviewer_agent",
)
builder = WorkflowBuilder()
# writer_agent and reviewer_agent are passed directly to the workflow builder
builder.add_edge(writer_agent, reviewer_agent)
builder.set_start_executor(writer_agent)
# All workflow instances created from the builder will share the same agent
# instances and agent threads
workflow = builder.build()
Exemple d'un code sécurisé pour les threads :
def create_writer_agent() -> ChatAgent:
"""Factory function to create a Writer agent."""
return AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent(
instructions=(
"You are an excellent content writer. You create new content and edit contents based on the feedback."
),
name="writer_agent",
)
def create_reviewer_agent() -> ChatAgent:
"""Factory function to create a Reviewer agent."""
return AzureOpenAIChatClient(credential=AzureCliCredential()).create_agent(
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."
),
name="reviewer_agent",
)
builder = WorkflowBuilder()
# Register agent factory functions with the workflow builder
builder.register_agent(factory_func=create_writer_agent, name="writer_agent")
builder.register_agent(factory_func=create_reviewer_agent, name="reviewer_agent")
# Add edges using registered factory function names
builder.add_edge("writer_agent", "reviewer_agent")
builder.set_start_executor("writer_agent")
# Each workflow instance created from the builder will have its own agent
# instances and agent threads
workflow = builder.build()
Conclusion
L’isolation de l’état dans les flux de travail Microsoft Agent Framework peut être gérée efficacement à l’aide de fonctions d’usine avec des générateurs de flux de travail pour créer des instances d’exécuteur et d’agent fraîches. En créant de nouvelles instances de flux de travail pour chaque tâche ou requête, vous pouvez conserver une isolation d’état appropriée et éviter le partage d’état involontaire entre différentes exécutions de flux de travail.