Functions

Function calling: definición y ejecución

El function calling permite que los modelos de OpenAI ejecuten funciones personalizadas durante una conversación, extendiendo significativamente sus capacidades más allá de la generación de texto. 

Esta funcionalidad transforma el modelo en un agente capaz de interactuar con sistemas externos, bases de datos, APIs y cualquier lógica de negocio que definamos.

Flujo de trabajo habitual con funciones:

1. Primera petición al LLM: pregunta del usuario + lista de tools
2. El LLM devuelve un mensaje especial que dice que quiere invocar una function
3. Nosotros invocamos esa tool y obtenemos el resultado y creamos un nuevo mensaje con ese resultado lo añadimos a la conversación
4. Hacemos nueva llamada al LLM con la pregunta inicial, la petición de function, el resultado de la function, y así ya el LLM tiene todo el contexto y nos da una respuesta final o se puede seguir repitiendo este proceso.

Problema: tenemos que gestionar manualmente esa "conversación" sin perder el historial de interacciones. Es decir, que hay que recolectar las peticiones a ejecutar functions y sus resultados y pasarlas de vuelta y repetir e iterar hasta que el proceso acabe.

Definición de funciones personalizadas

Para implementar function calling, primero debemos definir las funciones que queremos que el modelo pueda ejecutar. Estas funciones son código Python estándar que realizan tareas específicas:

import requests
import json

def obtener_clima(latitud, longitud):
    """Obtiene la temperatura actual de una ubicación específica"""
    url = f"https://api.open-meteo.com/v1/forecast"
    params = {
        "latitude": latitud,
        "longitude": longitud,
        "current": "temperature_2m,wind_speed_10m"
    }
    
    response = requests.get(url, params=params)
    data = response.json()
    return {
        "temperatura": data['current']['temperature_2m'],
        "velocidad_viento": data['current']['wind_speed_10m']
    }

def calcular_descuento(precio, porcentaje_descuento):
    """Calcula el precio final después de aplicar un descuento"""
    descuento = precio * (porcentaje_descuento / 100)
    precio_final = precio - descuento
    return {
        "precio_original": precio,
        "descuento_aplicado": descuento,
        "precio_final": precio_final
    }

Ejemplo:

Configuración del esquema de herramientas

El siguiente paso es describir estas funciones al modelo mediante un esquema JSON que especifica su nombre, descripción y parámetros esperados:

from openai import OpenAI

client = OpenAI()

tools = [
    {
        "type": "function",
        "name": "obtener_clima",
        "description": "Obtiene información meteorológica actual de una ubicación específica usando coordenadas geográficas.",
        "parameters": {
            "type": "object",
            "properties": {
                "latitud": {
                    "type": "number",
                    "description": "Latitud de la ubicación en grados decimales"
                },
                "longitud": {
                    "type": "number", 
                    "description": "Longitud de la ubicación en grados decimales"
                }
            },
            "required": ["latitud", "longitud"],
            "additionalProperties": False
        }
    },
    {
        "type": "function",
        "name": "calcular_descuento",
        "description": "Calcula el precio final de un producto después de aplicar un porcentaje de descuento.",
        "parameters": {
            "type": "object",
            "properties": {
                "precio": {
                    "type": "number",
                    "description": "Precio original del producto en euros"
                },
                "porcentaje_descuento": {
                    "type": "number",
                    "description": "Porcentaje de descuento a aplicar (0-100)"
                }
            },
            "required": ["precio", "porcentaje_descuento"],
            "additionalProperties": False
        }
    }
]

Ejemplo:

Ejecución de function calls

Una vez configuradas las herramientas, podemos realizar una consulta al modelo que active el function calling:

response = client.responses.create(
    model="gpt-4.1",
    input=[{
        "role": "user", 
        "content": "¿Cuál es la temperatura actual en Madrid? Las coordenadas son 40.4168, -3.7038"
    }],
    tools=tools
)

print("Respuesta del modelo:")
print(response.output)

Cuando el modelo determina que necesita ejecutar una función, la respuesta contendrá function calls en lugar de texto directo:

# Ejemplo de respuesta con function call
[
    {
        "type": "function_call",
        "id": "fc_weather_001",
        "call_id": "call_madrid_temp",
        "name": "obtener_clima",
        "arguments": "{\"latitud\": 40.4168, \"longitud\": -3.7038}"
    }
]

Ejemplo:

Procesamiento y ejecución de las llamadas

El siguiente paso es procesar estas llamadas y ejecutar las funciones correspondientes:

# Verificar si hay function calls en la respuesta
if response.output and isinstance(response.output, list):
    for tool_call in response.output:
        if tool_call.get("type") == "function_call":
            # Extraer información de la llamada
            function_name = tool_call["name"]
            arguments = json.loads(tool_call["arguments"])
            call_id = tool_call["call_id"]
            
            # Ejecutar la función correspondiente
            if function_name == "obtener_clima":
                resultado = obtener_clima(
                    arguments["latitud"], 
                    arguments["longitud"]
                )
            elif function_name == "calcular_descuento":
                resultado = calcular_descuento(
                    arguments["precio"],
                    arguments["porcentaje_descuento"]
                )
            
            print(f"Resultado de {function_name}: {resultado}")

Ejemplo:

Continuación de la conversación

Después de ejecutar las funciones, debemos enviar los resultados de vuelta al modelo para que pueda continuar la conversación:

# Preparar mensajes para la continuación
input_messages = [{
    "role": "user", 
    "content": "¿Cuál es la temperatura actual en Madrid? Las coordenadas son 40.4168, -3.7038"
}]

# Agregar la llamada a función del modelo
input_messages.append(tool_call)

# Agregar el resultado de la función
input_messages.append({
    "type": "function_call_output",
    "call_id": call_id,
    "output": json.dumps(resultado)
})

# Obtener respuesta final del modelo
response_final = client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools
)

print("Respuesta final:")
print(response_final.output_text)

Ejemplo:

Manejo de múltiples function calls

El modelo puede realizar múltiples llamadas a funciones en una sola respuesta. Por ejemplo, si preguntamos sobre el clima en varias ciudades:

response = client.responses.create(
    model="gpt-4.1",
    input=[{
        "role": "user",
        "content": "Compara el clima entre Madrid (40.4168, -3.7038) y Barcelona (41.3851, 2.1734)"
    }],
    tools=tools
)

# Procesar todas las llamadas a función
resultados = []
input_messages = [{"role": "user", "content": "Compara el clima entre Madrid y Barcelona"}]

for tool_call in response.output:
    if tool_call.get("type") == "function_call":
        args = json.loads(tool_call["arguments"])
        resultado = obtener_clima(args["latitud"], args["longitud"])
        
        # Agregar llamada y resultado a los mensajes
        input_messages.append(tool_call)
        input_messages.append({
            "type": "function_call_output",
            "call_id": tool_call["call_id"],
            "output": json.dumps(resultado)
        })

# Obtener comparación final
response_comparacion = client.responses.create(
    model="gpt-4.1",
    input=input_messages,
    tools=tools
)

Esta arquitectura permite crear aplicaciones conversacionales que pueden interactuar con sistemas externos de forma natural, manteniendo el contexto de la conversación mientras ejecutan operaciones complejas en tiempo real.