Update src/streamlit_app.py

src/streamlit_app.py

@@ -4,6 +4,12 @@ from llama_cpp import Llama
 from langchain_community.vectorstores import FAISS
 from langchain_community.embeddings import HuggingFaceEmbeddings
 from huggingface_hub import hf_hub_download
+from langchain.docstore.document import Document
+import logging
+
+# Configuration du logging pour un meilleur débogage
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # --- Configuration de la page Streamlit ---
 st.set_page_config(page_title="Votre Coach RAG", layout="wide")
@@ -11,42 +17,110 @@ st.title("Votre Coach Expert")
 st.write("Posez une question sur vos documents, et je vous répondrai en me basant sur leur contenu.")
 
 # --- Fonctions de chargement mises en cache ---
+# @st.cache_resource est CRUCIAL pour que Streamlit ne recharge pas les modèles à chaque interaction
+
+# Patch pour un problème de désérialisation avec Langchain et une version spécifique de Pydantic
+# Cela peut être nécessaire dans certains environnements.
+def custom_setstate(self, state):
+    if "__fields_set__" in state:
+        del state["__fields_set__"]
+    self.__dict__.update(state)
+
+Document.__setstate__ = custom_setstate
+
 @st.cache_resource
 def load_llm():
+    """
+    Charge le modèle LLM depuis le Hub Hugging Face.
+    Cette fonction est mise en cache pour n'être exécutée qu'une seule fois.
+    """
+    # Identifiants pour le modèle sur le Hub Hugging Face
+    # Il est recommandé d'utiliser un modèle quantifié (GGUF) pour un bon équilibre performance/taille.
     model_repo_id = "QuantFactory/Meta-Llama-3-8B-Instruct-GGUF"
     model_filename = "Meta-Llama-3-8B-Instruct.Q4_K_M.gguf"
     
-    with st.spinner(f"Téléchargement du modèle '{model_filename}'... (Cette étape est longue et n'a lieu qu'une seule fois)"):
-        model_path = hf_hub_download(
-            repo_id=model_repo_id,
-            filename=model_filename,
-            cache_dir='/tmp/hf_cache' 
-        )
-    
+    with st.spinner(f"Téléchargement du modèle '{model_filename}' depuis le Hub... (Cette étape peut être longue et n'a lieu qu'au premier démarrage)"):
+        try:
+            # Télécharge le fichier s'il n'est pas dans le cache de Hugging Face et retourne son chemin local
+            model_path = hf_hub_download(
+                repo_id=model_repo_id,
+                filename=model_filename
+            )
+            logger.info(f"Modèle téléchargé avec succès : {model_path}")
+        except Exception as e:
+            st.error(f"Erreur lors du téléchargement du modèle depuis le Hub : {e}")
+            logger.error(f"Erreur de téléchargement du modèle : {e}")
+            st.stop()
+
     with st.spinner("Chargement du modèle LLM en mémoire..."):
-        llm = Llama(model_path=model_path, n_gpu_layers=0, n_ctx=4096, verbose=False, chat_format="llama-3")
-    return llm
+        try:
+            # On utilise le CPU car les Spaces gratuits n'ont pas de GPU.
+            # n_gpu_layers=0 garantit l'utilisation du CPU.
+            llm = Llama(
+                model_path=model_path,
+                n_gpu_layers=0,
+                n_ctx=4096,      # Augmenter si nécessaire pour des contextes plus longs
+                verbose=False,
+                chat_format="llama-3"
+            )
+            logger.info("Modèle LLM chargé avec succès.")
+            return llm
+        except Exception as e:
+            st.error(f"Erreur lors du chargement du modèle Llama : {e}")
+            logger.error(f"Erreur de chargement Llama : {e}")
+            st.stop()
+
 
 @st.cache_resource
 def load_retriever(faiss_path, embeddings_path):
-    with st.spinner("Chargement de la base de connaissances (FAISS)..."):
-        embeddings_model = HuggingFaceEmbeddings(model_name=embeddings_path, model_kwargs={'device': 'cpu'})
-        vectorstore = FAISS.load_local(faiss_path, embeddings_model, allow_dangerous_deserialization=True)
-    return vectorstore.as_retriever(search_kwargs={"k": 5})
+    """
+    Charge le retriever FAISS et le modèle d'embeddings.
+    Cette fonction est également mise en cache.
+    """
+    with st.spinner("Chargement de la base de connaissances (FAISS) et des embeddings..."):
+        try:
+            # Spécifier 'cpu' car nous n'avons pas de GPU disponible.
+            embeddings_model = HuggingFaceEmbeddings(
+                model_name=embeddings_path,
+                model_kwargs={'device': 'cpu'}
+            )
+            
+            # Charger l'index FAISS local
+            # allow_dangerous_deserialization est nécessaire pour les index créés avec des versions plus anciennes de langchain.
+            vectorstore = FAISS.load_local(
+                faiss_path,
+                embeddings_model,
+                allow_dangerous_deserialization=True
+            )
+            
+            # Créer un retriever qui retournera les 5 documents les plus pertinents.
+            logger.info("Retriever chargé avec succès.")
+            return vectorstore.as_retriever(search_kwargs={"k": 5})
+        except Exception as e:
+            st.error(f"Erreur lors du chargement du retriever : {e}")
+            logger.error(f"Erreur de chargement du retriever : {e}")
+            st.stop()
 
-# --- Chemins d'accès (relatifs) ---
-# ✅ MODIFICATION : On remonte d'un dossier (de 'src' vers la racine) avec '../'
+# --- Chemins d'accès (relatifs à la racine de votre projet) ---
+# Assurez-vous que ces dossiers sont bien à la racine de votre Space Hugging Face.
 DOSSIER_PROJET = os.path.dirname(__file__)
-CHEMIN_INDEX_FAISS = os.path.join(DOSSIER_PROJET, "../faiss_index_wize")
-CHEMIN_MODELE_EMBEDDINGS = os.path.join(DOSSIER_PROJET, "../embedding_model")
+CHEMIN_INDEX_FAISS = os.path.join(DOSSIER_PROJET, "faiss_index_wize")
+CHEMIN_MODELE_EMBEDDINGS = os.path.join(DOSSIER_PROJET, "embedding_model")
 
-# --- Chargement des modèles via Streamlit ---
+# --- Vérification de l'existence des dossiers locaux ---
+if not os.path.exists(CHEMIN_INDEX_FAISS) or not os.path.exists(CHEMIN_MODELE_EMBEDDINGS):
+    st.error(f"Erreur critique : Les dossiers 'faiss_index_wize' ou 'embedding_model' sont manquants. Assurez-vous de les avoir téléversés à la racine de votre Space.")
+    st.stop()
+
+
+# --- Chargement principal des modèles via Streamlit ---
 try:
     llm = load_llm()
     retriever = load_retriever(CHEMIN_INDEX_FAISS, CHEMIN_MODELE_EMBEDDINGS)
-    st.success("Les modèles sont chargés et prêts !")
+    st.success("🎉 Les modèles sont chargés et prêts !")
 except Exception as e:
-    st.error(f"Erreur lors du chargement des modèles : {e}")
+    st.error(f"Une erreur inattendue est survenue lors du chargement des modèles : {e}")
+    logger.error(f"Erreur de chargement principale : {e}")
     st.stop()
 
 # --- Initialisation de l'historique de chat ---
@@ -60,19 +134,45 @@ for message in st.session_state.messages:
 
 # --- Logique de Chat ---
 if prompt := st.chat_input("Posez votre question ici..."):
+    # Ajouter et afficher le message de l'utilisateur
     st.session_state.messages.append({"role": "user", "content": prompt})
     with st.chat_message("user"):
         st.markdown(prompt)
 
+    # Préparer et afficher la réponse de l'assistant
     with st.chat_message("assistant"):
         with st.spinner("Je réfléchis..."):
+            # 1. Récupérer le contexte pertinent depuis la base de connaissances
             docs = retriever.invoke(prompt)
-            context = "\n".join([doc.page_content for doc in docs])
-            system_prompt = "Vous êtes Un coach expert. Répondez à la question en vous basant uniquement sur le contexte fourni."
-            full_prompt = f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>\n{system_prompt}\nContexte : {context}<|eot_id|><|start_header_id|>user<|end_header_id|>\nQuestion : {prompt}<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+            context = "\n\n".join([doc.page_content for doc in docs])
+
+            # 2. Créer le prompt complet pour le LLM avec le contexte
+            system_prompt = "Vous êtes un coach expert. Répondez à la question en vous basant UNIQUEMENT sur le contexte fourni. Ne mentionnez pas le contexte dans votre réponse."
             
-            response = llm(full_prompt, max_tokens=1500, stop=["<|eot_id|>"], echo=False)
-            answer = response['choices'][0]['text'].strip()
-            st.markdown(answer)
+            # Utilisation du template de chat Llama 3
+            messages_for_llm = [
+                {"role": "system", "content": f"{system_prompt}\n\nContexte:\n{context}"},
+                {"role": "user", "content": prompt}
+            ]
+
+            # 3. Générer la réponse
+            try:
+                # Utiliser la méthode create_chat_completion pour un format de chat structuré
+                response_stream = llm.create_chat_completion_stream(
+                    messages=messages_for_llm,
+                    max_tokens=1500,
+                    temperature=0.7,
+                    stop=["<|eot_id|>", "<|end_of_text|>"] # Tokens d'arrêt pour Llama 3
+                )
+
+                # Utiliser st.write_stream pour afficher la réponse en streaming
+                answer = st.write_stream(token['choices'][0]['delta'].get('content', '') for token in response_stream)
+
+            except Exception as e:
+                answer = f"Désolé, une erreur est survenue lors de la génération de la réponse : {e}"
+                st.error(answer)
+                logger.error(f"Erreur de génération LLM : {e}")
     
-    st.session_state.messages.append({"role": "assistant", "content": answer})
+    # Ajouter la réponse complète de l'assistant à l'historique
+    st.session_state.messages.append({"role": "assistant", "content": answer})
+