Update app.py

app.py

@@ -14,20 +14,13 @@ import time
 # ======================================================================
 
 DATA_FILE_PATH = "data/QR.csv"
-
-# CORRECTION CRITIQUE: Déplacement de la DB vers /tmp
-# Ce répertoire est le seul garanti en écriture sur Hugging Face Spaces.
 CHROMA_DB_PATH = "/tmp/bdd_ChromaDB"
 COLLECTION_NAME = "qr_data_dual_embeddings"
-
 Q_COLUMN_NAME = "Question"
 R_COLUMN_NAME = "Reponse"
 SYSTEM_PROMPT_PATH = "data/system_prompt.txt"
-
-# Les chemins des modèles sont conservés (ils se mettront en cache dans /tmp grâce au Dockerfile)
 SRC_CROSS_ENCODER = "models/mmarco-mMiniLMv2-L12-H384-v1"
 SRC_PARAPHRASE = "models/paraphrase-mpnet-base-v2"
-
 N_RESULTS_RETRIEVAL = 10
 N_RESULTS_RERANK = 3
 
@@ -39,10 +32,8 @@ GEMINI_API_KEY_DIRECT = "AIzaSyCpG2G3K0cZmTxWFO-c4OoOrW1fcTYQwgo"
 GEMINI_MODEL = "gemini-2.5-flash"
 
 MAX_CONVERSATION_HISTORY = 10
-
-# Configuration pour l'accès externe (host et port)
 API_HOST = '0.0.0.0'
-API_PORT = 1212  # Le port 1212 est conservé, il doit être configuré dans le README.md
+API_PORT = 1212
 
 # ======================================================================
 # VARIABLES GLOBALES
@@ -53,20 +44,19 @@ model_paraphrase: SentenceTransformer = None
 collection: chromadb.Collection = None
 system_prompt: str = None
 gemini_client_rag: genai.Client = None # Client pour la route RAG
-gemini_client_direct: genai.Client = None # Client pour la route directe
+gemini_client_direct: genai.Client = None # Client pour la route directe (CELUI UTILISÉ PAR api_gemini_only)
 
 conversation_histories: Dict[str, List[Dict[str, str]]] = {}
 conversation_start_times: Dict[str, str] = {}
 
 # ======================================================================
-# CHARGEMENT DES RESSOURCES
+# CHARGEMENT DES RESSOURCES (Inchangé, car les ressources RAG sont nécessaires)
 # ======================================================================
 
 def load_models():
     """Charge les modèles SentenceTransformer et CrossEncoder."""
     print("⏳ Chargement des modèles...")
     try:
-        # Tente de charger localement, sinon télécharge (le cache se fera dans /tmp)
         cross_encoder = CrossEncoder(
             SRC_CROSS_ENCODER if os.path.exists(SRC_CROSS_ENCODER)
             else "cross-encoder/mmarco-mMiniLMv2-L12-H384-v1"
@@ -79,7 +69,6 @@ def load_models():
         return cross_encoder, paraphrase
     except Exception as e:
         print(f"❌ Erreur chargement modèles: {e}")
-        # Note: L'erreur de PermissionError est maintenant gérée par le Dockerfile
         raise
 
 def load_data():
@@ -123,16 +112,13 @@ def initialize_gemini_client(api_key, client_name):
         raise
 
 # ======================================================================
-# CHROMADB SETUP
+# CHROMADB SETUP (Inchangé)
 # ======================================================================
 
 def setup_chromadb_collection(client, df, model_paraphrase):
     """Configure et remplit la collection ChromaDB."""
     total_docs = len(df) * 2
-
-    # S'assurer que le répertoire de la DB existe
     os.makedirs(CHROMA_DB_PATH, exist_ok=True)
-
     try:
         collection = client.get_or_create_collection(name=COLLECTION_NAME)
     except Exception as e:
@@ -148,7 +134,6 @@ def setup_chromadb_collection(client, df, model_paraphrase):
         return collection
 
     print(f"⏳ Remplissage de ChromaDB ({len(df)} lignes) à l'emplacement: {CHROMA_DB_PATH}...")
-
     docs, metadatas, ids = [], [], []
 
     for i, row in df.iterrows():
@@ -166,7 +151,6 @@ def setup_chromadb_collection(client, df, model_paraphrase):
 
     embeddings = model_paraphrase.encode(docs, show_progress_bar=False).tolist()
 
-    # Nettoyage et recréation (pour le cas où les données CSV ont changé)
     try:
         client.delete_collection(name=COLLECTION_NAME)
     except:
@@ -179,11 +163,12 @@ def setup_chromadb_collection(client, df, model_paraphrase):
     return collection
 
 # ======================================================================
-# RAG - RETRIEVAL & RERANKING
+# RAG - RETRIEVAL & RERANKING (Inchangé, mais seulement utilisé par api_get_answer)
 # ======================================================================
 
 def retrieve_and_rerank(query_text, collection, model_paraphrase, model_cross_encoder):
     """Récupère et rerank les résultats."""
+    # ... (logique inchangée) ...
     print(f"🔍 Récupération pour: '{query_text[:40]}...'")
 
     query_emb = model_paraphrase.encode([query_text]).tolist()
@@ -232,15 +217,13 @@ def generate_rag_prompt(query_text, df_results, conversation_history):
     history_str = ""
     if conversation_history:
         history_str = "HISTORIQUE:\n"
-        # Ajout du contexte pour le LLM, mais on ne veut pas l'historique complet
-        # On va limiter l'historique à l'affichage si on dépasse MAX_CONVERSATION_HISTORY
         display_history = conversation_history[-(MAX_CONVERSATION_HISTORY * 2):]
         for msg in display_history:
             role = "USER" if msg["role"] == "user" else "ASSISTANT"
-            # On utilise 'content' pour le texte du message
             history_str += f"{role}: {msg['content']}\n"
         history_str += "\n"
 
+    # Le prompt customisé RAG (avec Mathieu, NOVA, etc.)
     return f"""{history_str}UTILISATEUR: {query_text}
 
 CONTEXTE (si utile):
@@ -254,7 +237,7 @@ INSTRUCTIONS:
 - Mentionne obligatoirement Mathieu dans ta réponse"""
 
 # ======================================================================
-# GESTION HISTORIQUE
+# GESTION HISTORIQUE (Inchangé)
 # ======================================================================
 
 def get_conversation_history(session_id):
@@ -268,7 +251,6 @@ def add_to_history(session_id, role, content):
 
     conversation_histories[session_id].append({"role": role, "content": content})
 
-    # Limiter la taille de l'historique conservé en mémoire
     if len(conversation_histories[session_id]) > MAX_CONVERSATION_HISTORY * 2:
         conversation_histories[session_id] = conversation_histories[session_id][-(MAX_CONVERSATION_HISTORY * 2):]
 
@@ -277,76 +259,7 @@ def clear_history(session_id):
     conversation_histories[session_id] = []
 
 # ======================================================================
-# CALL GEMINI
-# ======================================================================
-
-def call_gemini(final_prompt, system_prompt, gemini_client):
-    """
-    Appelle Google Gemini avec une logique de réessai en cas d'échec de l'API.
-    Maximum de 10 tentatives.
-    """
-    MAX_RETRIES = 10
-    
-    # S'assurer que le client est bien initialisé
-    if gemini_client is None:
-        return "Erreur: Client Gemini non initialisé."
-
-    for attempt in range(MAX_RETRIES):
-        try:
-            print(f"    📞 Tentative d'appel Gemini #{attempt + 1}...")
-            # L'API Python de Google lève des exceptions `APIError` pour les échecs, 
-            # y compris ceux qui correspondent aux 5xx.
-            response = gemini_client.models.generate_content(
-                model=GEMINI_MODEL,
-                contents=f"{system_prompt}\n\n{final_prompt}"
-            )
-            # Si la réponse réussit, on sort de la boucle
-            return response.text.replace("*", "")
-
-        except Exception as e:
-            # Ici, on capture toute erreur d'API ou de connexion.
-            # On considère cela comme une erreur de service transitoire pour les réessais.
-            error_message = str(e)
-            print(f"    ❌ Erreur Gemini (Tentative {attempt + 1}/{MAX_RETRIES}): {error_message}")
-
-            if attempt < MAX_RETRIES - 1:
-                # Si ce n'est pas la dernière tentative, on attend avant de réessayer
-                sleep_time = 2  # Attente de 2 secondes
-                print(f"    😴 Attente de {sleep_time} secondes avant de réessayer...")
-                time.sleep(sleep_time)
-            else:
-                # Dernière tentative échouée
-                print("    🛑 Toutes les tentatives de réessai ont échoué.")
-                return f"Erreur fatale après {MAX_RETRIES} tentatives: {error_message}"
-
-    # Ne devrait jamais être atteint, mais par sécurité
-    return "Erreur inconnue dans la boucle de réessai de Gemini."
-
-# ======================================================================
-# PROCESSUS DE RÉPONSE - RAG
-# ======================================================================
-
-def get_answer_rag_process(query_text, collection, model_paraphrase, model_cross_encoder, conversation_history):
-    """Exécute le processus RAG complet."""
-    print(f"\n{'='*50}")
-    print(f"🚀 Traitement RAG: '{query_text}'")
-    print(f"{'='*50}")
-
-    df_results = retrieve_and_rerank(query_text, collection, model_paraphrase, model_cross_encoder)
-    final_prompt = generate_rag_prompt(query_text, df_results, conversation_history)
-
-    return final_prompt
-
-# ======================================================================
-# PROCESSUS DE RÉPONSE - DIRECT
-# ======================================================================
-
-def get_answer_direct_process(query_text):
-    """Génère le prompt direct sans RAG."""
-    return f"UTILISATEUR: {query_text}"
-
-# ======================================================================
-# INITIALISATION GLOBALE
+# INITIALISATION GLOBALE (Inchangé)
 # ======================================================================
 
 def initialize_global_resources():
@@ -362,16 +275,14 @@ def initialize_global_resources():
         model_cross_encoder, model_paraphrase = load_models()
         df = load_data()
         system_prompt = load_system_prompt()
-        # Initialisation des deux clients
         gemini_client_rag = initialize_gemini_client(GEMINI_API_KEY_RAG, "RAG (Env/Default)")
+        # Client Direct
         gemini_client_direct = initialize_gemini_client(GEMINI_API_KEY_DIRECT, "Direct (Hardcoded)")
     except Exception:
-        # L'erreur est déjà print dans les fonctions de chargement
         return False
 
     try:
         print(f"⏳ Initialisation de ChromaDB à l'emplacement: {CHROMA_DB_PATH}")
-        # Le PersistentClient créera les fichiers dans le chemin spécifié (maintenant dans /tmp)
         chroma_client = chromadb.PersistentClient(path=CHROMA_DB_PATH)
         collection = setup_chromadb_collection(chroma_client, df, model_paraphrase)
         print("✅ INITIALISATION COMPLÈTE\n")
@@ -385,7 +296,6 @@ def initialize_global_resources():
 # ======================================================================
 
 app = Flask(__name__)
-# CORS activé, permet les requêtes depuis n'importe quelle origine
 CORS(app)
 
 @app.route('/status', methods=['GET'])
@@ -395,10 +305,9 @@ def api_status():
 
 @app.route('/api/get_answer', methods=['POST'])
 def api_get_answer():
-    """Endpoint principal pour obtenir une réponse avec RAG."""
-    # Le client RAG utilise la clé d'environnement/par défaut
+    """Endpoint pour obtenir une réponse avec RAG (Inchangé)."""
     if any(x is None for x in [model_cross_encoder, model_paraphrase, collection, system_prompt, gemini_client_rag]):
-        return jsonify({"error": "Ressources RAG non chargées. Veuillez vérifier les logs d'initialisation."}), 500
+        return jsonify({"error": "Ressources RAG non chargées."}), 500
 
     try:
         data = request.get_json()
@@ -406,19 +315,34 @@ def api_get_answer():
         session_id = data.get('session_id', 'archive')
 
         if not query_text:
-            generic_message = "Problème avec l'API, veuillez réessayer plus tard."
-            return jsonify({"error": generic_message}), 500
+            return jsonify({"error": "Problème avec l'API, veuillez réessayer plus tard."}), 500
 
-        # Récupère historique
         history = get_conversation_history(session_id)
+        df_results = retrieve_and_rerank(query_text, collection, model_paraphrase, model_cross_encoder)
+        rag_prompt = generate_rag_prompt(query_text, df_results, history)
+
+        # Logique d'appel Gemini (intégrée de l'ancienne fonction call_gemini)
+        MAX_RETRIES = 10
+        response = "Erreur: Toutes les tentatives ont échoué."
+        client = gemini_client_rag
+
+        for attempt in range(MAX_RETRIES):
+            try:
+                print(f"    📞 Tentative d'appel Gemini RAG #{attempt + 1}...")
+                response_obj = client.models.generate_content(
+                    model=GEMINI_MODEL,
+                    contents=f"{system_prompt}\n\n{rag_prompt}"
+                )
+                response = response_obj.text.replace("*", "")
+                break # Succès
+            except Exception as e:
+                error_message = str(e)
+                print(f"    ❌ Erreur Gemini (Tentative {attempt + 1}/{MAX_RETRIES}): {error_message}")
+                if attempt < MAX_RETRIES - 1:
+                    time.sleep(2)
+                else:
+                    response = f"Erreur fatale après {MAX_RETRIES} tentatives: {error_message}"
 
-        # Génère prompt RAG
-        rag_prompt = get_answer_rag_process(query_text, collection, model_paraphrase, model_cross_encoder, history)
-
-        # Appelle Gemini avec le client RAG
-        response = call_gemini(rag_prompt, system_prompt, gemini_client_rag)
-
-        # Sauvegarde réponse
         add_to_history(session_id, "user", query_text)
         add_to_history(session_id, "assistant", response)
 
@@ -426,37 +350,63 @@ def api_get_answer():
 
     except Exception as e:
         print(f"❌ Erreur générale de l'API RAG: {e}")
-        generic_message = "Problème avec l'API RAG, veuillez réessayer plus tard."
-        return jsonify({"error": generic_message}), 500
+        return jsonify({"error": "Problème avec l'API RAG, veuillez réessayer plus tard."}), 500
+
+# ======================================================================
+# NOUVELLE ROUTE : TOTALEMENT AUTONOME
+# ======================================================================
 
 @app.route('/api/gemini_only', methods=['POST'])
 def api_gemini_only():
-    """NOUVELLE ROUTE : Endpoint pour les requêtes directes à Gemini sans RAG. Utilise la clé mise en dur."""
-    # Le client direct utilise la clé mise en dur
-    if gemini_client_direct is None:
+    """
+    ROUTE TOTALE : Endpoint pour les requêtes directes à Gemini sans RAG. 
+    Contient toute la logique d'appel, y compris les réessais.
+    """
+    # Vérification du client
+    client = gemini_client_direct
+    if client is None:
         return jsonify({"error": "Client Gemini direct non initialisé. Vérifiez les logs."}), 500
 
     try:
         data = request.get_json()
         query_text = data.get('query_text')
-        # On peut optionally récupérer un 'system_prompt_direct' pour customiser, sinon on utilise le prompt par défaut
+        # Utilisation du system_prompt par défaut si non spécifié
         custom_system_prompt = data.get('system_prompt', system_prompt) 
 
         if not query_text:
             return jsonify({"error": "Paramètre 'query_text' manquant."}), 400
 
         print(f"\n{'='*50}")
-        print(f"⚡ Traitement Direct: '{query_text}'")
+        print(f"⚡ Traitement Direct Intégral: '{query_text}'")
         print(f"{'='*50}")
 
-        # Génère le prompt final (juste la question)
-        final_prompt = get_answer_direct_process(query_text)
-
-        # Appelle Gemini avec le client direct
-        # On utilise le 'system_prompt' par défaut ou un custom s'il est fourni
-        response = call_gemini(final_prompt, custom_system_prompt, gemini_client_direct)
-
-        # Pas d'ajout à l'historique de conversation ici car c'est une route directe sans session RAG/Historique
+        # LOGIQUE INTÉGRÉE 1 : Préparation du prompt (remplace get_answer_direct_process)
+        final_prompt = f"UTILISATEUR: {query_text}"
+        
+        # LOGIQUE INTÉGRÉE 2 : Appel Gemini avec logique de réessai (remplace call_gemini)
+        MAX_RETRIES = 10
+        response = "Erreur: Toutes les tentatives ont échoué."
+        
+        for attempt in range(MAX_RETRIES):
+            try:
+                print(f"    📞 Tentative d'appel Gemini Direct #{attempt + 1}...")
+                response_obj = client.models.generate_content(
+                    model=GEMINI_MODEL,
+                    contents=f"{custom_system_prompt}\n\n{final_prompt}"
+                )
+                response = response_obj.text.replace("*", "")
+                break # Succès
+            except Exception as e:
+                error_message = str(e)
+                print(f"    ❌ Erreur Gemini (Tentative {attempt + 1}/{MAX_RETRIES}): {error_message}")
+                if attempt < MAX_RETRIES - 1:
+                    # Attente de 2 secondes avant de réessayer
+                    print("    😴 Attente de 2 secondes avant de réessayer...")
+                    time.sleep(2)
+                else:
+                    response = f"Erreur fatale après {MAX_RETRIES} tentatives: {error_message}"
+
+        # Pas d'ajout à l'historique
 
         return jsonify({"generated_response": response})
 
@@ -465,10 +415,9 @@ def api_gemini_only():
         generic_message = "Problème avec l'API directe, veuillez réessayer plus tard."
         return jsonify({"error": generic_message}), 500
 
-
 @app.route('/api/clear_history', methods=['POST'])
 def api_clear_history():
-    """Efface l'historique d'une session."""
+    """Efface l'historique d'une session (Inchangé)."""
     try:
         data = request.get_json()
         session_id = data.get('session_id', 'archive')
@@ -480,33 +429,30 @@ def api_clear_history():
         return jsonify({"error": generic_message}), 500
 
 # ======================================================================
-# MAIN
+# MAIN (Inchangé)
 # ======================================================================
 
 if __name__ == '__main__':
     print("start app.py")
     if initialize_global_resources():
 
-        # Récupération de l'adresse IP si possible (pour l'affichage)
         try:
             import socket
             s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-            s.connect(("8.8.8.8", 80))  # Connecte à un serveur externe pour trouver l'IP locale utilisée
+            s.connect(("8.8.8.8", 80))
             local_ip = s.getsockname()[0]
             s.close()
         except Exception:
-            local_ip = "127.0.0.1"  # Fallback si échec
+            local_ip = "127.0.0.1"
 
         print("\n" + "="*50)
         print("🌐 SERVEUR DÉMARRÉ")
         print(f"✅ API accessible à l'URL (via l'interface réseau locale): http://{local_ip}:{API_PORT}")
-        print(f"✅ Route Status: http://{local_ip}:{API_PORT}/status")
         print(f"✅ Route RAG (avec Historique): http://{local_ip}:{API_PORT}/api/get_answer")
-        print(f"✅ Route DIRECTE (Clé spéciale): http://{local_ip}:{API_PORT}/api/gemini_only")
+        print(f"✅ Route DIRECTE TOTALE (Clé spéciale): http://{local_ip}:{API_PORT}/api/gemini_only")
         print(f"💡 N'oubliez pas de configurer 'app_port: 1212' et 'sdk: docker' dans votre README.md !")
         print("="*50 + "\n")
 
-        # L'utilisation de host='0.0.0.0' dans app.run() permet l'accès depuis l'extérieur
         app.run(host=API_HOST, port=API_PORT, debug=False)
     else:
         print("❌ Impossible de démarrer le serveur. Veuillez vérifier les logs pour les erreurs d'initialisation.")