Ir al contenido principal
Español— Elegir un idioma
Menú

Llamada a funciones: conecta la IA con tus sistemas

Lección 10 de 22 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Llamada a funciones: conecta la IA con tus sistemas
  2. El flujo completo, paso a paso
  3. Permitir que el modelo elija entre varias herramientas
  4. El bucle del agente
  5. Blindar los argumentos con el modo estricto
  6. Puntos clave

Llamada a funciones: conecta la IA con tus sistemas

La llamada a funciones permite que el modelo invoque funciones que tú defines. Ten presente una regla fundamental, ya que todo lo demás se deriva de ella: el modelo no las ejecuta. Te indica qué función llamar y con qué argumentos; tu código realiza la ejecución y devuelve el resultado. Tu base de datos, credenciales y lógica de negocio nunca salen de tu infraestructura.

El flujo completo, paso a paso

El intercambio se produce en cuatro fases:

  1. Declaras las funciones disponibles junto con sus parámetros
  2. El modelo analiza la solicitud y decide llamar a una función
  3. Tu código ejecuta la función y obtiene el resultado
  4. Envías el resultado de vuelta al modelo para que pueda formular su respuesta

La declaración merece un cuidado especial: la description de la función y la descripción de cada parámetro son la única documentación de la que dispone el modelo para tomar su decisión. Las descripciones vagas provocan llamadas aproximadas. Observa también cómo cerrar el bucle: el resultado se devuelve con el call_id que recibiste, el cual actúa como acuse de recibo y permite a la API emparejar la respuesta con la solicitud.

from openai import OpenAI
import json

client = OpenAI()

# Paso 1: Declarar las funciones disponibles
tools = [{
    "type": "function",
    "name": "get_meteo",
    "description": "Obtener el tiempo actual para una ciudad",
    "parameters": {
        "type": "object",
        "properties": {
            "ville": {
                "type": "string",
                "description": "El nombre de la ciudad"
            },
            "unite": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Unidad de temperatura"
            }
        },
        "required": ["ville"]
    }
}]

# Paso 2: El modelo decide llamar a la función
response = client.responses.create(
    model="gpt-5.6-terra",
    input="¿Qué tiempo hace en Marsella?",
    tools=tools
)

# Paso 3: Ejecutar la función
for item in response.output:
    if item.type == "function_call":
        print(f"Función: {item.name}")
        print(f"Argumentos: {item.arguments}")
        args = json.loads(item.arguments)

        # Tu implementación real
        resultat_meteo = {"temperature": 22, "condition": "sunny"}

        # Paso 4: Enviar el resultado de vuelta al modelo
        final = client.responses.create(
            model="gpt-5.6-terra",
            input=[
                {"role": "user", "content": "¿Qué tiempo hace en Marsella?"},
                {
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": json.dumps(resultat_meteo)
                }
            ],
            tools=tools
        )
        print(f"Respuesta: {final.output_text}")

# Resultado:
# Función: get_meteo
# Argumentos: {"ville": "Marseille"}
# Respuesta: Actualmente hay 22 C en Marsella con tiempo soleado.

Permitir que el modelo elija entre varias herramientas

El valor real aparece cuando expones un catálogo completo de capacidades. En un asistente de comercio electrónico, declararías la búsqueda de productos, la verificación de stock y la realización de pedidos, dejando que el modelo arbitre. Ante la pregunta «¿Está disponible el portátil gaming XPS?», no realizará una búsqueda, sino que consultará el stock directamente: son las descripciones de tus funciones, y no una regla codificada, las que han impulsado esa elección.

tools = [
    {
        "type": "function",
        "name": "rechercher_produit",
        "description": "Buscar un producto en el catálogo",
        "parameters": {
            "type": "object",
            "properties": {
                "requête": {"type": "string", "description": "Términos de búsqueda"},
                "categorie": {"type": "string", "description": "Categoría (opcional)"}
            },
            "required": ["requête"]
        }
    },
    {
        "type": "function",
        "name": "verifier_stock",
        "description": "Comprobar la disponibilidad del producto",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string", "description": "ID del producto"}
            },
            "required": ["produit_id"]
        }
    },
    {
        "type": "function",
        "name": "passer_commande",
        "description": "Realizar un pedido de un producto",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string"},
                "quantite": {"type": "integer", "description": "Número de unidades"}
            },
            "required": ["produit_id", "quantite"]
        }
    }
]

# El modelo elige automáticamente la función correcta
response = client.responses.create(
    model="gpt-5.6-terra",
    input="¿Está disponible el portátil gaming XPS?",
    tools=tools
)

for item in response.output:
    if item.type == "function_call":
        print(f"Función elegida: {item.name}")
        print(f"Argumentos: {item.arguments}")

# Resultado: Función elegida: verifier_stock
# Argumentos: {"produit_id": "xps-gaming"}

Una única solicitud también puede desencadenar varias llamadas simultáneamente. Comparar el tiempo en dos ciudades genera dos llamadas independientes: por tanto, tu código debe iterar sobre response.output y gestionar todos los elementos function_call, no solo el primero. Esta es también una oportunidad para ejecutar estas llamadas en paralelo y reducir la latencia a la mitad.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compara el tiempo entre París y Lyon.",
    tools=[{
        "type": "function",
        "name": "get_meteo",
        "description": "Obtener el tiempo para una ciudad",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"]
        }
    }]
)

# El modelo realiza dos llamadas en paralelo
function_calls = [item for item in response.output if item.type == "function_call"]
print(f"Número de llamadas: {len(function_calls)}")
for call in function_calls:
    args = json.loads(call.arguments)
    print(f"  - get_meteo({args['ville']})")

# Resultado:
# Número de llamadas: 2
#   - get_meteo(Paris)
#   - get_meteo(Lyon)

El bucle del agente

Un único ida y vuelta rara vez es suficiente: el resultado de una función suele llevar al modelo a llamar a otra. Por ello, envuelves el intercambio en un bucle que se ejecuta mientras la respuesta contenga llamadas a funciones y se detiene en cuanto no las contiene, señal de que el modelo ha formulado su respuesta final. Este es el esqueleto de todo agente, y lo verás bajo diversas formas en todos los marcos de agentes.

def executer_fonction(nom: str, arguments: str) -> str:
    """Ejecutar una función y devolver el resultado."""
    args = json.loads(arguments)

    if nom == "get_meteo":
        # Simulación — sustituye por tu API real
        return json.dumps({"temp": 18, "condition": "cloudy"})
    elif nom == "get_heure":
        return json.dumps({"heure": "14:30", "timezone": "CET"})

    return json.dumps({"error": "Función desconocida"})

def agent_loop(question: str, tools: list) -> str:
    """Bucle del agente: llamar a funciones hasta la respuesta final."""
    input_messages = [{"role": "user", "content": question}]

    while True:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=input_messages,
            tools=tools
        )

        # Comprobar llamadas a funciones
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Sin llamadas a funciones = respuesta final
            return response.output_text

        # Ejecutar cada función y añadir los resultados
        for call in function_calls:
            resultat = executer_fonction(call.name, call.arguments)
            input_messages.append({
                "type": "function_call_output",
                "call_id": call.call_id,
                "output": resultat
            })

# Uso
reponse = agent_loop("¿Qué tiempo hace en París?", tools)
print(reponse)

Una advertencia sobre este patrón: el bucle while True carece de salvaguardas. En producción, añade un contador máximo de iteraciones; de lo contrario, un modelo que solicite indefinidamente la misma herramienta agotará tu presupuesto sin llegar nunca a una conclusión.

Blindar los argumentos con el modo estricto

El modo estricto aplica a los parámetros de la función la misma garantía que la Salida Estructurada aplica a las respuestas: los argumentos se adhieren estrictamente al esquema declarado. Para una función que crea un usuario, esto evita que recibas una edad como cadena de texto o un campo adicional que tu código no esperaba.

tools = [{
    "type": "function",
    "name": "creer_utilisateur",
    "description": "Crear un nuevo usuario",
    "strict": True,
    "parameters": {
        "type": "object",
        "properties": {
            "nom": {"type": "string"},
            "email": {"type": "string"},
            "age": {"type": "integer"}
        },
        "required": ["nom", "email", "age"],
        "additionalProperties": False
    }
}]

Puntos clave

  • La llamada a funciones conecta el modelo con tus sistemas sin exponer tus datos
  • El modelo decide qué función llamar; tu código la ejecuta
  • Devuelve el resultado usando function_call_output y el call_id
  • El modelo puede llamar a varias funciones en paralelo
  • Usa un bucle de agente para conversaciones de varios turnos que impliquen funciones
  • Activa strict: True para garantizar el cumplimiento de los argumentos