---
title: "Function calling con modelos abiertos: esquemas y código"
description: "Function calling en modelos abiertos compatibles con OpenAI: esquemas, llamadas en paralelo, los cinco fallos típicos y un bucle Python que valida y reintenta."
url: https://broadrouter.com/es/blog/tool-calling-open-models/
lang: es
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traducido del inglés con ayuda de IA. [Lea el original en inglés](https://broadrouter.com/blog/tool-calling-open-models/) (actualizado el 2026-11-16).

# Tool calling con modelos abiertos: esquemas, paralelismo, reintentos

Por el equipo de BroadNet Inference · 4 min de lectura · Publicado 2026-11-14 · Actualizado 2026-11-16

Los modelos abiertos en APIs compatibles con OpenAI usan el mismo formato tools y tool\_calls que OpenAI. Mantenga los esquemas pequeños y planos, analice los argumentos como cadenas JSON, valídelos antes de ejecutar nada y devuelva los errores al modelo como resultados de herramienta para que reintente. Limite los pasos. En BroadNet, GLM 5.3 y Qwen3.8 27B listan soporte de herramientas.

## Puntos clave

-   El formato es el mismo que el de OpenAI: una lista tools en la petición, tool\_calls en la respuesta y luego un mensaje con rol tool por cada tool\_call\_id.
-   Los argumentos llegan como una cadena JSON. La documentación de vLLM advierte que, cuando extrae las llamadas del texto en bruto, estas "may occasionally be malformed or violate the function's parameter schema" (Traducción: «pueden estar a veces mal formadas o incumplir el esquema de parámetros de la función»).
-   Valide cada llamada, devuelva los errores como resultados de herramienta y limite los reintentos y el total de pasos.
-   Menos herramientas y más planas funcionan mejor. OpenAI sugiere menos de 20 funciones al inicio de un turno.
-   En BroadNet Inference, use GLM 5.3 o Qwen3.8 27B para tool calling; pruebe DeepSeek V4.1 Flash antes de depender de él.

**En esta página**

1.  ¿Cómo funciona el tool calling en una API compatible con OpenAI?
2.  ¿Cómo escribir los esquemas de las herramientas?
3.  ¿Y las llamadas a herramientas en paralelo?
4.  ¿Por qué fallan las llamadas a herramientas?
5.  Un bucle de herramientas que valida y reintenta
6.  ¿Qué modelos de BroadNet admiten tool calling?
7.  Dónde encaja BroadNet Inference

El [tool calling](https://broadrouter.com/es/glossary/tool-calling/) (llamada a herramientas) es lo que convierte un modelo en un agente. Con modelos abiertos en una [API compatible con OpenAI](https://broadrouter.com/es/glossary/openai-compatible-api/), el formato de la petición es el mismo que usaría con OpenAI. Lo que cambia es la frecuencia con que algo sale mal y lo que hace el servidor para evitarlo. Este artículo cubre el formato, cómo escribir esquemas que los modelos abiertos manejen bien, las llamadas en paralelo, los cinco fallos que realmente verá y un bucle de Python que los resiste.

## ¿Cómo funciona el tool calling en una API compatible con OpenAI?

1.  Usted envía `messages` más una lista `tools`. Cada herramienta tiene un nombre, una descripción y un JSON Schema para sus argumentos.
2.  El modelo responde con `finish_reason: "tool_calls"` y una lista `tool_calls`. Cada entrada tiene un `id`, un nombre de función y `arguments` como una **cadena JSON**.
3.  Su código ejecuta cada llamada y añade un mensaje `role: "tool"` por llamada, con el `tool_call_id` correspondiente.
4.  Vuelve a llamar a la API. El modelo responde o pide más herramientas.

El modelo nunca ejecuta nada. Su código decide qué se ejecuta.

## ¿Cómo escribir los esquemas de las herramientas?

Los modelos abiertos siguen con más fiabilidad los esquemas sencillos. Estas reglas salen de la guía de OpenAI y de lo que suele romperse:

-   **Nombre las herramientas por la acción**, como `read_file` o `search_code`, y diga en la descripción _cuándo_ usar cada una.
-   **Mantenga la lista corta.** La guía de OpenAI presenta menos de 20 funciones al inicio de un turno como una sugerencia flexible. Además, cada esquema se envía en cada llamada; vea [el presupuesto de tokens del agente](https://broadrouter.com/es/blog/agent-token-budget/).
-   **Prefiera argumentos planos.** Cadenas, números, booleanos y enums. Evite el anidamiento profundo y los objetos de forma libre.
-   **Use enums** para opciones fijas, de modo que el modelo no pueda inventarse un valor. El [generador de JSON Schema](https://broadrouter.com/tools/json-schema-generator/) convierte un objeto de argumentos de ejemplo en un esquema plano que puede pegar en `parameters`.
-   **Marque los campos obligatorios.** El modo estricto de OpenAI exige `additionalProperties: false` y todos los campos en `required`, con `null` como tipo para los opcionales. Que un proveedor aplique `strict` o no varía, así que valide igualmente.

## ¿Y las llamadas a herramientas en paralelo?

Un modelo puede devolver varias entradas en `tool_calls` en un mismo turno, por ejemplo tres lecturas de archivo. Ejecute las llamadas independientes de forma concurrente y devuelva un resultado por cada `tool_call_id`, en cualquier orden. Si sus herramientas tienen efectos secundarios que dependen unos de otros, ponga `parallel_tool_calls: false`; la guía de OpenAI indica que eso limita al modelo a cero o una llamada por turno. Compruebe que su proveedor lo respeta.

## ¿Por qué fallan las llamadas a herramientas?

| Fallo | Lo que ve | Solución |
| --- | --- | --- |
| Argumentos mal formados | `json.loads` lanza una excepción | Devuelva el error de análisis como resultado de herramienta; reintente |
| No coincide con el esquema | Falta un campo, tipo erróneo, enum inventado | Valide; devuelva el error de validación |
| Herramienta desconocida | Un nombre que nunca definió | Devuelva “unknown tool, available: …” |
| No llama cuando debería | Responde con texto | `tool_choice: "required"` o una función con nombre |
| Llamada cortada | `finish_reason: "length"` | Suba `max_tokens`; el razonamiento lo comparte |

Los dos primeros son esperables, no raros. La documentación de tool calling de vLLM dice que en modo `auto`, salvo que una herramienta fije `strict: true` (o el servidor imponga un mínimo de rigor) y el parser del modelo admita restricciones, “vLLM extracts tool calls from raw text, so arguments may occasionally be malformed or violate the function’s parameter schema.” (Traducción: «vLLM extrae las llamadas a herramientas del texto en bruto, así que los argumentos pueden estar a veces mal formados o incumplir el esquema de parámetros de la función»). Una función con nombre usa el backend de salidas estructuradas de vLLM. Su proveedor puede servir los modelos de otra manera, así que considere obligatoria la validación.

La última fila sorprende a quien usa [modelos de razonamiento](https://broadrouter.com/es/glossary/reasoning-tokens/). GLM 5.3 y Qwen3.8 27B piensan antes de responder, y el pensamiento cuenta dentro de [`max_tokens`](https://broadrouter.com/es/glossary/max-tokens/). [Por qué las respuestas llegan vacías o cortadas](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/) explica cuánto margen dejar.

## Un bucle de herramientas que valida y reintenta

```python
import json, os
from openai import OpenAI
from jsonschema import validate, ValidationError

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=4)
MODEL = "broadnet/glm-5.3"

TOOLS = [{"type": "function", "function": {
    "name": "get_order_status",
    "description": "Look up one order by its ID. Use when the user asks where an order is.",
    "parameters": {"type": "object",
                   "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"], "additionalProperties": False}}}]
SCHEMAS = {t["function"]["name"]: t["function"]["parameters"] for t in TOOLS}
IMPL = {"get_order_status": lambda order_id: f"Order {order_id}: shipped"}

def run_call(call):
    name = call.function.name
    if name not in IMPL:
        return f"Error: unknown tool {name}. Available: {', '.join(IMPL)}"
    try:
        args = json.loads(call.function.arguments or "{}")
        validate(args, SCHEMAS[name])
    except (json.JSONDecodeError, ValidationError) as e:
        return f"Error: invalid arguments ({e}). Send the call again with valid JSON."
    return str(IMPL[name](**args))

def agent(messages, max_steps=8):
    for _ in range(max_steps):
        r = client.chat.completions.create(model=MODEL, messages=messages,
                                           tools=TOOLS, max_tokens=4000)
        msg = r.choices[0].message
        if r.choices[0].finish_reason == "length":
            raise RuntimeError("Output limit reached; raise max_tokens")
        messages.append(msg.model_dump(exclude_none=True))
        if not msg.tool_calls:
            return msg.content
        for call in msg.tool_calls:
            messages.append({"role": "tool", "tool_call_id": call.id,
                             "content": run_call(call)})
    raise RuntimeError("Step limit reached")
```

Aquí importan tres decisiones de diseño:

1.  **Los errores vuelven al modelo como resultados de herramienta.** El modelo ve qué estaba mal y suele corregirlo en el turno siguiente. Lanzar una excepción desperdicia esa oportunidad.
2.  **El bucle está acotado.** `max_steps` detiene a un modelo que sigue llamando herramientas sin avanzar.
3.  **Los reintentos de transporte van aparte.** `max_retries` en el cliente gestiona los 429 y 5xx. Los argumentos incorrectos se gestionan en el bucle. No mezcle ambas cosas; vea [errores y reintentos](https://broadrouter.com/es/guides/errors-and-retries/).

En herramientas con efectos secundarios, como enviar un correo, añada una clave de idempotencia para que un paso reintentado no actúe dos veces. [Agentes de larga duración](https://broadrouter.com/es/blog/long-running-agents-timeouts-retries/) trata este tema.

## ¿Qué modelos de BroadNet admiten tool calling?

| Modelo | Herramientas listadas | Contexto | Notas |
| --- | --- | --- | --- |
| [GLM 5.3](https://broadrouter.com/es/models/glm-5.3/) | Sí | 1,048,576 | También salida estructurada |
| [Qwen3.8 27B](https://broadrouter.com/es/models/qwen3.8-27b/) | Sí | 262,144 | También entrada de imágenes |
| [DeepSeek V4.1 Flash](https://broadrouter.com/es/models/deepseek-v4.1-flash/) | No listadas | 1,048,576 | Entrada de imágenes; pruebe las herramientas antes de depender de ellas |
| [Gemma 4 VL 26B](https://broadrouter.com/es/models/gemma-4-vl-26b/) | No listadas | 32,768 | No apto para bucles de herramientas |

Para elegir entre los dos modelos con herramientas, vea [GLM 5.3 frente a Qwen3.8 27B](https://broadrouter.com/compare/glm-5.3-vs-qwen3.8-27b/). Cuando la respuesta final debe ajustarse a una forma pero no hace falta ejecutar ninguna función, la [salida estructurada](https://broadrouter.com/es/blog/structured-output-json-schema/) es más sencilla que una herramienta.

## Dónde encaja BroadNet Inference

BroadNet Inference sirve GLM 5.3 y Qwen3.8 27B con tool calling listado, mediante el formato estándar de chat completions, así que el bucle anterior funciona sin cambios con el [SDK de OpenAI para Python](https://broadrouter.com/es/guides/openai-python-sdk/). Los precios por token están en la [página de precios](https://broadrouter.com/es/pricing/). No aloja herramientas del lado del servidor, como búsqueda web o ejecución de código, y su documentación no lista tool calling para DeepSeek V4.1 Flash, el modelo de los planes ilimitados. Para un agente con uso intensivo de herramientas, use GLM 5.3 o Qwen3.8 27B por token. Si de todos modos quiere el plan fijo, compruebe con una hora del plan Meteoro (Meteor) por $1 que DeepSeek V4.1 Flash llama a sus herramientas de forma fiable antes de comprar un mes.

Herramientas gratuitas sobre este tema (en inglés)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Herramientas gratuitas (en inglés)](https://broadrouter.com/tools/)

## Términos de este artículo

[Llamadas a herramientas (tool calling)](https://broadrouter.com/es/glossary/tool-calling/)

Las llamadas a herramientas (tool calling), también llamadas function calling, son una función de las APIs de LLM en la que el modelo devuelve una solicitud estructurada para ejecutar una función definida por el desarrollador, con argumentos JSON. La aplicación ejecuta la función y devuelve el resultado; el modelo nunca ejecuta código.

[Salida estructurada (structured output)](https://broadrouter.com/es/glossary/structured-output/)

La salida estructurada es una función de las APIs de LLM que restringe la respuesta del modelo a un formato que define el desarrollador, normalmente un JSON Schema, para que el código pueda procesarla de forma fiable. Es más estricta que JSON mode, que garantiza JSON válido pero no una forma concreta.

[Token](https://broadrouter.com/es/glossary/token/)

Un token es la unidad de texto que un modelo de lenguaje lee y escribe: una palabra, parte de una palabra, un signo de puntuación o una secuencia de bytes producida por el tokenizador del modelo. Las APIs de LLM cuentan, limitan y normalmente facturan el uso en tokens.

[vLLM](https://broadrouter.com/es/glossary/vllm/)

vLLM es una biblioteca de código abierto para inferencia y servicio de LLM, desarrollada originalmente en el Sky Computing Lab de UC Berkeley. Gestiona la memoria de la caché KV con PagedAttention, agrupa las solicitudes entrantes de forma continua, admite muchos formatos de cuantización y ofrece un servidor HTTP compatible con OpenAI.

[API compatible con OpenAI](https://broadrouter.com/es/glossary/openai-compatible-api/)

Una API compatible con OpenAI es una API HTTP que acepta los mismos formatos de solicitud y respuesta que la API de OpenAI, como POST /v1/chat/completions, de modo que los SDKs y herramientas de OpenAI pueden usarla cambiando solo la URL base, la clave de API y el nombre del modelo.

[JSON Schema (esquema JSON)](https://broadrouter.com/es/glossary/json-schema/)

JSON Schema es un vocabulario, escrito en JSON, para describir y validar la estructura de datos JSON: tipos, campos obligatorios, valores permitidos y anidamiento. La versión actual es la 2020-12. Las APIs de LLM lo usan para definir los parámetros de las herramientas y la forma exacta que debe seguir una salida estructurada.

[API de Chat Completions](https://broadrouter.com/es/glossary/chat-completions-api/)

La API de Chat Completions es el endpoint HTTP de OpenAI, POST /v1/chat/completions, que recibe un nombre de modelo y una lista de mensajes etiquetados con su rol y devuelve el siguiente mensaje del modelo. Su forma de solicitud y respuesta se convirtió en el formato común que reutilizan los proveedores y SDKs compatibles con OpenAI.

[Clave de idempotencia (idempotency key)](https://broadrouter.com/es/glossary/idempotency-key/)

Una clave de idempotencia es un valor único, normalmente un ID aleatorio como un UUID, que el cliente adjunta a una solicitud que cambia el estado, como un pago o una compra. Si la misma solicitud se envía de nuevo con la misma clave, el servidor devuelve el resultado original en lugar de ejecutar la acción dos veces.

## Preguntas frecuentes

### ¿Los modelos abiertos admiten function calling?

Muchos sí, pero el soporte depende del modelo y de cómo lo sirve el proveedor. En BroadNet Inference, la documentación lista tool calling para GLM 5.3 y Qwen3.8 27B. No lo lista para DeepSeek V4.1 Flash ni para Gemma 4 VL 26B.

### ¿Por qué los argumentos de mis llamadas a herramientas son JSON inválido?

Salvo que el servidor restrinja la decodificación, los argumentos se generan como texto y se analizan después. La documentación de vLLM indica que los argumentos extraídos del texto en bruto pueden estar mal formados de vez en cuando. Capture el error de análisis y devuélvalo como resultado de herramienta para que el modelo se corrija.

### ¿Cómo desactivo las llamadas a herramientas en paralelo?

En el formato de OpenAI, ponga parallel\_tool\_calls en false. Eso limita al modelo a cero o una llamada por turno. Compruebe que su proveedor respeta el campo.

### ¿Por qué el modelo responde con texto en lugar de llamar a una herramienta?

Con tool\_choice en auto, decide el modelo. Ponga tool\_choice en required, o en una función concreta, cuando la llamada sea obligatoria. Compruebe también que la descripción de la herramienta indica cuándo usarla.

### ¿Por qué se corta mi llamada a herramienta?

Los modelos de razonamiento cuentan el pensamiento dentro de max\_tokens. Un límite pequeño puede terminar la respuesta a mitad de los argumentos. Revise finish\_reason y suba max\_tokens.

## Siga leyendo

-   [OpenClaw y Hermes Agent con un modelo barato: configuración y tokens](https://broadrouter.com/es/blog/openclaw-hermes-agent-cheap-model/)
-   [Modo JSON o json\_schema: salida estructurada que no falla](https://broadrouter.com/es/blog/structured-output-json-schema/)
-   [Servidores MCP con cualquier modelo compatible con OpenAI](https://broadrouter.com/es/blog/mcp-with-openai-compatible-models/)
-   [Agentes de larga duración: timeouts, reintentos y checkpoints sólidos](https://broadrouter.com/es/blog/long-running-agents-timeouts-retries/)
-   [Presupuesto de tokens de un agente: adónde van los tokens del bucle](https://broadrouter.com/es/blog/agent-token-budget/)
-   [El hardware GPU de BroadNet y cómo sirve los modelos, según BroadNet](https://broadrouter.com/es/blog/broadnet-gpu-fleet-and-serving/)
-   [Caché de respuestas de APIs de LLM para reducir costos en Python](https://broadrouter.com/es/blog/cache-llm-responses-cut-cost/)
-   [Guía: Usar el SDK de OpenAI para Python con BroadNet Inference](https://broadrouter.com/es/guides/openai-python-sdk/)
-   [Guía: OpenAI Agents SDK con BroadNet Inference](https://broadrouter.com/es/guides/openai-agents-sdk-custom-provider/)
-   [Guía: ¿Por qué un modelo de razonamiento devuelve una respuesta vacía?](https://broadrouter.com/es/guides/reasoning-tokens-empty-response/)
-   [Guía: Códigos de error de BroadNet Inference y cuándo reintentar](https://broadrouter.com/es/guides/errors-and-retries/)

Pruébelo con su carga de trabajo real. Las cuentas nuevas empiezan con USD 5 de crédito para Gemma y transcripción. DeepSeek, GLM y Qwen3.8 requieren una recarga.

[Comenzar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-tool-calling-open-models&utm_content=page-cta) ·

**Fuentes**

-   [OpenAI, guía de function calling (consultado el 2026-11-14)](https://developers.openai.com/api/docs/guides/function-calling)
-   [Documentación de vLLM, tool calling (consultado el 2026-11-14)](https://docs.vllm.ai/en/latest/features/tool_calling/)
-   [Referencia de la API de BroadNet Inference, modelos (en inglés)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=es-blog-tool-calling-open-models&utm_content=sources#models)
