Herramientas y Function Calling en OpenAI

La capacidad de los modelos de lenguaje para interactuar con herramientas externas representa uno de los avances más significativos en el desarrollo de aplicaciones de inteligencia artificial. Mientras que los modelos por sí solos pueden generar texto y procesar información, la integración con function calling les permite ejecutar acciones específicas, consultar bases de datos, realizar cálculos complejos y conectarse con APIs externas.

Fundamentos del Function Calling

El function calling permite que los modelos de OpenAI identifiquen cuándo necesitan utilizar una función específica para responder a una consulta del usuario. En lugar de intentar generar una respuesta basada únicamente en su conocimiento interno, el modelo puede solicitar la ejecución de funciones definidas por el desarrollador.

Este mecanismo funciona mediante un proceso de dos pasos: primero, el modelo analiza la consulta del usuario y determina si necesita utilizar alguna herramienta disponible; segundo, si es necesario, genera una llamada estructurada a la función apropiada con los parámetros correctos.

from openai import OpenAI

client = OpenAI()

# Definición de una herramienta simple
tools = [
    {
        "type": "function",
        "function": {
            "name": "calcular_precio_total",
            "description": "Calcula el precio total incluyendo impuestos",
            "parameters": {
                "type": "object",
                "properties": {
                    "precio_base": {
                        "type": "number",
                        "description": "Precio antes de impuestos"
                    },
                    "tasa_impuesto": {
                        "type": "number",
                        "description": "Tasa de impuesto como decimal (ej: 0.21 para 21%)"
                    }
                },
                "required": ["precio_base", "tasa_impuesto"]
            }
        }
    }
]

Estructura de las Herramientas

Las herramientas en OpenAI se definen mediante un esquema JSON que especifica el nombre de la función, su descripción y los parámetros que acepta. Esta estructura permite al modelo comprender qué funciones están disponibles y cómo utilizarlas correctamente.

La descripción de la función es crucial, ya que el modelo la utiliza para determinar cuándo y cómo usar cada herramienta. Una descripción clara y específica mejora significativamente la precisión del function calling.

# Herramienta para consultar información meteorológica
weather_tool = {
    "type": "function",
    "function": {
        "name": "obtener_clima",
        "description": "Obtiene información meteorológica actual para una ciudad específica",
        "parameters": {
            "type": "object",
            "properties": {
                "ciudad": {
                    "type": "string",
                    "description": "Nombre de la ciudad"
                },
                "unidades": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unidades de temperatura"
                }
            },
            "required": ["ciudad"]
        }
    }
}

Implementación con la API Responses

La API Responses moderna de OpenAI simplifica el manejo de herramientas proporcionando una interfaz más intuitiva para el function calling. Esta API detecta automáticamente cuándo el modelo necesita utilizar una herramienta y estructura la respuesta de manera coherente.

from openai import OpenAI

client = OpenAI()

def calcular_precio_total(precio_base, tasa_impuesto=0.21):
    """Función que será llamada por el modelo"""
    return precio_base * (1 + tasa_impuesto)

# Configuración de la herramienta
tools = [
    {
        "type": "function",
        "function": {
            "name": "calcular_precio_total",
            "description": "Calcula el precio total con impuestos incluidos",
            "parameters": {
                "type": "object",
                "properties": {
                    "precio_base": {"type": "number"},
                    "tasa_impuesto": {"type": "number", "default": 0.21}
                },
                "required": ["precio_base"]
            }
        }
    }
]

response = client.responses.create(
    model="gpt-4.1",
    input="¿Cuál es el precio final de un producto que cuesta 100 euros con IVA?",
    tools=tools
)

Manejo de Respuestas con Herramientas

Cuando el modelo determina que necesita utilizar una herramienta, la respuesta incluye información sobre la función solicitada y los parámetros necesarios. El desarrollador debe implementar la lógica para ejecutar estas funciones y proporcionar los resultados de vuelta al modelo.

# Procesamiento de la respuesta con function calling
if hasattr(response, 'tool_calls') and response.tool_calls:
    for tool_call in response.tool_calls:
        function_name = tool_call.function.name
        function_args = json.loads(tool_call.function.arguments)
        
        # Ejecutar la función correspondiente
        if function_name == "calcular_precio_total":
            resultado = calcular_precio_total(**function_args)
            print(f"Precio total calculado: {resultado}")

Herramientas Múltiples y Encadenamiento

Los modelos pueden utilizar múltiples herramientas en una sola conversación, permitiendo flujos de trabajo complejos que requieren varios pasos. Esta capacidad es especialmente útil para aplicaciones que necesitan combinar diferentes fuentes de datos o realizar operaciones secuenciales.

# Definición de múltiples herramientas
herramientas_comerciales = [
    {
        "type": "function",
        "function": {
            "name": "consultar_inventario",
            "description": "Verifica la disponibilidad de un producto",
            "parameters": {
                "type": "object",
                "properties": {
                    "codigo_producto": {"type": "string"},
                    "cantidad": {"type": "integer"}
                },
                "required": ["codigo_producto"]
            }
        }
    },
    {
        "type": "function", 
        "function": {
            "name": "calcular_descuento",
            "description": "Calcula descuentos aplicables según cantidad",
            "parameters": {
                "type": "object",
                "properties": {
                    "cantidad": {"type": "integer"},
                    "precio_unitario": {"type": "number"}
                },
                "required": ["cantidad", "precio_unitario"]
            }
        }
    }
]

Validación y Manejo de Errores

La implementación robusta de function calling requiere validación de parámetros y manejo adecuado de errores. Los modelos pueden ocasionalmente generar llamadas a funciones con parámetros incorrectos o solicitar funciones que no existen.

def ejecutar_herramienta_segura(nombre_funcion, parametros):
    """Ejecuta una herramienta con validación de errores"""
    try:
        # Validar que la función existe
        if nombre_funcion not in funciones_disponibles:
            return {"error": f"Función {nombre_funcion} no disponible"}
        
        # Validar parámetros requeridos
        funcion = funciones_disponibles[nombre_funcion]
        resultado = funcion(**parametros)
        
        return {"resultado": resultado, "exito": True}
        
    except TypeError as e:
        return {"error": f"Parámetros incorrectos: {str(e)}", "exito": False}
    except Exception as e:
        return {"error": f"Error en ejecución: {str(e)}", "exito": False}

Optimización del Rendimiento

El uso eficiente de herramientas requiere consideraciones de rendimiento y costo. Cada llamada a función puede implicar latencia adicional, especialmente si las herramientas realizan operaciones complejas o consultas a servicios externos.

Las descripciones precisas de las funciones ayudan al modelo a tomar decisiones más acertadas sobre cuándo utilizar cada herramienta, reduciendo llamadas innecesarias y mejorando la experiencia del usuario.

# Herramienta optimizada con caché
import functools
from datetime import datetime, timedelta

@functools.lru_cache(maxsize=100)
def consultar_datos_cached(parametro, timestamp):
    """Función con caché para evitar consultas repetidas"""
    # Lógica de consulta costosa
    return realizar_consulta_externa(parametro)

def consultar_datos_con_cache(parametro):
    """Wrapper que incluye timestamp para invalidar caché"""
    timestamp = datetime.now().replace(second=0, microsecond=0)
    return consultar_datos_cached(parametro, timestamp)