Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,10 +1,10 @@
 import streamlit as st
 import os
-import tempfile  # On importe le module pour gérer les fichiers/dossiers temporaires
-from llama_cpp import Llama
+# from llama_cpp import Llama  # Nous n'utilisons plus llama-cpp-python
+from ctransformers import AutoModelForCausalLM
+from langchain.llms.ctransformers import CTransformers
 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
 
@@ -29,49 +29,31 @@ Document.__setstate__ = custom_setstate
 @st.cache_resource
 def load_llm():
     """
-    Charge le modèle LLM depuis le Hub Hugging Face en utilisant un cache temporaire sécurisé.
+    Charge le modèle LLM directement depuis le Hub Hugging Face en mémoire
+    en utilisant la bibliothèque ctransformers, qui ne nécessite pas d'écriture disque.
     """
-    model_repo_id = "QuantFactory/Meta-Llama-3-8B-Instruct-GGUF"
-    model_filename = "Meta-Llama-3-8B-Instruct.Q4_K_M.gguf"
-
-    # ✅ LA SOLUTION LA PLUS ROBUSTE :
-    # On demande au système de nous donner le chemin vers le répertoire temporaire.
-    # C'est la méthode standard de Python pour éviter les erreurs de permission.
-    temp_dir = tempfile.gettempdir()
-    cache_dir = os.path.join(temp_dir, "models_cache")
-    logger.info(f"Utilisation du répertoire de cache temporaire système : {cache_dir}")
+    model_repo_id = "TheBloke/Llama-2-7B-Chat-GGUF"
+    model_filename = "llama-2-7b-chat.Q4_K_M.gguf"
     
-    # On s'assure que le dossier de cache existe dans le répertoire temporaire
-    os.makedirs(cache_dir, exist_ok=True)
-
-
-    with st.spinner(f"Vérification/Téléchargement du modèle '{model_filename}'... (Long au premier démarrage)"):
+    with st.spinner(f"Chargement du modèle '{model_filename}' en mémoire... (Long au premier démarrage)"):
         try:
-            model_path = hf_hub_download(
-                repo_id=model_repo_id,
-                filename=model_filename,
-                cache_dir=cache_dir # On spécifie le chemin de cache sûr et valide
+            # ctransformers charge le modèle SANS le sauvegarder sur un disque local
+            # C'est la solution pour les environnements en lecture seule.
+            llm = CTransformers(
+                model=model_repo_id,
+                model_file=model_filename,
+                model_type="llama",
+                config={
+                    'max_new_tokens': 1500,
+                    'temperature': 0.7,
+                    'context_length': 4096
+                }
             )
-            logger.info(f"Chemin du modèle : {model_path}")
-        except Exception as e:
-            st.error(f"Erreur critique lors du téléchargement du modèle. Chemin tenté : {cache_dir}. Erreur : {e}")
-            logger.error(f"Erreur de téléchargement du modèle vers '{cache_dir}': {e}")
-            st.stop()
-
-    with st.spinner("Chargement du modèle LLM en mémoire..."):
-        try:
-            llm = Llama(
-                model_path=model_path,
-                n_gpu_layers=0,  # CPU
-                n_ctx=4096,
-                verbose=False,
-                chat_format="llama-3"
-            )
-            logger.info("Modèle LLM chargé avec succès.")
+            logger.info("Modèle LLM chargé avec succès en mémoire.")
             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.error(f"Erreur critique lors du chargement du modèle depuis le Hub : {e}")
+            logger.error(f"Erreur de chargement du modèle CTransformers : {e}")
             st.stop()
 
 @st.cache_resource
@@ -135,20 +117,22 @@ if prompt := st.chat_input("Posez votre question ici..."):
                 docs = retriever.invoke(prompt)
                 context = "\n\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. Ne mentionnez pas le contexte dans votre réponse."
+                # Création du prompt pour CTransformers
+                full_prompt = f"""
+System: 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.
+
+Contexte:
+{context}
+
+Question: {prompt}
+
+Réponse:
+"""
+                
+                # Invocation du LLM
+                answer = llm.invoke(full_prompt)
                 
-                messages_for_llm = [
-                    {"role": "system", "content": f"{system_prompt}\n\nContexte:\n{context}"},
-                    {"role": "user", "content": prompt}
-                ]
-
-                response_stream = llm.create_chat_completion_stream(
-                    messages=messages_for_llm,
-                    max_tokens=1500,
-                    temperature=0.7,
-                    stop=["<|eot_id|>", "<|end_of_text|>"]
-                )
-                answer = st.write_stream(token['choices'][0]['delta'].get('content', '') for token in response_stream)
+                st.markdown(answer)
                 st.session_state.messages.append({"role": "assistant", "content": answer})
 
             except Exception as e: