Aproveitando Function Calling para Criar Aplicações de LLM Mais Inteligentes
Modelos de linguagem grandes (LLMs) não estão mais limitados a gerar texto; agora eles lidam com tarefas mais complexas e orientadas por contexto. Um avanço importante nessa área é a chamada de funções, que permite que LLMs interajam com ferramentas externas, bancos de dados e APIs para realizar operações dinâmicas. Isso permite que eles vão além da geração de texto e trabalhem com dados e serviços do mundo real.
Em um recente Berlin Unstructured Data Meetup organizado pela Zilliz, Nikolai Danylchyk, engenheiro de clientes no Google, discutiu como Gemini, um LLM moderno, usa chamadas de funções para estender suas capacidades. Este blog recapitulará seus insights e demonstrará como aproveitar esse recurso poderoso para criar aplicações avançadas de LLM. Se você quiser saber mais detalhes, recomendamos que assista à gravação da palestra de Nikolai no YouTube.
Entendendo Chamadas de Funções Avançadas em LLMs
LLMs evoluíram significativamente, mas seu verdadeiro potencial se destaca quando interagem com sistemas externos por meio de chamadas de funções. Essa capacidade permite que LLMs vão além das limitações de seus dados de treinamento estáticos ao consultar bancos de dados ao vivo, executar comandos ou realizar cálculos em tempo real. Ao integrar chamadas de funções, LLMs podem se conectar perfeitamente a outros sistemas para fornecer respostas mais precisas, atuais e dinâmicas. Vamos detalhar como a chamada de funções funciona usando o Gemini como exemplo.
Figura 1- Etapas da chamada de funções e componentes usados em tempo de execução
Figura 1: Etapas da chamada de funções e componentes usados em tempo de execução.
O processo começa quando um usuário envia uma solicitação à API Gemini. Nesse ponto, o desenvolvedor já definiu uma ou mais declarações de função dentro da ferramenta, informando ao Gemini as funções disponíveis e como executá-las. Assim que a entrada do usuário é recebida, a API Gemini analisa o conteúdo e o prompt, retornando uma resposta de "Chamada de Função". Essa resposta inclui dados estruturados, como o nome da função a ser chamada e os parâmetros relevantes.
A próxima etapa ocorre fora do sistema Gemini: a aplicação usa o nome da função e os parâmetros da resposta do Gemini para fazer uma solicitação de API a um serviço externo. É aqui que o desenvolvedor intervém, usando ferramentas como a biblioteca
requestsem Python para chamar uma API REST ou qualquer outra biblioteca cliente adequada às suas necessidades.Depois que o sistema externo retorna sua resposta, a aplicação envia esses dados de volta ao Gemini. O modelo então usa essas novas informações para gerar uma resposta final para o usuário. Se forem necessários dados adicionais, o Gemini pode emitir outra chamada de função, continuando o ciclo conforme necessário.
Para entender a importância dessa capacidade avançada, considere um LLM tradicional sem o recurso de chamada de funções. Suas respostas são geradas com base nos dados nos quais foi treinado, que podem estar desatualizados ou ter escopo limitado. No entanto, com chamadas de funções, um LLM pode emitir comandos para obter informações em tempo real de um banco de dados, atualizar um registro em um sistema de gerenciamento de relacionamento com o cliente (CRM) ou até mesmo acionar ações como reservar uma passagem ou fazer um pedido. Essa abordagem expande a utilidade do modelo de simplesmente gerar respostas para realizar tarefas.
Em termos técnicos, uma chamada de função em um LLM envolve uma interação estruturada entre o modelo e uma API ou serviço externo. O modelo identifica um cenário adequado em que uma chamada de função é necessária, formula os parâmetros para a chamada e a executa.
Por exemplo, se um usuário pergunta: “Como está o tempo em Berlim?” A chamada de função acionaria uma API de clima, recuperando dados em tempo real para gerar a resposta. Nesse caso, o LLM atua como um intermediário inteligente entre o usuário e o sistema externo, orquestrando uma interação mais precisa e útil.
Agora que exploramos o conceito básico de chamada de função, vamos ver uma implementação prática usando o Gemini para interagir com uma API do mundo real — recuperando taxas de câmbio de moedas.
Exemplo: Usando Chamada de Função para Recuperação de Taxas de Câmbio
Vamos ver como podemos utilizar uma API de taxas de câmbio por meio da chamada de função do Gemini:
Instalando as Bibliotecas Necessárias e Definindo Variáveis do Projeto
Vamos começar atualizando e instalando a biblioteca google-cloud-aiplatform, que é necessária para interagir com a plataforma Vertex AI do Google Cloud. Em seguida, forneça o ID do seu projeto e a localização como variáveis.
!pip3 install --upgrade --user --quiet google-cloud-aiplatform
PROJECT_ID = "[your-project-id]" # @param {type:"string"}
LOCATION = "us-central1" # @param {type:"string"}
Estes são placeholders para identificar com qual projeto e região no Google Cloud você está trabalhando.
Importando Módulos Necessários e Definindo o Modelo Generativo
Em seguida, importe os módulos necessários para definir e trabalhar com um modelo generativo do Vertex AI. A biblioteca requests será usada posteriormente para buscar dados de uma API externa.
import requests
from vertexai.generative_models import (
Content,
FunctionDeclaration,
GenerativeModel,
Part,
Tool,
)
model = GenerativeModel("gemini-1.5-pro-001")
A última linha inicializa um modelo generativo, neste caso, gemini-1.5-pro-001. Você usará o modelo posteriormente para gerar respostas com base no prompt de entrada.
Definindo uma Função para Taxas de Câmbio e Criando uma Ferramenta
Em seguida, crie uma função que descreve os parâmetros necessários para obter uma taxa de câmbio entre duas moedas e envolva-a em uma ferramenta.
get_exchange_rate_func = FunctionDeclaration(
name="get_exchange_rate",
description="Get the exchange rate for currencies between countries",
parameters={
"type": "object",
"properties": {
"currency_date": {
"type": "string",
"description": "A date that must always be in YYYY-MM-DD format or the value 'latest' if a time period is not specified"
},
"currency_from": {
"type": "string",
"description": "The currency to convert from in ISO 4217 format"
},
"currency_to": {
"type": "string",
"description": "The currency to convert to in ISO 4217 format"
}
},
"required": [
"currency_from",
"currency_date",
]
},
)
exchange_rate_tool = Tool(
function_declarations=[get_exchange_rate_func],
)
Os parâmetros incluem currency_date (no formato YYYY-MM-DD ou a palavra-chave latest), currency_from (o código ISO 4217 da moeda da qual converter) e currency_to (o código ISO 4217 da moeda para a qual converter). A seção required especifica que currency_from e currency_date são obrigatórios. Em seguida, definimos uma ferramenta chamada exchange_rate_tool, que envolve a declaração da função get_exchange_rate. Posteriormente, passaremos essa ferramenta para o modelo para lidar com a recuperação da taxa de câmbio.
Gerando uma Resposta com o Modelo e Extraindo Parâmetros da Resposta
Vamos agora invocar uma resposta passando um prompt para o modelo. Esperamos que o modelo gere uma resposta contendo uma chamada de função com parâmetros.
prompt = """What is the exchange rate from Australian dollars to Swedish krona?
How much is 500 Australian dollars worth in Swedish krona?"""
response = model.generate_content(
prompt,
tools=[exchange_rate_tool],
)
response.candidates[0].content
params = {}
for key, value in response.candidates[0].content.parts[0].function_call.args.items():
params[key[9:]] = value
params
O código acima define um prompt que pergunta pela taxa de câmbio entre dólares australianos e coroas suecas. O modelo é então chamado usando generate_content, passando o prompt junto com o exchange_rate_tool. O modelo tentará gerar uma resposta.
A resposta é então analisada. O dicionário params é preenchido iterando pelas chaves e valores de function_call.args e removendo os primeiros 9 caracteres da chave para corresponder aos nomes de parâmetros esperados.
Buscando Taxas de Câmbio em uma API e Dando uma Resposta ao Usuário
Vamos agora solicitar a Frankfurter API (uma API gratuita de taxas de câmbio) usando os parâmetros extraídos da resposta anterior e gerar uma resposta para o usuário.
import requests
url = f"https://api.frankfurter.app/{params['date']}"
api_response = requests.get(url, params=params)
api_response.text
response = model.generate_content(
[
Content(role="user", parts=[
Part.from_text(prompt + """Give your answer in steps with lots of detail
and context, including the exchange rate and date."""),
]),
Content(role="function", parts=[
Part.from_dict({
"function_call": {
"name": "get_exchange_rate",
}
})
]),
Content(role="function", parts=[
Part.from_function_response(
name="get_exchange_rate",
response={
"content": api_response.text,
}
)
]),
],
tools=[exchange_rate_tool],
)
response.candidates[0].content.parts[0].text
No código acima, assim que obtemos uma resposta da API de taxa de câmbio, chamamos o método generate_content novamente, desta vez passando vários conteúdos: um do usuário (solicitando etapas detalhadas e contexto), uma chamada de função para get_exchange_rate e a resposta da Frankfurter API. Essa combinação leva o modelo a dar uma resposta mais completa, passo a passo. Por fim, imprimimos a parte de texto do conteúdo gerado pelo modelo. Esta é a resposta que devolvemos ao usuário.
Aqui está uma resposta de exemplo:
Figura 2- Saída de um programa mostrando a taxa de câmbio de dólares australianos para coroas suecas
Figura 2: Saída de um programa mostrando a taxa de câmbio de dólares australianos para coroas suecas
A resposta mostra que a chamada de função funcionou e nos deu a taxa de câmbio atual conforme listada pela Frankfurter API.
Até agora, cobrimos chamadas de função, o recurso avançado do Gemini e de muitos outros LLMs. Embora a chamada de função por si só possa executar tarefas complexas como recuperação de moeda, seu verdadeiro potencial é realizado quando combinada com outras técnicas poderosas, como Geração Aumentada por Recuperação (RAG).
Combinando Chamadas de Função com Geração Aumentada por Recuperação (RAG) para Maior Interatividade
A geração aumentada por recuperação (RAG) tornou-se uma das tendências mais significativas em processamento de linguagem natural (NLP). Os sistemas RAG combinam as capacidades generativas dos LLMs com a eficiência dos sistemas de recuperação alimentados por bancos de dados vetoriais como Milvus e Zilliz Cloud (o Milvus gerenciado). Especificamente, em um sistema RAG, o banco de dados vetorial recupera informações contextuais para o LLM e, em seguida, o LLM gera uma resposta mais precisa com base nas informações recuperadas. A chamada de funções aprimora esse processo ao permitir uma interação mais dinâmica entre o LLM e bancos de dados ou sistemas externos. Com a adição de chamadas de funções, os LLMs podem ampliar suas capacidades não apenas recuperando dados relevantes, mas também processando-os e interagindo com eles em tempo real.
Por exemplo, em uma aplicação de suporte ao cliente que usa tanto RAG quanto chamada de funções, o LLM oferece uma interação mais rica e personalizada. Quando um usuário pergunta: “Onde está meu pedido recente?” O sistema primeiro emprega RAG para recuperar informações gerais sobre o processamento de pedidos do banco de dados vetorial Milvus, fornecendo contexto. Por exemplo, a informação recuperada é “os pedidos normalmente levam de 3 a 5 dias úteis para entrega.” Simultaneamente, por meio da chamada de funções, ele acessa dados em tempo real ao consultar a conta do cliente. A resposta final se torna: “Seu pedido nº 12345 foi enviado em 10 de setembro e deve chegar em 15 de setembro.”
Essa integração de RAG com chamada de funções cria um sistema dinâmico que não apenas gera respostas relevantes e informativas, mas também interage ativamente com dados e serviços ao vivo, trazendo uma dimensão interativa. Essa combinação torna agentes inteligentes impulsionados por LLMs capazes de realizar interações complexas no mundo real.
- Consulte este tutorial para um guia passo a passo sobre como aproveitar os recursos de chamada de funções de LLMs para aprimorar sistemas RAG.
Casos de uso da combinação de RAG e chamada de funções
Vamos dar uma olhada em várias dessas interações do mundo real.
Saúde: recuperação de prontuários médicos e agendamento de consultas
Na área da saúde, RAG combinado com chamada de funções permite que os LLMs forneçam suporte altamente personalizado e orientado por dados tanto para pacientes quanto para profissionais de saúde. Um médico poderia pedir ao sistema dados históricos de um paciente, enquanto o sistema recupera prontuários médicos relevantes usando RAG a partir de um banco de dados vetorial como o Milvus. Ao mesmo tempo, por meio da chamada de funções, o LLM pode interagir com sistemas hospitalares externos para agendar consultas de acompanhamento ou recuperar dados diagnósticos em tempo real.
Exemplo: Um médico pergunta: “Qual é o resultado do exame mais recente do paciente X, e você pode marcar uma consulta de acompanhamento na próxima semana?” O sistema primeiro consulta o Milvus para recuperar documentos relacionados do histórico do paciente, fornecendo insights sobre tendências e condições. Em seguida, ele usa chamada de funções para acessar a API de agendamento do hospital e marcar uma consulta para o paciente.
Finanças: insights de investimento personalizados e transações em tempo real
No setor financeiro, RAG é empregado para recuperar informações de mercado relevantes e dados financeiros históricos armazenados em bancos de dados vetoriais como o Milvus. Ao combinar isso com chamada de funções, um LLM também pode executar ações em tempo real, como comprar ou vender ações, transferir fundos ou gerar recomendações personalizadas de portfólio com base em dados ao vivo.
Exemplo: Um usuário pergunta: “Como meu portfólio se saiu nos últimos seis meses, e você pode comprar $1000 em ações da Apple?” O sistema primeiro usa RAG para recuperar o histórico do portfólio do usuário do Milvus, fornecendo um resumo do desempenho passado. Em seguida, usando function calling, ele interage com uma API de negociação para executar a compra das ações e confirmar a transação ao usuário.
E-Commerce: Recomendações de produtos e rastreamento de pedidos em tempo real
No e-commerce, o RAG pode ajudar a recuperar informações de produtos, avaliações ou histórico do cliente do Milvus para personalizar uma experiência de compra. Quando combinado com function calling, o sistema pode interagir com sistemas de inventário ao vivo para fornecer disponibilidade de estoque, rastrear pedidos em tempo real ou até mesmo processar pagamentos.
Exemplo: Um cliente pergunta: Você pode recomendar um laptop semelhante à minha última compra e me dizer quando meu pedido atual chegará? O LLM recupera informações sobre as compras anteriores do cliente do Milvus e recomenda um produto semelhante. Function calling é então usado para consultar a API de rastreamento de pedidos para fornecer atualizações em tempo real sobre o status de entrega do pedido atual.
Viagens: Sugestões de itinerários e gerenciamento de reservas
Em viagens e hospitalidade, o RAG pode buscar detalhes sobre destinos, hotéis e itinerários de viagem armazenados em um banco de dados vetorial como o Milvus. Combinado com function calling, o sistema pode gerenciar reservas, sugerir itinerários personalizados ou oferecer atualizações em tempo real sobre voos e reservas.
Exemplo: Um viajante pergunta: Você pode sugerir um itinerário de 5 dias na Itália e remarcar minha reserva de hotel para uma data anterior? O sistema primeiro recupera sugestões de itinerário do Milvus com base nas preferências e viagens anteriores do viajante. Em seguida, usa function calling para interagir com o sistema de reservas do hotel para modificar a reserva e confirmar a alteração com o usuário.
À medida que vemos como function calling aprimora sistemas como RAG, é importante reconhecer os desafios e benefícios práticos ao implantar essas tecnologias em aplicações do mundo real.
Desafios e benefícios de Function Calling em casos de uso do mundo real
Embora o potencial de function calling seja imenso, ele vem com seu próprio conjunto de desafios. Uma das principais preocupações é garantir a segurança e a privacidade das interações. Quando um LLM emite function calls, pode exigir acesso a dados sensíveis, como contas de usuário ou informações financeiras. Garantir que essas transações sejam seguras e estejam em conformidade com as regulamentações de privacidade de dados é crucial.
Além disso, a complexidade de gerenciar múltiplas function calls em um único fluxo de trabalho pode levar a problemas de latência. Por exemplo, se um LLM estiver emitindo várias function calls para diferentes sistemas, o tempo de resposta pode aumentar, potencialmente afetando a experiência do usuário. Isso é particularmente importante em aplicações em tempo real, onde a velocidade é crítica.
Do lado positivo, function calling oferece vários benefícios, incluindo automação aprimorada de tarefas, respostas em tempo real mais precisas e melhor interação com o usuário. Em setores como saúde, finanças e atendimento ao cliente, function calling pode otimizar operações ao automatizar tarefas rotineiras. Por exemplo, na saúde, um LLM poderia buscar prontuários de pacientes, agendar consultas e enviar lembretes via function calls, liberando tempo para que profissionais médicos se concentrem em casos mais complexos.
Além dos benefícios e desafios práticos, há considerações éticas e técnicas que não devem ser negligenciadas, particularmente em torno da segurança de dados e da confiabilidade do sistema.
Considerações éticas e técnicas
Do ponto de vista técnico, nós, como desenvolvedores, precisamos gerenciar cuidadosamente como as chamadas de função são implementadas para evitar possíveis armadilhas. Um problema comum é a dependência excessiva de sistemas externos. Se um LLM está constantemente emitindo chamadas de função para serviços de terceiros, a confiabilidade do sistema passa a depender do tempo de atividade e do desempenho desses serviços. O tratamento adequado de erros e mecanismos de fallback devem estar em vigor para garantir que o sistema continue funcionando sem problemas, mesmo quando serviços externos estiverem indisponíveis.
Eticamente, as chamadas de função levantam preocupações sobre transparência e consentimento do usuário. Se um LLM está tomando decisões ou realizando ações em nome de um usuário, é essencial que o usuário esteja plenamente ciente do que o sistema está fazendo. Por exemplo, em serviços financeiros, se um LLM está executando negociações ou transferindo fundos, os usuários devem ser informados sobre as ações que estão sendo realizadas e devem ter a capacidade de intervir, se necessário. Documentação clara e mecanismos de consentimento do usuário são fundamentais para manter a confiança em tais sistemas.
Outra preocupação ética gira em torno do uso de dados. Quando chamadas de função acessam dados pessoais ou sensíveis, medidas rigorosas devem estar em vigor para proteger a privacidade do usuário. Os desenvolvedores precisam garantir que os dados sejam tratados de forma responsável e que as chamadas de função estejam em conformidade com regulamentações de privacidade, como GDPR ou HIPAA.
Conclusão
Nikolai fez um trabalho fantástico ao esclarecer como as chamadas de função oferecem uma melhoria crucial para grandes modelos de linguagem, permitindo que eles executem tarefas do mundo real ao interagir com sistemas e dados externos. Seja recuperando taxas de câmbio ou impulsionando interações mais complexas por meio de Geração Aumentada por Recuperação (RAG), as chamadas de função expandem os horizontes do que os LLMs podem alcançar.
Leitura adicional
Continue lendo
Zilliz Cloud On-Demand Compute: Pay Only for What You Use
The customer case behind Zilliz Cloud On-Demand: how a $10K vector search bill came down to under $500, and the engineering changes that made it possible.
Data Deduplication at Trillion Scale: How to Solve the Biggest Bottleneck of LLM Training
Explore how MinHash LSH and Milvus handle data deduplication at the trillion-scale level, solving key bottlenecks in LLM training for improved AI model performance.
Legal Document Analysis: Harnessing Zilliz Cloud's Semantic Search and RAG for Legal Insights
Enhance legal document analysis with Zilliz Cloud’s Semantic Search and RAG. Improve accuracy, efficiency, and scalability for contracts, case law, and compliance.