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

Conversas de Várias Interações em Python

Aula 7 de 14 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Uma Memória Que Não É Realmente Memória
  2. Os Três Papéis Que Estruturam o Histórico
  3. Uma Conversa Completa, Turno a Turno
  4. Impedir Que o Histórico Se Torne Proibitivamente Caro
  5. Criar a Mensagem de Sistema
  6. Pontos-chave

Uma Memória Que Não É Realmente Memória

Ao contrário de um motor de busca, um modelo de linguagem segue o fio condutor de uma conversa: considera o que foi dito anteriormente e constrói as suas respostas com base nesse contexto acumulado. Isto chama-se uma conversa multi-turno (várias interações) e é o que torna possíveis perguntas elípticas como «e com argumentos?».

Tecnicamente, no entanto, o modelo não se lembra de nada. Nenhum estado é preservado no servidor entre chamadas. Com cada pedido, tem de reenviar o histórico completo, que o modelo lê do início ao fim antes de responder. Este mecanismo explica duas coisas que revisitaremos mais tarde: é inteiramente responsável pela gestão da memória e cada turno da conversa custa mais do que o anterior.

Os Três Papéis Que Estruturam o Histórico

Cada mensagem no histórico possui um papel que indica ao modelo quem está a falar. O papel system define o comportamento geral: colocado em primeiro lugar, influencia todas as respostas seguintes.

{"role": "system", "content": "You are an expert assistant in French cuisine. Always respond in French using precise culinary terms."}

O papel user contém as mensagens do utilizador, ou seja, a pergunta ou instrução enviada:

{"role": "user", "content": "How do I make perfect puff pastry?"}

Finalmente, o papel assistant contém as respostas anteriores do modelo. Estas são as mensagens que reinjeta no histórico para manter a coerência. Esquecê-las equivale a apagar a memória da conversa a cada turno.

{"role": "assistant", "content": "To make perfect puff pastry, start by..."}

Uma Conversa Completa, Turno a Turno

O código abaixo aplica este princípio: uma função que adiciona a pergunta ao histórico, chama o modelo e, em seguida, armazena a resposta no local correto antes de a devolver.

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

historique = [
    {
        "role": "system",
        "content": "You are a teaching assistant specialized in Python programming. Respond concisely and include code examples."
    }
]

def poser_question(question: str) -> str:
    """Sends a question and updates the history."""
    historique.append({"role": "user", "content": question})

    response = client.chat.complete(
        model="mistral-small-latest",
        messages=historique,
    )

    reponse_texte = response.choices[0].message.content
    historique.append({"role": "assistant", "content": reponse_texte})

    return reponse_texte

# Turn 1
print("Q: What is a decorator in Python?")
r1 = poser_question("What is a decorator in Python?")
print(f"R: {r1}\n")

# Turn 2 — the model knows the context
print("Q: Can you show me a concrete example?")
r2 = poser_question("Can you show me a concrete example?")
print(f"R: {r2}\n")

# Turn 3 — implicit reference to previous turns
print("Q: How do I use it with arguments?")
r3 = poser_question("How do I use it with arguments?")
print(f"R: {r3}\n")

No terceiro turno, a pergunta já não menciona a palavra «decorator». O modelo continua a compreender que «usá-lo» se refere a esse conceito porque relê toda a troca. Remova a linha que adiciona a resposta ao histórico e execute novamente: o modelo perguntará sobre o que está a falar. Esta é a prova mais rápida de que a continuidade não vem do modelo, mas do seu código.

Impedir Que o Histórico Se Torne Proibitivamente Caro

Cada modelo tem uma janela de contexto limitada, medida em tokens. À medida que o histórico cresce, cada pedido torna-se mais dispendioso porque tudo é retransmitido. Uma conversa de trinta turnos fatura efetivamente o seu início trinta vezes.

A solução mais simples é truncar, mantendo a mensagem de sistema e as últimas N trocas:

MAX_MESSAGES = 20

def ajouter_message(historique, role, content):
    historique.append({"role": role, "content": content})

    # Keep the system message + the last N messages
    if len(historique) > MAX_MESSAGES + 1:  # +1 for the system message
        system_msg = historique[0]
        historique = [system_msg] + historique[-(MAX_MESSAGES):]

    return historique

Esta abordagem é barata, mas é brutal: o que o utilizador especificou no segundo turno desaparece para sempre. Quando a conversa é longa e esse contexto antigo é importante — uma entrevista de levantamento de requisitos, por exemplo — resuma-o em vez de o deitar fora:

def resumer_historique(client, historique):
    """Summarizes old messages to free up context."""
    texte_complet = "\n".join(
        f"{m['role']}: {m['content']}"
        for m in historique[1:-4]  # Exclude system and the last 4 messages
    )

    resume = client.chat.complete(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": f"Summarize this conversation in 3-4 sentences:\n{texte_complet}"}
        ]
    )

    return [
        historique[0],  # System message
        {"role": "assistant", "content": f"[Conversation Summary] {resume.choices[0].message.content}"},
    ] + historique[-4:]  # The last 4 messages

A ideia é comprimir o passado distante em algumas frases, mantendo as últimas quatro mensagens intactas, uma vez que estas carregam o contexto imediato. O resumo consome uma chamada extra, mas compensa muitas vezes nas interações subsequentes.

Criar a Mensagem de Sistema

A mensagem de sistema é a ferramenta mais poderosa e subutilizada nesta lição. Muitos contentam-se com um genérico «Você é um assistente prestativo» que nada acrescenta. Uma boa mensagem de sistema estabelece restrições verificáveis:

system_prompt = """You are a Corsen AI technical assistant.

Rules:
- Respond in French with a professional tone
- Provide code examples when relevant
- If you are unsure, say so rather than making things up
- Limit your responses to 200 words unless asked otherwise

Context: The user is working on a Python 3.12 project with FastAPI."""

Cada linha aqui produz um efeito mensurável: o limite de comprimento contém custos, o convite para reconhecer a incerteza reduz alucinações e a menção da pilha tecnológica evita respostas genéricas e fora de tema. Conciso, preciso, inequívoco — é tudo o que precisa de ser.

Pontos-chave

  • O histórico completo é reenviado com cada pedido — o modelo não «lembra» nada
  • Três papéis (system, user, assistant) estruturam a conversa
  • A mensagem system define o comportamento geral — coloque-a sempre em primeiro lugar
  • Gere o tamanho do contexto truncando ou resumindo mensagens antigas
  • Quanto mais longo for o histórico, mais cada pedido custa em tokens