Function Calling y Tool Use: Cómo las IAs Ejecutan Acciones Reales

¿Qué es Function Calling y Tool Use?

La capacidad de los modelos de lenguaje de gran escala (LLMs) para llamar funciones o usar herramientas representa un salto cualitativo en la interacción humano-IA. En lugar de solo generar texto, el modelo puede solicitar la ejecución de una función específica, recibir el resultado y continuar la conversación. Esto permite que la IA realice acciones reales: desde enviar un correo hasta consultar bases de datos o controlar dispositivos IoT.

¿Cómo funciona?

El proceso típico consta de cuatro pasos:

1. El usuario envía un prompt que implica una acción.
2. El modelo identifica que necesita ejecutar una herramienta y devuelve un objeto JSON con la función y los parámetros.
3. La aplicación ejecuta la función en un entorno controlado.
4. El resultado se envía de vuelta al modelo para que genere una respuesta final.

Ejemplo práctico con OpenAI

Supongamos que queremos que la IA pueda obtener el clima actual. Definimos la función:

{
  "name": "obtener_clima",
  "description": "Obtiene el clima actual para una ciudad dada.",
  "parameters": {
    "type": "object",
    "properties": {
      "ciudad": {
        "type": "string",
        "description": "Nombre de la ciudad"
      },
      "unidad": {
        "type": "string",
        "enum": ["celsius", "fahrenheit"]
      }
    },
    "required": ["ciudad"]
  }
}

Al preguntar "¿Qué clima hace en Madrid?", el modelo responde con:

{
  "function_call": {
    "name": "obtener_clima",
    "arguments": "{\"ciudad\": \"Madrid\", \"unidad\": \"celsius\"}"
  }
}

Nuestra aplicación ejecuta obtener_clima("Madrid", "celsius") y devuelve el resultado (ej. {"temperatura": 22, ...}). El modelo entonces genera una respuesta natural: "En Madrid ahora mismo hay 22°C."

Casos de uso reales

• Atención al cliente: consultar pedidos, cancelar suscripciones.
• Asistentes personales: crear eventos en calendario, enviar mensajes.
• Automatización: interactuar con APIs empresariales (CRM, ERP).
• Ciencia de datos: ejecutar consultas SQL y generar informes.

Mejores prácticas

1. Descripciones claras: Describe cada función y parámetro de forma precisa.
2. Validación: Siempre valida los argumentos antes de ejecutar.
3. Seguridad: No expongas funciones peligrosas. Usa autenticación y límites.
4. Manejo de errores: Si una función falla, inyecta el error en el contexto para que la IA lo maneje.

Implementación con LangChain

LangChain simplifica el tool use. Definimos una herramienta:

from langchain.tools import tool

@tool
def obtener_clima(ciudad: str) -> str:
    """Obtiene el clima de una ciudad."""
    # Llamada a API externa
    return f"La temperatura en {ciudad} es 22°C"

Luego creamos un agente que puede usar las herramientas:

from langchain.agents import initialize_agent, AgentType
from langchain.llms import OpenAI

llm = OpenAI(model_name="gpt-4")
agent = initialize_agent(
    [obtener_clima], llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True
)
agent.run("¿Cuál es el clima en Buenos Aires?")

Limitaciones y consideraciones

• Tokens: Las definiciones de funciones consumen tokens del contexto.
• Alucinaciones: El modelo puede inventar argumentos o funciones. Es crucial validar.
• Latencia: Cada llamada a herramienta añade un round-trip, incrementando el tiempo de respuesta.

El futuro

Con modelos como GPT-4o o Claude 3.5, las capacidades de tool use se vuelven más robustas. La combinación con multimodalidad (imágenes, audio) abre puertas a asistentes que pueden ver, escuchar y actuar.

Conclusión

Function calling y tool use transforman a los LLMs de simples generadores de texto en agentes autónomos capaces de ejecutar acciones reales. Para desarrolladores, es una herramienta poderosa para crear asistentes inteligentes que interactúan con el mundo digital.

Referencias

• OpenAI Function Calling Guide
• LangChain Tools Documentation