Update app.py

app.py

@@ -31,9 +31,11 @@ SRC_PARAPHRASE = "models/paraphrase-mpnet-base-v2"
 N_RESULTS_RETRIEVAL = 10
 N_RESULTS_RERANK = 3
 
-# Récupération de la clé depuis l'environnement (Hugging Face Secrets)
-# Si non trouvée, utilise la clé de placeholder.
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY", "AIzaSyDXXY7uSXryTxZ51jQFsSLcPnC_Ivt9V1g")
+# Clé pour la route RAG (récupérée de l'environnement ou par défaut)
+GEMINI_API_KEY_RAG = os.getenv("GEMINI_API_KEY", "AIzaSyDXXY7uSXryTxZ51jQFsSLcPnC_Ivt9V1g")
+# NOUVELLE CLÉ demandée, mise en dur pour la route directe
+GEMINI_API_KEY_DIRECT = "AIzaSyCpG2G3K0cZmTxWFO-c4OoOrW1fcTYQwgo"
+
 GEMINI_MODEL = "gemini-2.5-flash"
 
 MAX_CONVERSATION_HISTORY = 10
@@ -50,7 +52,8 @@ model_cross_encoder: CrossEncoder = None
 model_paraphrase: SentenceTransformer = None
 collection: chromadb.Collection = None
 system_prompt: str = None
-gemini_client: genai.Client = None
+gemini_client_rag: genai.Client = None # Client pour la route RAG
+gemini_client_direct: genai.Client = None # Client pour la route directe
 
 conversation_histories: Dict[str, List[Dict[str, str]]] = {}
 conversation_start_times: Dict[str, str] = {}
@@ -106,14 +109,17 @@ def load_system_prompt():
         print(f"⚠️ System prompt non trouvé à {SYSTEM_PROMPT_PATH}. Utilisation du prompt par défaut.")
         return default
 
-def initialize_gemini_client():
-    """Initialise le client Google Gemini."""
-    if GEMINI_API_KEY == "AIzaSyDXXY7uSXryTxZ51jQFsSLcPnC_Ivt9V1g":
-        print("⚠️ AVIS: Clé Gemini par défaut/placeholder détectée. Veuillez la remplacer par un secret d'environnement nommé 'GEMINI_API_KEY' pour la production.")
+def initialize_gemini_client(api_key, client_name):
+    """Initialise un client Google Gemini."""
+    if api_key == "AIzaSyDXXY7uSXryTxZ51jQFsSLcPnC_Ivt9V1g":
+        print(f"⚠️ AVIS pour {client_name}: Clé Gemini par défaut/placeholder détectée.")
+    if api_key == "AIzaSyCpG2G3K0cZmTxWFO-c4OoOrW1fcTYQwgo":
+        print(f"💡 AVIS pour {client_name}: Clé Gemini directe mise en dur détectée.")
     try:
-        return genai.Client(api_key=GEMINI_API_KEY)
+        print(f"✅ Client Gemini '{client_name}' initialisé.")
+        return genai.Client(api_key=api_key)
     except Exception as e:
-        print(f"❌ Erreur lors de l'initialisation du client Gemini: {e}")
+        print(f"❌ Erreur lors de l'initialisation du client Gemini '{client_name}': {e}")
         raise
 
 # ======================================================================
@@ -273,26 +279,26 @@ def clear_history(session_id):
 # ======================================================================
 # CALL GEMINI
 # ======================================================================
-def call_gemini(rag_prompt, system_prompt, gemini_client):
+
+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
     
-    # L'API Gemini Python ne retourne pas directement les codes HTTP comme 503, 
-    # mais lève des exceptions `APIError` ou `ResourceExhaustedError` qui correspondent
-    # à des erreurs de service. Nous allons intercepter l'exception générique 
-    # pour capturer toutes les erreurs potentielles liées à l'appel.
+    # 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}...")
+            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{rag_prompt}"
+                contents=f"{system_prompt}\n\n{final_prompt}"
             )
             # Si la réponse réussit, on sort de la boucle
             return response.text.replace("*", "")
@@ -301,56 +307,64 @@ def call_gemini(rag_prompt, system_prompt, gemini_client):
             # 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}")
+            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...")
+                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é.")
+                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."
 
 # ======================================================================
-# ANSWER PROCESS
+# PROCESSUS DE RÉPONSE - RAG
 # ======================================================================
 
-def get_answer(query_text, collection, model_paraphrase, model_cross_encoder, conversation_history):
+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: '{query_text}'")
+    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)
 
-    # On retourne le prompt final RAG pour référence, mais l'appel Gemini est fait après
     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
 # ======================================================================
 
 def initialize_global_resources():
     """Initialise tous les modèles et ressources."""
-    global model_cross_encoder, model_paraphrase, collection, system_prompt, gemini_client
+    global model_cross_encoder, model_paraphrase, collection, system_prompt
+    global gemini_client_rag, gemini_client_direct
 
     print("\n" + "="*50)
-    print("⚙️  INITIALISATION RAG")
+    print("⚙️  INITIALISATION RAG & Clients Gemini")
     print("="*50)
 
-    # Le répertoire /tmp est géré par la variable CHROMA_DB_PATH
-
     try:
         model_cross_encoder, model_paraphrase = load_models()
         df = load_data()
         system_prompt = load_system_prompt()
-        gemini_client = initialize_gemini_client()
+        # Initialisation des deux clients
+        gemini_client_rag = initialize_gemini_client(GEMINI_API_KEY_RAG, "RAG (Env/Default)")
+        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
@@ -381,9 +395,10 @@ def api_status():
 
 @app.route('/api/get_answer', methods=['POST'])
 def api_get_answer():
-    """Endpoint principal pour obtenir une réponse."""
-    if any(x is None for x in [model_cross_encoder, model_paraphrase, collection, system_prompt, gemini_client]):
-        return jsonify({"error": "Ressources non chargées. Veuillez vérifier les logs d'initialisation."}), 500
+    """Endpoint principal pour obtenir une réponse avec RAG."""
+    # Le client RAG utilise la clé d'environnement/par défaut
+    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
 
     try:
         data = request.get_json()
@@ -398,10 +413,10 @@ def api_get_answer():
         history = get_conversation_history(session_id)
 
         # Génère prompt RAG
-        rag_prompt = get_answer(query_text, collection, model_paraphrase, model_cross_encoder, history)
+        rag_prompt = get_answer_rag_process(query_text, collection, model_paraphrase, model_cross_encoder, history)
 
-        # Appelle Gemini
-        response = call_gemini(rag_prompt, system_prompt, gemini_client)
+        # 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)
@@ -410,10 +425,47 @@ def api_get_answer():
         return jsonify({"generated_response": response})
 
     except Exception as e:
-        print(f"❌ Erreur générale de l'API: {e}")
-        generic_message = "Problème avec l'API, veuillez réessayer plus tard."
+        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
 
+@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:
+        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
+        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"{'='*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
+
+        return jsonify({"generated_response": response})
+
+    except Exception as e:
+        print(f"❌ Erreur générale de l'API Direct: {e}")
+        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."""
@@ -449,6 +501,8 @@ if __name__ == '__main__':
         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"💡 N'oubliez pas de configurer 'app_port: 1212' et 'sdk: docker' dans votre README.md !")
         print("="*50 + "\n")