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

Conversa com Múltiplas Interações

Aula 7 de 14 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Para Além de Chamadas Únicas
  2. O Princípio: Manter o Histórico
  3. Ciclo Completo de Conversa
  4. Exemplo de Conversa com Múltiplas Interações
  5. Encadeamento de Chamadas Sequenciais
  6. Gestão do Tamanho do Histórico
  7. Pontos-chave

Para Além de Chamadas Únicas

Numa aplicação real, os utilizadores não fazem uma única pergunta e desaparecem. Encadeiam pedidos, retomam tópicos anteriores e deixam pistas como “e este?” que a frase isolada não consegue resolver. A chamada de funções deve operar neste contexto de conversa com múltiplas interações, onde o modelo pode invocar funções em cada passo do diálogo sem nunca perder o rasto do que aconteceu antes.

O Princípio: Manter o Histórico

A chave resume-se a uma frase: mantenha todas as mensagens numa lista que cresce a cada troca. O modelo não tem memória própria entre chamadas à API; o único contexto que possui é o que lhe envia de volta. É este histórico completo que lhe permite compreender referências implícitas.

import os
import json
from mistralai.client import Mistral
from functools import partial

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Histórico da conversa
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Ciclo Completo de Conversa

O código abaixo funciona em duas fases. process_tool_calls executa todas as chamadas solicitadas pelo modelo e reinicia a conversa com os resultados; chat gere uma volta completa, desde a entrada do utilizador até ao texto final.

def process_tool_calls(response, messages, available_functions, tools):
    """Processa tool_calls e devolve a resposta final."""
    message = response.choices[0].message
    messages.append(message)

    # Executa cada tool_call
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)

        if function_name in available_functions:
            result = available_functions[function_name](**function_params)
        else:
            result = json.dumps({"error": f"Unknown function {function_name}"})

        messages.append({
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        })

    # Chama novamente o modelo com os resultados
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Gere uma volta completa da conversa."""
    messages.append({"role": "user", "content": user_input})

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message

    # Repete enquanto o modelo quiser chamar funções
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # O modelo terminou — responde com texto
    messages.append(message)
    return message.content

O ciclo while é a peça crítica. Após receber o resultado de uma função, o modelo pode muito bem solicitar outra: o ciclo continua enquanto produzir tool_calls e só para quando finalmente devolver texto. Um simples if trataria a primeira chamada e devolveria depois uma resposta vazia em qualquer caso em que fossem necessárias duas chamadas.

Exemplo de Conversa com Múltiplas Interações

Vejamos como fica este ciclo ao longo de quatro voltas encadeadas.

# Volta 1
reponse = chat("What is the status of payment T1001?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."

# Volta 2 — pergunta de seguimento
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Volta 3 — nova transação
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Volta 4 — pergunta sem função
reponse = chat("Thanks, that's all for today.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."

A Volta 2 é a que deve examinar com atenção. “When was it made?” não contém nenhum identificador; é o histórico que permite ao modelo compreender que isto ainda se refere ao T1001 e chamar retrieve_payment_date com o argumento correto. Remova as mensagens da Volta 1 e esta frase torna-se insolúvel. Na Volta 3, o modelo pode decidir chamar várias funções — estado e data para o T1003 — para construir a comparação com os resultados já obtidos para o T1001. A Volta 4 não aciona nenhuma chamada: o modelo também sabe quando se deve conter.

Encadeamento de Chamadas Sequenciais

Alguns pedidos exigem que o modelo espere por um resultado antes de saber o que pedir a seguir. O ciclo while em chat() trata deste caso sem uma única linha de código extra.

# O utilizador pede algo que requer 2 chamadas sequenciais
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# O modelo pode:
# 1. Chamar retrieve_payment_status(T1002)
# 2. Receber o resultado
# 3. Chamar retrieve_payment_date(T1002)
# 4. Receber o resultado
# 5. Formular a resposta final com ambas as informações

Visto a partir do histórico de mensagens, o fluxo sequencial parece isto:

user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)

Conte as voltas do assistente: três, ou seja, três pedidos faturados à API. Esse é o custo da execução sequencial, e a razão pela qual a próxima lição se foca em chamadas paralelas.

Gestão do Tamanho do Histórico

Em produção, uma conversa de longa duração torna-se dispendiosa: cada volta reenvia todo o conjunto de mensagens anteriores, e a fatura de tokens cresce quadraticamente. Uma estratégia simples consiste em manter apenas a mensagem de sistema e as trocas mais recentes.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Mantém a mensagem de sistema e as últimas N mensagens."""
    system_messages = [m for m in messages if hasattr(m, "role")
                       and m.get("role") == "system"
                       or (isinstance(m, dict) and m.get("role") == "system")]

    non_system = [m for m in messages if m not in system_messages]

    if len(non_system) > max_messages:
        non_system = non_system[-max_messages:]

    return system_messages + non_system

Uma precaução antes de integrar esta função: nunca corte um tool_call sem a sua mensagem tool correspondente. Se o truncamento ocorrer entre os dois, a API recebe um pedido de chamada sem resposta e rejeita a consulta. Ajuste o ponto de corte para preservar pares completos em vez de contar mensagens cegamente.

Pontos-chave

  • Mantenha um histórico completo de mensagens para que o modelo compreenda o contexto
  • Utilize um ciclo while para gerir chamadas de funções sequenciais
  • O modelo compreende referências implícitas (“aquele”, “o anterior”) graças ao contexto
  • Em produção, limite o tamanho do histórico mantendo intactos os pares tool_call/tool
  • A função chat() aqui apresentada é um padrão reutilizável para qualquer aplicação de chamada de funções