Ajout app.py et requirements.txt

.env

@@ -0,0 +1,3 @@
+MISTRAL_API_KEY=MKsv7UiQIa9cZiK1wTBj8fJxkdGQmtp0
+QDRANT_URL=https://60345ec0-33a0-4d58-8c6b-0ee3836eab9a.europe-west3-0.gcp.cloud.qdrant.io:6333
+QDRANT_API_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0._j3BGXxD1_81_iYQNMY_MNNMMfAZaiA39IW_EirgnQA

README.md

@@ -1,19 +1,14 @@
----
-title: Parlement Rag
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Générateur de projets de réponse à des questions écrites
----
+# CamemBERT finetuné progressif 🚀
 
-# Welcome to Streamlit!
+Ce modèle est une version finetunée de [CamemBERT](https://huggingface.co/camembert-base) 
+dans le cadre de mon projet CS50.  
+Il est conçu pour générer des embeddings adaptés à des tâches de compréhension de texte en français.
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## 📦 Utilisation
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+```python
+from sentence_transformers import SentenceTransformer
+
+model = SentenceTransformer("Whisler/camembert_finetuned_progressive")
+embeddings = model.encode(["Exemple de phrase en français"])
+print(embeddings)

app.py

@@ -0,0 +1,764 @@
+import streamlit as st
+import hashlib
+import yaml
+import requests
+import pyperclip
+import os
+from yaml.loader import SafeLoader
+from docx import Document
+from dotenv import load_dotenv
+
+import streamlit as st
+st.set_page_config(page_title="Generateur", page_icon="🗳️")
+
+# --- 1. Chargement des variables d'environnement ---
+load_dotenv()
+QDRANT_URL = os.getenv("QDRANT_URL", "").strip()
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY", "").strip()
+MISTRAL_API_KEY = os.getenv("MISTRAL_API_KEY", "").strip()
+QDRANT_COLLECTION = "QuestionParlementaire"
+
+if not QDRANT_URL.startswith("https://"):
+    raise RuntimeError("❌ QDRANT_URL doit commencer par https://")
+if not QDRANT_API_KEY:
+    raise RuntimeError("❌ QDRANT_API_KEY manquant. Vérifiez votre fichier .env")
+if not MISTRAL_API_KEY:
+    raise RuntimeError("❌ MISTRAL_API_KEY manquant. Vérifiez votre fichier .env")
+
+print("QDRANT_URL:", QDRANT_URL)
+print("QDRANT_API_KEY (début):", QDRANT_API_KEY[:10], "...")
+
+
+from sentence_transformers import SentenceTransformer
+import streamlit as st
+
+# --- 3. Chargement du modèle ---
+EMBEDDING_MODEL_PATH = "./models/camembert_finetuned_progressive"
+
+@st.cache_resource
+def load_embedding_model():
+    try:
+        model = SentenceTransformer(EMBEDDING_MODEL_PATH)
+        test_embedding = model.encode("Test de chargement du modèle.")
+        VECTOR_SIZE = len(test_embedding)
+        print("✅ Modèle CamemBERT chargé. Dimension:", VECTOR_SIZE)
+        return model
+    except Exception as e:
+        print("❌ Erreur de chargement du modèle:", str(e))
+        raise
+
+embedding_model = load_embedding_model()
+
+
+
+
+
+# --- 4. Connexion à Qdrant ---
+try:
+    qdrant_client = QdrantClient(
+        url=QDRANT_URL,
+        api_key=QDRANT_API_KEY,
+        timeout=10.0,
+        check_compatibility=False
+    )
+    collections = qdrant_client.get_collections()
+    print(f"✅ Connexion réussie. Collections disponibles: {[c.name for c in collections.collections]}")
+except Exception as e:
+    print(f"❌ Erreur de connexion à Qdrant: {e}")
+    raise
+
+
+
+
+# --- 6. Fonction de recherche ---
+def search_similar_questions(query: str, legislature: str = None, rubrique: str = None, limit: int = 5):
+    collections = qdrant_client.get_collections()
+    if QDRANT_COLLECTION not in [c.name for c in collections.collections]:
+        raise HTTPException(
+            status_code=500,
+            detail=f"La collection '{QDRANT_COLLECTION}' n'existe pas encore. Veuillez l'initialiser."
+        )
+    embedding = embedding_model.encode(query).tolist()
+    query_filter = None
+    conditions = []
+    if legislature:
+        conditions.append(models.FieldCondition(key="legislature", match=models.MatchText(text=legislature)))
+    if rubrique:
+        conditions.append(models.FieldCondition(key="rubrique", match=models.MatchText(text=rubrique)))
+    if conditions:
+        query_filter = models.Filter(must=conditions)
+    results = qdrant_client.search(
+        collection_name=QDRANT_COLLECTION,
+        query_vector=embedding,
+        query_filter=query_filter,
+        limit=limit,
+        with_payload=True
+    )
+    if not results:
+        raise HTTPException(status_code=404, detail=f"Aucun résultat trouvé dans '{QDRANT_COLLECTION}'.")
+    return [result.payload for result in results]
+
+def search_documents(query: str = None, legislature: str = None, rubrique: str = None,
+                    ministere: str = None, limit: int = 10, offset: int = 0):
+    """Recherche des documents dans Qdrant avec filtres"""
+    conditions = []
+    if legislature:
+        conditions.append(models.FieldCondition(key="legislature", match=models.MatchText(text=legislature)))
+    if rubrique:
+        conditions.append(models.FieldCondition(key="rubrique", match=models.MatchText(text=rubrique)))
+    if ministere:
+        conditions.append(models.FieldCondition(key="ministeres_attribues", match=models.MatchAny(any=[ministere])))
+
+    query_filter = models.Filter(must=conditions) if conditions else None
+
+    # Recherche par similarité ou scroll
+    if query:
+        embedding = embedding_model.encode(query).tolist()
+        results = qdrant_client.search(
+            collection_name=QDRANT_COLLECTION,
+            query_vector=embedding,
+            query_filter=query_filter,
+            limit=limit,
+            offset=offset,
+            with_payload=True
+        )
+    else:
+        results, _ = qdrant_client.scroll(
+            collection_name=QDRANT_COLLECTION,
+            query_filter=query_filter,
+            limit=limit,
+            offset=offset,
+            with_payload=True
+        )
+
+    # Formatage des résultats
+    documents = []
+    for result in results:
+        payload = result.payload
+        documents.append(DocumentInfo(
+            uid=payload.get("uid", ""),
+            date=payload.get("date_reponse", payload.get("date_question", "Inconnue")),
+            chambre=(
+                "Assemblée nationale" if str(payload.get("uid", "")).startswith('QAN')
+                else "Sénat" if str(payload.get("uid", "")).isdigit() or isinstance(payload.get("uid"), (int, float))
+                else "Inconnue"
+            ),
+            question=payload.get("question", "")[:200] + "..." if len(payload.get("question", "")) > 200 else payload.get("question", ""),
+            themes=payload.get("rubrique", "").split(";") if payload.get("rubrique") else [],
+            ministeres=payload.get("ministeres_attribues", [])
+        ))
+
+    return {
+        "documents": documents,
+        "total": len(results) if query else qdrant_client.get_collection(QDRANT_COLLECTION).points_count,
+        "limit": limit,
+        "offset": offset
+    }
+
+
+
+
+
+# --- 7. Génération de la réponse ---
+@app.post("/ask", response_model=RAGResponse)
+async def generate_response(request: QuestionRequest):
+    try:
+        # Recherche des questions similaires (5 résultats)
+        similar_results = search_similar_questions(
+            request.question,
+            legislature=request.legislature,
+            rubrique=request.rubrique,
+            limit=5
+        )
+
+        # MODIFIÉ : Création d'une liste de SimilarQuestion avec le numéro de question
+        similar_questions = [
+            SimilarQuestion(
+                date=result.get("date_reponse", "Inconnue"),
+                chambre=(
+                    f"Assemblée nationale ({result.get('uid', '')})"
+                    if isinstance(result.get("uid"), str) and result.get("uid", "").startswith('QAN') else
+                    f"Sénat ({result.get('uid', '')})"
+                    if isinstance(result.get("uid"), (int, float)) or (isinstance(result.get("uid"), str) and result.get("uid", "").isdigit()) else
+                    "Inconnue"
+                ),
+                question=result.get("question", ""),
+                reponse=result.get("reponse", "")
+            )
+            for result in similar_results
+            if "question" in result
+        ]
+
+        # Recherche des contextes pour la réponse (3 résultats)
+        rag_results = search_similar_questions(
+            request.question,
+            legislature=request.legislature,
+            rubrique=request.rubrique,
+            limit=3
+        )
+        contexts = []
+        textes_juridiques = set()
+        for result in rag_results:
+            contexts.append(result.get("reponse", ""))
+            if "textes_juridiques" in result:
+                for texte in result["textes_juridiques"]:
+                    texte_str = f"{texte.get('code', '')} {texte.get('article', '')}".strip()
+                    if texte_str:
+                        textes_juridiques.add(texte_str)
+        context_str = "\n\n".join([f"Contexte {i+1}: {ctx}" for i, ctx in enumerate(contexts)])
+        textes_juridiques_str = (
+            "\n".join(f"- {texte}" for texte in textes_juridiques)
+            if textes_juridiques
+            else "Aucun texte juridique spécifique"
+        )
+
+        # Définition du prompt selon le type de requête (analyse ou question parlementaire)
+        def build_prompt(request: QuestionRequest, context_str: str, textes_juridiques_str: str):
+            """Construit le prompt avec toutes les options"""
+
+            # Mapping du type de réponse attendue
+            orientation_mapping = {
+                "Répondre de façon neutre": "",
+                "Répondre négativement aux propositions du parlementaire":
+                    "Répondez de manière polie mais ferme en rejetant les propositions du parlementaire. "
+                    "Mettez en avant les contraintes légales, budgétaires ou politiques qui empêchent "
+                    "de donner suite à cette demande. Utilisez des formulations comme: "
+                    "'comme indiqué précédemment', 'conformément à la réglementation en vigueur', "
+                    "'les contraintes budgétaires ne permettent pas'.",
+
+                "Répondre positivement aux propositions du parlementaire":
+                    "Répondez de manière positive. Utilisez des formulations comme: "
+                    "'le Gouvernement salue cette initiative', 'cette proposition va dans le sens de', "
+                    "'nous partageons pleinement cette préoccupation', 'nous travaillerons avec cette assemblée pour' "
+                    "'nous travaillerons avec vous pour', 'Mettez en avant les aspects "
+                    "innovants et l'engagement du gouvernement.",
+
+                "Répondre de manière technique et détaillée":
+                    "Fournissez une réponse extrêmement détaillée et technique. "
+                    "Incluez des références précises aux articles de loi, des données chiffrées, "
+                    "et des explications sur les procédures administratives. Utilisez un vocabulaire "
+                    "spécialisé et des termes juridiques précis."
+
+            }
+
+            # Instructions personnalisées
+            custom_instructions_part = ""
+            if request.custom_instructions:
+                custom_instructions_part = f"""
+                **Instructions spécifiques supplémentaires:**
+                {request.custom_instructions}
+                """
+            # Construction du prompt selon le mode
+            if request.mode == "analyse":
+                prompt = f"""
+                [INST]
+                Vous êtes un assistant parlementaire expert. Fournissez une analyse synthétique du sujet,
+                en mettant en avant les points clés et les références juridiques pertinentes.
+
+                **Question:** {request.question}
+
+                **Contexte:**
+                {context_str}
+
+                **Textes juridiques applicables:**
+                {textes_juridiques_str}
+
+                **Consignes:**
+                - Détail juridique: {request.detail_juridique}/5
+                - Longueur: {request.longueur}
+                - Style: concis, analytique, pédagogique.
+                [/INST]
+                """
+
+            else:  # mode == "parlementaire"
+                prompt = f"""
+                [INST]
+                {orientation_mapping.get(request.response_orientation, "")}
+
+                {custom_instructions_part}
+
+                Vous êtes attaché au ministère. Rédigez une réponse officielle à une question écrite parlementaire
+                dans le style des réponses publiées au Journal Officiel.
+
+                **Question:** {request.question}
+
+                **Contexte:**
+                {context_str}
+
+                **Textes juridiques applicables:**
+                {textes_juridiques_str}
+
+                **Consignes:**
+                - Détail juridique: {request.detail_juridique}/5
+                - Commencez la réponse en rappelant la préoccupation du député.
+                - Poursuivez avec les chiffres, les références juridiques et les mesures en cours de mise en oeuvre.
+                - Concluez en réaffirmant l'engagement du Gouvernement.
+                - Ne pas mélanger le sujet à d'autres sujets trop éloignés dans la conclusion.
+                - Utilisez un style administratif et formel, comme dans les réponses ministérielles.
+                - La réponse doit être rédigée en prose continue, sans titres, sans puces, sans numérotation.
+                - Utilisez uniquement des paragraphes rédigés, comme dans les réponses ministérielles publiées au Journal Officiel.
+                - Si vous avez plusieurs éléments à présenter, intégrez-les dans des phrases complètes reliées par des connecteurs ("par ailleurs", "en outre", "de plus").
+                - Ne pas mettre de formule de politesse à la fin.
+                - **Contrainte de longueur absolue** : La réponse ne doit pas dépasser {request.longueur}.
+                - Toute réponse plus longue sera rejetée.
+                - Si le sujet est trop complexe pour tenir dans cette limite, concentrez-vous sur les points les plus importants.
+                - Toute réponse qui se termine par une phrase tronquée est incorrecte.
+                - Toute réponse qui contient des listes ou des titres est incorrecte.
+                [/INST]
+                """
+            return prompt
+
+        # --- Adapter max_tokens dynamiquement ---
+        if request.longueur.startswith("Courte"):
+            max_tokens = 500    # marge pour ~300 mots
+        elif request.longueur.startswith("Moyenne"):
+            max_tokens = 1000   # marge pour ~500 mots
+        elif request.longueur.startswith("Longue"):
+            max_tokens = 2200   # marge pour ~1000 mots
+        else:
+            max_tokens = 1000   # valeur par défaut
+
+        # Construire le prompt
+        prompt = build_prompt(request, context_str, textes_juridiques_str)
+
+        # 1ère interrogation Mistral
+        mistral_api_url = "https://api.mistral.ai/v1/chat/completions"
+        headers = {"Authorization": f"Bearer {MISTRAL_API_KEY}", "Content-Type": "application/json"}
+
+        payload = {
+            "model": "mistral-large-latest",
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.3,
+            "max_tokens": max_tokens
+        }
+
+        response = requests.post(mistral_api_url, headers=headers, json=payload, timeout=90)
+        response.raise_for_status()
+        data = response.json()
+        mistral_response = data["choices"][0]["message"]["content"]
+
+        # Vérification du tronquage
+        is_truncated = data["choices"][0].get("finish_reason") == "length"
+
+        if is_truncated:
+            # Extraction de la dernière phrase incomplète
+            last_period = mistral_response.rfind('.')
+            if last_period > 0 and last_period < len(mistral_response) - 100:
+                incomplete_part = mistral_response[last_period+1:]
+            else:
+                incomplete_part = mistral_response[-100:]
+
+            # Prompt de complétion optimisé
+            completion_prompt = f"""
+            [INST]
+            Complétez cette réponse parlementaire de manière naturelle et formelle:
+
+            Contexte: {request.question[:200]}...
+            Dernière partie à compléter: "{incomplete_part}"
+
+            Consignes:
+            - Terminez la phrase/paragraphe en cours de manière cohérente.
+            - Ajoutez une conclusion sur le thème de la question en 1-2 phrases maximum.
+            - Utilisez un style administratif et formel, comme dans les réponses ministérielles.
+            - Respectez strictement la limite de 400 caractères.
+            - Tout complément de réponse plus long sera rejeté.
+            - Concluez en réaffirmant l'engagement du Gouvernement.
+            - La réponse doit être rédigée en prose continue, sans titres, sans puces, sans numérotation.
+            - Utilisez uniquement des paragraphes rédigés, comme dans les réponses ministérielles publiées au Journal Officiel.
+            - Si vous avez plusieurs éléments à présenter, intégrez-les dans des phrases complètes reliées par des connecteurs ("par ailleurs", "en outre", "de plus").
+            - Ne pas mettre de formule de politesse à la fin.
+            - Tout complément de réponse qui se termine par une phrase tronquée est incorrecte.
+            - Toute complément de réponse qui contient des listes ou des titres est incorrecte.
+
+            [/INST]
+            """
+
+            completion_payload = {
+                "model": "mistral-large-latest",
+                "messages": [{"role": "user", "content": completion_prompt}],
+                "temperature": 0.1,  # Plus déterministe
+                "max_tokens": 60
+            }
+
+            try:
+                # Deuxième et dernier appel à Mistral
+                completion_response = requests.post(
+                    mistral_api_url,
+                    headers=headers,
+                    json=completion_payload,
+                    timeout=30
+                )
+                completion_response.raise_for_status()
+                completion = completion_response.json()["choices"][0]["message"]["content"]
+
+                # Fusion intelligente
+                if mistral_response.endswith("..."):
+                    mistral_response = mistral_response[:-3] + completion
+                elif mistral_response.endswith(" "):
+                    mistral_response += completion
+                else:
+                    mistral_response += " " + completion
+
+                # Vérification finale de la ponctuation
+                if not mistral_response.endswith(('.', '!', '?')):
+                    mistral_response += "."
+
+            except Exception as e:
+                # Fallback en cas d'échec de la complétion
+                mistral_response += " Je vous prie d'agréer, Monsieur le Député, l'expression de ma considération distinguée."
+
+        return {
+            "question": request.question,
+            "context": contexts,
+            "response": mistral_response,
+            "sources": list(textes_juridiques),
+            "similar_questions": similar_questions,
+            "metadata": {
+                "legislature": request.legislature,
+                "rubrique": request.rubrique,
+                "model_used": "mistral-large-latest",
+                "was_completed": is_truncated,
+                "final_length": len(mistral_response)
+            }
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur backend: {str(e)}")
+
+# --- NOUVEL ENDPOINT SIMPLIFIÉ POUR LISTER LES DOCUMENTS ---
+
+@app.get("/simple-documents-list")
+async def get_simple_documents_list():
+    """Retourne juste les deux catégories de documents - VERSION STATIQUE"""
+    return {
+        "documents": [
+            {
+                "type": "Questions écrites (QE) de l'Assemblée nationale",
+                "periode": "2017-2025",
+                "description": "Questions ayant obtenu une réponse ministérielle (avant le 1er novembre 2025)."
+            },
+            {
+                "type": "Questions écrites (QE) du Sénat",
+                "periode": "2017-2025",
+                "description": "Collection complète des questions écrites ayant obtenu une réponse ministérielle (avant le 1er novembre 2025)."
+            }
+        ]
+    }
+
+# st.set_page_config(page_title="Générateur de réponses aux questions écrites parlementaires", page_icon="🏛️", layout="wide")
+    
+# --- 1. Configuration ---
+with open('config.yaml') as file:
+    config = yaml.load(file, Loader=SafeLoader)
+
+# --- 2. Authentification ---
+if 'authentication_status' not in st.session_state:
+    st.session_state.authentication_status = None
+
+def check_password():
+    if st.session_state["username"] in config['credentials']['usernames']:
+        stored_password = config['credentials']['usernames'][st.session_state["username"]]["password"]
+        if hashlib.sha256(st.session_state["password"].encode()).hexdigest() == stored_password:
+            st.session_state["authentication_status"] = True
+            st.session_state["name"] = config['credentials']['usernames'][st.session_state["username"]]["name"]
+            return
+    st.session_state["authentication_status"] = False
+
+# --- 3. Connexion ou contenu principal ---
+if st.session_state.authentication_status is not True:
+    # Masquer la sidebar avant connexion
+    st.markdown("""
+        <style>
+        [data-testid="stSidebar"] {display: none;}
+        /* Centrer le titre */
+        .auth-title {text-align: center; margin-top: 0.5rem;}
+        /* Centrer le paragraphe d'intro */
+        .auth-intro {text-align: center; color: #5c5c5c;}
+        </style>
+    """, unsafe_allow_html=True)
+
+    # --- Page d'authentification ---
+    st.markdown('<h1 class="auth-title">🔐 Authentification requise</h1>', unsafe_allow_html=True)
+    st.markdown('<p class="auth-intro">Veuillez entrer vos identifiants pour accéder au générateur de réponses aux questions écrites.</p>', unsafe_allow_html=True)
+
+    # Colonnes pour réduire la largeur et centrer les champs
+    # Ajuste les ratios pour obtenir la largeur souhaitée (ici ~25% de la page)
+    left, center, right = st.columns([3, 2, 3])
+    with center:
+        st.text_input("Nom d'utilisateur", key="username")
+        st.text_input("Mot de passe", type="password", key="password")
+        if st.button("Se connecter"):
+            check_password()
+            st.rerun()
+
+    if st.session_state.authentication_status is False:
+        st.error("Identifiants incorrects. Veuillez réessayer.")
+
+else:
+    # Réafficher la sidebar après connexion
+    st.markdown("""
+        <style>
+        [data-testid="stSidebar"] {display: block;}
+        </style>
+    """, unsafe_allow_html=True)
+
+    # --- Tout le reste du contenu (après connexion) ---
+
+    # --- 4. Section Consulter les documents RAG ---
+
+    # --- 6. Configuration de la page et CSS ---
+    st.markdown("""
+    <style>
+        /* Votre CSS existant */
+        .stApp { background-color: #f8f9fa; }
+        .stTabs [data-baseweb="tab-list"] { gap: 0; background-color: #e9ecef; border-radius: 6px 6px 0 0; padding: 4px; }
+        .stTabs [data-baseweb="tab"] { height: 36px; white-space: pre-wrap; background-color: #f8f9fa; border: none; border-radius: 4px 4px 0 0; padding: 0 12px; }
+        .stTabs [aria-selected="true"] { background-color: #ffffff; font-weight: bold; color: #3d3d3d; }
+        .stButton>button { background-color: #4a8bfc; color: white; border: none; border-radius: 4px; padding: 8px 16px; font-weight: 500; }
+        .stButton>button:hover { background-color: #3a7bfc; }
+        .stExpander { background-color: #ffffff; border: 1px solid #e9ecef; border-radius: 6px; margin-bottom: 8px; }
+        .stTextArea textarea { font-family: 'Segoe UI', sans-serif; font-size: 16px; line-height: 1.5; }
+        .stAlert { border-radius: 6px; }
+        .source-text { font-family: monospace; font-size: 14px; background-color: #f8f9fa; padding: 8px; border-radius: 4px; border-left: 3px solid #4a8bfc; }
+        .response-text { font-family: 'Segoe UI', sans-serif; font-size: 16px; line-height: 1.6; white-space: pre-wrap; background-color: white; padding: 16px; border-radius: 6px; border: 1px solid #e9ecef; }
+    </style>
+    """, unsafe_allow_html=True)
+
+    st.title("🏛️ Générateur de réponses aux questions écrites parlementaires")
+    st.markdown("""
+    Application (version Beta) générant des projets de réponse aux questions parlementaires,
+    appuyée sur une base documentaire (embedding avec **camemBERT**) et le modèle **Mistral Large**.
+    """)
+
+    # --- Sidebar unifiée ---
+    with st.sidebar:
+        # Bouton Déconnexion
+        if st.button('Déconnexion', key="logout"):
+            st.session_state.authentication_status = None
+            st.rerun()
+
+        # Message de bienvenue
+        st.write(f'Bienvenue *{st.session_state["name"]}*')
+
+        # Séparateur
+        st.markdown("---")
+
+        # Paramètres de mode
+        mode = st.radio(
+            "Type de réponse souhaitée",
+            ["Réponse parlementaire", "Analyse synthétique"],
+            index=0
+        )
+
+        # Ajoutez une séparation visuelle
+        st.sidebar.markdown("---")  # ← AJOUTEZ CETTE LIGNE
+
+    # --- 8. Zone de saisie (hauteur x2) ---
+    question = st.text_area(
+        "Posez votre question parlementaire:",
+        height=300,  # ← ICI : hauteur doublée
+        placeholder="Exemple: Quelles sont les dernières mesures contre la précarité énergétique ?",
+        key="question_input"
+    )
+
+    # --- NOUVEAU : Paramètres de réponse (entre question et bouton) ---
+    st.markdown("### Paramètres de réponse")
+
+    # Organisation en 3 colonnes
+    col1, col2, col3 = st.columns(3)
+
+    with col1:
+        # Orientation de la réponse
+        response_orientation_options = [
+            "Répondre de façon neutre",
+            "Répondre négativement aux propositions du parlementaire",
+            "Répondre positivement aux propositions du parlementaire",
+            "Répondre de manière technique et détaillée"
+        ]
+        selected_orientation = st.selectbox(
+            "Orientation de la réponse",
+            response_orientation_options,
+            index=0
+        )
+
+    with col2:
+        # Longueur de la réponse (déplacée ici)
+        longueur = st.selectbox(
+            "Longueur de la réponse",
+            ["Courte (300 mots)", "Moyenne (500 mots)", "Longue (1000 mots)"],
+            index=1
+        )
+
+    with col3:
+        # Niveau de détail juridique
+        detail_juridique = st.slider(
+            "Niveau de détail juridique (1 = bas, 5 = élevé)",
+            min_value=1,
+            max_value=5,
+            value=3
+        )
+
+    # Instructions supplémentaires (pleine largeur)
+    # Limite de longueur (ex: 300 caractères)
+    MAX_LEN = 300
+    # Zone de saisie
+    custom_instructions = st.text_area(
+        "Instructions (succinctes) supplémentaires pour la réponse",
+        placeholder="Ex: Insister sur l'aspect budgétaire, mentionner le projet de loi X, conclure en rappelant la mobilisation du Gouvernement contre toutes les violences exercées à l’égard des femmes...",
+        height=100,
+        key="custom_instructions"
+    )
+    # Affichage du compteur
+    if custom_instructions:
+        remaining = MAX_LEN - len(custom_instructions)
+        if remaining >= 0:
+            st.caption(f"✍️ {len(custom_instructions)}/{MAX_LEN} caractères utilisés")
+        else:
+            st.warning(f"⚠️ Vous avez dépassé la limite de {MAX_LEN} caractères ({len(custom_instructions)} actuellement).")
+            # Optionnel : tronquer automatiquement
+            custom_instructions = custom_instructions[:MAX_LEN]
+            st.caption(f"✍️ {MAX_LEN}/{MAX_LEN} caractères utilisés (texte tronqué)")
+    else:
+        st.caption(f"✍️ 0/{MAX_LEN} caractères utilisés")
+
+    # --- 9. Génération de la réponse et historique ---
+    if "full_historique" not in st.session_state:
+        st.session_state.full_historique = {}
+
+    if st.button("Générer la réponse", type="primary", key="generate_button"):
+        if not question.strip():
+            st.warning("Veuillez entrer une question.")
+        else:
+            with st.spinner("Recherche de contextes pertinents et génération de la réponse..."):
+                try:
+                    # Traduire le choix du radio en valeur pour le backend
+                    mode_value = "analyse" if mode == "Analyse synthétique" else "parlementaire"
+
+                    response = requests.post(
+                        "http://127.0.0.1:8000/ask",
+                        json={
+                            "question": question,
+                            "detail_juridique": detail_juridique,
+                            "longueur": longueur,
+                            "mode": mode_value,
+                            "response_orientation": selected_orientation,  # ← AJOUTEZ CECI
+                            "custom_instructions": custom_instructions    # ← ET CECI
+                        }
+                    )
+
+                    response.raise_for_status()
+                    response_data = response.json()
+
+                    # Stocker la réponse dans l'historique complet
+                    st.session_state.full_historique[question] = {
+                        "response": response_data["response"],
+                        "context": response_data["context"],
+                        "sources": response_data["sources"],
+                        "mode": mode_value
+                    }
+
+                    # Afficher les onglets de réponse et sources
+                    tab1, tab2 = st.tabs(["📜 Réponse", "🔍 Sources"])
+                    with tab1:
+                        st.markdown("### Réponse générée")
+                        # Affichage unique de la réponse avec un id
+                        st.markdown(
+                            f'<div id="response-text" class="response-text">{response_data["response"]}</div>',
+                            unsafe_allow_html=True
+                        )
+
+                        # --- Bouton Export TXT ---
+                        st.download_button(
+                            label="⬇️ Exporter en .txt",
+                            data=response_data["response"],
+                            file_name="reponse.txt",
+                            mime="text/plain"
+                        )
+
+                    # Afficher les questions similaires dans l'onglet Sources
+                    with tab2:
+                        st.markdown("## 📚 Anciennes QE similaires")
+                        if "similar_questions" in response_data and response_data["similar_questions"]:
+                            for idx, similar_item in enumerate(response_data["similar_questions"]):
+                                with st.expander(f"{idx + 1}. {similar_item.get('question', '')[:100]}..."):
+                                    st.markdown(f"**Date de la réponse :** {similar_item.get('date', 'Inconnue')}")
+                                    st.markdown(f"**Chambre :** {similar_item.get('chambre', 'Inconnue')}")
+                                    st.markdown(f"**Question :** {similar_item.get('question', '')}")
+                                    st.markdown(f"**Réponse :** {similar_item.get('reponse', '')}")
+
+                        st.markdown("## 📜 Textes juridiques")
+                        if "sources" in response_data and response_data["sources"]:
+                            for source in response_data["sources"]:
+                                st.markdown(f"- {source}")
+
+                        st.markdown("## 📄 Documents du RAG")
+                        documents = ["Document 1", "Document 2", "Document 3"]  # Exemple
+                        for doc in documents:
+                            st.markdown(f"- {doc}")
+
+                except requests.exceptions.RequestException as e:
+                    if "Connection refused" in str(e):
+                        st.error("⚠️ Le serveur backend n'est pas démarré. Vérifiez que `backend/app.py` est lancé.")
+                    elif hasattr(e, 'response') and e.response.status_code == 500:
+                        st.error(f"⚠️ Erreur serveur: {e.response.json().get('detail', str(e))}")
+                    else:
+                        st.error(f"⚠️ Erreur inattendue: {e}")
+
+    # --- 10. Affichage de l'historique complet ---
+    if st.session_state.full_historique:
+        st.markdown("## 📚 Historique des questions")
+
+        for idx, (question, data) in enumerate(st.session_state.full_historique.items()):
+            with st.expander(f"{idx+1}. {question[:80]}..."):
+                # Afficher la question complète
+                st.markdown("**Question complète :**")
+                st.write(question)
+
+                # Afficher la réponse complète
+                st.markdown("**Réponse générée :**")
+                st.markdown(
+                    f'<div class="response-text">{data["response"]}</div>',
+                    unsafe_allow_html=True
+                )
+
+                # --- Bouton Export (question + réponse) ---
+                from docx import Document
+                import io
+
+                doc = Document()
+                doc.add_heading("Question", level=1)
+                doc.add_paragraph(question)
+                doc.add_heading("Réponse", level=1)
+                doc.add_paragraph(data["response"])
+
+                buffer_word = io.BytesIO()
+                doc.save(buffer_word)
+                buffer_word.seek(0)
+
+                st.download_button(
+                    label="⬇️ Exporter Question + Réponse (Word)",
+                    data=buffer_word,
+                    file_name=f"historique_{idx+1}.docx",
+                    mime="application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+                )
+
+                # --- Sources associées ---
+                if "sources" in data and data["sources"]:
+                    with st.expander("🔍 Sources utilisées"):
+                        for i, (context, source) in enumerate(zip(data["context"], data["sources"])):
+                            with st.expander(f"Source {i+1}: {source}"):
+                                st.markdown(
+                                    f'<div class="source-text">{context}</div>',
+                                    unsafe_allow_html=True
+                                )
+
+
+st.title("📑 Générateur de réponses parlementaires")
+
+question = st.text_input("Posez votre question :")
+
+if question:
+    request = {"question": question}
+    response = generate_response(request)
+    st.write("### Réponse générée :")
+    st.write(response)

requirements.txt

@@ -1,3 +1,6 @@
 altair
 pandas
-streamlit
+streamlit
+sentence-transformers
+transformers
+torch