Uma visão geral da arquitetura do agente

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

Objetivos

O Agent Framework foi desenvolvido tendo em mente as seguintes prioridades-chave:

• A estrutura do agente do Kernel Semântico serve como a base principal para a implementação das funcionalidades do agente.
• Vários agentes de diferentes tipos podem colaborar em uma única conversa, cada um contribuindo com suas capacidades únicas, enquanto integra a contribuição humana.
• Um agente pode participar e gerenciar várias conversas simultâneas simultaneamente.

Agente

A classe abstrata Agent serve como a abstração central 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 agentes mais específicas, todas as quais aproveitam os recursos do Kernel para executar suas respetivas 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 ser orquestrados por diferentes padrões. Essa estrutura flexível permite que os agentes se adaptem a vários cenários conversacionais ou orientados por 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. Ele abstrai as diferentes maneiras pelas quais o estado de conversação pode ser gerenciado para diferentes agentes.

Os serviços de agente com estado geralmente armazenam o estado da conversa no serviço, e pode-se interagir com ele por meio de um ID. Outros agentes podem exigir que todo o histórico de conversa seja passado para o agente em cada invocação, caso em que o estado da conversa é gerido localmente na aplicação.

Os agentes com estado normalmente trabalham apenas com a implementação correspondente AgentThread, enquanto outros tipos de agentes podem trabalhar com mais do que um tipo de AgentThread. Por exemplo, AzureAIAgent necessita de uma correspondência equivalente AzureAIAgentThread. Isso ocorre porque o serviço Azure AI Agent 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 Agent Orchestration no Semantic Kernel permite a coordenação de vários agentes para resolver 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é-construídos, como Simultâneo, Sequencial, Handoff, Chat de Grupo e Magentic, permitem que os desenvolvedores escolham o modelo de colaboração mais adequado para seu cenário. Cada padrão define uma maneira diferente para os agentes se comunicarem e processarem tarefas (consulte a tabela 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, suportando tipos de dados simples e complexos.
• Humano no circuito: Alguns padrões suportam o humano no circuito, permitindo que agentes humanos participem no processo de orquestração. Isto é particularmente útil para cenários em que é necessário julgamento humano ou perícia.

Essa arquitetura permite que os desenvolvedores criem sistemas inteligentes e multiagentes que podem resolver problemas do mundo real por meio de colaboração, especialização e coordenação dinâmica.

Alinhamento do agente com recursos do kernel semântico

O Agent Framework é construído sobre os conceitos e recursos fundamentais que muitos desenvolvedores conheceram dentro do ecossistema do Kernel Semântico. Esses princípios fundamentais servem como blocos de construção para o design do Agent Framework. Ao aproveitar a estrutura familiar e os recursos do Kernel Semântico, o Agent Framework estende sua funcionalidade para permitir comportamentos de agente mais avançados e autônomos, mantendo a consistência com a arquitetura mais ampla do Kernel Semântico. 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.

Plugins e Chamada de Função

Os plugins são um aspeto fundamental do Kernel Semântico, permitindo que os desenvolvedores integrem funcionalidades personalizadas e estendam os recursos de um aplicativo de IA. Esses plugins oferecem uma maneira flexível de incorporar recursos especializados ou lógica específica do negócio nos principais fluxos de trabalho de IA. Além disso, os recursos do agente dentro da estrutura podem ser significativamente aprimorados utilizando plug-ins e utilizando a 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 diversas aplicações.

Saiba como configurar agentes para usar plug-ins aqui.

Mensagens do agente

As mensagens do agente, incluindo entrada e resposta, são construídas com base nos principais tipos de conteúdo do Kernel Semântico, fornecendo uma estrutura unificada para comunicação. Essa escolha de design simplifica o processo de transição de padrões tradicionais de conclusão de bate-papo para padrões mais avançados orientados por agente no desenvolvimento de aplicativos. Ao aproveitar os tipos de conteúdo familiares do Kernel Semântico, 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.

Templateização

O papel de um agente é principalmente moldado pelas instruções que recebe, que ditam o seu comportamento e ações. Semelhante a invocar 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 a 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óximos passos