Function calling y herramientas: conectar modelos con acciones

Por sí solo, un modelo de lenguaje solo puede producir texto. No puede consultar el tiempo de hoy, interrogar tu base de datos, enviar un correo ni hacer aritmética de forma fiable. El function calling —también llamado uso de herramientas— es el mecanismo que cierra esa brecha, permitiendo que un modelo vaya más allá del texto hacia acciones reales y datos en vivo. Es el cimiento de casi todos los agentes de IA y la capacidad más importante para construir aplicaciones que hacen cosas en lugar de solo hablar de ellas. La mecánica, sin embargo, sorprende, porque el modelo nunca ejecuta realmente tu código. Este explicativo recorre lo que ocurre de verdad, y dónde falla.

La brecha que llena el function calling

Un modelo de lenguaje es, en esencia, un generador de texto. Eso lo hace excelente en lenguaje y poco fiable en todo lo que requiere información actual o efecto en el mundo real. Pídele el tiempo y producirá un texto que suena plausible pero que no está conectado a ningún termómetro. Pídele aritmética precisa y puede que adivine. Pídele que recupere el pedido de un cliente y no tiene forma de mirar.

El function calling resuelve esto dándole al modelo acceso a herramientas —funciones que tú defines y controlas— que sí pueden hacer estas cosas: llamar a una API, ejecutar un cálculo, consultar una base de datos, disparar una acción. El trabajo del modelo es decidir cuándo hace falta una herramienta y con qué entradas. El trabajo de tu código es ejecutarla de verdad. Esa división del trabajo es la idea entera, y tenerla clara es la clave para entender todo lo que sigue.

Qué ocurre en realidad (la parte que sorprende)

El malentendido más común es que el modelo ejecuta funciones. No lo hace. El modelo solo produce texto, incluyendo, cuando corresponde, una petición estructurada que dice que quiere ejecutar una herramienta. Tu aplicación es la que ejecuta. El flujo es así:

1. Describes al modelo las herramientas disponibles: sus nombres, qué hacen y las entradas que esperan.
2. El usuario pregunta algo. El modelo decide si responder bien requiere una herramienta.
3. Si es así, el modelo devuelve un mensaje estructurado: "llama a esta herramienta con estos argumentos". No ejecuta nada.
4. Tu código analiza esa petición, ejecuta la función real y obtiene un resultado.
5. Envías el resultado de vuelta al modelo.
6. El modelo usa ese resultado para componer su respuesta final.

El modelo es quien decide; tu aplicación son las manos. Mantener clara esa frontera es esencial, porque todo lo relativo a seguridad y fiabilidad depende de recordar que tú controlas la ejecución, no el modelo.

Describir las herramientas para que el modelo las use bien

Una herramienta es solo tan útil como su descripción, porque el modelo decide si usarla y cómo basándose enteramente en lo que le dices. Una herramienta necesita un nombre claro, una explicación de qué hace y cuándo usarla, y una especificación de sus entradas: qué argumentos toma, sus tipos y cuáles son obligatorios.

La calidad de estas descripciones determina directamente el comportamiento. Una herramienta descrita de forma vaga se usa en los momentos equivocados o con argumentos mal formados; una descrita con claridad se usa adecuadamente. Ayuda pensar en la descripción como instrucciones para un asistente capaz que solo puede ver lo que escribiste: si una persona no pudiera deducir de tu descripción cuándo usar la herramienta, el modelo tampoco. La documentación de Anthropic y OpenAI especifica el formato exacto para declarar herramientas, y seguirlo con precisión es lo que permite al modelo devolver llamadas bien formadas sobre las que tu código puede actuar.

Por qué esto desbloquea los agentes

El function calling es el bloque de construcción bajo toda la idea de un agente de IA. Un agente es, a grandes rasgos, un bucle: al modelo se le da un objetivo y un conjunto de herramientas, decide una acción, tu código la ejecuta, el resultado retroalimenta y el modelo decide la siguiente acción, repitiendo hasta que la tarea esté hecha.

Cada vuelta de ese bucle es una llamada de función. El modelo revisa sus herramientas, elige una, tú la ejecutas, y el resultado moldea la siguiente decisión. Así es como un sistema puede descomponer una petición vaga como "encuentra el vuelo más barato y resérvalo" en una secuencia de usos concretos de herramientas —buscar, comparar, reservar—, ninguno de los cuales realiza el modelo en sí, todos los cuales orquesta. Una vez que ves que un agente es function calling en bucle, el comportamiento aparentemente mágico de los sistemas agénticos se vuelve mucho menos misterioso: es el mismo flujo de seis pasos, ejecutado repetidamente hacia un objetivo.

Dónde falla

El function calling introduce modos de fallo que la generación de solo texto no tiene, y anticiparlos es la mayor parte de construir un sistema robusto.

• El modelo elige la herramienta o los argumentos equivocados. Decide basándose en tus descripciones, lo que significa que descripciones pobres producen decisiones pobres. Herramientas vagas o solapadas son una causa frecuente.
• Las herramientas fallan. La API está caída, la consulta da error, la entrada no es válida. Tu código debe manejar los fallos de herramienta y decidir qué reportar de vuelta al modelo, que a menudo puede recuperarse con elegancia si se le dice qué salió mal.
• El modelo inventa argumentos. Si se le pide llamar a una herramienta sin toda la información que necesita, un modelo puede rellenar con valores plausibles pero erróneos. Valida los argumentos antes de actuar sobre ellos; nunca confíes en ellos a ciegas.
• Los bucles se descontrolan. En un escenario de agente, un modelo puede quedar atascado llamando a herramientas sin converger. Los límites sobre el número de pasos evitan que un agente confundido corra para siempre.

No son casos límite exóticos: son la textura normal de construir con herramientas, y un sistema en producción tiene que manejar cada uno de ellos.

La frontera de seguridad que no puedes saltarte

Como las herramientas ejecutan acciones reales, el function calling es también una superficie de seguridad, y es el único lugar donde el descuido sale más caro. El principio rector es que la petición del modelo de llamar a una herramienta es entrada no confiable. Está moldeada por el prompt del usuario, y un usuario puede intentar dirigir al modelo a llamar herramientas de formas que no pretendías.

Eso significa que nunca le das al modelo una herramienta que no dejarías disparar a un usuario no confiable con argumentos arbitrarios. Valida cada argumento antes de actuar. Acota lo que cada herramienta puede hacer tan estrechamente como permita la tarea. Aplica la misma autorización y los mismos límites de tasa que aplicarías a cualquier otra vía hacia tus sistemas. Una herramienta que borra registros o gasta dinero exige mucha más cautela que una que lee un feed de datos público. El modelo decide; tu código debe verificar antes de actuar.

En resumen

El function calling es lo que convierte un generador de texto en un sistema que actúa: permite que el modelo decida cuál de tus herramientas usar y con qué entradas, mientras tu código hace la ejecución real. Esa frontera es el punto entero: el modelo es quien decide, tu aplicación son las manos, y tú mantienes el control de la ejecución. Describe tus herramientas con claridad suficiente para que un asistente capaz pudiera usarlas solo con la descripción, maneja las inevitables elecciones erróneas y los fallos de herramienta, y trata cada llamada de herramienta como entrada no confiable que validas antes de actuar. Acierta en eso y el function calling se convierte en el cimiento de los agentes y de cualquier aplicación que haga trabajo real, construido sobre un sencillo flujo de seis pasos que puedes razonar de principio a fin.