Uma visão geral da arquitetura do agente

Este artigo aborda os principais conceitos na arquitetura do Agent Framework, incluindo princípios fundamentais, objetivos de design e metas estratégicas.

Metas

O Agent Framework foi desenvolvido com as seguintes prioridades principais em mente:

• O framework de agentes do Kernel Semântico serve como a base principal para implementar funcionalidades de agentes.
• Vários agentes de diferentes tipos podem colaborar em uma única conversa, cada um contribuindo com suas funcionalidades exclusivas, ao mesmo tempo em que integram a entrada humana.
• Um agente pode participar e gerenciar várias conversas simultâneas simultaneamente.

Agente

A classe Agent abstrata serve como a abstração principal para todos os tipos de agentes, fornecendo uma estrutura fundamental que pode ser estendida para criar agentes mais especializados. Essa classe base forma a base para implementações de agente mais específicas, todas aproveitando os recursos do Kernel para executar suas respectivas funções. Consulte todos os tipos de agente disponíveis na seção Tipos de Agente .

Os agentes podem ser invocados diretamente para executar tarefas ou orquestrados por padrões diferentes. Essa estrutura flexível permite que os agentes se adaptem a vários cenários de conversação ou orientados a tarefas, fornecendo aos desenvolvedores ferramentas robustas para a criação de sistemas inteligentes e multiagentes.

Tipos de agente no kernel semântico

• ChatCompletionAgent
• OpenAIAssistantAgent
• AzureAIAgent
• OpenAIResponsesAgent
• CopilotStudioAgent

Thread do Agente

A classe abstrata AgentThread serve como a abstração central para threads ou estado de conversação. Ela abstrai as diferentes maneiras pelas quais o estado da conversa pode ser gerenciado para diferentes agentes.

Os serviços de agente com estado geralmente armazenam o estado de conversa no serviço e você pode interagir com ele por meio de uma ID. Outros agentes podem exigir que todo o histórico de chat seja passado para o agente em cada invocação, caso em que o estado da conversa é gerenciado localmente no aplicativo.

Normalmente, agentes de estado funcionam apenas com uma implementação correspondente de AgentThread, enquanto outros tipos de agentes podem trabalhar com mais de um tipo de AgentThread. Por exemplo, AzureAIAgent requer um AzureAIAgentThreadcorrespondente. Isso ocorre porque o serviço agente de IA do Azure armazena conversas no serviço e requer chamadas de serviço específicas para criar um thread e atualizá-lo. Se um tipo de thread de agente diferente for usado com o AzureAIAgent, falharemos rapidamente devido a um tipo de thread inesperado e geraremos uma exceção para alertar o chamador.

Orquestração de agentes

A estrutura Orquestração de Agente no Kernel Semântico permite que a coordenação de vários agentes resolva tarefas complexas de forma colaborativa. Ele fornece uma estrutura flexível para definir como os agentes interagem, compartilham informações e delegam responsabilidades. Os principais componentes e conceitos incluem:

• Padrões de orquestração: Padrões pré-criados, como Simultâneo, Sequencial, Entrega, Chat em Grupo e Magêntico, permitem que os desenvolvedores escolham o modelo de colaboração mais adequado para seu cenário. Cada padrão define uma maneira diferente de os agentes se comunicarem e processarem tarefas (consulte a tabela de padrões de orquestração para obter detalhes).
• Lógica de Transformação de Dados: As transformações de entrada e saída permitem que os fluxos de orquestração adaptem dados entre agentes e sistemas externos, dando suporte a tipos de dados simples e complexos.
• Human-in-the-loop: Alguns padrões dão suporte ao human-in-the-loop, permitindo que agentes humanos participem do processo de orquestração. Isso é particularmente útil para cenários em que o julgamento ou a experiência humana são necessários.

Essa arquitetura capacita os desenvolvedores a criar sistemas inteligentes de vários agentes que podem resolver problemas do mundo real por meio da colaboração, especialização e coordenação dinâmica.

Alinhamento do agente com recursos de kernel semântico

Ele Agent Framework é construído com base nos conceitos e recursos fundamentais que muitos desenvolvedores passaram a conhecer dentro do ecossistema do Kernel Semântico. Esses princípios básicos servem como blocos de construção para o design do Agent Framework. Aproveitando a estrutura familiar e as funcionalidades do Kernel Semântico, o Agent Framework estende sua funcionalidade para habilitar comportamentos de agente autônomo mais avançados, mantendo a consistência com a arquitetura de Kernel Semântica mais ampla. Isso garante uma transição suave para os desenvolvedores, permitindo que eles apliquem seus conhecimentos existentes para criar agentes inteligentes e adaptáveis dentro da estrutura.

Plug-ins e chamada de função

Os plug-ins são um aspecto fundamental do Kernel Semântico, permitindo que os desenvolvedores integrem funcionalidades personalizadas e estendam os recursos de um aplicativo de IA. Esses plug-ins oferecem uma maneira flexível de incorporar recursos especializados ou lógica específica de negócios nos principais fluxos de trabalho de IA. Além disso, os recursos do agente dentro da estrutura podem ser significativamente aprimorados utilizando plugins e aproveitando chamada de funções. Isso permite que os agentes interajam dinamicamente com serviços externos ou executem tarefas complexas, expandindo ainda mais o escopo e a versatilidade do sistema de IA em diversos aplicativos.

Saiba como configurar agentes para usar plug-ins aqui.

Mensagens do agente

As mensagens do agente, incluindo entrada e resposta, são criadas sobre os principais tipos de conteúdo do Kernel Semântico, fornecendo uma estrutura unificada para comunicação. Essa opção de design simplifica o processo de transição de padrões tradicionais de conclusão de chat para padrões mais avançados orientados por agente no desenvolvimento de aplicativos. Aproveitando tipos de conteúdo de Kernel Semântico familiares, os desenvolvedores podem integrar perfeitamente os recursos do agente em seus aplicativos sem a necessidade de revisar os sistemas existentes. Essa simplificação garante que, à medida que você evolui da IA conversacional básica para agentes mais autônomos e orientados a tarefas, a estrutura subjacente permaneça consistente, tornando o desenvolvimento mais rápido e eficiente.

Modelagem de texto

O papel de um agente é moldado principalmente pelas instruções que recebe, que ditam seu comportamento e ações. Semelhante à chamada de um Kernelprompt, as instruções de um agente podem incluir parâmetros de modelo — valores e funções — que são substituídos dinamicamente durante a execução. Isso permite respostas flexíveis e sensíveis ao contexto, permitindo que o agente ajuste sua saída com base na entrada em tempo real.

Além disso, um agente pode ser configurado diretamente usando uma Configuração de Modelo de Prompt, fornecendo aos desenvolvedores uma maneira estruturada e reutilizável de definir seu comportamento. Essa abordagem oferece uma ferramenta poderosa para padronizar e personalizar as instruções do agente, garantindo consistência em vários casos de uso e, ao mesmo tempo, mantendo a adaptabilidade dinâmica.

Saiba mais sobre como criar um agente com o modelo de Kernel Semântico aqui.

Especificação declarativa

from semantic_kernel.agents import register_agent_type, Agent, DeclarativeSpecMixin

@register_agent_type("custom_agent")
class CustomAgent(DeclarativeSpecMixin, Agent):
    ...

@classmethod
async def from_yaml(cls, yaml_str: str, *, kernel=None, plugins=None, prompt_template_config=None, settings=None, extras=None, **kwargs):
    # Resolves placeholders and loads YAML, then delegates to from_dict.
    ...

@classmethod
async def from_dict(cls, data: dict, *, kernel=None, plugins=None, prompt_template_config=None, settings=None, **kwargs):
    # Normalizes and passes spec fields to _from_dict.
    ...

@classmethod
@abstractmethod
async def _from_dict(cls, data: dict, *, kernel, prompt_template_config=None, **kwargs):
    # Subclasses implement this to create the agent from a dict.
    ...

@classmethod
def resolve_placeholders(cls, yaml_str: str, settings=None, extras=None) -> str:
    # Optional: override this to customize how environment or runtime placeholders are resolved in YAML.
    return yaml_str

Próximas etapas