White Paper sobre agentes do Google e aplicativos básicos (versão em chinês)

Por Julia Wiesinger, Patrick Marlow e Vladimir Vuskovic
Original: https://www.kaggle.com/whitepaper-agents

diretório (no disco rígido do computador)

breve

O que é um corpo inteligente?

modelagem

artefato

camada de orquestração

Inteligência e modelagem

Arquitetura cognitiva: como funciona a inteligência

Ferramentas: nossas chaves para o mundo exterior

extensões

Extensões de amostra

função (matemática)

caso de uso

Código de amostra de função

armazenamento de dados

Realização e aplicação

Revisão da ferramenta

Aprimoramento do desempenho do modelo por meio de aprendizado direcionado

Início rápido do Intelligentsia com LangChain

Aplicativos de produção que usam as inteligências de IA da Vertex

resumos

Essa combinação de raciocínio, lógica e acesso a informações externas, associada a modelos de IA generativos, leva ao conceito de inteligências.

breve

Os seres humanos são muito bons em lidar com tarefas confusas de reconhecimento de padrões. No entanto, muitas vezes dependem de ferramentas, como livros, pesquisas no Google ou calculadoras, para complementar seu conhecimento prévio antes de chegarem a uma conclusão.

Assim como os seres humanos, os modelos de IA generativa podem ser treinados para usar ferramentas para acessar informações em tempo real ou sugerir ações no mundo real. Por exemplo, os modelos podem usar ferramentas de pesquisa de banco de dados para acessar informações específicas, como o histórico de compras de um cliente, a fim de gerar recomendações de compras personalizadas.

Como alternativa, com base em uma consulta do usuário, o modelo pode fazer várias chamadas de API, enviar uma resposta de e-mail a um colega ou concluir uma transação financeira em seu nome. Para fazer isso, o modelo deve não apenas acessar um conjunto de ferramentas externas, mas também ter a capacidade de planejar e executar qualquer tarefa de forma autodirigida.

Essa combinação de raciocínio, lógica e acesso a informações externas se conecta ao modelo de IA generativa, levando à noção de um corpo ou programa inteligente que amplia os recursos independentes do modelo de IA generativa. Este whitepaper explora todos esses aspectos e outros relacionados em mais detalhes.

O que é um corpo inteligente?

Em sua forma mais básica, uma inteligência de IA generativa pode ser definida como um aplicativo que tenta atingir uma meta observando o mundo e agindo sobre ele usando as ferramentas disponíveis. As inteligências são autônomas e podem agir independentemente da intervenção humana, especialmente quando recebem metas ou intenções adequadas para cumprir. A Intelligentsia também pode ser proativa em sua abordagem para atingir seus objetivos. Mesmo na ausência de um conjunto explícito de instruções de um ser humano, um corpo inteligente pode raciocinar sobre o que deve fazer em seguida para atingir seu objetivo final. Embora o conceito de inteligências em IA seja bastante geral e poderoso, este whitepaper se concentra nos tipos específicos de inteligências que os modelos de IA generativa podem criar no momento da publicação.

Para entender o funcionamento interno das inteligências, vamos primeiro descrever os componentes subjacentes que orientam seu comportamento, ações e decisões. A combinação desses componentes pode ser descrita como uma arquitetura cognitiva, e existem muitas arquiteturas desse tipo que podem ser realizadas por meio da combinação e combinação desses componentes. Concentrando-nos nas funções principais, há três componentes básicos na arquitetura cognitiva de um corpo inteligente, conforme mostrado na Figura 1.

Figura 1: Arquitetura e componentes genéricos de inteligência

modelagem

No contexto da Intelligentsia, um modelo é um Modelo de Linguagem (LM) que será usado como um tomador de decisões centralizado para os processos da Intelligentsia. Os modelos usados pela Intelligentsia podem ser um ou mais LMs de qualquer tamanho (pequeno/grande) capazes de seguir o raciocínio baseado em instruções e estruturas lógicas, como ReAct, Chain of Thought ou Thinking Tree. Os modelos podem ser genéricos, multimodais ou ajustados às necessidades de sua arquitetura específica de smartbody. Para obter os melhores resultados de produção, você deve utilizar um modelo que seja mais adequado ao aplicativo final pretendido e, de preferência, que tenha sido treinado na assinatura de dados associada às ferramentas que você planeja usar em sua arquitetura cognitiva. É importante observar que o modelo normalmente não é treinado usando as definições de configuração específicas (ou seja, seleção de ferramentas, definições de orquestração/raciocínio) das inteligências. No entanto, o modelo pode ser otimizado ainda mais para executar as tarefas do corpo inteligente, fornecendo-lhe exemplos que demonstrem a funcionalidade do corpo inteligente, incluindo instâncias em que o corpo inteligente usa ferramentas específicas ou etapas de raciocínio em vários contextos.

artefato

O modelo subjacente, apesar de seus impressionantes recursos de geração de texto e imagem, ainda é limitado por sua incapacidade de interagir com o mundo externo. As ferramentas preenchem essa lacuna, permitindo que as inteligências interajam com dados e serviços externos e, ao mesmo tempo, liberem um escopo mais amplo de operações além do próprio modelo subjacente. As ferramentas podem assumir várias formas e ter diferentes níveis de complexidade, mas geralmente estão alinhadas com métodos comuns de API da Web, como GET, POST, PATCH e DELETE. Por exemplo, as ferramentas podem atualizar as informações do cliente em um banco de dados ou buscar dados meteorológicos para influenciar as recomendações de viagem que uma inteligência fornece a um usuário. Com as ferramentas, as inteligências podem acessar e processar informações do mundo real. Isso permite que elas ofereçam suporte a sistemas mais especializados, como a geração aprimorada por recuperação (RAG), que amplia significativamente os recursos das inteligências além do que o modelo subjacente pode alcançar por si só. Discutiremos as ferramentas mais detalhadamente a seguir, mas é muito importante entender que elas preenchem a lacuna entre as funções internas das inteligências e o mundo externo, liberando assim uma gama maior de possibilidades.

camada de orquestração

A camada de orquestração descreve um processo cíclico que controla como um corpo inteligente adquire informações, executa algum raciocínio interno e usa esse raciocínio para informar sua próxima ação ou decisão. Normalmente, esse ciclo continuará até que o corpo inteligente atinja sua meta ou ponto de parada. A complexidade da camada de orquestração pode variar muito, dependendo das inteligências e das tarefas que elas executam. Alguns loops podem ser cálculos simples com regras de decisão, enquanto outros podem conter lógica encadeada, envolver algoritmos adicionais de aprendizado de máquina ou implementar outras técnicas de raciocínio probabilístico. Discutiremos a implementação da camada de orquestração da inteligência em mais detalhes na seção Arquitetura cognitiva.

Inteligência e modelagem

Para ter uma visão mais clara da diferença entre inteligências e modelos, considere o diagrama a seguir:

Arquitetura cognitiva: como funciona a inteligência

Imagine um chef em uma cozinha movimentada. Seu objetivo é criar pratos deliciosos para os clientes do restaurante, o que envolve um ciclo de planejamento, execução e ajustes.

• Eles coletam informações como pedidos de clientes e ingredientes na despensa e na geladeira.
• Eles fazem um raciocínio interno sobre os pratos e sabores que podem ser feitos com base nas informações que acabaram de coletar.
• Eles agem para preparar pratos: cortam legumes, misturam temperos, fritam carne.

Em cada etapa do processo, os chefs fazem ajustes conforme necessário, refinando seus planos à medida que os ingredientes acabam ou quando recebem feedback dos clientes, e usando o conjunto anterior de resultados para determinar seu próximo plano de ação. Esse ciclo de ingestão de informações, planejamento, execução e ajuste descreve a arquitetura cognitiva exclusiva que os chefs empregam para atingir seus objetivos.

Assim como um chef, um corpo inteligente pode usar uma arquitetura cognitiva para atingir seu objetivo final, processando informações de forma iterativa, tomando decisões informadas e refinando as ações subsequentes com base nos resultados anteriores. No centro da arquitetura cognitiva de um corpo inteligente está a camada de orquestração, responsável por manter a memória, o estado, o raciocínio e o planejamento. Ela usa o campo em rápida evolução da engenharia de dicas e estruturas relacionadas para orientar o raciocínio e o planejamento, permitindo que as inteligências interajam com seus ambientes e concluam tarefas com mais eficiência. As pesquisas nas áreas de estruturas de engenharia de dicas e planejamento de tarefas para modelos de linguagem estão evoluindo rapidamente, produzindo uma variedade de abordagens promissoras. Embora não seja uma lista exaustiva, a seguir estão algumas das estruturas e técnicas de raciocínio mais populares até a publicação deste white paper:

• O ReAct, uma estrutura de engenharia de dicas, fornece uma estratégia de processo de pensamento para que os modelos de linguagem raciocinem e atuem nas consultas dos usuários, com ou sem exemplos contextuais. As dicas do ReAct demonstraram ter um desempenho superior a várias linhas de base do SOTA e melhoram a capacidade de ação humana e a credibilidade de grandes modelos de linguagem.
• Chain of Thought (CoT), uma estrutura de engenharia de dicas que permite recursos de raciocínio por meio de etapas intermediárias. Há várias subtécnicas de CoT, incluindo autorreferencial, dicas ativas e CoT multimodal, cada uma delas com vantagens e desvantagens, dependendo da aplicação específica.
• A Thinking Tree (ToT), uma estrutura de engenharia de dicas, é ideal para tarefas de previsão exploratórias ou estratégicas. Ela generaliza os prompts da cadeia de pensamento e permite que os modelos explorem várias cadeias de pensamento que atuam como etapas intermediárias para a solução de problemas gerais usando modelos de linguagem.

Um corpo inteligente pode usar uma das técnicas de raciocínio acima ou muitas outras para selecionar a próxima melhor ação para uma determinada solicitação do usuário. Por exemplo, vamos considerar um usuário programado para usar o ReAct A estrutura seleciona as ações e ferramentas corretas para a inteligência da consulta do usuário. A sequência de eventos pode ser semelhante a esta:

1. O usuário envia uma consulta ao corpo inteligente
2. A inteligência inicia a sequência ReAct
3. O corpo inteligente fornece avisos ao modelo solicitando que ele gere o próximo ReAct
   Uma das etapas e sua saída correspondente:
   a. Perguntas: perguntas de entrada de consultas do usuário, fornecidas com prompts
   b. Reflexões: modelagem de reflexões sobre o que deve ser feito em seguida
   c. Operação: a decisão do modelo sobre qual ação tomar em seguida
   i. É aqui que as ferramentas podem ser selecionadas
   ii. Por exemplo, uma ação poderia ser [Flight, Search, Code, None], em que as três primeiras representam ferramentas conhecidas que o modelo pode selecionar, e a última representa uma "não seleção de ferramenta".
   d. Insumos operacionais: as decisões do modelo sobre quais insumos devem ser fornecidos à ferramenta, se houver.
   e. Observações: resultados de operações/manipulação de sequências de entrada
   i. Essa entrada/observação de pensamento/operação/operação pode ser repetida quantas vezes forem necessárias. ii.
   f. Resposta final: a resposta final à consulta original do usuário fornecida pelo modelo
   4. o loop do ReAct termina e a resposta final PS é fornecida ao usuário:Prática da lógica de implementação do ReAct

Figura 2. Exemplo de Intelligentsia usando o raciocínio ReAct na camada de orquestração

Conforme mostrado na Figura 2, o modelo, a ferramenta e as inteligências são configurados para trabalhar em conjunto e fornecer ao usuário uma resposta informada e concisa com base na consulta original do usuário. Embora o modelo possa adivinhar a resposta com base em seu conhecimento a priori (criando uma ilusão), ele usa a ferramenta (voos) para buscar informações externas em tempo real. Essas informações adicionais são fornecidas ao modelo para que ele possa tomar decisões mais informadas com base em dados factuais reais, que são agregados e devolvidos ao usuário.

Em resumo, a qualidade da resposta de um organismo inteligente pode estar diretamente relacionada à capacidade do modelo de raciocinar e operar nessas várias tarefas, incluindo a capacidade de selecionar as ferramentas certas e a qualidade da definição dessas ferramentas. Da mesma forma que um chef prepara um prato com ingredientes frescos e presta atenção ao feedback do cliente, um organismo inteligente depende de um raciocínio sólido e de informações confiáveis para obter resultados ideais. Na próxima seção, vamos nos aprofundar nas várias maneiras pelas quais a inteligência se conecta a dados atualizados.

Ferramentas: nossas chaves para o mundo exterior

Embora os modelos de linguagem sejam bons no processamento de informações, eles não têm a capacidade de perceber e influenciar diretamente o mundo real. Isso limita sua utilidade em situações em que precisam interagir com sistemas ou dados externos. Isso significa que, de certa forma, um modelo de linguagem é tão bom quanto o que ele aprende com os dados de treinamento. Entretanto, não importa a quantidade de dados que alimentamos nossos modelos, eles ainda não têm a capacidade básica de interagir com o mundo externo. Então, como podemos dar aos nossos modelos a capacidade de interagir com sistemas externos em tempo real e com reconhecimento de contexto? Funções, extensões, armazenamentos de dados e plug-ins são maneiras de fornecer aos modelos esse recurso essencial.

Embora tenham muitos nomes, as ferramentas são o elo que cria uma conexão entre nossos modelos subjacentes e o mundo externo. Essa conexão com sistemas e dados externos permite que nossas inteligências executem uma ampla variedade de tarefas com maior precisão e confiabilidade. Por exemplo, as ferramentas podem permitir que um corpo inteligente ajuste as configurações de uma casa inteligente, atualize um calendário, recupere informações do usuário de um banco de dados ou envie um e-mail com base em um conjunto específico de instruções.

Até a data deste whitepaper, há três tipos principais de ferramentas com as quais os modelos do Google podem interagir: extensões, funções e armazenamentos de dados. Ao equipar as inteligências com ferramentas, liberamos seu enorme potencial não apenas para entender o mundo, mas também para agir sobre ele, abrindo as portas para inúmeros novos aplicativos e possibilidades.

extensões

A maneira mais fácil de entender as extensões é pensar nelas como uma ponte entre APIs e inteligências de forma padronizada, permitindo que as inteligências executem APIs sem problemas, independentemente de sua implementação subjacente. Digamos que você tenha criado uma inteligência cujo objetivo seja ajudar os usuários a reservar voos. Você sabe que deseja usar a API do Google Flights para recuperar informações de voos, mas não sabe como fazer com que seu corpo inteligente chame esse endpoint da API.

Figura 3: Como as inteligências interagem com APIs externas?

Uma abordagem pode ser implementar um código personalizado que receba uma consulta do usuário, analise-a para obter informações relevantes e, em seguida, faça uma chamada à API. Por exemplo, no caso de uso de reserva de voo, um usuário pode dizer "Quero reservar um voo de Austin para Zurique". Nesse caso, nossa solução de código personalizado precisaria extrair "Austin" e "Zurique" como entidades relevantes da consulta do usuário antes de tentar fazer uma chamada à API. Mas o que acontece se o usuário disser "I want to book a flight to Zurich" (Quero reservar um voo para Zurique) sem fornecer uma cidade de partida? Sem os dados necessários, a chamada à API falhará e será necessário implementar mais código para capturar esses casos extremos. Essa abordagem não é dimensionável e pode falhar facilmente em qualquer situação que esteja além do escopo do código personalizado implementado.

Uma abordagem mais confiável é usar extensões. As extensões preenchem a lacuna entre as inteligências e as APIs das seguintes maneiras:

1. Use os exemplos para ensinar às inteligências como usar os pontos de extremidade da API.
2. Ensine à inteligência quais parâmetros são necessários para chamar com êxito o ponto de extremidade da API.

Figura 4. Extensão para conectar inteligências a APIs externas

As extensões podem ser criadas independentemente da Inteligência, mas devem ser fornecidas como parte da configuração da Inteligência. Os Intelligent Bodies usam modelos e exemplos em tempo de execução para determinar quais extensões, se houver, são apropriadas para resolver a consulta do usuário. Isso destaca uma vantagem importante das extensões, seus tipos de exemplos incorporados, que permitem que o Órgão Inteligente selecione dinamicamente a extensão mais apropriada para a tarefa.

Figura 5. Relação de 1 para muitos entre o Intelligentsia, as extensões e as APIs

Isso pode ser entendido da seguinte forma: um desenvolvedor de software decide qual endpoint de API usar ao resolver o problema de um usuário. Se um usuário quiser reservar um voo, o desenvolvedor poderá usar a API do Google Flights e, se um usuário quiser saber onde fica a cafeteria mais próxima de sua localização, o desenvolvedor poderá usar a API do Google Maps. Da mesma forma, o Intelligentsia/Model Stack usa um conjunto de extensões conhecidas para decidir qual é a mais adequada para a consulta do usuário. Se quiser ver as extensões em ação, você pode encontrá-las na página Gêmeos Experimente-as no aplicativo acessando Settings > Extensions (Configurações > Extensões) e ativando qualquer extensão que você queira testar. Por exemplo, você pode ativar a extensão Google Flights e pedir ao Gemini para "mostrar voos de Austin para Zurique na próxima sexta-feira".

Extensões de amostra

Para simplificar o uso das extensões, o Google fornece várias extensões prontas para uso que podem ser importadas rapidamente para o seu projeto e usadas com o mínimo de configuração. Por exemplo, a extensão do interpretador de código no Code Snippet 1 permite que você gere e execute código Python a partir de descrições de linguagem natural.

Python

importar vertexai
import pprint
PROJECT_ID = "YOUR_PROJECT_ID"
REGIÃO = "us-central1"
vertexai.init(project=PROJECT_ID, location=REGION)
from vertexai.preview.extensions import Extension
extension_code_interpreter = Extension.from_hub("code_interpreter")
CODE_QUERY = """Escreva um método python para inverter uma árvore binária em tempo O(n).""""
response = extension_code_interpreter.execute(
operation_id = "generate_and_execute",
operation_params = {"query": CODE_QUERY}
)
print("Código gerado:")
pprint.pprint({response['generated_code']})
# O snippet acima gerará o seguinte código.
# Código gerado.
# class TreeNode.
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right

Python

def invert_binary_tree(root).
"""
Inverte uma árvore binária.
Args.
root: A raiz da árvore binária.
Args: root: A raiz da árvore binária.
A raiz da árvore binária invertida.
"""
if not root: return None
return None
# Trocar os filhos da esquerda e da direita recursivamente
root.left, root.right = \
invert_binary_tree(root.right), invert_binary_tree(root.left)
invert_binary_tree(root.left)
# Exemplo de uso.
# Construir uma árvore binária de amostra
# 4
# / \
# 2 7
# / \ \ \ \ \ \
# 1 3 6 9
raiz = TreeNode(4)
root.left = TreeNode(2)
root.right = TreeNode(7)
root.left.left = TreeNode(1)
root.left.right = TreeNode(3)
root.right.left = TreeNode(6)
root.right.right = TreeNode(9)
# Inverter a árvore binária
inverted_root = invert_binary_tree(root)

Trecho de código 1: A extensão do interpretador de código gera e executa o código Python.

Em resumo, as extensões oferecem às inteligências uma variedade de maneiras de perceber, interagir e influenciar o mundo externo. A seleção e a invocação dessas extensões são orientadas pelo uso de exemplos, todos definidos como parte da configuração da extensão.

função (matemática)

No campo da engenharia de software, as funções são definidas como módulos de código autônomos que são usados para realizar tarefas específicas e podem ser reutilizados conforme necessário. Quando os desenvolvedores de software escrevem programas, eles geralmente criam muitas funções para executar várias tarefas. Eles também definem a lógica para chamar a função_a e a função_b, bem como as entradas e saídas esperadas.

As funções funcionam de maneira muito semelhante no domínio das inteligências, mas podemos usar modelos em vez de desenvolvedores de software. Os modelos podem usar um conjunto de funções conhecidas e, com base em sua especificação, decidir quando usar cada função e quais argumentos a função usa. As funções diferem das extensões de várias maneiras, principalmente:

1. Funções de saída do modelo e seus parâmetros, mas sem chamadas de API em tempo real.
2. As funções são executadas no lado do cliente, enquanto as extensões são executadas no lado do smartbody.
   Usando novamente o exemplo do Google Flights, uma configuração simples da função pode se parecer com a Figura 7.

Figura 7: Como as funções interagem com APIs externas?

Observe que a principal diferença aqui é que nem as funções nem as inteligências interagem diretamente com a API do Google Flights. Então, como as chamadas à API realmente acontecem?

Ao usar funções, a lógica e a execução da chamada dos endpoints reais da API são transferidas da inteligência para o aplicativo cliente, conforme mostrado nas Figuras 8 e 9 abaixo. Isso proporciona ao desenvolvedor um controle mais granular sobre o fluxo de dados no aplicativo. Há muitos motivos pelos quais um desenvolvedor pode optar por usar funções em vez de extensões, mas alguns casos de uso comuns são:

• As APIs precisam ser chamadas em outro nível da pilha de aplicativos, em vez de diretamente no processo de arquitetura do agente (por exemplo, usando um sistema de middleware, uma estrutura de front-end etc.).
• Limitações de segurança ou autenticação que impedem o agente de chamar a API diretamente (por exemplo, a API não está exposta à Internet ou a infraestrutura do agente não tem acesso à API).
• Limitações de tempo ou sequência de operações que impedem os agentes de chamar a API em tempo real (por exemplo, operações em lote, processos de revisão manual etc.).
• É necessária uma lógica de transformação de dados adicional para as respostas de API que o agente não pode executar. Por exemplo, alguns endpoints de API não fornecem mecanismos de filtragem para limitar o número de resultados retornados. O uso de funções no lado do cliente oferece aos desenvolvedores oportunidades adicionais para realizar essas transformações.
• Os desenvolvedores querem iterar no desenvolvimento de proxy sem implantar infraestrutura adicional para pontos de extremidade de API (por exemplo, as chamadas de função podem ser usadas como "simulações de piquetagem" para APIs).

Embora as diferenças entre as duas abordagens sejam mais sutis do ponto de vista da arquitetura interna, conforme mostrado na Figura 8, as chamadas de função oferecem controle adicional e reduzem a dependência da infraestrutura externa, tornando-as uma opção atraente para os desenvolvedores.

Figura 8. Controles do lado do cliente e do lado do Smartbody que descrevem extensões e chamadas de função

caso de uso

Os modelos podem ser usados para chamar funções a fim de lidar com processos complexos de execução no lado do cliente para usuários finais, em que o desenvolvedor da inteligência pode não querer que o modelo de linguagem gerencie a execução da API (como seria o caso das extensões). Vamos considerar o exemplo a seguir, em que um corpo inteligente é treinado como concierge de viagens para interagir com um usuário que deseja reservar uma viagem de férias. O objetivo é que o corpo inteligente gere uma lista de cidades que possamos usar em nosso aplicativo de middleware para fazer download de imagens, dados etc. para o planejamento de viagem do usuário. O usuário pode dizer:

Gostaria de fazer uma viagem para esquiar com minha família, mas não tenho certeza de onde ir.

Em um prompt típico do modelo, o resultado pode ser o seguinte:

Obviamente, aqui está uma lista de cidades a serem consideradas para uma viagem de esqui em família:

• Crested Butte, CO, Estados Unidos da América
• Whistler, Colúmbia Britânica, Canadá
• Zermatt, Suíça

Embora a saída acima contenha os dados de que precisamos (nomes de cidades), o formato não é adequado para análise. Com uma chamada de função, podemos ensinar o modelo a formatar essa saída em um estilo estruturado (por exemplo, JSON), que é mais fácil de ser analisado por outro sistema. Dado o mesmo prompt de entrada do usuário, o exemplo de saída JSON da função pode se parecer com o trecho de código 5.

não corrigido

function_call {
name: "display_cities"
args: {
"cities": ["Crested Butte", "Whistler", "Zermatt"], "preferences": "skiing
"preferences": "skiing"
}
}

Trecho de código 5: Exemplo de carga de chamada de função para exibir uma lista de cidades e preferências do usuário Essa carga de JSON é gerada pelo modelo e, em seguida, enviada ao nosso servidor cliente para executar qualquer ação que desejemos realizar nela. Nesse caso específico, chamaremos a API do Google Places para buscar as cidades fornecidas pelo modelo e procurar as imagens e, em seguida, apresentá-las aos nossos usuários como conteúdo avançado formatado. Consulte o diagrama de sequência na Figura 9, que mostra em detalhes as etapas da interação acima.

Figura 9: Diagrama de sequência mostrando o ciclo de vida da chamada de função

O resultado do exemplo da Figura 9 é que o modelo é usado para "preencher os espaços em branco" com os parâmetros necessários para que a interface do usuário do cliente chame a API do Google Places. A interface do usuário do cliente usa os parâmetros fornecidos pelo modelo na função retornada para gerenciar a chamada real à API. Esse é apenas um caso de uso para chamadas de função, mas há muitos outros cenários a serem considerados, como, por exemplo:

• Você deseja que o modelo de linguagem sugira uma função que possa ser usada em seu código, mas não deseja incluir credenciais no código. Como a chamada de função não executa a função, você não precisa incluir credenciais com informações sobre a função em seu código.
• Você está executando uma operação assíncrona que pode levar mais de alguns segundos para ser concluída. Esses cenários se aplicam às chamadas de função porque são operações assíncronas.
• Você deseja executar a função em um dispositivo diferente do sistema que gerou a chamada de função e seus argumentos.

Um aspecto importante a ser lembrado sobre as funções é que elas se destinam a fornecer ao desenvolvedor mais controle sobre a execução das chamadas de API e o fluxo geral de dados no aplicativo. No exemplo da Figura 9, o desenvolvedor optou por não retornar as informações da API para a inteligência porque elas não são relevantes para as ações que a inteligência poderá realizar no futuro. No entanto, dependendo da arquitetura do aplicativo, pode fazer sentido retornar dados de chamadas de API externas ao corpo inteligente para influenciar o raciocínio, a lógica e a escolha de ações futuras. Em última análise, cabe ao desenvolvedor do aplicativo escolher o que é apropriado para um determinado aplicativo.

Código de amostra de função

Para obter o resultado acima de nossa cena de férias de esqui, vamos criar cada componente para trabalhar com nosso modelo gemini-1.5-flash-001. Primeiro, definimos a função display_cities como um método Python simples.

Python

def display_cities(cities: list[str], preferences: Optional[str] = None).
"""Fornece uma lista de cidades com base na consulta de pesquisa e nas preferências do usuário.
Args.
preferences (str): preferências de pesquisa do usuário, por exemplo, esqui,
praias, restaurantes, churrascos etc.
cities (list[str]): lista de cidades recomendadas para o usuário.
Retorna: list[str]: lista de cidades recomendadas para o usuário.
list[str]: uma lista de cidades recomendadas para o usuário.
"""
return cities

Trecho de código 6: Exemplo de método Python para uma função que exibe uma lista de cidades.

Em seguida, instanciaremos nosso modelo, criaremos a ferramenta e passaremos a consulta do usuário e a ferramenta para o modelo. A execução do código abaixo produzirá o resultado mostrado na parte inferior do snippet de código.

Python

from vertexai.generative_models import GenerativeModel, Tool, FunctionDeclaration
model = GenerativeModel("gemini-1.5-flash-001")
display_cities_function = FunctionDeclaration.from_func(display_cities)
tool = Tool(function_declarations=[display_cities_function])
message = "Gostaria de fazer uma viagem para esquiar com minha família, mas não tenho certeza para onde ir."
res = model.generate_content(message, tools=[tool])
print(f "Nome da função: {res.candidates[0].content.parts[0].function_call.name}")
print(f "Args da função: {res.candidates[0].content.parts[0].function_call.args}")
> Nome da função: display_cities
> Function Args: {'preferences': 'skiing', 'cities': ['Aspen', 'Vail'.
'Park City']}

O trecho de código 7. cria a ferramenta, envia-a para o modelo com a consulta do usuário e permite que sejam feitas chamadas de função

Em resumo, as funções fornecem uma estrutura simples que permite que os desenvolvedores de aplicativos tenham um controle refinado sobre o fluxo de dados e a execução do sistema, ao mesmo tempo em que utilizam inteligências/modelos de forma eficaz para a geração de entradas importantes. Os desenvolvedores podem optar por manter as inteligências "no circuito", retornando dados externos, ou omiti-las, dependendo dos requisitos específicos da arquitetura do aplicativo.

armazenamento de dados

Imagine um modelo de linguagem como uma vasta biblioteca que contém seus dados de treinamento. No entanto, ao contrário de uma biblioteca que está constantemente adquirindo novos livros, essa biblioteca permanece estática, contendo apenas o conhecimento do treinamento inicial. Isso é um desafio porque o conhecimento do mundo real está constantemente sendo
Desenvolvimento. O armazenamento de dados resolve essa limitação fornecendo acesso a informações mais dinâmicas e atualizadas e garantindo que as respostas do modelo sejam sempre baseadas em fatos e relevância.

Considere um cenário comum em que um desenvolvedor pode precisar fornecer uma pequena quantidade de dados adicionais a um modelo, talvez na forma de uma planilha ou PDF.

Figura 10: Como as inteligências interagem com dados estruturados e não estruturados?

Os armazenamentos de dados permitem que os desenvolvedores forneçam dados adicionais às inteligências em seu formato original, eliminando a necessidade de conversão de dados demorada, retreinamento de modelos ou ajuste fino. O armazenamento de dados converte os documentos recebidos em um conjunto de embeddings de banco de dados vetoriais que podem ser usados pelas inteligências para extrair as informações necessárias para complementar sua próxima ação ou resposta ao usuário.

Figura 11. Os armazenamentos de dados conectam as inteligências a vários tipos de novas fontes de dados em tempo real.

Realização e aplicação

No contexto das inteligências de IA generativas, o armazenamento de dados é frequentemente implementado como bancos de dados vetoriais, aos quais os desenvolvedores esperam que as inteligências tenham acesso em tempo de execução. Embora não vamos nos aprofundar nos bancos de dados vetoriais aqui, o ponto principal a ser entendido é que eles armazenam dados na forma de embeddings vetoriais, que são vetores de alta dimensão ou representações matemáticas dos dados fornecidos. Nos últimos anos, um dos exemplos mais comuns do uso de armazenamentos de dados com modelos de linguagem tem sido os aplicativos Retrieval Augmented Generation (RAG). Esses aplicativos tentam ampliar a amplitude e a profundidade do conhecimento do modelo, fornecendo aos modelos acesso a dados em vários formatos, por exemplo:

• Conteúdo do site
• Dados estruturados em PDF, documentos do Word, CSV, planilhas eletrônicas e outros formatos.
• Dados não estruturados em HTML, PDF, TXT e outros formatos.

Figura 12. Relação de um para muitos entre inteligências e repositórios de dados que podem representar vários tipos de dados pré-indexados

O processo básico de cada solicitação do usuário e o ciclo de resposta do organismo inteligente são normalmente modelados conforme mostrado na Figura 13.

1. 1. A consulta do usuário é enviada ao modelo de incorporação para gerar uma incorporação da consulta
   2. A incorporação da consulta é então combinada com o conteúdo do banco de dados de vetores usando um algoritmo de correspondência (por exemplo, ScaNN)
   3. Recuperar correspondências do banco de dados de vetores em formato de texto e enviá-las de volta ao corpo inteligente
   4. A Intelligentsia recebe as consultas do usuário e o conteúdo recuperado e, em seguida, formula respostas ou ações

5. enviar a resposta final ao usuário

Figura 13: Ciclo de vida da solicitação do usuário e resposta do corpo inteligente em aplicativos baseados em RAG

O resultado final é um aplicativo que permite que as inteligências combinem a consulta do usuário com um armazenamento de dados conhecido por meio de pesquisa vetorial, recuperem o conteúdo bruto e o forneçam à camada de orquestração e ao modelo para processamento adicional. A próxima etapa pode ser fornecer ao usuário a resposta final ou realizar pesquisas vetoriais adicionais para otimizar ainda mais os resultados. Um exemplo de interação com um corpo inteligente que implementa um RAG com raciocínio/planejamento ReAct é mostrado na Figura 14.

Figura 14: Exemplo de aplicativo RAG usando o raciocínio/planejamento do ReAct

Revisão da ferramenta

Em resumo, as extensões, as funções e os armazenamentos de dados compõem vários tipos diferentes de ferramentas que as inteligências podem usar em tempo de execução. Cada ferramenta tem sua própria finalidade e pode ser usada em conjunto ou separadamente, a critério do desenvolvedor da inteligência.

Desempenho aprimorado do modelo e aprendizado direcionado

Um aspecto fundamental do uso eficaz de modelos é sua capacidade de selecionar as ferramentas certas ao gerar resultados, especialmente ao usar ferramentas em escala na produção. Embora o treinamento geral possa ajudar os modelos a desenvolver essa habilidade.Mas os cenários do mundo real geralmente exigem mais do queconhecimento dos dados de treinamento. Pense nisso como a diferença entre habilidades culinárias básicas e o domínio de uma culinária específica. Ambas exigem conhecimento básico de culinária, mas a última requer aprendizado direcionado para obter resultados mais matizados.

Existem várias abordagens para ajudar os modelos a adquirir esse tipo de conhecimento específico:

• Aprendizagem contextual: essa abordagem fornece aos modelos genéricos dicas, ferramentas e pequenas amostras de raciocínio, permitindo que eles aprendam "na hora" como e quando usar essas ferramentas para tarefas específicas. A estrutura ReAct é um exemplo dessa abordagem em linguagem natural.
• Aprendizagem de contexto baseada em recuperação: essa técnica preenche dinamicamente as dicas do modelo recuperando as informações, as ferramentas e os exemplos relacionados mais relevantes do armazenamento externo. Um exemplo disso é o "armazenamento de exemplos" na extensão Vertex AI ou a arquitetura RAG de armazenamento de dados mencionada anteriormente.
• Aprendizagem baseada em ajuste fino: esse método envolve o treinamento do modelo com um conjunto de dados específico de exemplo maior antes do raciocínio. Isso ajuda o modelo a entender quando e como aplicar determinadas ferramentas antes de receber qualquer consulta do usuário.

Para ilustrar melhor os objetivos de cada método de aprendizagem, podemos voltar à analogia da cozinha para explorá-la.

• Imagine que um chef receba uma receita específica (dica), alguns ingredientes importantes (ferramentas relacionadas) e algumas amostras de pratos de clientes (menos amostras). Com base nessas informações limitadas e no conhecimento culinário geral do chef, ele precisa descobrir como preparar "na hora" o prato que melhor corresponda à receita e às preferências do cliente. Esse é o aprendizado contextual.
• Agora vamos imaginar nosso chefe em uma cozinha bem abastecida com uma despensa (armazenamento externo de dados) cheia de ingredientes e receitas (exemplos e ferramentas). O chef agora pode selecionar dinamicamente ingredientes e receitas da despensa e alinhar-se melhor às receitas e preferências do cliente. Isso permite que os chefs aproveitem o conhecimento existente e o novo para criar pratos mais inteligentes e sofisticados. Esse é o aprendizado contextual baseado em recuperação.
• Por fim, vamos imaginar que enviamos o chef de volta à escola para aprender uma nova culinária ou pratos (pré-treinados em um conjunto de dados maior e específico de exemplos). Isso permite que o chef aborde futuras receitas de clientes desconhecidos com uma compreensão mais profunda. Se quisermos que o chef
  Essa abordagem é perfeita quando você se destaca em uma cozinha específica (área de conhecimento). Esse é um aprendizado baseado no ajuste fino.

Cada abordagem tem vantagens e desvantagens exclusivas em termos de velocidade, custo e latência. No entanto, ao combinar essas técnicas em uma estrutura de corpo inteligente, podemos aproveitar as vantagens e minimizar as desvantagens, resultando em uma solução mais robusta e adaptável.

Início rápido do Intelligentsia com LangChain

Para dar um exemplo de uma inteligência executável em ação, criaremos um protótipo rápido usando as bibliotecas LangChain e LangGraph. Essas bibliotecas populares de código aberto permitem que os usuários criem inteligências de clientes "vinculando" sequências de lógica e raciocínio, bem como invocando ferramentas para responder às consultas dos usuários. Usaremos nosso modelo gemini-1.5-flash-001 e algumas ferramentas simples para responder a uma consulta de vários estágios de um usuário, conforme mostrado no trecho de código 8.

As ferramentas que usamos são a SerpAPI (para pesquisa no Google) e a API do Google Places. Você pode ver o exemplo de saída no trecho de código 9 depois de executar nosso procedimento no trecho de código 8.

Python

from langgraph.prebuilt import create_react_agent
from langchain_core.tools import tool
from langchain_community.utilities import SerpAPIWrapper
from langchain_community.tools import GooglePlacesTool
os.environ["SERPAPI_API_KEY"] = "XXXXX"
os.environ["GPLACES_API_KEY"] = "XXXXX"
@tool
def search(query: str):
"""Use a SerpAPI para executar uma pesquisa do Google.""""
search = SerpAPIWrapper()
return search.run(query)
@ferramenta
def places(query: str): """Use o Google Places(query: str):""
"""Use a API do Google Places para executar uma consulta do Google Places.""""
places = GooglePlacesTool()
return places.run(query)
model = ChatVertexAI(model="gemini-1.5-flash-001")
tools = [search, places]
consulta = "Com quem os Texas Longhorns jogaram no futebol na semana passada? Qual é o endereço do estádio do outro time?"
agente = create_react_agent(model, tools)
input = {"messages": [("human", query)]}
para s em agent.stream(input, stream_mode="values"):
message = s["messages"][-1]
if isinstance(message, tuple).
print(message)
else: message.pretty_print(message, tuple): print(message)
message.pretty_print()

Trecho de código 8. Exemplos de uso das ferramentas LangChain e LangGraph Intelligentsia

não corrigido

=============================== Notícias do usuário ================================
Quem foi o adversário do time de futebol americano Texas Longhorns na semana passada? Qual é o endereço do estádio do time adversário?
================================= Mensagem de IA =================================
Chamada de ferramenta: search
Parâmetro:
Search: Texas Longhorns Football Schedule
================================ Mensagem da ferramenta ================================
Nome: Search
{... Resultado: "NCAA Division I Football, Georgia, Data..."}
================================= AI News =================================
O Texas Longhorns jogou contra o Georgia Bulldogs na semana passada.
Chamada de ferramenta: location
Parâmetros:
Consulta: Estádio dos Bulldogs da Geórgia
================================ Mensagem da ferramenta ================================
Nome: Localização
{... Endereço do Estádio Sanford: 100 Sanford Road...}
================================= Mensagem de IA =================================
O endereço do Georgia Bulldogs Stadium é 100 Sanford Road, Athens, Georgia 30602.

Trecho de código 9: Saída do programa no trecho de código 8.

Embora esse seja um exemplo bastante simples de um corpo inteligente, ele demonstra todos os componentes básicos do modelo, da orquestração e das ferramentas trabalhando juntos para atingir um objetivo específico. Na seção final, exploraremos como esses componentes se encaixam nos produtos hospedados em escala do Google, como as inteligências Vertex AI e os Generative Playbooks.

Aplicativos de produção que usam as inteligências de IA da Vertex

Embora este whitepaper explore os principais componentes das inteligências, a criação de aplicativos de nível de produção exige a integração deles com outras ferramentas, como interfaces de usuário, estruturas de avaliação e mecanismos de melhoria contínua. A plataforma Vertex AI do Google simplifica esse processo fornecendo um ambiente totalmente hospedado que inclui todos os elementos essenciais descritos anteriormente. Usando uma interface de linguagem natural, os desenvolvedores podem definir rapidamente os principais elementos de suas inteligências - objetivos, descrições de tarefas, ferramentas, subinteligências para delegação de tarefas e exemplos - para criar facilmente o comportamento desejado do sistema. Além disso, a plataforma oferece um conjunto de ferramentas de desenvolvimento que podem ser usadas para testar, avaliar, medir o desempenho das inteligências, depurar e melhorar a qualidade geral das inteligências desenvolvidas. Isso permite que os desenvolvedores se concentrem na criação e na otimização de suas inteligências, enquanto a complexidade da infraestrutura, da implantação e da manutenção é gerenciada pela própria plataforma.

Na Figura 15, apresentamos um exemplo de arquitetura para uma inteligência desenvolvida na plataforma Vertex AI que usa vários recursos, como Vertex Agent Builder, Vertex Extensions, Vertex Function Calls e Vertex Example Storage. A arquitetura inclui muitos dos vários componentes necessários para aplicativos prontos para produção.

Figura 15: Exemplo de arquitetura de inteligências de ponta a ponta criadas na plataforma Vertex AI

Você pode experimentar este exemplo de arquitetura smartbody pré-construída em nossa documentação oficial.

resumos

Neste whitepaper, discutimos os componentes básicos das inteligências de IA generativas, sua composição e maneiras eficazes de implementá-las na forma de arquiteturas cognitivas. Algumas das principais conclusões deste whitepaper incluem:

• A Intelligentsia amplia a funcionalidade dos modelos de linguagem usando ferramentas para acessar informações em tempo real, sugerir ações práticas e planejar e executar tarefas complexas de forma autônoma. A Intelligentsia pode usar um ou mais modelos de linguagem para determinar quando e como fazer a transição de estados e usar ferramentas externas para executar qualquer número de tarefas complexas que seriam difíceis ou impossíveis de serem executadas pelo modelo por conta própria.
• No centro da operação das inteligências está a camada de orquestração, uma arquitetura cognitiva que desenvolve o raciocínio, o planejamento, a tomada de decisões e orienta suas ações. Várias técnicas de raciocínio (por exemplo, ReAct, cadeias de pensamento e árvores de pensamento) fornecem uma estrutura para a camada de orquestração receber informações, realizar raciocínio interno e gerar decisões ou respostas informadas.
• As ferramentas (por exemplo, extensões, funções e armazenamentos de dados) atuam como chaves para o mundo externo das inteligências, permitindo que elas interajam com sistemas externos e acessem o conhecimento além dos dados de treinamento. As extensões fornecem uma ponte entre as inteligências e as APIs externas.Isso permite a execução de chamadas de API e a recuperação de informações em tempo real. As funções oferecem aos desenvolvedores um controle mais granular por meio da divisão de responsabilidades, permitindo que as inteligências gerem parâmetros de função que podem ser executados no cliente. Os armazenamentos de dados fornecem às inteligências acesso a dados estruturados ou não estruturados para dar suporte a aplicativos orientados por dados.

O futuro dos corpos inteligentes reserva avanços empolgantes, e estamos apenas começando a arranhar a superfície do que é possível. À medida que as ferramentas se tornarem mais sofisticadas e os recursos de raciocínio forem aprimorados, as inteligências serão capazes de resolver problemas cada vez mais complexos. Além disso, a abordagem estratégica da "Chaining Intelligentsia" continuará ganhando força. Combinando inteligências especializadas, cada uma delas excelente em um domínio ou tarefa específica, podemos oferecer resultados superiores em todos os setores e áreas problemáticas.

É importante lembrar que a criação de arquiteturas de inteligências complexas requer uma abordagem iterativa. A experimentação e o refinamento são fundamentais para encontrar soluções para casos específicos de negócios e necessidades organizacionais. Não há duas inteligências idênticas devido à natureza generativa dos modelos subjacentes que sustentam sua arquitetura. Entretanto, ao aproveitar os pontos fortes de cada componente subjacente, podemos criar aplicativos impactantes que ampliam os recursos do modelo de linguagem e geram valor real.

nota final

• Shafran, I., Cao, Y. et al., 2022, 'ReAct: Synergising Reasoning and Acting in Language Models'. Disponível em.
  https://arxiv.org/abs/2210.03629
• Wei, J., Wang, X. et al., 2023, 'Chain-of-Thought Prompting Elicits Reasoning in Large Language Models'.
  Disponível em: https://arxiv.org/pdf/2201.11903.pdf.
• Wang, X. et al., 2022, "Self-Consistency Improves Chain of Thought Reasoning in Language Models" (A autoconsistência melhora a cadeia de raciocínio em modelos de linguagem).
  Disponível em: https://arxiv.org/abs/2203.11171.
• Diao, S. et al., 2023, 'Active Prompting with Chain-of-Thought for Large Language Models'. Disponível em.
  https://arxiv.org/pdf/2302.12246.pdf.
• Zhang, H. et al., 2023, 'Multimodal Chain-of-Thought Reasoning in Language Models'. Disponível em.
  https://arxiv.org/abs/2302.00923.
• Yao, S. et al., 2023, 'Tree of Thoughts: Deliberate Problem Solving with Large Language Models'. Disponível em.
  https://arxiv.org/abs/2305.10601.
• Long, X., 2023, 'Large Language Model Guided Tree-of-Thought'. Disponível em.
  https://arxiv.org/abs/2305.08291.
• **Google. 'Aplicativo Google Gemini'. Disponível em: **http://gemini.google.com.
• **Swagger. 'Especificação da OpenAPI'. Disponível em: **https://swagger.io/specification/.
• Xie, M., 2022, 'How does in-context learning work? A framework for understanding the differences from
  Traditional supervised learning". Disponível em: https://ai.stanford.edu/blog/understanding-incontext/.
• Google Research. 'ScaNN (Scalable Nearest Neighbors)'. Disponível em.
  https://github.com/google-research/google-research/tree/master/scann.
• **LangChain. 'LangChain'. Disponível em: **https://python.langchain.com/v0.2/docs/introduction/.