Introducción a las Tools

Qué son las Tools

Una tool es una pieza de software que un LLM puede invocar desde tu aplicación para realizar una acción concreta (por ejemplo, consultar una API interna, buscar en la web o leer un fichero) y usar el resultado en su respuesta.

La tool no forma parte del modelo en sí, sino que es una capacidad adicional que conectas al modelo para que pueda hacer cosas en el mundo real más allá de limitarse a generar texto.

Podemos imaginar un pequeño diagrama conceptual donde el usuario habla con el modelo, el modelo decide si necesita llamar a una tool, y tu backend ejecuta esa tool y devuelve el resultado al modelo para que construya la respuesta final.

De esta forma, el modelo aporta el razonamiento en lenguaje natural, mientras que las tools aportan el acceso a datos y la ejecución de acciones sobre tu sistema.

• 1. Cuándo tiene sentido usar tools:

Cuando el modelo necesita información que no está en sus pesos, o debe realizar acciones sobre tus sistemas (por ejemplo, crear un pedido, consultar un stock o lanzar un script), las tools son el mecanismo recomendado por OpenAI para conectar el LLM con tu lógica de negocio.

• 2. Relación con tu backend:

La tool suele ser una función de tu backend (o un servicio externo) que ya existe o que puedes desarrollar, y el modelo solo tiene que decidir cuándo llamarla y con qué argumentos, sin tener que conocer los detalles de implementación.

• 3. Diferencia con un simple prompt:

Con solo prompt, el modelo solo puede imaginar respuestas; con tools, el modelo puede consultar fuentes reales y ejecutar lógica determinista, lo que mejora la precisión, la trazabilidad y el control de lo que ocurre en tu sistema.

Tools en OpenAI

OpenAI organiza el uso de tools alrededor del parámetro tools que envías en cada petición a la API, y que indica qué herramientas tiene disponibles el modelo en esa conversación.

Dentro de ese parámetro se suelen distinguir varias categorías conceptuales de tools que utilizaremos a lo largo del curso.

• 1. Built-in tools de OpenAI:

Son tools mantenidas por OpenAI e integradas directamente en la plataforma, como web_search, file_search o code_interpreter, y permiten al modelo hacer cosas como buscar en la web, trabajar con ficheros o ejecutar código Python sin que tengas que implementar esa funcionalidad desde cero.

• 2. Function tools (tools de función):

Son tools personalizadas definidas por ti con JSON Schema, donde describes el nombre de la función, su propósito y los parámetros de entrada, permitiendo que el modelo genere argumentos estructurados para llamar a tu lógica de negocio de forma controlada y tipada.

• 3. Custom tools externas:

Son tools que encapsulan acceso a servicios externos (por ejemplo, una API interna, una base de datos o un shell local) y que puedes exponer al modelo como herramientas de alto nivel, gestionando desde tu código los detalles de seguridad, autenticación y orquestación.

En código Python, el uso básico de tools con el cliente oficial de OpenAI podría verse así:

from openai import OpenAI
client = OpenAI()

tools = [
    # Built-in web_search
    {"type": "web_search"},
    # Function tool personalizada
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Devuelve el tiempo actual para una ciudad",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nombre de la ciudad"},
                },
                "required": ["city"],
            },
        },
    },
]

response = client.responses.create(
    model="gpt-5.1",
    input="¿Qué tiempo hace hoy en Madrid?",
    tools=tools,
)

En este ejemplo el modelo todavía no ejecuta ninguna tool, solo sabe que dispone de web_search y de la función get_weather, y en la respuesta nos indicará si quiere usar alguna de ellas mediante una tool call.

Las tools que veremos en el resto del módulo (web search, function tools, local shell, code interpreter, MCP, tool loop) se construyen siempre sobre esta misma idea: el modelo decide qué herramienta usar y nuestro código se encarga de ejecutarla de forma segura.

Mensajes de tool

Cuando activas tools, la salida del modelo deja de ser solo texto plano y pasa a incluir mensajes estructurados que describen las invocaciones de herramientas y sus argumentos, lo que permite a tu backend saber exactamente qué tiene que ejecutar.

En este contexto hablaremos de tool calls (peticiones del modelo para usar una herramienta) y de tool call outputs (resultados que tú le devuelves al modelo después de ejecutar la herramienta).

tool calls

Una tool call es un mensaje especial que obtenemos del LLM en el que nos indica que necesita invocar una tool concreta, ya sea una tool built-in o personalizada.

El modelo ha leído el prompt, ha razonado sobre lo que le pedimos y decide que tiene que invocar una tool, pero no la ejecuta directamente, sino que nos devuelve una estructura indicando qué herramienta quiere usar y con qué argumentos.

Ejemplo, llamamos al LLM:

response = client.responses.create(
    model="gpt-5.1",
    input=input_messages,
    tools=tools
)

Y el LLM nos responde con una salida que incluye una o varias tool calls:

[
    ResponseFunctionToolCall(
        arguments='{"latitude": 43.5321, "longitude": -5.6773}',
        call_id='call_yYpL33aoXTilg6k9jtV605WY',
        name='get_weather',
        type='function_call',
        id='fc_68333fc3aaf08191824d11daf3373e72060c8d9e6e9cec73',
        status='completed',
    )
]

El modelo puede querer realizar una o varias tool calls, por lo que deberemos iterar sobre esa lista para ejecutar todas las herramientas solicitadas desde nuestro código Python.

Un patrón típico consiste en recorrer la salida y procesar solo los elementos que son tool calls:

import json

for item in response.output:
    if isinstance(item, ResponseFunctionToolCall):
        args = json.loads(item.arguments)
        # Aquí ejecutaremos la tool real con esos argumentos

De esta forma mantenemos separado el razonamiento del modelo de la ejecución real de nuestras herramientas, lo que facilita depurar, registrar y auditar lo que está ocurriendo.

tool call ouputs

Una vez que el modelo nos ha enviado una o varias tool calls, es responsabilidad de nuestra aplicación ejecutar esas tools y construir las correspondientes tool call outputs con los resultados.

Cada tool, al ejecutarse, genera un output (por ejemplo, un JSON con el tiempo en una ciudad, una lista de productos o el resultado de una consulta SQL) que debemos empaquetar en el formato que espera la API para poder devolvérselo al modelo.

Por ejemplo, podríamos hacer algo así:

response = client.responses.create(
    model="gpt-5.1-nano",
    input=input_messages,
    tools=tools
)
function_call = response.output[0]
args = json.loads(function_call.arguments)

result = get_weather(args["latitude"], args["longitude"])
function_call_output = {
    "type": "function_call_output",
    "call_id": function_call.call_id,
    "output": str(result),
}

Tanto function_call como function_call_output los agregaremos al input de la siguiente petición al modelo para que vea el prompt original, la llamada a la tool, el resultado de la tool y, con toda esa información, pueda generar la respuesta final o seguir solicitando nuevas tool calls si lo considera necesario.

Bucle de herramientas

Un LLM puede decidir invocar una o más herramientas, obtener información parcial y, a partir de ese nuevo contexto, decidir seguir invocando herramientas adicionales antes de producir una respuesta final al usuario.

Por ello, en la práctica se construye un bucle de tool calling en el que tu backend alterna entre llamar al modelo y ejecutar tools, hasta que el modelo ya no solicite más herramientas y devuelva solo texto para el usuario.

Si lo describimos como diagrama textual, el flujo típico sería: usuario → modelo → tool call → ejecución de tool → tool call output → modelo → (posibles nuevas tool calls) → respuesta final al usuario.

Este patrón de bucle es la base de muchos frameworks de agentes de IA como LangChain-LanGraph o CrewAI, que automatizan parte de esta orquestación.