Ajuste fino para llamadas a funciones
En esta página
Actualización 2 de noviembre de 2026 — Disponibilidad del ajuste fino. El servicio de ajuste fino de autoservicio de OpenAI está siendo retirado gradualmente: desde el 7 de mayo de 2026, las organizaciones que nunca lo han utilizado ya no pueden crear trabajos; desde el 2 de julio, es necesario haber usado un modelo ajustado en los últimos 60 días; y a partir del 6 de enero de 2027, ningún cliente podrá lanzar nuevos trabajos. Los modelos ya entrenados seguirán siendo utilizables hasta que se retire su modelo base. Este curso sigue siendo útil para comprender y aprovechar un modelo existente; para nuevos proyectos, prioriza la ingeniería de prompts, RAG y las evaluaciones.
Por qué realizar un ajuste fino para llamadas a funciones
Las llamadas a funciones permiten que el modelo decida cuándo y cómo invocar funciones externas. En este contexto, el ajuste fino no consiste en retocar el estilo de escritura: se trata de robustecer un mecanismo de toma de decisiones. Un modelo entrenado con tus propias llamadas aprende primero a seleccionar la función correcta entre varias opciones disponibles. Si tu aplicación expone tanto la consulta de huecos como la creación de citas, la frase «Me gustaría ver qué hay libre el jueves» nunca debe desencadenar una reserva.
A continuación, aprende a extraer los parámetros correctos de la solicitud del usuario; es decir, a convertir formulaciones naturales en valores que se ajusten al esquema: «mañana a las 14:00» se convierte en una fecha y hora normalizadas. El mismo mecanismo enseña reflejos menos vistosos pero igualmente críticos. Saber cuándo NO llamar a una función evita la trampa de que el modelo active una herramienta ante un simple saludo. Y encadenar varias llamadas a funciones de forma lógica —listar disponibilidad y luego reservar el hueco elegido— requiere que el modelo haya visto secuencias completas durante el entrenamiento, no llamadas aisladas.
Formato de datos para llamadas a funciones
Los ejemplos de entrenamiento incluyen las definiciones de las funciones (herramientas) y las llamadas correspondientes. El mensaje del asistente ya no contiene texto, sino un array tool_calls; el resultado devuelto por tu sistema aparece en un mensaje con el rol tool, vinculado a la llamada mediante tool_call_id; el asistente vuelve a hablar entonces para formular la respuesta destinada al usuario. Es todo este bucle, no solo la llamada, lo que el modelo debe aprender a reproducir.
{
"messages": [
{
"role": "system",
"content": "Eres un asistente que ayuda a gestionar citas."
},
{
"role": "user",
"content": "Resérvame un hueco mañana a las 14:00 con el 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": "Tu cita con el Dr. Martin está confirmada para mañana a las 14:00. Referencia: APPT-42."
}
],
"tools": [
{
"type": "function",
"function": {
"name": "create_appointment",
"description": "Crea una nueva cita médica",
"parameters": {
"type": "object",
"properties": {
"date": {
"type": "string",
"description": "Fecha en formato AAAA-MM-DD"
},
"time": {
"type": "string",
"description": "Hora en formato HH:MM"
},
"practitioner": {
"type": "string",
"description": "Nombre del profesional"
}
},
"required": ["date", "time", "practitioner"]
}
}
},
{
"type": "function",
"function": {
"name": "list_slots",
"description": "Lista los huecos disponibles para un profesional",
"parameters": {
"type": "object",
"properties": {
"practitioner": {"type": "string"},
"date": {"type": "string"}
},
"required": ["practitioner"]
}
}
}
]
}
Casos de uso habituales
Selección de la función correcta
Entrena al modelo para distinguir qué función llamar según el contexto. En el ejemplo siguiente, la solicitud concerne a consultar la disponibilidad, no a hacer una reserva: el ejemplo refuerza que una pregunta abierta llama a list_slots, y nada más.
{
"messages": [
{"role": "user", "content": "¿Qué huecos hay libres el jueves con el Dr. Martin?"},
{
"role": "assistant",
"tool_calls": [
{
"id": "call_002",
"type": "function",
"function": {
"name": "list_slots",
"arguments": "{\"practitioner\": \"Dr. Martin\", \"date\": \"2026-04-04\"}"
}
}
]
}
],
"tools": ["... mismas herramientas que arriba ..."]
}
NO llamar a una función
Reserva parte de tu conjunto de datos para intercambios en los que el modelo no debe usar ninguna función. Un modelo entrenado exclusivamente con llamadas coge la costumbre de producir una en cada turno, incluso para un saludo o una pregunta general; un comportamiento que molesta a los usuarios y cuesta dinero a tu backend. El contraejemplo siguiente ocupa apenas unas líneas y elimina toda una clase de errores.
{
"messages": [
{"role": "user", "content": "Hola, ¿qué tal estás?"},
{
"role": "assistant",
"content": "¡Hola! Estoy bien, gracias. ¿En qué puedo ayudarte hoy con tus citas?"
}
],
"tools": ["... mismas herramientas ..."]
}
Extracción de parámetros complejos
Las solicitudes reales rara vez están estructuradas. «El próximo lunes por la mañana» y «el cardiólogo» deben convertirse en una fecha absoluta, un periodo de tiempo y una especialidad. Precisamente aquí es donde el modelo base suele fallar más a menudo, por lo que es donde el ajuste fino ofrece la ganancia más visible: multiplica este tipo de ejemplos en lugar de casos que ya están limpios.
{
"messages": [
{"role": "user", "content": "Cancela mi cita del próximo lunes por la mañana con el cardiólogo"},
{
"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 preparación de datos
La construcción del archivo sigue siendo mecánica: una función de ensamblaje, una definición de herramienta compartida por todos los ejemplos, una lista de casos y, a continuación, la escritura línea a línea en formato JSONL. Observa el uso de json.dumps para el campo arguments, que debe ser una cadena, no un objeto.
import json
def create_function_calling_example(
messages: list[dict],
tools: list[dict]
) -> dict:
"""Crea un ejemplo de entrenamiento para llamadas a funciones."""
return {
"messages": messages,
"tools": tools
}
# Definiciones de herramientas
tools = [
{
"type": "function",
"function": {
"name": "search_product",
"description": "Busca un producto en el catálogo",
"parameters": {
"type": "object",
"properties": {
"query": {"type": "string", "description": "Términos de búsqueda"},
"category": {"type": "string", "enum": ["electronics", "clothing", "home"]},
"max_price": {"type": "number", "description": "Precio máximo en euros"}
},
"required": ["query"]
}
}
}
]
# Ejemplos de entrenamiento
examples = [
create_function_calling_example(
messages=[
{"role": "user", "content": "Busco auriculares por menos de 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
)
]
# Guardar
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")
Lanzamiento del trabajo de ajuste fino
El trabajo se crea exactamente igual que para el ajuste fino conversacional: el formato enriquecido se reconoce a partir del contenido del archivo, sin parámetros adicionales.
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"
)
Buenas prácticas
El resultado depende, en primer lugar, de la diversidad de tu conjunto de datos. Cada función debe aparecer varias veces, las formulaciones de los usuarios deben variar para una misma intención y resulta beneficioso incluir casos ambiguos acompañados de la resolución que consideres correcta, sin olvidar las conversaciones normales que no llaman a ninguna función.
A continuación está el realismo de los parámetros. Los arguments deben coincidir exactamente con el esquema definido en tools, con valores plausibles en lugar de marcadores de posición como «xxx»; un modelo entrenado con valores falsos los producirá. Comprueba sistemáticamente que cada campo arguments sea JSON válido: falta una llave o una comilla y el ejemplo queda inservible.
Por último, está la cuestión de las proporciones. Para un conjunto de datos de 100 ejemplos que cubren 3 funciones, la distribución siguiente ofrece un equilibrio saludable entre cobertura funcional y prudencia.
| Tipo de ejemplo | Cantidad |
|---|---|
| Por función | 25-30 |
| Sin llamada a función | 10-15 |
| Llamadas encadenadas (varios pasos) | 5-10 |
Puntos clave
- El formato incluye
toolsademás demessages - Las llamadas a funciones usan
tool_callsen el mensaje del asistente - Incluye ejemplos en los que el modelo NO debe llamar a una función
- Varía las formulaciones para una misma intención
- Verifica que todos los
argumentssean JSON válidos y se ajusten al esquema