Partilhar via

Fluxos de Trabalho do Microsoft Agent Framework - Isolamento de Estado

Em aplicações reais, gerir corretamente o estado é fundamental ao lidar com múltiplas tarefas ou pedidos. Sem isolamento adequado, o estado partilhado entre diferentes execuções de fluxos de trabalho pode resultar em comportamentos inesperados, corrupção de dados e condições de corrida. Este artigo explica como garantir o isolamento de estados dentro dos Fluxos de Trabalho do Microsoft Agent Framework, fornecendo insights sobre as melhores práticas e armadilhas comuns.

Construtores de Fluxos de Trabalho Mutáveis vs Fluxos de Trabalho Imutáveis

Os fluxos de trabalho são criados por criadores de fluxos de trabalho. Os construtores de fluxos de trabalho são geralmente considerados mutáveis, onde se pode adicionar, modificar o executor inicial ou outras configurações após a criação do construtor ou mesmo depois de um fluxo de trabalho ter sido construído. Por outro lado, os fluxos de trabalho são imutáveis porque, uma vez construído, um fluxo de trabalho não pode ser modificado (não existe uma API pública para modificar um fluxo de trabalho).

Esta distinção é importante porque afeta a forma como o estado é gerido em diferentes execuções de workflow. Não é recomendado reutilizar uma única instância de fluxo de trabalho para múltiplas tarefas ou pedidos, pois isso pode levar à partilha de estado não intencional. Em vez disso, recomenda-se criar uma nova instância de fluxo de trabalho a partir do construtor para cada tarefa ou pedido, de modo a garantir o isolamento adequado do estado e a segurança das threads.

Garantir o isolamento de estados em construtores de fluxos de trabalho

Quando uma instância executor é passada diretamente para um construtor de workflow, essa instância executor é partilhada entre todas as instâncias de workflow criadas a partir do builder. Isto pode causar problemas se a instância do executor contiver estado que não deve ser partilhado entre múltiplas execuções de workflow. Para garantir o isolamento adequado do estado e a segurança da thread, recomenda-se usar funções de fábrica de forma a criar uma nova instância de executor para cada instância de workflow.

Brevemente...

Exemplo não seguro para fios:

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()

Exemplo de thread-safe

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()

Sugestão

Para garantir o isolamento adequado do estado e a segurança de threads, certifique-se também de que as instâncias do executor criadas por funções factory não partilham estado mutável.

Gestão do Estado do Agente

O contexto do agente é gerido através de threads do agente. Por defeito, cada agente num fluxo de trabalho terá o seu próprio thread, a menos que o agente seja gerido por um executor personalizado. Para mais informações, consulte Trabalhar com Agentes.

Os threads de agentes são mantidos ao longo das execuções de workflow. Isto significa que, se um agente for invocado na primeira execução de um fluxo de trabalho, o conteúdo gerado pelo agente estará disponível em execuções subsequentes da mesma instância de workflow. Embora isto possa ser útil para manter a continuidade dentro de uma única tarefa, também pode levar a uma partilha de estado não intencional se a mesma instância de fluxo de trabalho for reutilizada para tarefas ou pedidos diferentes. Para garantir que cada tarefa tem um estado de agente isolado, use funções-fábrica de agentes no seu construtor de fluxos de trabalho para criar uma nova instância de fluxo de trabalho para cada tarefa ou pedido.

Brevemente...

Exemplo não seguro para fios:

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()

Exemplo de thread-safe:

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

Isolamento de estado no Microsoft Agent Framework Os fluxos de trabalho podem ser geridos eficazmente usando funções de fábrica com construtores de workflow para criar instâncias novas de executor e agente. Ao criar novas instâncias de fluxo de trabalho para cada tarefa ou pedido, pode manter o isolamento adequado do estado e evitar a partilha não intencional de estados entre diferentes execuções de workflow.

Próximas Etapas

  • Last updated on