Conversations multi-tours

Claude est sans état

Un point fondamental à comprendre : Claude n’a aucune mémoire entre les requêtes. Chaque appel à l’API est totalement indépendant. Si vous envoyez “Bonjour, je m’appelle Marie” puis “Comment je m’appelle ?”, Claude ne saura pas répondre — sauf si vous lui renvoyez l’historique complet.

Pour simuler une conversation, c’est à vous de maintenir et renvoyer tout l’historique à chaque requête. Ce n’est pas une limitation à contourner mais une propriété à exploiter : puisque vous contrôlez l’historique, vous pouvez en retirer un échange raté, en résumer une partie, ou repartir d’un point antérieur. Une conversation devient une donnée que vous manipulez, pas un état opaque détenu par le serveur.

Le principe

À chaque tour de conversation, vous envoyez la liste complète des messages précédents, plus le nouveau message de l’utilisateur. Claude répond en tenant compte de tout ce contexte.

Tour 1 : [user: "Bonjour"]
Tour 2 : [user: "Bonjour", assistant: "Bonjour !", user: "Ça va ?"]
Tour 3 : [user: "Bonjour", assistant: "Bonjour !", user: "Ça va ?", assistant: "Très bien !", user: "Parle-moi de Python"]

Construire des fonctions utilitaires

Pour éviter de gérer manuellement l’historique, créons des fonctions :

from dotenv import load_dotenv
import anthropic

load_dotenv()
client = anthropic.Anthropic()

def add_user_message(conversation, text):
    """Ajoute un message utilisateur a la conversation."""
    conversation.append({"role": "user", "content": text})

def add_assistant_message(conversation, text):
    """Ajoute un message assistant a la conversation."""
    conversation.append({"role": "assistant", "content": text})

def chat(conversation, user_message, model="claude-sonnet-5", max_tokens=1024):
    """Envoie un message et retourne la réponse de Claude."""
    add_user_message(conversation, user_message)

    response = client.messages.create(
        model=model,
        max_tokens=max_tokens,
        messages=conversation
    )

    assistant_text = response.content[0].text
    add_assistant_message(conversation, assistant_text)

    return assistant_text

Exemple : une conversation complète

conversation = []

# Tour 1
reponse = chat(conversation, "Qu'est-ce que l'informatique quantique ?")
print(f"Claude : {reponse}\n")

# Tour 2 — Claude se souvient du contexte
reponse = chat(conversation, "Quels sont ses principaux avantages ?")
print(f"Claude : {reponse}\n")

# Tour 3 — Claude sait toujours qu'on parle d'informatique quantique
reponse = chat(conversation, "Et quels sont les défis actuels ?")
print(f"Claude : {reponse}\n")

Au tour 2, Claude comprend que “ses” fait référence à l’informatique quantique, parce qu’il voit tout l’historique.

Examiner l’historique

À tout moment, vous pouvez inspecter la conversation :

for msg in conversation:
    role = "Vous" if msg["role"] == "user" else "Claude"
    print(f"{role} : {msg['content'][:80]}...")
    print()

Attention à la taille de la conversation

Le revers de ce fonctionnement mérite un calcul, parce qu’il surprend : au vingtième échange, vous ne payez pas vingt messages mais la somme de tous les historiques renvoyés à chaque tour. Le coût d’une conversation croît donc de façon quadratique, pas linéaire — c’est ce qui rend les stratégies ci-dessous nécessaires bien plus tôt qu’on ne l’imagine.

• Coûter cher : tous les messages précédents sont recomptés à chaque requête
• Dépasser la fenêtre de contexte : il y a une limite au nombre total de tokens

Stratégies pour gérer ça :

• Tronquer les messages les plus anciens
• Résumer périodiquement la conversation
• Utiliser le cache (que nous verrons plus tard)

Points à retenir

• Claude est sans état : pas de mémoire entre les requêtes
• Vous devez envoyer l’historique complet à chaque fois
• Des fonctions utilitaires simplifient la gestion de la conversation
• Attention à la taille croissante de l’historique

Dans la prochaine leçon, vous mettrez tout ça en pratique en construisant un chatbot.