Update src/streamlit_app.py

src/streamlit_app.py

@@ -19,18 +19,14 @@ if GOOGLE_API_KEY:
     try:
         genai.configure(api_key=GOOGLE_API_KEY)
     except Exception as e:
-        # Cette erreur est critique, donc on l'affiche de manière proéminente.
         st.error(f"Erreur de configuration de l'API Google : {e}")
 else:
-    # Avertissement si la clé n'est pas trouvée au démarrage.
     st.warning("La clé API Google (GOOGLE_API_KEY) n'est pas configurée. L'application ne pourra pas fonctionner.")
 
 
 # -----------------------------------------------------------------------------
 # Définition des modèles disponibles
 # -----------------------------------------------------------------------------
-# Remplacé par les modèles Gemini les plus récents et pertinents.
-# 'latest' pointe toujours vers la version la plus récente du modèle.
 AVAILABLE_MODELS = [
     {
         "id": "gemini-1.5-flash-latest",
@@ -52,11 +48,9 @@ DEFAULT_MODEL_ID = "gemini-1.5-flash-latest"
 def initialize_session_state():
     """Initialise toutes les variables nécessaires dans le session state pour éviter les erreurs."""
     
-    # Messages par défaut
     DEFAULT_SYSTEM_MESSAGE = "Vous êtes KolaChatBot, un assistant IA serviable, créatif et honnête. Répondez en français."
     DEFAULT_STARTER_MESSAGE = "Bonjour ! Je suis KolaChatBot. Comment puis-je vous aider aujourd'hui ? 🤖"
 
-    # Initialisation de base
     if "selected_model_id" not in st.session_state:
         st.session_state.selected_model_id = DEFAULT_MODEL_ID
     if "system_message" not in st.session_state:
@@ -66,7 +60,6 @@ def initialize_session_state():
     if "chat_history" not in st.session_state:
         st.session_state.chat_history = [{"role": "assistant", "content": st.session_state.starter_message, "type": "text"}]
 
-    # Paramètres de génération
     if "max_response_length" not in st.session_state:
         st.session_state.max_response_length = 1024
     if "temperature" not in st.session_state:
@@ -74,15 +67,12 @@ def initialize_session_state():
     if "top_p" not in st.session_state:
         st.session_state.top_p = 0.95
 
-    # Fonctionnalité de recherche web
     if "enable_web_search" not in st.session_state:
         st.session_state.enable_web_search = False
 
-    # Stockage temporaire pour les résultats de recherche (pour affichage)
     if 'last_search_results' not in st.session_state:
         st.session_state.last_search_results = None
 
-# Appel de la fonction d'initialisation au début du script
 initialize_session_state()
 
 # -----------------------------------------------------------------------------
@@ -96,10 +86,7 @@ def format_history_to_txt(chat_history: list[dict]) -> str:
     return "".join(lines)
 
 def format_history_to_json(chat_history: list[dict]) -> str:
-    export_data = {
-        "export_date": datetime.now().isoformat(),
-        "conversation": chat_history
-    }
+    export_data = {"export_date": datetime.now().isoformat(), "conversation": chat_history}
     return json.dumps(export_data, indent=2, ensure_ascii=False)
 
 def format_history_to_md(chat_history: list[dict]) -> str:
@@ -114,27 +101,27 @@ def format_history_to_md(chat_history: list[dict]) -> str:
 # Fonctions principales (Recherche Web et Appel API)
 # -----------------------------------------------------------------------------
 def perform_web_search(query: str, num_results: int = 5) -> tuple[str, list]:
-    """Effectue une recherche web avec DuckDuckGo et retourne le contexte et les sources."""
-    st.session_state.last_search_results = None  # Réinitialiser à chaque recherche
+    st.session_state.last_search_results = None
     try:
         with DDGS() as ddgs:
             results = list(ddgs.text(keywords=query, region='fr-fr', max_results=num_results))
             if not results:
                 return "Aucun résultat de recherche trouvé.", []
-
+            
             formatted_context = ""
-            source_details = []
             for i, res in enumerate(results):
                 formatted_context += f"[Source {i+1}]\nTitre: {res.get('title', 'N/A')}\nExtrait: {res.get('body', 'N/A')}\nURL: {res.get('href', 'N/A')}\n\n"
-                source_details.append(res)
             
-            st.session_state.last_search_results = source_details  # Sauvegarder pour affichage ultérieur
-            return formatted_context, source_details
+            st.session_state.last_search_results = results
+            return formatted_context, results
     except Exception as e:
         return f"Erreur lors de la recherche web: {e}", []
 
 def get_gemini_response_stream(model_id: str, system_prompt: str, chat_history_for_api: list[dict], params: dict):
-    """Appelle l'API Google Gemini et retourne un générateur (stream) pour la réponse."""
+    """
+    Appelle l'API Google Gemini et retourne un générateur (stream) pour la réponse.
+    CETTE FONCTION EST CORRIGÉE.
+    """
     if not GOOGLE_API_KEY:
         yield "Erreur: La clé API Google n'est pas configurée. Veuillez l'ajouter pour continuer."
         return
@@ -145,12 +132,12 @@ def get_gemini_response_stream(model_id: str, system_prompt: str, chat_history_f
             system_instruction=system_prompt
         )
 
-        gemini_history = []
+        # *** CORRECTION APPLIQUÉE ICI ***
+        # Prépare l'historique complet pour l'API dans le format attendu.
+        api_contents = []
         for msg in chat_history_for_api:
             role = 'user' if msg['role'] == 'user' else 'model'
-            gemini_history.append({"role": role, "parts": [msg['content']]})
-        
-        current_prompt = gemini_history.pop()['parts'][0]
+            api_contents.append({"role": role, "parts": [msg['content']]})
 
         generation_config = genai.types.GenerationConfig(
             max_output_tokens=params.get("max_new_tokens"),
@@ -158,10 +145,10 @@ def get_gemini_response_stream(model_id: str, system_prompt: str, chat_history_f
             top_p=params.get("top_p"),
         )
         
+        # Appelle generate_content avec l'argument 'contents' qui contient toute la conversation.
         response_stream = model.generate_content(
-            current_prompt,
+            contents=api_contents,  # Argument correct
             generation_config=generation_config,
-            history=gemini_history,
             stream=True
         )
 
@@ -173,7 +160,7 @@ def get_gemini_response_stream(model_id: str, system_prompt: str, chat_history_f
         yield f"Erreur lors de l'appel à l'API Google: {e}"
 
 # -----------------------------------------------------------------------------
-# Configuration de la page Streamlit
+# Configuration de la page Streamlit et de la Sidebar
 # -----------------------------------------------------------------------------
 st.set_page_config(page_title="KolaChatBot IA", page_icon="🤖", layout="wide")
 
@@ -181,9 +168,6 @@ st.title("🤖 KolaChatBot IA")
 selected_model_info = next((m for m in AVAILABLE_MODELS if m['id'] == st.session_state.selected_model_id), None)
 st.markdown(f"*Modèle actuel : **{selected_model_info['name']}***")
 
-# -----------------------------------------------------------------------------
-# Barre latérale (Sidebar)
-# -----------------------------------------------------------------------------
 with st.sidebar:
     st.header("🛠️ Configuration")
 
@@ -191,7 +175,6 @@ with st.sidebar:
     model_options = {model['id']: model['name'] for model in AVAILABLE_MODELS}
     
     def on_model_change():
-        """Callback pour réinitialiser la conversation lors du changement de modèle."""
         st.session_state.chat_history = [{"role": "assistant", "content": st.session_state.starter_message, "type": "text"}]
         st.toast(f"Modèle changé. Conversation réinitialisée.")
 
@@ -222,23 +205,23 @@ with st.sidebar:
 
     st.subheader("🔄 Gestion")
     col1, col2 = st.columns(2)
-    if col1.button("♻️ Nouvelle Conv.", use_container_width=True, help="Démarre une nouvelle conversation."):
+    if col1.button("♻️ Nouvelle Conv.", use_container_width=True):
         st.session_state.chat_history = [{"role": "assistant", "content": st.session_state.starter_message, "type": "text"}]
         st.toast("Nouvelle conversation démarrée.")
         st.rerun()
-    if col2.button("🗑️ Effacer", type="primary", use_container_width=True, help="Efface l'historique de la conversation."):
+    if col2.button("🗑️ Effacer", type="primary", use_container_width=True):
         st.session_state.chat_history = [{"role": "assistant", "content": st.session_state.starter_message, "type": "text"}]
         st.toast("Conversation effacée.")
         st.rerun()
 
     st.subheader("📥 Exporter")
     if len(st.session_state.chat_history) > 1:
-        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        st.download_button("TXT", format_history_to_txt(st.session_state.chat_history), f"kolachat_{timestamp}.txt")
-        st.download_button("JSON", format_history_to_json(st.session_state.chat_history), f"kolachat_{timestamp}.json")
-        st.download_button("Markdown", format_history_to_md(st.session_state.chat_history), f"kolachat_{timestamp}.md")
+        ts = datetime.now().strftime("%Y%m%d_%H%M")
+        st.download_button("TXT", format_history_to_txt(st.session_state.chat_history), f"kolachat_{ts}.txt")
+        st.download_button("JSON", format_history_to_json(st.session_state.chat_history), f"kolachat_{ts}.json")
+        st.download_button("Markdown", format_history_to_md(st.session_state.chat_history), f"kolachat_{ts}.md")
     else:
-        st.caption("La conversation est vide.")
+        st.caption("Conversation vide.")
         
     st.divider()
     st.markdown("""
@@ -256,49 +239,43 @@ for message in st.session_state.chat_history:
     avatar = "👤" if message["role"] == "user" else "🤖"
     with st.chat_message(message["role"], avatar=avatar):
         st.markdown(message["content"])
-        # Afficher les sources si elles sont attachées au message de l'assistant
         if message.get("sources"):
             with st.expander("Sources web consultées", expanded=False):
                 for i, source in enumerate(message["sources"]):
                     st.markdown(f"**{i+1}. {source.get('title', 'Titre inconnu')}**\n"
                                 f"[*Source*]({source.get('href', '#')})\n"
-                                f"> {source.get('body', 'Aucun extrait disponible.')}\n---")
+                                f"> {source.get('body', 'Aucun extrait.')}\n---")
 
 # Logique de traitement de l'entrée utilisateur
-if prompt := st.chat_input(f"Envoyer un message...", disabled=not GOOGLE_API_KEY):
-    # Ajouter et afficher le message de l'utilisateur
+if prompt := st.chat_input("Envoyer un message...", disabled=not GOOGLE_API_KEY):
     st.session_state.chat_history.append({"role": "user", "content": prompt, "type": "text"})
     with st.chat_message("user", avatar="👤"):
         st.markdown(prompt)
 
-    # Préparer et afficher la réponse de l'assistant
     with st.chat_message("assistant", avatar="🤖"):
         history_for_api = st.session_state.chat_history.copy()
         
-        # Logique de Recherche Web (RAG)
         if st.session_state.enable_web_search:
             with st.spinner("KolaChatBot recherche sur le web..."):
                 search_context, sources = perform_web_search(prompt)
             
             if sources:
                 rag_prompt = (
-                    "En te basant STRICTEMENT sur les informations suivantes issues d'une recherche web, réponds à la question de l'utilisateur. "
+                    "En te basant STRICTEMENT sur les informations suivantes, réponds à la question. "
                     "Cite tes sources en utilisant le format [Source X] après chaque phrase concernée.\n\n"
-                    f"--- CONTEXTE DE LA RECHERCHE ---\n{search_context}\n--- FIN DU CONTEXTE ---\n\n"
-                    f"Question de l'utilisateur : {prompt}"
+                    f"--- CONTEXTE ---\n{search_context}\n--- FIN DU CONTEXTE ---\n\n"
+                    f"Question : {prompt}"
                 )
                 history_for_api[-1]['content'] = rag_prompt
             else:
                  st.toast("La recherche web n'a pas fourni de résultats.")
 
-        # Appel API et Affichage en Streaming
         params = {
             "max_new_tokens": st.session_state.max_response_length,
             "temperature": st.session_state.temperature,
             "top_p": st.session_state.top_p,
         }
         
-        # Utiliser st.write_stream pour afficher la réponse mot par mot
         response_content = st.write_stream(get_gemini_response_stream(
             st.session_state.selected_model_id,
             st.session_state.system_message,
@@ -306,13 +283,11 @@ if prompt := st.chat_input(f"Envoyer un message...", disabled=not GOOGLE_API_KEY
             params
         ))
 
-    # Sauvegarder la réponse complète de l'assistant dans l'historique
     assistant_message = {"role": "assistant", "content": response_content, "type": "text"}
     if st.session_state.get('last_search_results'):
         assistant_message["sources"] = st.session_state.last_search_results
-        st.session_state.last_search_results = None  # Nettoyer
+        st.session_state.last_search_results = None
 
     st.session_state.chat_history.append(assistant_message)
-    # Un seul `rerun` est nécessaire si les sources ont été utilisées pour les réafficher correctement.
     if "sources" in assistant_message:
         st.rerun()