No início da década de 1990, trabalhei em um grande laboratório de pesquisa em telecomunicações, como parte do grupo Advanced Local Loop. O nosso domínio de problema era o “último quilómetro” – levar serviços às casas das pessoas. Uma das minhas áreas de pesquisa envolveu pensar sobre o que poderia acontecer quando a mudança da rede de serviços analógicos para digitais estivesse completa.

Passei muito tempo na biblioteca do laboratório, contemplando como seria a computação em um futuro com largura de banda universal. Um dos conceitos que me fascinou foi a computação ubíqua, onde os computadores desaparecem em segundo plano e os agentes de software se tornam nossos proxies, interagindo com os serviços de rede em nosso nome. Essa ideia inspirou trabalhos na Apple, IBM, General Magic e muitas outras empresas.

Uma das pioneiras no conceito de agente de software foi a professora do MIT, Pattie Maes. O seu trabalho ultrapassou as fronteiras entre redes, programação e inteligência artificial e concentrou-se em duas ideias relacionadas: agentes inteligentes e agentes autónomos. Eram programas adaptativos que podiam encontrar e extrair informações para os usuários e mudar seu comportamento ao fazê-lo.

A indústria de software levou mais de 30 anos para acompanhar essa pesquisa pioneira, mas com uma combinação de grandes modelos de linguagem (LLMs) baseados em transformadores e pipelines de orquestração adaptativos, finalmente conseguimos começar a entregar essas ambiciosas ideias originais .

Kernel Semântico como estrutura de agente

A equipe do Kernel Semântico da Microsoft está se baseando no modelo Assistant da OpenAI para fornecer um tipo de agente inteligente, junto com um conjunto de ferramentas para gerenciar a chamada de múltiplas funções. Eles também estão fornecendo uma maneira de gerenciar as mensagens enviadas de e para a API OpenAI e de usar plug-ins para integrar bate-papo de uso geral com integrações baseadas em dados usando RAG.

A equipe está começando a ir além do modelo de orquestração original do tipo LangChain com o recente lançamento 1.01 e agora está pensando no Kernel Semântico como um tempo de execução para uma conversa contextual. Isso requer muito mais gerenciamento da conversa e do histórico de prompts usado. Todas as interações passarão pela função de chat, com o Kernel Semântico gerenciando entradas e saídas.

Há muita coisa acontecendo aqui. Primeiro, estamos vendo um movimento em direção a uma pilha de IA. O modelo Copilot da Microsoft talvez seja melhor pensado como uma implementação de uma pilha de agentes moderna, com base no investimento da empresa em infraestrutura pronta para IA (para inferência e também para treinamento), sua biblioteca de modelos básicos, até o suporte para plug-ins que funcionam nas plataformas da Microsoft e OpenAI.

O papel dos plug-ins do Kernel Semântico

Um aspecto importante das atualizações recentes do Kernel Semântico simplifica os bate-papos com interfaces de usuário LLM, já que não há mais necessidade de gerenciar explicitamente os históricos. Isso agora é tratado pelo Kernel Semântico assim que você define os serviços de IA que usará para seu aplicativo. O resultado é um código muito mais fácil de entender, abstraído do modelo subjacente.

Ao gerenciar o estado da conversa para você, o Kernel Semântico se torna o agente de contexto do seu agente. Em seguida, ele precisa de uma forma de interagir com ferramentas externas. É aqui que os plug-ins adicionam descrições amigáveis ​​​​ao LLM aos métodos. Não há necessidade de fazer mais do que adicionar esses metadados ao seu código. Uma vez lá, um bate-papo pode acionar ações por meio de uma API, como aumentar a temperatura usando uma plataforma doméstica inteligente como o Home Assistant.

Quando você adiciona um plug-in ao objeto kernel do Kernel Semântico, ele fica disponível para orquestração baseada em chat. O LLM subjacente fornece o entendimento do idioma necessário para executar a ação associada à descrição mais provável do plugin. Isso garante que os usuários que executam seu agente não precisem ser tediosamente precisos. Uma descrição do plugin “Definir a temperatura ambiente” pode ser acionada por “Aquecer o ambiente” ou “Ajustar o ambiente para 17ºC”. Ambos indicam a mesma intenção e instruem o Kernel Semântico a chamar o método apropriado.

Alternativamente, você poderá usar plug-ins OpenAI, cujo suporte é atualmente experimental. Esses plugins usam especificações OpenAPI para acessar APIs externas, com chamadas vinculadas a descrições semânticas. A descrição semântica de uma chamada de API permite que os LLMs da OpenAI façam a chamada apropriada com base no conteúdo de um prompt. O Kernel Semântico pode gerenciar o contexto geral e encadear chamadas para uma série de APIs, usando seus próprios plug-ins e plug-ins OpenAI. O Kernel Semântico pode até misturar modelos e usá-los junto com sua própria memória semântica, usando pesquisas vetoriais para fundamentar o LLM em dados do mundo real.

O trabalho da Microsoft aqui pega os recursos de linguagem de um LLM e os envolve no contexto do usuário, dos dados e da API. É aqui que é possível começar a chamar o Kernel Semântico de uma ferramenta para a construção de agentes inteligentes, pois ele usa prompts e bate-papos de usuários para orquestrar consultas dinamicamente em fontes de dados e recursos hospedados na Internet.

Os agentes baseados em LLM podem ser autônomos?

Outro conjunto de funções do Kernel Semântico começa a implementar uma forma de autonomia. É aqui que as coisas ficam realmente interessantes, porque ao gerenciar o contexto, nosso agente do Kernel Semântico pode selecionar os plug-ins apropriados de sua biblioteca atual para fornecer respostas.

Aqui podemos aproveitar as vantagens dos planejadores do Kernel Semântico para criar um fluxo de trabalho. O planejador Handlebars lançado recentemente pode gerar dinamicamente uma orquestração que inclui loops e instruções condicionais. Quando um usuário cria uma tarefa em um chat, o planejador cria uma orquestração baseada nessas instruções, chamando plug-ins conforme necessário para concluir a tarefa. O Kernel Semântico baseia-se apenas nos plug-ins definidos no código do kernel, usando um prompt que garante que apenas esses plug-ins sejam usados.

Existem problemas com código que opera de forma autônoma. Como você pode ter certeza de que ele permanece fundamentado e evita imprecisões e erros? Uma opção é trabalhar com a ferramenta Prompt Flow no Azure AI Studio para criar uma estrutura de teste que avalie a precisão dos seus planejadores e plug-ins. Ele é capaz de usar uma grande variedade de dados de benchmark para determinar como seu agente funciona com diferentes entradas do usuário. Talvez seja necessário gerar consultas sintéticas para obter dados suficientes, usando um LLM para produzir as solicitações iniciais.

Os Copilotos da Microsoft são um exemplo de agentes inteligentes em ação, e é bom ver a equipe do Kernel Semântico usando o termo. Com mais de 30 anos de pesquisa em agentes de software, há muita experiência que pode ser explorada para avaliar e melhorar os resultados da orquestração do Kernel Semântico e para orientar os desenvolvedores na construção das experiências de usuário e dos enquadramentos que esses agentes podem oferecer.

Agentes inteligentes 30 anos depois

É importante observar que o modelo de agente do Kernel Semântico difere do conceito de agente original de uma forma significativa: você não está enviando código inteligente para executar consultas em plataformas remotas. Mas nos últimos 30 anos, assistimos a uma grande revolução no desenvolvimento de aplicações distribuídas que mudou muito do que é necessário para suportar tecnologias de agente.

O resultado dessa nova abordagem de desenvolvimento é que não há mais necessidade de executar código arbitrário e não confiável em servidores remotos. Em vez disso, podemos aproveitar as APIs e os recursos da nuvem para tratar um agente como um fluxo de trabalho orquestrado que abrange sistemas distribuídos. Além disso, esse agente pode reorganizar de forma inteligente essa orquestração com base em operações anteriores e atuais. Os microsserviços modernos são uma plataforma ideal para isso, baseados em conceitos de arquitetura orientada a serviços com descrições autodocumentadas de OpenAPI e GraphQL.

Este parece ser o modelo que o Semantic Kernel está adotando, ao fornecer uma estrutura para hospedar esses fluxos de trabalho dinâmicos. Combinar chamadas de API, pesquisas vetoriais e plug-ins OpenAI com uma estrutura programática relativamente simples oferece uma maneira de construir uma alternativa moderna à premissa original do agente. Afinal, como poderíamos distinguir agentes benignos de malware? Em 1994, os vírus de computador eram uma ocorrência rara e os ataques à rede eram matéria de ficção científica.

Hoje podemos usar definições OpenAPI para ensinar LLMs como consultar e extrair dados de APIs confiáveis. Todo o código necessário para fazer essas conexões é entregue pela IA subjacente: tudo o que você precisa é de um prompt e de uma pergunta do usuário. O Kernel Semântico fornece os prompts e as respostas em linguagem natural, no contexto da pergunta original.

Você pode pensar nisso como uma abordagem moderna para concretizar os conceitos iniciais de agente, executando código em um só lugar na nuvem, em vez de em muitos sistemas diferentes. O uso de APIs reduz a carga nos sistemas que fornecem informações ao agente e torna o processo mais seguro.

À medida que estas tecnologias evoluem, é importante não tratá-las como algo totalmente novo. Este é o resultado de décadas de trabalho de pesquisa, um trabalho que finalmente atende aos usuários pretendidos. Há muita coisa nessa pesquisa que poderia nos ajudar a fornecer agentes confiáveis, fáceis de usar e inteligentes que sirvam como nossos proxies na rede da próxima geração – assim como os pesquisadores iniciais pretendiam na década de 1990.