Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Chamadas de Funções em Paralelo

Aula 8 de 14 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Quando o modelo necessita de múltiplas informações simultaneamente
  2. Ler uma resposta com múltiplas chamadas
  3. Devolver cada resultado à sua chamada original
  4. Passar do paralelismo aparente ao paralelismo real
  5. Retomar o controlo com parallel_tool_calls
  6. O que o paralelismo realmente altera
  7. Pontos-chave

Quando o modelo necessita de múltiplas informações simultaneamente

Até agora, cada turno na conversa resultou numa única chamada de função. Muitas perguntas do mundo real não se enquadram nesse molde. Considere um utilizador que pergunta: «Qual é o estado e a data do pagamento T1001?». O modelo precisa de duas informações que residem em duas funções distintas: retrieve_payment_status e retrieve_payment_date. Poderia solicitá-las uma após a outra, aguardando a sua resposta no intervalo. No entanto, determina aqui que nenhuma depende da outra, pelo que gera múltiplas tool_calls numa única resposta. Recebe toda a carga de trabalho de uma vez e decide como executá-la.

Ler uma resposta com múltiplas chamadas

A implicação prática é simples: message.tool_calls deixa de ser uma lista de um único item. Deve iterar sobre ela em vez de capturar tool_calls[0], um reflexo comum quando se aprende chamada de funções com exemplos de função única.

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

message = response.choices[0].message

# Múltiplas tool_calls na mesma resposta
for tc in message.tool_calls:
    print(f"Function: {tc.function.name}")
    print(f"Arguments: {tc.function.arguments}")
    print(f"ID: {tc.id}")
    print("---")

# Possible output:
# Function: retrieve_payment_status
# Arguments: {"transaction_id": "T1001"}
# ID: call_abc123
# ---
# Function: retrieve_payment_date
# Arguments: {"transaction_id": "T1001"}
# ID: call_def456

Note que ambas as chamadas usam o mesmo argumento, T1001, mas possuem IDs diferentes: call_abc123 e call_def456. Estes IDs são a única forma de o modelo saber qual resultado corresponde a qual pedido.

Devolver cada resultado à sua chamada original

A regra é estrita: deve executar todas as funções e devolver todos os resultados numa mensagem tool separada, contendo o tool_call_id correspondente. Se esquecer ou trocar um ID, o modelo poderá atribuir a data ao campo de estado ou recusar-se a responder.

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

# Executar todas as funções solicitadas
for tool_call in message.tool_calls:
    function_name = tool_call.function.name
    function_params = json.loads(tool_call.function.arguments)

    # Executar a função
    result = available_functions[function_name](**function_params)

    # Adicionar o resultado com o tool_call_id correto
    messages.append({
        "role": "tool",
        "name": function_name,
        "content": result,
        "tool_call_id": tool_call.id
    })

# Enviar todos os resultados de volta ao 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."

O modelo une então os dois fragmentos numa única frase, como se a informação viesse de uma única fonte. Este é exatamente o efeito que deseja da perspetiva do utilizador.

Passar do paralelismo aparente ao paralelismo real

Uma nuance escapa frequentemente aos leitores numa primeira leitura: no ciclo for acima, as funções executam-se uma após a outra. O modelo solicitou as suas chamadas em paralelo, mas o seu código permanece sequencial. Enquanto as suas funções lerem um DataFrame em memória, isso não importa. No entanto, assim que consultarem uma API externa ou uma base de dados, duas chamadas de 300 ms tornam-se 600 ms de latência percecionada, e o benefício do paralelismo evapora-se. Se as suas funções forem assíncronas, asyncio.gather lança-as em conjunto e aguarda todo o lote.

import asyncio
import json

async def execute_tools_parallel(tool_calls, available_functions):
    """Executes tool_calls in parallel and returns the results."""

    async def execute_one(tool_call):
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)
        # If your functions are async:
        result = await available_functions[function_name](**function_params)
        return {
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        }

    # Execute all functions in parallel
    tasks = [execute_one(tc) for tc in tool_calls]
    return await asyncio.gather(*tasks)

A maioria das bases de código existentes expõe funções síncronas que não quererá reescrever como async apenas para isto. Um pool de threads produz o mesmo efeito sem tocar na sua lógica de negócio.

from concurrent.futures import ThreadPoolExecutor

def execute_tools_threaded(tool_calls, available_functions):
    """Executes tool_calls using a thread pool."""
    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

Retomar o controlo com parallel_tool_calls

O paralelismo nem sempre é desejável. O parâmetro parallel_tool_calls permite permitir ou proibir essa funcionalidade. Quando definido como True (o padrão), o modelo decide se agrupa as suas chamadas. Quando definido como False, só pode produzir uma tool_call por resposta.

# Allow parallel calls (default)
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=True  # Model decides
)

# Force sequential calls
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    parallel_tool_calls=False  # Only one tool_call per response
)

Três situações justificam definir isto como False. A primeira é quando a ordem de execução importa: faturar antes de verificar o stock produz um resultado diferente do inverso. A segunda envolve dependências de dados, onde o resultado de uma função é necessário para chamar a seguinte — por exemplo, encontrar um contacto para obter o seu ID antes de modificar o seu registo. A terceira relaciona-se simplesmente com a necessidade de um controlo mais fino sobre o fluxo, tipicamente durante a depuração, quando deseja observar cada chamada isoladamente antes de abrir as comportas.

O que o paralelismo realmente altera

O ganho não reside apenas nas threads; diz respeito principalmente ao número de viagens de ida e volta à API, que dominam a latência total.

# Sequential (2 API calls to the model)
user → assistant(fc.1) → tool(r.1) → assistant(fc.2) → tool(r.2) → assistant(response)

# Parallel (only 1 additional API call)
user → assistant(fc.1, fc.2) → tool(r.1), tool(r.2) → assistant(response)

No padrão sequencial, o modelo deve completar dois turnos completos de raciocínio antes da resposta final. No padrão paralelo, um único pedido recupera todas as tool_calls, e apenas um pedido adicional é necessário para a resposta. Para uma pergunta que envolva duas ou três funções, isto poupa frequentemente vários segundos ao utilizador.

Pontos-chave

  • O modelo pode gerar múltiplas tool_calls numa única resposta
  • Cada resultado deve ser devolvido com o tool_call_id correto
  • Para funções de rede, utilize asyncio ou ThreadPoolExecutor para uma execução verdadeiramente paralela
  • O parâmetro parallel_tool_calls controla este comportamento (True por padrão)
  • O padrão paralelo reduz os pedidos à API e melhora a latência