🐍 Prompter en python

Lorsque vous rédigez un prompt en texte libre, vous dépendez surtout du langage naturel pour décrire ce que vous voulez accomplir. Le risque est de laisser place à des ambiguïtés, des imprécisions ou même des contradictions involontaires. Par exemple, si vous demandez «Donne-moi une liste de films que je pourrais regarder ce soir», la formulation peut conduire à des résultats divers selon la façon dont le modèle interprète des notions comme «films que je pourrais regarder» (genre, durée, popularité, etc.).

Prompter en Python (ou dans tout autre langage de programmation) permet d’introduire une structure et une logique supplémentaire dans vos requêtes. Voici pourquoi c’est souvent considéré comme plus efficace :

1. Précision et contrôle
   • Avec du code, vous pouvez spécifier très clairement vos critères de recherche, appliquer des filtres ou effectuer des calculs (par exemple filtrer une liste par note IMDB minimale, par durée, etc.).
   • Vous pouvez enchaîner plusieurs opérations de manière ordonnée : d’abord récupérer un jeu de données, puis le filtrer, puis choisir un format de sortie, etc.
2. Réutilisation et reproductibilité
   • Le code est réutilisable : une fois que vous avez mis au point une série de fonctions ou de scripts, vous pouvez les conserver, les partager et les rejouer pour obtenir des résultats cohérents.
   • Dans un contexte de développement plus vaste, cette reproductibilité est cruciale pour tester différentes approches, automatiser des tâches ou intégrer des appels à l’IA dans un flux de production.
3. Séparation des responsabilités
   • Il est souvent plus clair de séparer la logique métier (programmation) et la formulation du prompt (en texte, souvent dans une variable ou un fichier à part). Le développeur peut ainsi optimiser la partie code (récupération de données, structure du prompt, etc.), tandis qu’un expert domaine peut peaufiner le texte lui-même.
4. Gestion d’erreurs et robustesse
   • En scriptant, vous pouvez mieux gérer les erreurs ou les résultats inattendus, notamment via des structures conditionnelles, des exceptions, etc.
   • Les prompts en code peuvent s’adapter automatiquement si le modèle renvoie des réponses partielles ou différentes de ce qui était anticipé, là où un simple prompt en texte peut aboutir à un blocage ou à un résultat difficile à interpréter.

En résumé, le prompt au format Python (ou un autre langage) peut être plus efficace parce qu’il apporte un cadre plus rigoureux et facilite le contrôle du processus. Il réduit les ambiguïtés courantes du langage naturel et autorise l’automatisation de traitements complexes, garantissant une plus grande fiabilité et reproductibilité des résultats.

---

Voici un exemple concret pour illustrer la différence entre un prompt en « texte libre » et un prompt « piloté par du code » (en Python). Dans cet exemple, nous cherchons à obtenir une liste de 5 recettes de cuisine faciles :

• Qui utilisent du poulet,
• Qui se préparent en moins de 20 minutes,
• Avec la liste détaillée des ingrédients,
• Et dans un format de sortie structuré (titre, temps de préparation, ingrédients, etc.).

1) Exemple de prompt en texte libre

Prompt (texte) :
« Donne-moi 5 recettes de cuisine faciles, parfaites pour le déjeuner,
utilisant du poulet, qui se préparent en moins de 20 minutes,
et avec la liste des ingrédients pour chacune. »

Sortie potentielle

Réponse (exemple, texte libre) :
Voici quelques recettes :

1. Poulet grillé
   • Temps de préparation : 25 minutes
   • Ingrédients : poulet, huile, sel, poivre
2. Salade de poulet rapide
   • Temps de préparation : 15 minutes
   • Ingrédients : poulet, laitue, tomates, sauce vinaigrette
3. Poulet à la crème
   • Temps de préparation : 30 minutes
   • Ingrédients : poulet, crème fraîche, champignons, oignons
4. Wrap au poulet
   • Temps de préparation : 10 minutes
   • Ingrédients : tortilla, poulet, salade, sauce
5. Poulet curry
   • Temps de préparation : 20 minutes
   • Ingrédients : poulet, curry, lait de coco, riz

J’espère que cela vous aidera !

Problèmes potentiels dans cet exemple :

• Certaines recettes dépassent le temps de préparation demandé (25 ou 30 minutes).
• Aucune structure précise n’est garantie (une recette est nommée « Wrap au poulet », une autre « Poulet à la crème », etc.).
• Le format n’est pas systématiquement uniforme (certains détails sont plus ou moins fournis).

Lorsque vous utilisez un prompt en texte libre, vous dépendez essentiellement du modèle pour :

• Analyser chaque contrainte (moins de 20 minutes, poulet, etc.).
• Structurer la réponse comme vous l’aviez imaginé.
• Appliquer correctement tous vos critères (ou risque d’oubli).

2) Exemple de prompt en Python

Ici, au lieu de simplement dire en texte ce que l’on veut, on va contrôler précisément les données, la logique de filtrage et la mise en forme. Nous allons :

• Définir un petit jeu de données (nos recettes).
• Filtrer sur le temps de préparation (< 20 minutes) et un ingrédient particulier (poulet).
• Limiter la sortie à 5 résultats.
• Retourner un format de réponse précis (JSON, par exemple).

Code Python (exemple simplifié) :
recipes = [
{
"title": "Poulet grillé à l'huile d'olive",
"ingredients": ["Poulet", "Huile d'olive", "Sel", "Poivre"],
"prep_time": 25,
"description": "Un poulet savoureux rôti au four."
},
{
"title": "Wrap au poulet et salade",
"ingredients": ["Poulet", "Tortilla", "Salade", "Sauce"],
"prep_time": 10,
"description": "Idéal pour un déjeuner rapide."
},
{
"title": "Salade de poulet express",
"ingredients": ["Poulet", "Laitue", "Tomates", "Vinaigrette"],
"prep_time": 15,
"description": "Fraîche et légère."
},
{
"title": "Poulet curry minute",
"ingredients": ["Poulet", "Curry", "Lait de coco", "Oignons"],
"prep_time": 20,
"description": "Un curry prêt à toute vitesse."
},
{
"title": "Brochettes de poulet et légumes",
"ingredients": ["Poulet", "Poivrons", "Oignons", "Epices"],
"prep_time": 18,
"description": "Parfait pour un barbecue."
},
{
"title": "Poulet à la crème et champignons",
"ingredients": ["Poulet", "Crème fraîche", "Champignons", "Oignons"],
"prep_time": 30,
"description": "Une sauce onctueuse."
}
]

def filter_recipes(recipes, ingredient, max_prep_time, max_results):
# Filtrer d’abord les recettes sur l’ingrédient
filtered = []
for r in recipes:
# Vérifier si l’ingrédient est dans la liste
if any(ingredient.lower() in i.lower() for i in r["ingredients"]):
# Vérifier si le temps de préparation est inférieur au max
if r["prep_time"] < max_prep_time:
filtered.append(r)
# Ne conserver que le nombre de résultats souhaités
return filtered[:max_results]

# Paramètres de notre "prompt Python"
ingredient_to_search = "poulet"
max_time = 20
max_number_of_results = 5

# Récupération des recettes filtrées
filtered_recipes = filter_recipes(recipes, ingredient_to_search, max_time, max_number_of_results)

import json
print(json.dumps(filtered_recipes, indent=4, ensure_ascii=False))


Sortie produite par le code

[
    {
        "title": "Wrap au poulet et salade",
        "ingredients": [
            "Poulet",
            "Tortilla",
            "Salade",
            "Sauce"
        ],
        "prep_time": 10,
        "description": "Idéal pour un déjeuner rapide."
    },
    {
        "title": "Salade de poulet express",
        "ingredients": [
            "Poulet",
            "Laitue",
            "Tomates",
            "Vinaigrette"
        ],
        "prep_time": 15,
        "description": "Fraîche et légère."
    },
    {
        "title": "Brochettes de poulet et légumes",
        "ingredients": [
            "Poulet",
            "Poivrons",
            "Oignons",
            "Epices"
        ],
        "prep_time": 18,
        "description": "Parfait pour un barbecue."
    }
]

• Seules 3 recettes répondent effectivement aux critères (moins de 20 minutes et contenant « Poulet »).
• Le format de sortie est un JSON clair et exploitable par d’autres programmes.
• Aucune marge d’erreur possible sur le temps de préparation, car c’est un filtre strict (strictement inférieur à 20).

Avantages du prompt en Python

1. Maîtrise des filtres et des critères :
   Vous définissez exactement ce que vous cherchez. Le langage de programmation vous permet d’appliquer des règles strictes (par exemple, prep_time < 20).
2. Réutilisation et évolutivité :
   Le script peut être rejoué avec d’autres paramètres (par exemple max_prep_time = 30, ou ingredient_to_search = "boeuf"), sans risquer d’oubli ou d’erreur d’interprétation.
3. Structure de la sortie :
   Vous pouvez forcer un format (JSON, CSV, etc.), très utile pour de l’automatisation ou de l’export de données.
4. Logique de contrôle (conditions, boucles, etc.) :
   Le langage de programmation vous donne un contrôle total sur la façon de sélectionner, trier, limiter ou enrichir les données.
5. Gestion des erreurs :
   Vous pouvez gérer les cas particuliers (pas de recette trouvée, données manquantes, etc.) avec des conditions if/else ou des exceptions.

---

Conclusion

• Prompt texte libre : plus rapide à écrire, mais parfois ambigu ou moins fiable. Le modèle peut ignorer (involontairement) certaines contraintes ou ne pas respecter le format souhaité.
• Prompt en Python : permet de spécifier et d’appliquer sans ambiguïté des instructions complexes, d’avoir des sorties formatées et de rendre le tout réutilisable et automatisable.

La « supériorité » du prompt Python (ou d’un autre langage) réside surtout dans cette précision et cette automatisation : on élimine un grand nombre d’ambiguïtés liées au langage naturel, tout en offrant une structure réplicable pour des tâches complexes.

---

Voici un exemple d’approche « prompt en Python » plus avancée, intégrant divers réglages de génération (température, top-p, top-k, etc.), ainsi que des techniques de décomposition de la requête (Chain of Thought, auto-vérification, etc.). Le but est de montrer comment on peut :

1. Assembler un prompt complexe en plusieurs parties (contexte, instruction, exemples, etc.).
2. Utiliser des paramètres de génération (« hyperparamètres » comme la température, top-p, top-k…).
3. Procéder à une décomposition : envoyer une requête intermédiaire (Chain-of-Thought, ou auto-réflexion) avant de fournir la réponse finale.
4. Vérifier ou ré-évaluer la cohérence de la réponse et réitérer si nécessaire.

Remarque : le code ci-dessous se base sur l’API OpenAI (ou un mécanisme similaire) pour illustrer la mise en place. Selon la bibliothèque ou le service utilisé, les paramètres et méthodes peuvent varier (ex. : Hugging Face Transformers, autre service LLM, etc.).

---

Extrait de code Python illustratif

import openai
import time

# ------------------------------------------------------------------
# 1) Définir des paramètres de configuration (exemples)
# ------------------------------------------------------------------

MODEL_NAME = "gpt-3.5-turbo"   # Ou un autre modèle selon l’accès (gpt-4, etc.)
TEMPERATURE = 0.7              # Contrôle la "créativité". 0 = déterministe, 1 = plus aléatoire
TOP_P = 0.9                    # Nucleus sampling. 1 = considérer tout le vocabulaire
TOP_K = None                   # Certains frameworks gèrent top-k (ex. : top-k=40)
MAX_TOKENS = 512               # Longueur max de la réponse
N_RETRIES = 3                  # Nombre de tentatives si la première réponse est insatisfaisante

# (NB : OpenAI ne supporte pas toujours explicitement top_k, 
#       mais d’autres bibliothèques comme HuggingFace Transformers le font.)

# ------------------------------------------------------------------
# 2) Exemple de prompt complexe avec sections
# ------------------------------------------------------------------

def build_prompt(user_query):
    """
    Construit un prompt multi-parties, incluant :
    - Contexte ou rôle
    - Instructions spécifiques
    - éventuels exemples
    - la question finale
    """
    
    # SECTION "RÔLE" / PERSONA
    role_description = (
        "Vous êtes un assistant expert, capable d'expliquer des sujets complexes "
        "en langage clair et concis. Vous fournissez des réponses fiables "
        "et structurées, et vous justifiez vos raisonnements lorsque c'est pertinent.\n\n"
    )
    
    # SECTION "INSTRUCTIONS" / CONSIGNES PRINCIPALES
    instructions = (
        "Consignes :\n"
        "1. Répondez en français.\n"
        "2. Fournissez des exemples concrets si possible.\n"
        "3. Évitez les réponses vagues ou non justifiées.\n"
        "4. Donnez la meilleure explication possible.\n\n"
    )
    
    # SECTION "EXEMPLES" / FEW-SHOT (facultatif)
    # (On peut insérer un ou deux exemples de question-réponse pour guider le modèle)
    examples = (
        "Exemple Q : Qu'est-ce que le Machine Learning ?\n"
        "Exemple R : Le Machine Learning est ... [exemple de réponse détaillée]\n\n"
    )
    
    # SECTION "QUESTION UTILISATEUR"
    user_section = f"Question : {user_query}\n\n"
    
    # ASSEMBLAGE FINAL DU PROMPT
    prompt_final = role_description + instructions + examples + user_section
    return prompt_final

# ------------------------------------------------------------------
# 3) Décomposition de la requête (Chain of Thought, Self-Ask, etc.)
# ------------------------------------------------------------------

def chain_of_thought(query):
    """
    Exécution d’une requête intermédiaire qui force le modèle
    à réfléchir étape par étape avant de donner la réponse finale.
    
    *Note* : Dans certains cas, on peut préférer ne pas afficher
             cette 'chain-of-thought' à l’utilisateur final.
    """
    # On prépare un prompt plus directif, demandant explicitement
    # une réflexion pas à pas (Self-Ask, Chain-of-Thought).
    
    # ATTENTION : Les politiques de certains fournisseurs (OpenAI)
    #             peuvent déconseiller d’afficher mot pour mot
    #             les "chain of thought" final à l'utilisateur.
    #             Mais pour la démonstration, nous le faisons ici.
    
    cot_prompt = (
        "Analyse pas à pas la question suivante et explique "
        "ton raisonnement avant de donner la réponse finale.\n\n"
        f"Question : {query}\n\n"
        "Réfléchis étape par étape :\n"
    )
    
    # Appel d’API ou de fonction interne
    response = openai.ChatCompletion.create(
        model=MODEL_NAME,
        messages=[{"role": "user", "content": cot_prompt}],
        temperature=TEMPERATURE,
        top_p=TOP_P,
        max_tokens=512
    )
    
    # Récupération du 'reasoning' (la partie "chain of thought")
    chain_of_thought_answer = response["choices"][0]["message"]["content"]
    
    return chain_of_thought_answer

def final_answer(query):
    """
    Utilise la sortie chain-of-thought pour générer la réponse finale
    (auto-réflexion -> réponse concise).
    """
    # On peut injecter le chain-of-thought dans un nouveau prompt,
    # puis demander une synthèse propre.
    
    cot = chain_of_thought(query)
    
    # Prompt pour la synthèse
    synthesis_prompt = (
        "Tu viens de produire le raisonnement suivant :\n\n"
        f"{cot}\n\n"
        "Maintenant, fournis la réponse finale résumée, claire et structurée, "
        "sans trop divulguer le raisonnement détaillé.\n"
    )
    
    response = openai.ChatCompletion.create(
        model=MODEL_NAME,
        messages=[{"role": "user", "content": synthesis_prompt}],
        temperature=TEMPERATURE,
        top_p=TOP_P,
        max_tokens=MAX_TOKENS
    )
    
    return response["choices"][0]["message"]["content"]

# ------------------------------------------------------------------
# 4) Exemple de fonction principale pour gérer les retrys / validation
# ------------------------------------------------------------------

def get_answer_with_retries(user_query):
    """
    1. Construit un prompt
    2. Tente plusieurs fois si la réponse n’est pas satisfaisante
    3. Intègre un mécanisme de validation basique
    """
    
    prompt = build_prompt(user_query)
    
    for attempt in range(N_RETRIES):
        try:
            # Appel direct (sans chain-of-thought)
            response = openai.ChatCompletion.create(
                model=MODEL_NAME,
                messages=[{"role": "user", "content": prompt}],
                temperature=TEMPERATURE,
                top_p=TOP_P,
                max_tokens=MAX_TOKENS
            )
            
            answer = response["choices"][0]["message"]["content"]
            
            # Vérification basique (exemple : longueur minimale)
            if len(answer) < 30:
                print(f"[Tentative {attempt+1}] Réponse trop courte, on réessaie...")
                continue
            
            # Si la réponse nous semble satisfaisante, on la renvoie
            return answer
        
        except Exception as e:
            print(f"Erreur lors de la requête : {e}")
            time.sleep(1)
    
    # Si toutes les tentatives échouent, on renvoie un message d’erreur
    return "Désolé, je n'ai pas pu obtenir de réponse satisfaisante après plusieurs essais."

# ------------------------------------------------------------------
# 5) Exemple d'utilisation
# ------------------------------------------------------------------

if __name__ == "__main__":
    # Exemples de requêtes
    query1 = "Explique-moi la différence entre la température et le top-p dans les modèles de génération de texte."
    
    # a) Appel direct avec prompt complet + retrys
    print("=== EXEMPLE SANS CHAIN OF THOUGHT ===")
    answer_direct = get_answer_with_retries(query1)
    print(answer_direct)
    
    # b) Appel avec Chain of Thought suivi d’une synthèse
    print("\n=== EXEMPLE AVEC CHAIN OF THOUGHT (SELF-ASK) ===")
    answer_cot = final_answer(query1)
    print(answer_cot)

Explications / Points clés

1. Paramètres de génération
   • temperature : contrôle l’aléatoire dans le choix des tokens. Plus la température est élevée, plus les réponses peuvent être créatives ou variables.
   • top_p (nucleus sampling) : si top_p = 0.9, le modèle ne pioche les tokens que dans le groupe représentant 90 % de la probabilité cumulée. Cela permet de réduire les réponses trop farfelues.
   • top_k : limite le nombre de tokens candidats à chaque étape (ex. : top_k = 40). Tous les frameworks ne gèrent pas ce paramètre de la même façon.
   • max_tokens : longueur maximale de la réponse.
2. Décomposition (Chain of Thought / Self-Ask)
   • On appelle d’abord le modèle pour générer un raisonnement interne.
   • Dans un second temps, on réinjecte ce raisonnement pour obtenir une réponse finale concise.
   • Avantage : permet parfois des réponses plus fiables et structurées, car le modèle a déjà « pensé » à haute voix avant de répondre.
   • Inconvénient : c’est plus long (2 appels successifs) et, selon la politique du fournisseur, on peut préférer ne pas exposer directement la « chain-of-thought » à l’utilisateur final.
3. Auto-vérification / Réessais
   • Exemples de checks possibles :
     • Longueur minimale (si la réponse fait moins de X caractères, on réessaie).
     • Recherche de mots-clés (par ex. si on veut s’assurer que le mot « Exemple » figure dans la réponse).
     • Raison d’erreur : si l’API renvoie un timeout ou une erreur, on retente.
4. Prompt multi-parties
   • Rôle / Persona : préciser le registre de langue, la posture (expert, pédagogue, etc.).
   • Instructions : directives claires (langue, style, format, points à aborder).
   • Exemples (few-shot) : montrer au modèle le type de réponses attendu.
   • Question : la requête finale de l’utilisateur.
5. Réutilisabilité
   • Une fois votre pipeline Python monté (prompting, chain-of-thought, vérification…), vous pouvez l’étendre à d’autres sujets, d’autres projets.

---

Conclusion

En combinant des prompts structurés (multi-parties), en utilisant des réglages fins de génération (température, top-p, top-k, max_tokens, etc.) et en implémentant des techniques de décomposition (Chain-of-Thought, Self-Ask), vous obtenez :

• Plus de contrôle sur la forme et la fiabilité de la réponse,
• La possibilité de réessayer automatiquement en cas de réponse incomplète ou insatisfaisante,
• Une flexibilité pour enrichir l’approche (vérification, post-traitement, etc.).

C’est toute la force du « prompt Python » : passer d’un simple texte libre à un flux d’instructions, de filtrage, de vérification et d’assemblage qui garantit une meilleure reproductibilité et une plus grande précision.

---

Voici un exemple de script Python qui illustre :

1. Comment poser une question à un LLM (via une API, ici illustrée façon OpenAI) concernant un personnage historique.
2. Structurer la réponse (biographie, faits marquants, vérification) avec un prompt complet (rôle, instructions, etc.).
3. Inclure une petite étape de vérification (si la réponse est trop courte, ou ne contient pas certains champs, on refait une tentative).

Remarque : Cet exemple suppose que vous avez des identifiants d’API (variable openai.api_key) et que vous pouvez appeler openai.ChatCompletion.create. Vous pouvez l’adapter à d’autres bibliothèques ou fournisseurs si besoin.

---

Script Python d’exemple

import openai
import time

# Assurez-vous d'avoir configuré votre clé API, par exemple :
# openai.api_key = "sk-..."

MODEL_NAME = "gpt-3.5-turbo"  # ou "gpt-4", selon vos accès
TEMPERATURE = 0.7
TOP_P = 0.9
MAX_TOKENS = 800
N_RETRIES = 3

def build_prompt_for_historical_figure(figure_name: str) -> str:
    """
    Construit un prompt structuré pour demander une présentation
    d'un personnage historique donné, avec des exigences claires
    sur le format et le contenu.
    """
    
    role_description = (
        "Vous êtes un assistant historique et pédagogique, spécialisé "
        "dans la présentation claire et fiable de personnages célèbres.\n\n"
    )
    
    instructions = (
        "Consignes :\n"
        "1. Répondez en français.\n"
        "2. Fournissez une structure organisée en sections :\n"
        "   - Nom et dates clés (naissance, décès)\n"
        "   - Brève biographie\n"
        "   - Réalisations / faits marquants\n"
        "   - Influence ou héritage\n"
        "3. Vérifiez la cohérence des informations et ne pas inventer de détails.\n"
        "4. Restez concis mais précis.\n\n"
    )
    
    # On peut donner un exemple de format (facultatif)
    example = (
        "Exemple de format :\n"
        "Nom et dates clés : ...\n"
        "Biographie : ...\n"
        "Réalisations : ...\n"
        "Influence : ...\n\n"
    )
    
    user_question = f"Décris le personnage historique suivant : {figure_name}\n\n"
    
    prompt_final = role_description + instructions + example + user_question
    return prompt_final

def ask_historical_figure(figure_name: str) -> str:
    """
    Interroge le modèle sur un personnage historique, en construisant
    un prompt structuré et en gérant les éventuels réessais si la réponse
    est incomplète ou non conforme.
    """
    prompt = build_prompt_for_historical_figure(figure_name)
    
    for attempt in range(N_RETRIES):
        try:
            response = openai.ChatCompletion.create(
                model=MODEL_NAME,
                messages=[{"role": "user", "content": prompt}],
                temperature=TEMPERATURE,
                top_p=TOP_P,
                max_tokens=MAX_TOKENS
            )
            
            answer = response["choices"][0]["message"]["content"]
            
            # Vérification basique : la réponse contient-elle les sections demandées ?
            # (Vous pouvez raffiner ce check)
            if ("Nom et dates clés" not in answer or 
                "Biographie" not in answer or
                "Réalisations" not in answer or
                "Influence" not in answer):
                print(f"[Tentative {attempt+1}] La réponse ne semble pas contenir toutes les sections. On réessaie...\n")
                continue
            
            # Vérification longueur minimale
            if len(answer) < 200:
                print(f"[Tentative {attempt+1}] Réponse trop courte, on réessaie...\n")
                continue
            
            # Si tout va bien, on retourne la réponse
            return answer
        
        except Exception as e:
            print(f"Erreur lors de la requête : {e}. Tentative {attempt+1} sur {N_RETRIES}.")
            time.sleep(1)
    
    # Si on n’a pas obtenu de réponse satisfaisante après N_RETRIES
    return "Désolé, je n'ai pas pu obtenir de réponse satisfaisante après plusieurs essais."

def main():
    # Exemple d'utilisation
    print("Entrez le nom du personnage historique :")
    figure_name = input("> ")
    
    # Appel de la fonction
    structured_answer = ask_historical_figure(figure_name)
    
    print("\n=== RÉPONSE STRUCTURÉE ===\n")
    print(structured_answer)

if __name__ == "__main__":
    main()

---

Explications

1. build_prompt_for_historical_figure
   • Construit un prompt structuré : il décrit le rôle (assistant expert), liste des consignes précises (sections attendues : dates clés, biographie, réalisations, influence), fournit un exemple de format et pose la question.
2. ask_historical_figure
   • Envoie ce prompt au modèle via openai.ChatCompletion.create.
   • Implémente un système de retrys (N_RETRIES) :
     • S’il manque l’une des sections attendues (ex. : “Nom et dates clés”, “Biographie”, “Réalisations”, “Influence”), on réessaie.
     • S’il juge la réponse trop courte, on réessaie.
   • Si après plusieurs tentatives, la réponse n’est toujours pas satisfaisante, on renvoie un message d’erreur.
3. main
   • Demande à l’utilisateur un nom de personnage historique (par exemple : “Napoléon Bonaparte”, “Cléopâtre”, “Martin Luther King”, etc.).
   • Appelle ask_historical_figure pour obtenir la réponse.
   • Affiche la réponse structurée.

Paramétrage

• Temperature = 0.7 : le texte reste relativement cohérent mais un peu créatif. Pour un contenu historique, vous pouvez baisser la température (ex. 0.3) si vous souhaitez des réponses plus « factuelles ».
• Top-P = 0.9 : on limite les options de tokens à 90 % du cumul de probabilité.
• max_tokens = 800 : limite la longueur de la réponse.
• N_RETRIES = 3 : nombre de tentatives avant d’abandonner.

Vous pouvez affiner ces paramètres selon vos besoins.

---

Conclusion

Grâce à ce prompt Python :

• L’utilisateur saisit un personnage historique ;
• Le script construit un prompt structuré (rôle, instructions claires, format) ;
• On vérifie la présence des sections attendues (Dates clés, Biographie, etc.) et on réessaie en cas de réponse incomplète ;
• On obtient enfin une réponse fiable, dans un format standardisé.

Ce type de configuration et de vérification automatique illustre la puissance du « prompt en Python » : on contrôle la cohérence et la structure de la réponse, plutôt que de s’en remettre simplement à un prompt en texte libre.