Llamadas paralelas y secuenciales
En esta página
Llamadas paralelas y secuenciales
El modelo puede emitir varias llamadas a funciones en una única respuesta, haciéndolo automáticamente siempre que identifica necesidades independientes. Esto no es solo una optimización cosmética: tres llamadas de dos segundos ejecutadas juntas tardan dos segundos en total, pero encadenadas secuencialmente tardarían seis.
El verdadero foco de esta lección no es cómo paralelizar —el modelo se encarga de eso—, sino cómo reconocer los casos en los que no debes hacerlo. Dos llamadas son independientes cuando el orden de ejecución no afecta al resultado. En cuanto una operación lee lo que otra escribe, o un parámetro debe provenir de una llamada anterior, el paralelismo se convierte en un error difícil de reproducir.
Llamadas paralelas
No hace falta activar nada: este es el comportamiento predeterminado. Una consulta sobre tres ciudades produce tres elementos function_call en la misma respuesta; tú los ejecutas. Ten en cuenta que el modelo razona sobre el significado de las funciones basándose en tus descripciones; las descripciones impulsan la decisión, como en casi todo en este curso.
from openai import OpenAI
import json
import asyncio
client = OpenAI()
tools = [
{
"type": "function",
"name": "get_meteo",
"description": "Obtener el tiempo actual para una ciudad",
"parameters": {
"type": "object",
"properties": {
"ville": {"type": "string"}
},
"required": ["ville"],
"additionalProperties": False
},
"strict": True
},
{
"type": "function",
"name": "get_taux_change",
"description": "Obtener el tipo de cambio entre dos divisas",
"parameters": {
"type": "object",
"properties": {
"source": {"type": "string"},
"cible": {"type": "string"}
},
"required": ["source", "cible"],
"additionalProperties": False
},
"strict": True
}
]
response = client.responses.create(
model="gpt-5.6-terra",
input="¿Qué tiempo hace en París y Berlín, "
"y cuál es el tipo de cambio EUR/USD?",
tools=tools
)
# El modelo emite 3 llamadas en paralelo
appels = [item for item in response.output if item.type == "function_call"]
print(f"Nombre d'appels : {len(appels)}")
# => Nombre d'appels : 3
Ejecutar llamadas paralelas en el lado del cliente
Recibir tres llamadas a la vez es inútil si tu código las ejecuta una tras otra: pierdes toda la ganancia en el lado del cliente. asyncio.gather es el mínimo; añade dos precauciones para producción: un límite de concurrencia, para no abrir cincuenta conexiones simultáneas a un servicio que solo soporta diez, y gestión de errores por llamada, para que un fallo aislado no eche abajo los demás resultados.
async def executer_fonction(name: str, arguments: str) -> dict:
args = json.loads(arguments)
if name == "get_meteo":
return await api_meteo(args["ville"])
elif name == "get_taux_change":
return await api_change(args["source"], args["cible"])
async def traiter_appels_paralleles(appels):
taches = [
executer_fonction(appel.name, appel.arguments)
for appel in appels
]
resultats = await asyncio.gather(*taches)
return [
{
"type": "function_call_output",
"call_id": appel.call_id,
"output": json.dumps(resultat)
}
for appel, resultat in zip(appels, resultats)
]
# Ejecutar
resultats = asyncio.run(traiter_appels_paralleles(appels))
# Enviar de vuelta al modelo
response_finale = client.responses.create(
model="gpt-5.6-terra",
input=response.output + resultats,
tools=tools
)
print(response_finale.output_text)
Desactivar llamadas paralelas
parallel_tool_calls=False obliga al modelo a emitir solo una llamada por respuesta. Usa esta configuración deliberadamente: intercambias latencia por seguridad. Resérvala para funciones que escriben, modifican o activan algo externo.
response = client.responses.create(
model="gpt-5.6-terra",
input="Procesa estos tres pedidos",
tools=tools,
parallel_tool_calls=False # Una llamada por respuesta
)
Casos de uso para desactivar el paralelismo:
- Operaciones que deben ejecutarse en un orden específico
- Funciones con efectos secundarios que interfieren entre sí
- Cuando el resultado de una llamada condiciona la siguiente
Llamadas secuenciales con un bucle
La ejecución secuencial no se controla mediante un parámetro: emerge del bucle. Ejecutas la llamada, envías el resultado y el modelo decide el siguiente paso basándose en lo que acaba de aprender. Esto es precisamente lo que distingue una cadena dinámica de un plan rígido: si el paso 2 revela que el paso 3 es innecesario, el modelo no lo llamará.
def boucle_function_calling(prompt: str, tools: list, max_tours: int = 10):
"""Bucle completo para llamadas a funciones secuenciales."""
messages_input = prompt
tour = 0
while tour < max_tours:
response = client.responses.create(
model="gpt-5.6-terra",
input=messages_input,
tools=tools,
parallel_tool_calls=False
)
# Comprobar llamadas a funciones
appels = [i for i in response.output if i.type == "function_call"]
if not appels:
# El modelo ha terminado, respondiendo con texto
return response.output_text
# Ejecutar cada llamada
resultats = []
for appel in appels:
resultat = executer_fonction_sync(appel.name, appel.arguments)
resultats.append({
"type": "function_call_output",
"call_id": appel.call_id,
"output": json.dumps(resultat)
})
# Preparar la siguiente vuelta
messages_input = response.output + resultats
tour += 1
return "Límite de vueltas alcanzado"
Ejemplo práctico: tubería de procesamiento
Un caso típico donde la ejecución secuencial es obligatoria, porque cada paso consume lo que produjo el anterior:
tools_pipeline = [
{
"type": "function",
"name": "valider_commande",
"description": "Verificar la validez del pedido (stock, precio, cliente)",
"parameters": {
"type": "object",
"properties": {
"commande_id": {"type": "string"}
},
"required": ["commande_id"],
"additionalProperties": False
},
"strict": True
},
{
"type": "function",
"name": "calculer_livraison",
"description": "Calcular gastos de envío y plazos. "
"Requiere un pedido validado.",
"parameters": {
"type": "object",
"properties": {
"commande_id": {"type": "string"},
"mode": {"type": "string", "enum": ["standard", "express"]}
},
"required": ["commande_id", "mode"],
"additionalProperties": False
},
"strict": True
},
{
"type": "function",
"name": "confirmer_commande",
"description": "Confirmar el pedido y activar el pago. "
"Requiere validación previa y cálculo de envío.",
"parameters": {
"type": "object",
"properties": {
"commande_id": {"type": "string"},
"livraison_id": {"type": "string"}
},
"required": ["commande_id", "livraison_id"],
"additionalProperties": False
},
"strict": True
}
]
# El modelo llamará naturalmente en este orden:
# 1. valider_commande
# 2. calculer_livraison (usando el resultado del paso 1)
# 3. confirmer_commande (usando los resultados de los pasos 1 y 2)
resultat = boucle_function_calling(
"Procesar pedido CMD-42567 con envío exprés",
tools_pipeline
)
Patrón híbrido: paralelo y luego secuencial
En la práctica, la mayoría de los flujos de trabajo del mundo real siguen este patrón mixto: una fase de recopilación donde todo puede ejecutarse simultáneamente, seguida de una fase de procesamiento que respeta las dependencias. No necesitas codificar nada especial para esto; es la consecuencia natural del bucle, siempre que tus descripciones hagan claras las dependencias.
# Vuelta 1: Recopilación de datos en paralelo
# El modelo llama a get_client Y get_stock en paralelo
# Vuelta 2: Decisión secuencial basada en resultados
# El modelo llama a valider_commande con la información recopilada
# Vuelta 3: Acción final
# El modelo llama a confirmer_commande
Este patrón resulta natural: el modelo paraleliza automáticamente cuando las llamadas son independientes y luego las encadena secuencialmente cuando aparece una dependencia.
Puntos clave
- El modelo paraleliza automáticamente las llamadas independientes
- Usa
asyncio.gatherpara ejecutar llamadas paralelas en el lado del cliente - Desactiva con
parallel_tool_calls=Falsecuando el orden importa - Implementa un bucle para flujos de trabajo de varios pasos
- Las descripciones de las funciones guían al modelo sobre las dependencias entre pasos