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

Conversas de Várias Voltas com Ferramentas

Aula 11 de 14 Atualizada a 29 de julho de 2026 Programador
Nesta página
  1. Conversas de várias voltas com chamada de funções
  2. O parâmetro max_turns
  3. Ciclo de várias voltas no lado do cliente
  4. Contexto de várias voltas com a API de Respostas
  5. Padrões de conversação de várias voltas
  6. Gestão de memória
  7. Pontos-chave

Conversas de várias voltas com chamada de funções

Numa conversa real, o modelo pode precisar de chamar ferramentas várias vezes ao longo da troca. Cada volta pode envolver novas chamadas, resultados que desencadeiam outras chamadas ou pedidos de esclarecimento ao utilizador antes de usar uma ferramenta.

O parâmetro max_turns

O parâmetro max_turns limita o número de voltas assistente/ferramenta no lado do servidor num único pedido. Aplica-se apenas a ferramentas integradas (web_search, code_interpreter, etc.).

response = client.responses.create(
    model="grok-4.5",
    input="Analyze 2026 tech trends",
    tools=[{"type": "web_search"}],
    max_turns=5  # Maximum 5 web searches before responding
)

Ponto importante: as invocações de ferramentas no lado do cliente reiniciam o contador. Quando envia de volta um function_call_output, começa uma nova alocação de max_turns.

Ciclo de várias voltas no lado do cliente

Para gerir conversas em que o modelo chama ferramentas várias vezes, implemente um ciclo:

import json

def multi_turn_chat(user_message, tools, max_iterations=10):
    messages = [{"role": "user", "content": user_message}]

    for i in range(max_iterations):
        response = client.chat.completions.create(
            model="grok-4.5",
            messages=messages,
            tools=tools
        )

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

        # If no tool_call, the conversation is over
        if not message.tool_calls:
            return message.content

        # Execute all requested tools
        for tool_call in message.tool_calls:
            args = json.loads(tool_call.function.arguments)
            result = execute_function(tool_call.function.name, args)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "content": json.dumps(result)
            })

    return "Maximum number of iterations reached"

A variável max_iterations é uma salvaguarda essencial para evitar ciclos infinitos. Em produção, defina um limite razoável (5–10 voltas).

Contexto de várias voltas com a API de Respostas

A API de Respostas oferece dois mecanismos para manter o contexto:

1. Armazenamento remoto

# First message
r1 = client.responses.create(
    model="grok-4.5",
    input="What's the weather like in Paris?",
    tools=tools,
    store_messages=True
)

# Tool result
r2 = client.responses.create(
    model="grok-4.5",
    input=[{
        "type": "function_call_output",
        "call_id": r1.output[0].call_id,
        "output": {temp: 18}
    }],
    previous_response_id=r1.id,
    store_messages=True
)

# Follow-up question (context is preserved)
r3 = client.responses.create(
    model="grok-4.5",
    input="What about tomorrow?",
    previous_response_id=r2.id,
    tools=tools,
    store_messages=True
)

A vantagem: não precisa de gerir o histórico de mensagens. A xAI armazena e recupera-o automaticamente através do previous_response_id.

2. Conteúdo encriptado no lado do cliente

response = client.responses.create(
    model="grok-4.5",
    input="Search for flight prices to Nice",
    tools=tools,
    use_encrypted_content=True
)

Com use_encrypted_content=True, recebe o raciocínio e os resultados das ferramentas sob forma encriptada. Envie-os de volta tal como estão nos pedidos subsequentes, sem poder lê-los. Isto é útil quando não quer que os dados passem em texto claro através do seu servidor.

Padrões de conversação de várias voltas

Padrão: Pesquisa e depois ação

Turn 1 : User → "Find a cheap Paris-Nice flight"
         Model → tool_call: search_flights(from="CDG", to="NCE")
         Client → result : [{flight1}, {flight2}, {flight3}]
Turn 2 : Model → "I found 3 flights. The cheapest is €89. Do you want to book it?"
         User → "Yes, book the €89 flight"
Turn 3 : Model → tool_call: book_flight(flight_id="FL123", passengers=1)

Padrão: Agregação de dados

Turn 1 : Model → tool_call: get_sales(month="march")
Turn 2 : Model → tool_call: get_expenses(month="march")
Turn 3 : Model → tool_call: get_headcount(month="march")
Turn 4 : Model → "Here is the monthly report: sales +12%, expenses -3%, headcount stable."

Padrão: Refinamento progressivo

Turn 1 : Model → tool_call: search_products(query="running shoes")
         Result → 150 products
Turn 2 : Model → "I found 150 products. What size and budget?"
         User → "42, max €120"
Turn 3 : Model → tool_call: search_products(query="running shoes", size=42, max_price=120)
         Result → 8 products

Gestão de memória

Em conversas longas, o histórico — que inclui cada tool_call e cada resultado de ferramenta — cresce rapidamente e, com ele, o custo de cada volta. Estão disponíveis três estratégias, desde a manual até à totalmente delegada. A sumarização periódica condensa as voltas mais antigas num parágrafo injetado no prompt do sistema: mantém a substância das trocas passadas por uma fração do seu peso em tokens, ao custo de alguma perda de detalhe. A janela deslizante é mais brusca, mas mais simples: mantenha apenas as últimas N voltas, aceitando que o modelo esquecerá o início da conversa — adequado quando as trocas mais antigas já não têm importância operacional. O armazenamento remoto, finalmente, delega o problema à xAI com store_messages=True: o histórico vive no lado do servidor e a sua aplicação carrega apenas uma referência. A escolha certa depende do que a sua aplicação precisa de recordar e por quanto tempo.

Pontos-chave

  • max_turns limita as voltas de ferramentas no servidor — as ferramentas do cliente reiniciam o contador
  • Implemente um ciclo com max_iterations para evitar ciclos infinitos
  • previous_response_id encadeia conversas sem reenviar o histórico
  • store_messages=True delega o armazenamento do contexto à xAI
  • use_encrypted_content=True protege os dados em trânsito
  • Gere a memória em conversas longas (sumarização, janela deslizante)