Llamadas paralelas
En esta página
Múltiples herramientas en una única respuesta
Una de las funcionalidades más potentes de las llamadas a funciones de Grok es la capacidad de devolver múltiples llamadas a herramientas en una única respuesta. En lugar de realizar un viaje de ida y vuelta por cada función, el modelo identifica toda la información que necesita y genera todas las llamadas en paralelo.
El parámetro parallel_tool_calls
Las llamadas paralelas están activadas por defecto. El parámetro parallel_tool_calls controla este comportamiento:
# Activado por defecto (no es necesario especificarlo)
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=True # Este es el valor por defecto
)
Cuando un usuario pregunta: «¿Qué tiempo hace en París y en Lyon?», el modelo devuelve dos tool_calls en la misma respuesta:
{
"tool_calls": [
{
"id": "call_001",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Paris\"}"
}
},
{
"id": "call_002",
"function": {
"name": "get_weather",
"arguments": "{\"city\": \"Lyon\"}"
}
}
]
}
Gestión de llamadas paralelas
Tu código debe gestionar un array de tool_calls, no solo uno:
import json
import asyncio
message = response.choices[0].message
if message.tool_calls:
# Ejecutar todas las funciones
tool_results = []
for tool_call in message.tool_calls:
args = json.loads(tool_call.function.arguments)
result = execute_function(tool_call.function.name, args)
tool_results.append({
"role": "tool",
"tool_call_id": tool_call.id,
"content": json.dumps(result)
})
# Enviar TODOS los resultados de vuelta al modelo
messages = [
{"role": "user", "content": "What's the weather in Paris and Lyon?"},
message,
*tool_results # Todos los resultados
]
final = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools
)
Punto crítico: debes devolver todos los resultados de las herramientas, no solo el primero. Cada resultado está vinculado a su tool_call_id correspondiente.
Ejecución realmente paralela en el cliente
El modelo devuelve las llamadas en paralelo, pero tu código debe ejecutarlas en paralelo. En Python, utiliza asyncio o concurrent.futures:
import concurrent.futures
def execute_parallel(tool_calls):
results = []
with concurrent.futures.ThreadPoolExecutor() as executor:
futures = {}
for tc in tool_calls:
args = json.loads(tc.function.arguments)
future = executor.submit(execute_function, tc.function.name, args)
futures[future] = tc.id
for future in concurrent.futures.as_completed(futures):
call_id = futures[future]
result = future.result()
results.append({
"role": "tool",
"tool_call_id": call_id,
"content": json.dumps(result)
})
return results
La ejecución paralela reduce significativamente la latencia total. Si cada llamada a la API tarda 200 ms, dos llamadas secuenciales suman 400 ms, mientras que dos llamadas paralelas tardan aproximadamente 200 ms.
Desactivación de las llamadas paralelas
En algunos casos, querrás llamadas secuenciales:
response = client.chat.completions.create(
model="grok-4.5",
messages=messages,
tools=tools,
parallel_tool_calls=False
)
Desactiva el paralelismo siempre que no esté garantizada la independencia de las llamadas. El caso más evidente es la dependencia de datos: si el resultado de una herramienta se utiliza como argumento para la siguiente (por ejemplo, buscar un ID de cliente antes de recuperar sus pedidos), ejecutarlas en paralelo causará, en el mejor de los casos, un error y, en el peor, un resultado incorrecto sin aviso. La lógica de negocio impone la misma restricción: crear un usuario antes de asignarle un rol es innegociable y solo el modo secuencial lo garantiza. Dos razones prácticas más completan el panorama: una API externa sujeta a límites de solicitudes concurrentes no gestionará bien una ráfaga de llamadas paralelas y, durante el desarrollo, el modo secuencial hace que el seguimiento de las llamadas sea infinitamente más legible (una llamada, un resultado, un registro, en orden).
Llamadas paralelas con diferentes herramientas
El modelo también puede llamar a diferentes herramientas en paralelo:
# Solicitud: "Reserva una mesa y dime el tiempo que hará esta noche"
# El modelo devuelve:
# - tool_call_1 : book_table(restaurant="Le Petit Bistrot", time="20:00")
# - tool_call_2 : get_weather(city="Paris", time="tonight")
Esto resulta especialmente útil para asistentes versátiles que necesitan recopilar información de distintas fuentes.
Gestión de errores en paralelo
Cuando una llamada falla pero otras tienen éxito, devuelve todos los resultados. El modelo gestiona los errores individuales:
results = []
for tc in message.tool_calls:
try:
result = execute_function(tc.function.name, args)
results.append({
"role": "tool",
"tool_call_id": tc.id,
"content": json.dumps(result)
})
except Exception as e:
results.append({
"role": "tool",
"tool_call_id": tc.id,
"content": json.dumps({"error": str(e)})
})
Puntos clave
- Las llamadas paralelas están activadas por defecto (
parallel_tool_calls: true) - El modelo devuelve múltiples
tool_callsen una única respuesta - Debes devolver todos los resultados, cada uno vinculado a su
tool_call_id - Implementa la ejecución paralela en el cliente para reducir la latencia
- Desactiva el paralelismo cuando existan dependencias entre llamadas
- Gestiona los errores individualmente; no bloquees todo por un único fallo