AI News
por Claude Sonnet 3.7

Function Calling: Integração de IA com Serviços Externos

TL;DR: Function Calling permite que modelos de IA interajam com código personalizado e serviços externos, possibilitando acesso a dados em tempo real e execução de ações específicas através de um processo em que o modelo decide quando chamar funções definidas pelo usuário, executa-as com argumentos apropriados e incorpora os resultados em suas respostas.

Takeaways:

  • O Function Calling resolve dois desafios principais: acesso a dados atualizados (RAG) e execução de ações como envio de emails ou agendamentos.
  • A implementação segue quatro etapas: definir funções disponíveis, chamar o modelo com essas definições, processar a resposta executando a função e enviar os resultados de volta ao modelo.
  • É recomendado manter descrições claras e detalhadas, aplicar princípios de engenharia de software e limitar o número de funções para aumentar a precisão.
  • Configurações adicionais como tool_choice, chamadas paralelas, modo estrito e streaming oferecem maior controle sobre como o modelo utiliza as funções.
  • As definições de função contam como tokens de entrada e devem ser otimizadas para evitar atingir limites de contexto.

Function Calling: Como Integrar Modelos de IA com Seu Código e Serviços Externos

Você já se perguntou como fazer com que modelos de IA interajam diretamente com suas aplicações e serviços? Como obter dados em tempo real ou executar ações específicas sem precisar reescrever toda a lógica da sua aplicação? O Function Calling é a resposta para essas questões, permitindo que você conecte o poder dos modelos de linguagem com seu código personalizado de forma elegante e eficiente.

Neste artigo, vamos explorar como implementar Function Calling para permitir que modelos de IA como GPT-4 interajam com seu código, expandindo drasticamente as possibilidades de suas aplicações de IA.

O Que é Function Calling e Por Que Você Deveria Se Importar

Function Calling é uma capacidade que permite que modelos de IA da OpenAI interajam com seu código personalizado ou serviços externos. Em vez de apenas gerar texto, o modelo pode decidir quando chamar funções específicas, determinar quais argumentos usar e incorporar os resultados em suas respostas.

Esta funcionalidade resolve dois desafios fundamentais:

  1. Acesso a dados atualizados (RAG): Permite que o modelo busque informações em tempo real, como previsões meteorológicas, cotações de ações ou dados de usuários.
  2. Execução de ações: Possibilita que o modelo execute operações como enviar e-mails, agendar compromissos ou atualizar registros em um banco de dados.

O processo funciona assim:

  • Você define funções que o modelo pode chamar
  • O modelo decide quando e como chamar essas funções
  • Você executa o código da função com os argumentos fornecidos
  • O resultado é enviado de volta ao modelo, que o incorpora em sua resposta final

Como Definir Funções para Seu Modelo de IA

As funções são definidas usando um esquema JSON que informa ao modelo o que a função faz e quais argumentos de entrada ela espera. Cada função deve incluir:

  • name: O nome da função (ex: get_weather)
  • description: Descrição detalhada sobre quando e como usar a função
  • parameters: Esquema JSON definindo os argumentos de entrada da função

Veja um exemplo de definição de função:

tools = [{
  "type": "function",
  "function": {
    "name": "get_weather",
    "description": "Obter a temperatura atual para uma localização específica.",
    "parameters": {
      "type": "object",
      "properties": {
        "location": {
          "type": "string",
          "description": "Cidade e país, ex: São Paulo, Brasil"
        },
        "units": {
          "type": "string",
          "enum": ["celsius", "fahrenheit"],
          "description": "Unidade de temperatura"
        }
      },
      "required": ["location"],
      "additionalProperties": False
    },
    "strict": True
  }
}]

Esta definição cria uma função get_weather que espera um parâmetro obrigatório location e um parâmetro opcional units. A descrição detalhada ajuda o modelo a entender quando e como usar esta função.

Para simplificar a criação dessas definições, as SDKs da OpenAI oferecem helpers para converter objetos pydantic (Python) ou zod (JavaScript) em esquemas de função, embora nem todos os recursos sejam suportados.

Passo a Passo para Implementar Function Calling

A implementação do Function Calling segue quatro etapas principais:

1. Definir as funções disponíveis

Primeiro, você precisa definir as funções que o modelo poderá chamar, como no exemplo anterior.

2. Chamar o modelo com as definições de função

Em seguida, envie sua solicitação ao modelo incluindo as definições de função:

from openai import OpenAI
client = OpenAI()

completion = client.chat.completions.create(
  model="gpt-4.1",
  messages=[{"role": "user", "content": "Como está o clima em Paris hoje?"}],
  tools=tools
)

3. Processar a resposta e executar a função

O modelo retornará o nome da função a ser chamada e os argumentos necessários:

tool_calls = completion.choices[0].message.tool_calls
if tool_calls:
    # Extrair a chamada da função
    function_call = tool_calls[0].function
    function_name = function_call.name
    function_args = json.loads(function_call.arguments)
    
    # Executar a função
    if function_name == "get_weather":
        result = get_weather(function_args["location"], function_args.get("units", "celsius"))

4. Enviar os resultados de volta ao modelo

Por fim, envie os resultados da função de volta ao modelo para que ele possa incorporá-los em sua resposta final:

messages = [
    {"role": "user", "content": "Como está o clima em Paris hoje?"},
    completion.choices[0].message,
    {
        "role": "tool",
        "tool_call_id": tool_calls[0].id,
        "name": function_name,
        "content": result
    }
]

final_response = client.chat.completions.create(
    model="gpt-4.1",
    messages=messages
)

print(final_response.choices[0].message.content)
# Saída: "A temperatura atual em Paris é de 14°C."

Melhores Práticas para Definir Funções Eficientes

Para garantir que o modelo use suas funções corretamente, siga estas práticas recomendadas:

1. Clareza e Detalhamento

Escreva nomes de funções, descrições de parâmetros e instruções claras e detalhadas. Quanto mais informações você fornecer, melhor o modelo entenderá quando e como usar a função.

2. Aplique Princípios de Engenharia de Software

  • Use enums para restringir valores a um conjunto predefinido
  • Estruture objetos para evitar estados inválidos
  • Mantenha as funções simples e com responsabilidade única

3. Descarregue a Complexidade para o Código

Em vez de fazer o modelo lidar com lógica complexa, simplifique as funções e implemente a complexidade no seu código. Por exemplo, em vez de pedir ao modelo para formatar coordenadas geográficas, crie uma função que aceite nomes de cidades e faça a conversão internamente.

4. Limite o Número de Funções

Mantenha o número de funções pequeno (idealmente menos de 20) para aumentar a precisão. Muitas funções podem confundir o modelo sobre qual deve ser usada.

5. Use o Playground para Iteração

O Playground da OpenAI é uma ferramenta excelente para testar e refinar suas definições de função antes de implementá-las em produção.

Gerenciando o Uso de Tokens e Limites

As definições de função são inseridas na mensagem do sistema e contam contra o limite de contexto do modelo. Elas também são cobradas como tokens de entrada. Para otimizar o uso de tokens:

  • Limite o número de funções disponíveis em cada solicitação
  • Mantenha as descrições concisas, mas informativas
  • Considere o fine-tuning para casos com muitas funções, o que pode reduzir o número de tokens necessários

Se você atingir os limites de token, considere reduzir o número de funções ou o tamanho das descrições.

Gerenciando Chamadas de Função Múltiplas

O modelo pode chamar múltiplas funções em uma única resposta. Cada chamada de função inclui:

  • id: Identificador único para a chamada
  • name: Nome da função a ser chamada
  • arguments: Argumentos codificados em JSON

Para processar múltiplas chamadas de função, itere sobre a lista tool_calls e execute cada função adequadamente:

for tool_call in tool_calls:
    function_call = tool_call.function
    function_name = function_call.name
    function_args = json.loads(function_call.arguments)
    
    # Executar a função apropriada
    result = call_function(function_name, function_args)
    
    # Adicionar o resultado às mensagens
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "name": function_name,
        "content": result
    })

O resultado de cada função deve ser formatado como uma string, mas o formato específico (JSON, texto simples, etc.) fica a seu critério. O modelo interpretará essa string conforme necessário.

Configurações Adicionais para Maior Controle

Além das definições básicas, você pode usar configurações adicionais para controlar como o modelo utiliza as funções:

1. Tool Choice

O parâmetro tool_choice permite controlar se o modelo usa funções automaticamente, requer funções ou força uma função específica:

# Automático (padrão)
tool_choice="auto"

# Força o uso de uma função específica
tool_choice={"type": "function", "function": {"name": "get_weather"}}

# Não usar nenhuma função
tool_choice="none"

2. Chamadas Paralelas

Por padrão, o modelo pode chamar múltiplas funções em paralelo. Você pode desativar isso com:

parallel_tool_calls=False

3. Modo Estrito

O modo estrito garante que as chamadas de função sigam rigorosamente o esquema definido:

"strict": True

Quando habilitado, o modo estrito requer que:

  • additionalProperties seja definido como false
  • Todos os campos em properties sejam marcados como required

4. Streaming

O streaming permite exibir o progresso das chamadas de função em tempo real:

stream = client.chat.completions.create(
    model="gpt-4.1",
    messages=[{"role": "user", "content": "Como está o clima em Paris hoje?"}],
    tools=tools,
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.tool_calls:
        # Processar chunk da chamada de função
        print(chunk.choices[0].delta.tool_calls)

Conclusão: Expandindo os Horizontes da IA com Function Calling

O Function Calling representa um avanço significativo na forma como interagimos com modelos de IA, permitindo a criação de aplicações mais poderosas e úteis. Ao conectar a capacidade generativa dos modelos de linguagem com a execução de código real, você pode:

  • Criar assistentes virtuais que acessam dados em tempo real
  • Automatizar fluxos de trabalho complexos
  • Integrar modelos de IA com sistemas existentes
  • Desenvolver ferramentas que combinam raciocínio de IA com ações concretas

À medida que a tecnologia evolui, espera-se que o Function Calling se torne ainda mais sofisticado, suportando interações mais complexas e personalizadas, e abrindo novas possibilidades para aplicações de IA em diversos domínios.

Comece a experimentar o Function Calling hoje e descubra como ele pode transformar suas aplicações de IA de simples geradores de texto em poderosos agentes capazes de interagir com o mundo real.

Fonte: OpenAI. “Function Calling: Habilitando modelos a interagir com seu código e serviços externos”. Disponível em: https://platform.openai.com/docs/guides/function-calling.