Ir al contenido principal
Español— Elegir un idioma
Menú

Llamadas paralelas y secuenciales

Lección 3 de 20 Desarrollador
En esta página
  1. Llamadas paralelas y secuenciales
  2. Llamadas paralelas
  3. Desactivar llamadas paralelas
  4. Llamadas secuenciales con un bucle
  5. Ejemplo práctico: tubería de procesamiento
  6. Patrón híbrido: paralelo y luego secuencial
  7. Puntos clave

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.gather para ejecutar llamadas paralelas en el lado del cliente
  • Desactiva con parallel_tool_calls=False cuando 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