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

Llamadas a funciones en paralelo

Lección 8 de 14 Actualizado el 29 de julio de 2026 Desarrollador
En esta página
  1. Cuando el modelo necesita varios datos a la vez
  2. Leer una respuesta con múltiples llamadas
  3. Devolver cada resultado a su llamada original
  4. Pasar del paralelismo aparente al real
  5. Recuperar el control con parallel_tool_calls
  6. Qué cambia realmente el paralelismo
  7. Puntos clave

Cuando el modelo necesita varios datos a la vez

Hasta ahora, cada turno de la conversación ha generado una única llamada a función. Muchas preguntas del mundo real no encajan en ese molde. Imagina que un usuario pregunta: «¿Cuál es el estado y la fecha del pago T1001?». El modelo necesita dos piezas de información que residen en dos funciones distintas: retrieve_payment_status y retrieve_payment_date. Podría solicitarlas una tras otra, esperando tu respuesta entre medias. Sin embargo, en este caso determina que ninguna depende de la otra, por lo que genera múltiples tool_calls en una única respuesta. Recibes toda la carga de trabajo de golpe y tú decides cómo ejecutarla.

Leer una respuesta con múltiples llamadas

La implicación práctica es sencilla: message.tool_calls ya no es una lista de un solo elemento. Debes iterar sobre ella en lugar de tomar directamente tool_calls[0], un reflejo común cuando se aprende la llamada a funciones con ejemplos de una sola función.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

message = response.choices[0].message

# Múltiples tool_calls en la misma respuesta
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Posible salida:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Observa que ambas llamadas usan el mismo argumento, T1001, pero tienen IDs distintos: call_abc123 y call_def456. Estos IDs son la única forma que tiene el modelo de saber qué resultado corresponde a qué solicitud.

Devolver cada resultado a su llamada original

La regla es estricta: debes ejecutar todas las funciones y devolver todos los resultados en un mensaje tool independiente que lleve el tool_call_id correspondiente. Si olvidas o intercambias un ID, el modelo podría atribuir la fecha al campo de estado o negarse a responder.

message = response.choices[0].message
messages.append(message)

# Ejecutar todas las funciones solicitadas
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Ejecutar la función
    result = available_functions[function_name](**function_params)

    # Añadir el resultado con el tool_call_id correcto
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Enviar todos los resultados de vuelta al modelo
final_response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

print(final_response.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026, and its status is: paid."

El modelo une entonces los dos fragmentos en una sola frase, como si la información proviniera de una única fuente. Este es exactamente el efecto que deseas desde la perspectiva del usuario.

Pasar del paralelismo aparente al real

Un matiz suele escaparse a los lectores en la primera lectura: en el bucle for anterior, las funciones se ejecutan una tras otra. El modelo ha solicitado sus llamadas en paralelo, pero tu código sigue siendo secuencial. Mientras tus funciones lean un DataFrame en memoria, esto no importa. Sin embargo, en cuanto consulten una API externa o una base de datos, dos llamadas de 300 ms se convierten en 600 ms de latencia percibida y el beneficio del paralelismo se desvanece. Si tus funciones son asíncronas, asyncio.gather las lanza juntas y espera a todo el lote.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Ejecuta tool_calls en paralelo y devuelve los resultados."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # Si tus funciones son asíncronas:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Ejecutar todas las funciones en paralelo
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

La mayoría de las bases de código existentes exponen funciones síncronas que no querrás reescribir como async solo por esto. Un pool de hilos produce el mismo efecto sin tocar tu lógica de negocio.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Ejecuta tool_calls usando un pool de hilos."""
    def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        result = available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    with ThreadPoolExecutor(max_workers=5) as executor:
        results = list(executor.map(execute_one, tool_calls))

    return results

Recuperar el control con parallel_tool_calls

El paralelismo no siempre es deseable. El parámetro parallel_tool_calls te permite permitirlo o prohibirlo. Cuando se establece en True (el valor por defecto), el modelo decide si agrupa sus llamadas. Cuando se establece en False, solo puede producir un tool_call por respuesta.

# Permitir llamadas en paralelo (por defecto)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # El modelo decide
)

# Forzar llamadas secuenciales
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Solo un tool_call por respuesta
)

Tres situaciones justifican establecer esto en False. La primera es cuando el orden de ejecución importa: facturar antes de comprobar el stock da un resultado distinto que hacerlo al revés. La segunda implica dependencias de datos, donde el resultado de una función es necesario para llamar a la siguiente; por ejemplo, encontrar un contacto para obtener su ID antes de modificar su registro. La tercera se refiere simplemente a la necesidad de un control más fino sobre el flujo, típicamente durante la depuración, cuando quieres observar cada llamada de forma aislada antes de abrir el grifo.

Qué cambia realmente el paralelismo

La ganancia no radica solo en los hilos; afecta principalmente al número de viajes de ida y vuelta a la API, que dominan la latencia total.

# Secuencial (2 llamadas a la API del modelo)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Paralelo (solo 1 llamada adicional a la API)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

En el patrón secuencial, el modelo debe completar dos turnos completos de razonamiento antes de la respuesta final. En el patrón paralelo, una única solicitud recupera todos los tool_calls y solo se necesita una solicitud adicional para la respuesta. Para una pregunta que involucra dos o tres funciones, esto suele ahorrar al usuario varios segundos.

Puntos clave

  • El modelo puede generar múltiples tool_calls en una única respuesta
  • Cada resultado debe devolverse con el tool_call_id correcto
  • Para funciones de red, usa asyncio o ThreadPoolExecutor para una ejecución verdaderamente paralela
  • El parámetro parallel_tool_calls controla este comportamiento (True por defecto)
  • El patrón paralelo reduce las solicitudes a la API y mejora la latencia