Fine-tuning per il function calling
In questa pagina
Aggiornamento 2 novembre 2026 — Disponibilità del fine-tuning. Il servizio di fine-tuning self-service di OpenAI sta venendo dismesso: dal 7 maggio 2026, le organizzazioni che non lo hanno mai utilizzato non possono più creare job; dal 2 luglio, devi aver usato un modello fine-tuned negli ultimi 60 giorni; e a partire dal 6 gennaio 2027, nessun cliente potrà avviare nuovi job. I modelli già addestrati rimangono utilizzabili fino al ritiro del loro modello base. Questo corso rimane utile per comprendere e sfruttare un modello esistente; per nuovi progetti, dai priorità al prompt engineering, al RAG e alle valutazioni.
Perché fare fine-tuning per il function calling
Il function calling permette al modello di decidere quando e come invocare funzioni esterne. In questo contesto, il fine-tuning non serve a modificare lo stile di scrittura: rafforza un meccanismo decisionale. Un modello addestrato sulle tue chiamate impara innanzitutto a scegliere la funzione corretta tra diverse opzioni disponibili. Se la tua app espone sia la ricerca di slot disponibili sia la creazione di appuntamenti, la frase “Vorrei vedere cosa è libero giovedì” non deve mai attivare una prenotazione.
Impara poi a estrarre i parametri corretti dalla richiesta dell’utente, ovvero a convertire formulazioni naturali in valori conformi allo schema: “domani alle 14:00” diventa una data e un’ora normalizzate. Lo stesso meccanismo insegna riflessi meno appariscenti ma altrettanto critici. Sapere quando NON chiamare una funzione evita l’errore di un modello che attiva uno strumento per un semplice saluto. E concatenare logicamente più chiamate di funzione — elencare la disponibilità, poi prenotare lo slot scelto — richiede che il modello abbia visto sequenze complete durante l’addestramento, non chiamate isolate.
Formato dati per il function calling
Gli esempi di addestramento includono le definizioni delle funzioni (strumenti) e le chiamate corrispondenti. Il messaggio dell’assistente non contiene più testo, ma un array tool_calls; il risultato restituito dal tuo sistema appare in un messaggio con ruolo tool, collegato alla chiamata tramite tool_call_id; l’assistente parla poi di nuovo per formulare la risposta destinata all’utente. È l’intero ciclo, non solo la chiamata, che il modello deve imparare a riprodurre.
{
"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"]
}
}
}
]
}
Casi d’uso comuni
Selezionare la funzione corretta
Addestra il modello a distinguere quale funzione chiamare in base al contesto. Nell’esempio seguente, la richiesta riguarda la verifica della disponibilità, non la prenotazione: l’esempio rafforza il fatto che una domanda aperta chiami list_slots, e nient’altro.
{
"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 ..."]
}
NON chiamare una funzione
Riserva parte del tuo dataset per scambi in cui il modello non deve usare alcuna funzione. Un modello addestrato esclusivamente su chiamate prende l’abitudine di produrne una a ogni passo, anche per un saluto o una domanda generale: un comportamento che infastidisce gli utenti e appesantisce il tuo backend. Il contro-esempio seguente richiede poche righe ed elimina un’intera classe di errori.
{
"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 ..."]
}
Estrarre parametri complessi
Le richieste reali sono raramente strutturate. “Lunedì prossimo mattina” e “il cardiologo” devono diventare una data assoluta, un intervallo di tempo e una specialità. È proprio qui che il modello base inciampa più spesso, quindi è dove il fine-tuning offre il guadagno più visibile: moltiplica questo tipo di esempi piuttosto che casi già puliti.
{
"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 di preparazione dei dati
La costruzione del file rimane meccanica: una funzione di assemblaggio, una definizione di strumento condivisa da tutti gli esempi, una lista di casi, poi la scrittura riga per riga in formato JSONL. Nota l’uso di json.dumps per il campo arguments, che deve essere una stringa, non un oggetto.
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")
Avvio del job di fine-tuning
Il job viene creato esattamente come per il fine-tuning conversazionale: il formato arricchito viene riconosciuto dal contenuto del file, senza parametri aggiuntivi.
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"
)
Migliori pratiche
Il risultato dipende innanzitutto dalla diversità del tuo dataset. Ogni funzione deve apparire più volte, le formulazioni degli utenti devono variare per la stessa intenzione e ti conviene includere casi ambigui accompagnati dalla risoluzione che ritieni corretta, senza dimenticare le conversazioni normali che non chiamano alcuna funzione.
Segue poi il realismo dei parametri. Gli arguments devono corrispondere esattamente allo schema definito in tools, con valori plausibili piuttosto che segnaposto come “xxx”: un modello addestrato su valori falsi li produrrà. Verifica sistematicamente che ogni campo arguments sia JSON valido: una parentesi graffa o una virgoletta mancante bastano a rendere l’esempio inutilizzabile.
Infine, c’è la questione delle proporzioni. Per un dataset di 100 esempi che coprono 3 funzioni, la distribuzione seguente offre un equilibrio sano tra copertura funzionale e moderazione.
| Tipo di esempio | Quantità |
|---|---|
| Per funzione | 25-30 |
| Nessuna chiamata di funzione | 10-15 |
| Chiamate concatenate (multi-step) | 5-10 |
Punti chiave
- Il formato include
toolsoltre aimessages - Le chiamate di funzione usano
tool_callsnel messaggio dell’assistente - Includi esempi in cui il modello NON deve chiamare una funzione
- Varia le formulazioni per la stessa intenzione
- Verifica che tutti gli
argumentssiano JSON validi e conformi allo schema