Function calling: a técnica que permite LLMs interagirem com APIs e bancos de dados

A capacidade dos modelos de linguagem de grande escala (LLMs) de gerar texto coerente e responder perguntas complexas revolucionou a forma como interagimos com a inteligência artificial. No entanto, esses modelos enfrentam uma limitação fundamental: são treinados com dados até uma data de corte específica e não podem, por si só, acessar informações em tempo real ou executar ações em sistemas externos.

É aqui que entra o function calling (chamada de funções), uma funcionalidade que está transformando os LLMs de simples geradores de texto em agentes capazes de interagir com o mundo real através de ferramentas externas e APIs.

O que é function calling e por que é importante?

Function calling é a capacidade de conectar LLMs de forma confiável a ferramentas externas, permitindo que eles executem ações além da simples geração de texto. Modelos como GPT-4 e GPT-3.5 foram especialmente ajustados para detectar quando uma função precisa ser chamada e então gerar JSON contendo os argumentos necessários para executar essa função.

Na prática, isso significa que você pode criar aplicações que:

• Respondem perguntas com dados em tempo real: Um chatbot pode consultar APIs de clima, cotações de ações ou status de pedidos para fornecer informações atualizadas

• Extraem e estruturam dados: Converter texto não estruturado em dados estruturados, como extrair nomes de pessoas de um artigo da Wikipedia

• Traduzem linguagem natural em código: Transformar uma pergunta como "mostre as vendas do último trimestre" em uma query SQL válida

• Interagem com sistemas externos: Realizar ações como enviar e-mails, criar tickets ou atualizar registros em bancos de dados

A importância do function calling está em permitir que LLMs se tornem verdadeiros agentes conversacionais, capazes de não apenas conversar, mas também executar tarefas práticas e acessar informações em tempo real.

Como funciona na prática: exemplo com GPT-4

Para entender melhor como o function calling opera, vamos analisar um exemplo prático. Imagine que um usuário pergunta:

"Qual é o clima em Londres?"

Um LLM sozinho não conseguiria responder a essa pergunta com informações atualizadas, já que foi treinado com dados até uma data específica. A solução é combinar o LLM com uma ferramenta externa através do function calling.

Passo 1: Definir as funções disponíveis

O primeiro passo é definir quais funções o modelo pode chamar. No caso do clima, definiríamos uma função como esta:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_weather",
            "description": "Get the current weather in a given location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "The city and state, e.g. San Francisco, CA",
                    },
                    "unit": {
                        "type": "string", 
                        "enum": ["celsius", "fahrenheit"]
                    },
                },
                "required": ["location"],
            },
        },   
    }
]

Passo 2: Enviar a mensagem do usuário junto com as funções

Em seguida, enviamos a pergunta do usuário junto com a definição das funções disponíveis para a API do modelo:

messages = [
    {
        "role": "user",
        "content": "What is the weather like in London?"
    }
]

response = get_completion(messages, tools=tools)

Passo 3: O modelo identifica a função e extrai os argumentos

O modelo analisa a pergunta e retorna um objeto JSON contendo a função que deve ser chamada e os argumentos necessários:

{
  "function": "get_current_weather",
  "arguments": {
    "location": "London",
    "unit": "celsius"
  }
}

É importante entender que, neste ponto, nenhuma função foi executada. O modelo apenas identificou qual função deveria ser chamada e extraiu os parâmetros necessários da linguagem natural do usuário.

Passo 4: Executar a função e retornar o resultado

Agora, sua aplicação executa a chamada real para a API de clima com os parâmetros fornecidos, obtém os dados e pode passar essas informações de volta ao modelo para gerar uma resposta final em linguagem natural para o usuário.

Casos de uso comprovados do function calling

A capacidade de function calling abre portas para diversos casos de uso práticos que vão muito além de chatbots simples:

1. Agentes conversacionais inteligentes

Chatbots que podem responder perguntas complexas acessando APIs externas ou bases de conhecimento. Por exemplo:

• Assistentes de atendimento ao cliente que consultam sistemas de pedidos

• Chatbots de suporte técnico que verificam status de serviços em tempo real

• Assistentes pessoais que gerenciam calendários e enviam lembretes

2. Extração e estruturação de dados

Transformar texto não estruturado em dados estruturados e realizar tarefas como:

• Reconhecimento de entidades nomeadas (NER)

• Análise de sentimento

• Extração de palavras-chave e metadados

• Conversão de documentos em formatos estruturados como JSON ou CSV

3. Integração com sistemas empresariais

Conectar LLMs a sistemas corporativos para automatizar processos:

• Consultar e atualizar registros em CRM

• Criar tickets em sistemas de suporte

• Gerar relatórios de bancos de dados

• Automatizar fluxos de trabalho entre diferentes plataformas

4. Resolução de problemas matemáticos

Definir funções customizadas para resolver problemas matemáticos complexos que exigem múltiplas etapas e diferentes tipos de cálculos avançados.

5. Conversão de linguagem natural em código

Transformar perguntas em linguagem natural em:

• Queries SQL válidas

• Chamadas de API formatadas corretamente

• Scripts de automação

• Comandos de linha de comando

Function calling com modelos open source

Embora o GPT-4 da OpenAI tenha popularizado o function calling, a capacidade não está limitada apenas aos modelos proprietários. Diversos modelos open source também estão sendo desenvolvidos com suporte nativo a function calling.

Projetos como LangChain e frameworks similares facilitam a implementação de function calling com diferentes modelos, permitindo que desenvolvedores criem soluções flexíveis e personalizadas sem depender exclusivamente de APIs comerciais.

Boas práticas ao implementar function calling

Para aproveitar ao máximo o function calling em suas aplicações, considere estas recomendações:

Desafios e considerações

Apesar de suas vantagens, o function calling apresenta alguns desafios que precisam ser considerados:

Segurança: É crucial implementar controles adequados sobre quais funções podem ser chamadas e com quais parâmetros, para evitar execução de código malicioso ou acesso não autorizado a sistemas.

Custo: Cada chamada ao modelo para determinar se uma função deve ser executada representa um custo adicional em tokens e tempo de processamento.

Confiabilidade: O modelo nem sempre identifica corretamente qual função chamar ou pode extrair parâmetros incorretos, exigindo validação cuidadosa.

Complexidade: Gerenciar múltiplas funções e suas dependências pode aumentar significativamente a complexidade da aplicação.

O futuro do function calling

A tendência é que o function calling se torne cada vez mais sofisticado e integrado aos LLMs. Já estamos vendo desenvolvimentos em:

• Chamadas de função encadeadas: Modelos que podem executar sequências complexas de chamadas de função

• Aprendizado de novas funções: Sistemas que podem aprender dinamicamente sobre novas ferramentas e APIs

• Execução autônoma: Agentes que podem não apenas identificar funções, mas também executá-las autonomamente com supervisão mínima

Conclusão

Function calling representa um avanço fundamental na forma como os LLMs podem ser utilizados em aplicações práticas. Ao permitir que modelos de linguagem interajam com APIs externas, bancos de dados e outras ferramentas, essa técnica transforma LLMs de geradores de texto em verdadeiros agentes capazes de executar tarefas complexas e fornecer informações em tempo real.

Para desenvolvedores e empresas que buscam criar aplicações de IA mais sofisticadas e úteis, dominar o function calling é essencial. A capacidade de conectar a inteligência dos LLMs com a vasta gama de ferramentas e dados disponíveis abre possibilidades praticamente ilimitadas para inovação.

Se você está começando a explorar o desenvolvimento com LLMs, comece experimentando casos de uso simples de function calling, como consultar APIs de clima ou converter linguagem natural em queries de banco de dados. À medida que você ganha experiência, poderá construir agentes cada vez mais sofisticados que realmente transformam a forma como usuários interagem com sistemas de informação.

Perguntas frequentes sobre function calling

O function calling executa as funções automaticamente?
Não. O modelo apenas identifica qual função deve ser chamada e extrai os parâmetros necessários. A execução real da função precisa ser implementada pelo desenvolvedor.

Quais modelos suportam function calling?
GPT-4, GPT-3.5-turbo e diversos modelos open source já suportam function calling. A lista continua crescendo à medida que a técnica se populariza.

É possível usar múltiplas funções em uma única requisição?
Sim. Você pode definir várias funções e o modelo escolherá a mais apropriada com base no contexto da pergunta do usuário.

Function calling consome mais tokens?
Sim. As definições de função e os argumentos retornados consomem tokens adicionais, o que pode impactar o custo das chamadas à API.

Como garantir que o modelo escolha a função correta?
Forneça descrições claras e detalhadas de cada função, incluindo quando ela deve ser usada e quais parâmetros são necessários.