¿Qué es Function Calling (Llamada a Funciones) en LLMs?

Function calling (llamada a funciones) es la capacidad de un LLM para solicitar la ejecución de una función externa durante una conversación. El modelo no ejecuta el código — tú lo haces. El modelo devuelve un objeto estructurado (normalmente JSON) que describe qué función llamar y con qué argumentos. Tu aplicación ejecuta la función, obtiene el resultado y se lo devuelve al modelo para que genere la respuesta final. Esto convierte al LLM de un generador de texto estático a un orquestador que decide qué herramientas usar para responder con datos actualizados.

Tip Pro: Function calling no significa que el modelo pueda ejecutar código en tu servidor. El modelo solo sugiere llamadas. Tú decides si ejecutarlas. Esto mantiene el control de seguridad en tu lado.

¿Qué es?

Function calling es un mecanismo que aparece en los modelos más modernos (GPT-4, Claude 3.5, Gemini, Mistral, Llama 3) y funciona así:

1. Defines funciones con su nombre, descripción y esquema de parámetros (usualmente JSON Schema).
2. Incluyes esas definiciones en la API call al LLM.
3. El modelo analiza el prompt y, si corresponde, devuelve un tool_call con la función y los argumentos que quiere invocar.
4. Tu código ejecuta la función y devuelve el resultado al modelo.
5. El modelo genera la respuesta final en lenguaje natural usando ese resultado.

El LLM no ejecuta nada. Solo reconoce cuándo necesita información externa y estructura la petición para que tú puedas obtenerla.

Nota: No confundas function calling con "el modelo es capaz de llamar APIs". El modelo solo genera JSON. Todo lo demás —autenticación, HTTP requests, lógica de negocio— lo haces tú.

Modelo mental

Piensa en function calling como un asistente que sabe pedir ayuda. El asistente (LLM) reconoce cuando algo está fuera de su alcance —datos en tiempo real, cuentas de usuario, un cálculo exacto— y en vez de inventar una respuesta, llena un formulario (JSON) pidiendo la información que necesita.

Usuario: "¿Cuánto vale mi portafolio?"
LLM:   [devuelve tool_call → get_portfolio_value(user_id: "123")]
App:   [ejecuta la función, obtiene $45,230]
App → LLM: "El valor actual es $45,230"
LLM:   "Tu portafolio vale $45,230 al cierre de hoy."

Sin function calling, el modelo inventaría un número o diría "no tengo acceso a esa información". Con function calling, el modelo sabe exactamente qué pedir y en qué formato.

¿Cómo se usa?

La mayoría de los proveedores de LLM ofrecen function calling. El ejemplo más común es con la API de OpenAI.

1. Definir la función

Le pasas al modelo la definición de las funciones disponibles usando JSON Schema:

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtiene el clima actual para una ubicación",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "Ciudad y país, ej: Bogotá, Colombia"
                    },
                    "units": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"]
                    }
                },
                "required": ["location"]
            }
        }
    }
]

Advertencia: Las descripciones importan. Un description pobre hará que el modelo no invoque la función cuando debería, o la invoque con argumentos incorrectos. Sé explícito.

2. Hacer la llamada a la API

Incluyes tools en la request junto con el mensaje del usuario:

from openai import OpenAI
 
client = OpenAI()
 
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "¿Qué clima hace en Bogotá?"}],
    tools=tools,
    tool_choice="auto"  # el modelo decide si llama o no
)

3. Procesar el tool_call

Si el modelo decide llamar una función, la respuesta incluye tool_calls:

message = response.choices[0].message
 
if message.tool_calls:
    for tool_call in message.tool_calls:
        if tool_call.function.name == "get_weather":
            args = json.loads(tool_call.function.arguments)
            # args → {"location": "Bogotá, Colombia", "units": "celsius"}
            result = get_weather(args["location"], args["units"])
            # Envías el resultado de vuelta al modelo

4. Devolver el resultado al modelo

Agregas el resultado como un mensaje con role: "tool":

messages.append(message)
messages.append({
    "role": "tool",
    "tool_call_id": tool_call.id,
    "content": json.dumps(result)
})
 
second_response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools
)

El modelo ahora genera su respuesta final en lenguaje natural basada en el resultado real de la función.

Tip Pro: Usa tool_choice: "required" si quieres forzar al modelo a llamar una función en cada turno. Útil cuando construyes asistentes que siempre deben consultar una base de datos antes de responder.

Ejemplo completo mínimo

import json
from openai import OpenAI
 
client = OpenAI()
 
def get_weather(location, units="celsius"):
    # En producción esto llamaría una API real
    return {"temperature": 19, "condition": "nublado", "units": units}
 
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtiene el clima actual para una ubicación",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string"},
                    "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["location"]
            }
        }
    }
]
 
messages = [{"role": "user", "content": "¿Qué clima hace en Bogotá?"}]
 
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools
)
 
message = response.choices[0].message
messages.append(message)
 
if message.tool_calls:
    for tc in message.tool_calls:
        args = json.loads(tc.function.arguments)
        result = get_weather(**args)
        messages.append({
            "role": "tool",
            "tool_call_id": tc.id,
            "content": json.dumps(result)
        })
 
    final = client.chat.completions.create(
        model="gpt-4o", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)

¿Cuándo usarlo / cuándo no?

Tip Pro: Si solo necesitas que el modelo devuelva JSON estructurado (sin ejecutar nada), usa response_format: { "type": "json_object" } sin function calling. Es más simple, más barato y más rápido.

Historia y evolución