Ajuste fino para chamada de funções
Nesta página
Atualização de 2 de novembro de 2026 — Disponibilidade do ajuste fino. O serviço de ajuste fino self-service da OpenAI está a ser descontinuado: desde 7 de maio de 2026, as organizações que nunca o utilizaram já não podem criar tarefas; desde 2 de julho, é necessário ter utilizado um modelo ajustado nos últimos 60 dias; e a partir de 6 de janeiro de 2027, nenhum cliente poderá lançar novas tarefas. Os modelos já treinados permanecem utilizáveis até que o seu modelo base seja desativado. Este curso mantém a sua utilidade para compreender e aproveitar um modelo existente; para novos projetos, priorize a engenharia de prompts, a RAG e as avaliações.
Por que fazer ajuste fino para chamada de funções
A chamada de funções permite ao modelo decidir quando e como invocar funções externas. Neste contexto, o ajuste fino não serve para afinar o estilo de escrita: serve para robustecer um mecanismo de tomada de decisões. Um modelo treinado com as suas próprias chamadas aprende primeiro a selecionar a função correta entre várias opções disponíveis. Se a sua aplicação expõe tanto a consulta de horários como a criação de marcações, a frase “gostaria de ver o que está livre na quinta-feira” nunca deve acionar uma reserva.
Em seguida, o modelo aprende a extrair os parâmetros corretos do pedido do utilizador, ou seja, a converter formulações naturais em valores que respeitem o esquema: “amanhã às 14h” torna-se uma data e hora normalizadas. O mesmo mecanismo ensina reflexos menos vistosos, mas igualmente críticos. Saber quando NÃO chamar uma função evita a armadilha de um modelo que aciona uma ferramenta perante um simples “olá”. E encadear várias chamadas de função de forma lógica — listar disponibilidades e, depois, reservar o horário escolhido — exige que o modelo tenha visto sequências completas durante o treino, e não chamadas isoladas.
Formato de dados para chamada de funções
Os exemplos de treino incluem as definições das funções (ferramentas) e as chamadas correspondentes. A mensagem do assistente deixa de conter texto para passar a incluir um array tool_calls; o resultado devolvido pelo seu sistema surge numa mensagem com a função tool, ligada à chamada através do tool_call_id; o assistente fala novamente para formular a resposta destinada ao utilizador. É todo este ciclo, e não apenas a chamada, que o modelo deve aprender a reproduzir.
{
"messages": [
{
"role": "system",
"content": "You are an assistant that helps manage appointments."
},
{
"role": "user",
"content": "Book me a slot tomorrow at 2 PM with Dr. Martin."
},
{
"role": "assistant",
"tool_calls": [
{
"id": "call_001",
"type": "function",
"function": {
"name": "create_appointment",
"arguments": "{\"date\": \"2026-04-03\", \"time\": \"14:00\", \"practitioner\": \"Dr. Martin\"}"
}
}
]
},
{
"role": "tool",
"tool_call_id": "call_001",
"content": "{\"status\": \"confirmed\", \"id\": \"appt_42\"}"
},
{
"role": "assistant",
"content": "Your appointment with Dr. Martin is confirmed for tomorrow at 2 PM. Reference: APPT-42."
}
],
"tools": [
{
"type": "function",
"function": {
"name": "create_appointment",
"description": "Creates a new medical appointment",
"parameters": {
"type": "object",
"properties": {
"date": {
"type": "string",
"description": "Date in YYYY-MM-DD format"
},
"time": {
"type": "string",
"description": "Time in HH:MM format"
},
"practitioner": {
"type": "string",
"description": "Name of the practitioner"
}
},
"required": ["date", "time", "practitioner"]
}
}
},
{
"type": "function",
"function": {
"name": "list_slots",
"description": "Lists available slots for a practitioner",
"parameters": {
"type": "object",
"properties": {
"practitioner": {"type": "string"},
"date": {"type": "string"}
},
"required": ["practitioner"]
}
}
}
]
}
Casos de uso comuns
Selecionar a função correta
Treine o modelo para distinguir qual a função a chamar consoante o contexto. No exemplo abaixo, o pedido refere-se à verificação de disponibilidades, e não à realização de uma reserva: o exemplo reforça que uma pergunta aberta deve acionar list_slots, e nada mais.
{
"messages": [
{"role": "user", "content": "What slots are free on Thursday with Dr. Martin?"},
{
"role": "assistant",
"tool_calls": [
{
"id": "call_002",
"type": "function",
"function": {
"name": "list_slots",
"arguments": "{\"practitioner\": \"Dr. Martin\", \"date\": \"2026-04-04\"}"
}
}
]
}
],
"tools": ["... same tools as above ..."]
}
NÃO chamar uma função
Reserve parte do seu conjunto de dados para trocas em que o modelo não deve utilizar nenhuma função. Um modelo treinado exclusivamente com chamadas adquire o hábito de produzir uma a cada passo, mesmo para uma saudação ou uma pergunta geral — um comportamento que irrita os utilizadores e onera o seu backend. O contraexemplo abaixo ocupa apenas algumas linhas e elimina toda uma classe de erros.
{
"messages": [
{"role": "user", "content": "Hello, how are you?"},
{
"role": "assistant",
"content": "Hello! I'm doing well, thanks. How can I help you with your appointments today?"
}
],
"tools": ["... same tools ..."]
}
Extrair parâmetros complexos
Os pedidos reais raramente são estruturados. “Na próxima segunda-feira de manhã” e “o cardiologista” devem transformar-se numa data absoluta, num período de tempo e numa especialidade. É precisamente aqui que o modelo base mais falha, pelo que é onde o ajuste fino oferece o ganho mais visível: multiplique este tipo de exemplos em vez de casos que já estejam limpos.
{
"messages": [
{"role": "user", "content": "Cancel my appointment next Monday morning with the cardiologist"},
{
"role": "assistant",
"tool_calls": [
{
"id": "call_003",
"type": "function",
"function": {
"name": "cancel_appointment",
"arguments": "{\"date\": \"2026-04-06\", \"period\": \"morning\", \"specialty\": \"cardiology\"}"
}
}
]
}
],
"tools": ["..."]
}
Script de preparação de dados
A construção do ficheiro permanece mecânica: uma função de montagem, uma definição de ferramenta partilhada por todos os exemplos, uma lista de casos e, depois, a escrita linha a linha no formato JSONL. Note o uso de json.dumps para o campo arguments, que deve ser uma string e não um objeto.
import json
def create_function_calling_example(
messages: list[dict],
tools: list[dict]
) -> dict:
"""Creates a training example for function calling."""
return {
"messages": messages,
"tools": tools
}
# Tool definitions
tools = [
{
"type": "function",
"function": {
"name": "search_product",
"description": "Searches for a product in the catalog",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "Search terms"},
"category": {"type": "string", "enum": ["electronics", "clothing", "home"]},
"max_price": {"type": "number", "description": "Maximum price in euros"}
},
"required": ["query"]
}
}
}
]
# Training examples
examples = [
create_function_calling_example(
messages=[
{"role": "user", "content": "I'm looking for headphones under 100 euros"},
{
"role": "assistant",
"tool_calls": [{
"id": "call_1",
"type": "function",
"function": {
"name": "search_product",
"arguments": json.dumps({
"query": "headphones",
"category": "electronics",
"max_price": 100
})
}
}]
}
],
tools=tools
)
]
# Save
with open("function_calling_train.jsonl", "w", encoding="utf-8") as f:
for ex in examples:
f.write(json.dumps(ex, ensure_ascii=False) + "\n")
Lançamento da tarefa de ajuste fino
A tarefa é criada exatamente como para o ajuste fino conversacional: o formato enriquecido é reconhecido a partir do conteúdo do ficheiro, sem parâmetros adicionais.
from openai import OpenAI
client = OpenAI()
file = client.files.create(
file=open("function_calling_train.jsonl", "rb"),
purpose="fine-tune"
)
job = client.fine_tuning.jobs.create(
training_file=file.id,
model="gpt-5.6-luna",
suffix="function-calling-v1"
)
Boas práticas
O resultado depende, em primeiro lugar, da diversidade do seu conjunto de dados. Cada função deve aparecer várias vezes, as formulações dos utilizadores devem variar para a mesma intenção e beneficia de incluir casos ambíguos acompanhados da resolução que considera correta, sem esquecer as conversas normais que não acionam nenhuma função.
Em seguida, vem o realismo dos parâmetros. Os arguments devem corresponder exatamente ao esquema definido em tools, com valores plausíveis em vez de marcadores como “xxx” — um modelo treinado com valores falsos irá produzi-los. Teste sistematicamente se cada campo arguments é um JSON válido: falta de uma chave ou de uma aspa basta para tornar o exemplo inutilizável.
Por fim, coloca-se a questão das proporções. Para um conjunto de dados de 100 exemplos que abrange 3 funções, a distribuição abaixo oferece um equilíbrio saudável entre cobertura funcional e moderação.
| Tipo de exemplo | Quantidade |
|---|---|
| Por função | 25-30 |
| Sem chamada de função | 10-15 |
| Chamadas encadeadas (várias etapas) | 5-10 |
Pontos-chave
- O formato inclui
toolspara além demessages - As chamadas de função utilizam
tool_callsna mensagem do assistente - Inclua exemplos em que o modelo NÃO deve chamar uma função
- Varie as formulações para a mesma intenção
- Verifique se todos os
argumentssão JSON válidos e conformes ao esquema