Update src/streamlit_app.py

src/streamlit_app.py

@@ -8,28 +8,54 @@ from huggingface_hub import InferenceClient
 # -----------------------------------------------------------------------------
 load_dotenv()
 HUGGINGFACEHUB_API_TOKEN = os.getenv("HUGGINGFACEHUB_API_TOKEN")
-
-if not HUGGINGFACEHUB_API_TOKEN:
-    st.error("Le token HUGGINGFACEHUB_API_TOKEN est introuvable. Vérifiez votre fichier .env.")
-    st.stop()
-
 model_id = "mistralai/Mistral-7B-Instruct-v0.3"
 
 # -----------------------------------------------------------------------------
-# LLM helper - Modifié pour utiliser la tâche 'conversational'
-# La fonction get_llm_hf_inference n'est plus nécessaire dans sa forme originale.
-# On instanciera le client directement dans get_response.
+# LLM helper
 # -----------------------------------------------------------------------------
 
+def get_llm_hf_inference(model_id=model_id, max_new_tokens: int = 128, temperature: float = 0.1):
+    """Return an InferenceClient wrapper for Hugging Face inference."""
+    client = InferenceClient(model=model_id, token=HUGGINGFACEHUB_API_TOKEN)
+
+    def run(prompt: str) -> str:
+        try:
+            # For future versions with .conversational method
+            response = client.conversational(
+                inputs=prompt,
+                parameters={
+                    "max_new_tokens": max_new_tokens,
+                    "temperature": temperature,
+                },
+            )
+            return response.generated_text
+        except AttributeError:
+            # Fallback for older huggingface_hub clients
+            response = client.post(
+                json={
+                    "inputs": prompt,
+                    "parameters": {
+                        "max_new_tokens": max_new_tokens,
+                        "temperature": temperature,
+                    },
+                },
+                task="conversational"
+            )
+            return response["generated_text"]
+
+    return run
+
 # -----------------------------------------------------------------------------
 # Streamlit page configuration
 # -----------------------------------------------------------------------------
 st.set_page_config(page_title="KolaChatBot", page_icon="🤗")
 st.title("KolaChatBot")
-st.markdown(f"*KolaChatBot utilise l'API Inference de Hugging Face avec le modèle **{model_id}**.*")
+st.markdown(
+    f"*KolaChatBot utilise l'API Inference de Hugging Face avec le modèle **{model_id}**.*"
+)
 
 # -----------------------------------------------------------------------------
-# Session‑state initialisation
+# Session ‐state initialisation
 # -----------------------------------------------------------------------------
 if "avatars" not in st.session_state:
     st.session_state.avatars = {"user": "👤", "assistant": "🤗"}
@@ -53,12 +79,8 @@ with st.sidebar:
     st.header("Paramètres du système")
 
     # AI Settings
-    # NOTE: Le message système pourrait ne pas être pris en charge directement par l'API 'conversational'.
-    # Si le modèle en a besoin, il faudrait potentiellement l'inclure dans le premier message utilisateur
-    # ou configurer l'endpoint différemment. Pour l'instant, on le garde comme réglage mais il n'est pas
-    # passé directement dans l'appel API 'conversational'.
     st.session_state.system_message = st.text_area(
-        "System Message (Non supporté directement par l'API 'conversational')", value=st.session_state.system_message
+        "System Message", value=st.session_state.system_message
     )
     st.session_state.starter_message = st.text_area(
         "First AI Message", value=st.session_state.starter_message
@@ -66,7 +88,7 @@ with st.sidebar:
 
     # Model Settings
     st.session_state.max_response_length = st.number_input(
-        "Max Response Length", value=st.session_state.max_response_length, min_value=1
+        "Max Response Length", value=st.session_state.max_response_length
     )
 
     # Avatar Selection
@@ -93,145 +115,66 @@ if "chat_history" not in st.session_state or reset_history:
     ]
 
 # -----------------------------------------------------------------------------
-# Core inference helper (Modifié pour la tâche 'conversational')
+# Core inference helper
 # -----------------------------------------------------------------------------
 
-# La fonction build_prompt n'est plus utilisée avec la tâche 'conversational'
-# def build_prompt(...): pass
+def build_prompt(system_message: str, chat_history: list[dict], user_text: str) -> str:
+    """Format the conversation as a prompt for the LLM."""
+    prompt = f"### SYSTEM:\n{system_message}\n\n"
+    for msg in chat_history:
+        role_tag = "USER" if msg["role"] == "user" else "ASSISTANT"
+        prompt += f"### {role_tag}:\n{msg['content']}\n\n"
+    prompt += f"### USER:\n{user_text}\n\n### ASSISTANT:\n"
+    return prompt
 
-def get_response(chat_history: list[dict], max_new_tokens: int = 256, temperature: float = 0.1):
-    """
-    Génère une réponse en utilisant la tâche 'conversational' de l'API Inference.
-    Construit les inputs attendus par cette tâche à partir de l'historique.
-    """
-    # Instancier le client InferenceClient pour cet appel
-    client = InferenceClient(model=model_id, token=HUGGINGFACEHUB_API_TOKEN)
 
-    # Préparer l'historique pour le format de l'API 'conversational'
-    # L'API attend un dictionnaire inputs avec :
-    # {"text": "message utilisateur courant",
-    #  "past_user_inputs": ["ancien message user 1", "ancien message user 2", ...],
-    #  "generated_responses": ["ancienne réponse IA 1", "ancienne réponse IA 2", ...]}
-
-    api_past_user_inputs = []
-    api_generated_responses = []
-
-    # Parcourir l'historique de chat_history, en excluant le dernier message
-    # (qui est le message utilisateur courant) et les messages système.
-    # On suppose que chat_history est dans l'ordre chronologique
-    # [msg1, msg2, ..., dernier_message_utilisateur].
-    # Donc l'historique "passé" pour l'API est tout sauf le dernier élément.
-    history_for_api = [msg for msg in chat_history[:-1] if msg["role"] != "system"]
-
-    # Construire les listes appariées pour l'API.
-    # On suppose que history_for_api contient des messages alternés "user" et "assistant".
-    temp_user_inputs = []
-    temp_generated_responses = []
-
-    for msg in history_for_api:
-        if msg["role"] == "user":
-            temp_user_inputs.append(msg["content"])
-        elif msg["role"] == "assistant":
-             temp_generated_responses.append(msg["content"])
-
-    # L'API 'conversational' exige que past_user_inputs et generated_responses
-    # aient la même longueur, représentant des tours de conversation complétés
-    # (utilisateur -> assistant). On tronque si nécessaire (ne devrait pas l'être
-    # si l'historique est bien géré).
-    min_len = min(len(temp_user_inputs), len(temp_generated_responses))
-    api_past_user_inputs = temp_user_inputs[:min_len]
-    api_generated_responses = temp_generated_responses[:min_len]
-
-
-    # Le message utilisateur courant est le contenu du dernier message dans chat_history
-    current_user_input_api = chat_history[-1]["content"]
-
-    # Appeler la tâche 'conversational' en utilisant l'instance client
-    try:
-        response = client.conversational( # Utiliser client.conversational comme indiqué par le ValueError
-             inputs={
-                 "text": current_user_input_api, # Message utilisateur courant
-                 "past_user_inputs": api_past_user_inputs, # Liste des anciens messages utilisateur
-                 "generated_responses": api_generated_responses, # Liste des anciennes réponses de l'IA
-             },
-             parameters={
-                 "max_new_tokens": max_new_tokens,
-                 "temperature": temperature,
-                 # Ajouter d'autres paramètres supportés par l'API pour la tâche conversational si besoin
-                 # (ex: repetition_penalty, do_sample, top_k, top_p etc.)
-                 # Consulter la documentation de l'API Inference Hugging Face pour le modèle/tâche spécifique.
-             },
-        )
-        # La réponse de la tâche 'conversational' est un objet avec l'attribut generated_text
-        response_text = response.generated_text
-    except Exception as e:
-         # Afficher l'erreur et retourner un message d'erreur dans le chat
-         print(f"Error during conversational API call: {e}")
-         response_text = f"Une erreur est survenue lors de la génération de la réponse : {e}"
-         # Retourne un message d'erreur pour que le tour de conversation soit visuellement complété.
+def get_response(system_message: str, chat_history: list[dict], user_text: str, max_new_tokens: int = 256):
+    """Generate a response and update chat history."""
+
+    prompt = build_prompt(system_message, chat_history, user_text)
 
-    # Retourner le texte généré (ou le message d'erreur)
-    # La boucle principale Streamlit gérera l'ajout de cette réponse à st.session_state.chat_history
-    return response_text
+    llm = get_llm_hf_inference(max_new_tokens=max_new_tokens, temperature=0.1)
+    response_text = llm(prompt)
 
+    # Update history
+    chat_history.append({"role": "user", "content": user_text})
+    chat_history.append({"role": "assistant", "content": response_text})
+
+    return response_text, chat_history
 
 # -----------------------------------------------------------------------------
-# Streamlit chat interface (Boucle principale)
+# Streamlit chat interface
 # -----------------------------------------------------------------------------
 chat_interface = st.container(border=True)
 with chat_interface:
-    output_container = st.container() # Conteneur où les messages sont affichés
-
-    # Affichage des messages de l'historique
-    # Cette boucle s'exécute à chaque redémarrage du script Streamlit.
-    with output_container:
-        for message in st.session_state.chat_history:
-            if message["role"] == "system":
-                continue # Ne pas afficher les messages de rôle 'system'
-            # Utiliser .get pour éviter une erreur si l'avatar n'était pas trouvé (sécurité)
-            with st.chat_message(
-                message["role"], avatar=st.session_state.avatars.get(message["role"], "❓")
-            ):
-                st.markdown(message["content"])
-
-    # Champ de saisie pour l'utilisateur
-    # Lorsque l'utilisateur entre du texte, st.session_state.user_text est mis à jour
-    # et le script Streamlit redémarre depuis le début.
+    output_container = st.container()
     st.session_state.user_text = st.chat_input(placeholder="Entrez votre message ici…")
 
-# Ce bloc s'exécute si le script a redémarré parce que st.session_state.user_text a été mis à jour.
-if st.session_state.user_text:
-    # 1. Ajouter le nouveau message utilisateur à l'historique de l'état de session.
-    #    Cet ajout rend le message utilisateur visible lors du prochain redémarrage du script
-    #    (qui arrivera après que la réponse de l'IA soit générée et ajoutée).
-    st.session_state.chat_history.append({"role": "user", "content": st.session_state.user_text})
-
-    # 2. Afficher l'indicateur de chargement pour la réponse de l'IA.
-    #    Le message utilisateur vient d'être ajouté à st.session_state.chat_history,
-    #    il est donc inclus lorsque get_response analyse l'historique.
-    with st.chat_message(
-        "assistant", avatar=st.session_state.avatars["assistant"]
-    ):
-        with st.spinner("KolaChatBot réfléchit…"):
-            # Appeler get_response pour générer le texte de l'IA.
-            # get_response utilise maintenant correctement la tâche 'conversational'
-            # et construit le dictionnaire d'entrée pour l'API à partir de l'historique mis à jour.
-            response_text = get_response(
-                chat_history=st.session_state.chat_history, # Passer l'historique *complet* (incluant le dernier message user)
-                max_new_tokens=st.session_state.max_response_length,
-                temperature=0.1, # Ou récupérer depuis la sidebar si réglable
-            )
-            # 3. Ajouter la réponse générée par l'IA à l'historique de l'état de session.
-            #    Cet ajout rend le message de l'IA visible lors du prochain et dernier redémarrage.
-            st.session_state.chat_history.append({"role": "assistant", "content": response_text})
-
-            # 4. Afficher la réponse de l'IA immédiatement pour une meilleure expérience utilisateur.
-            st.markdown(response_text)
-
-    # 5. Nettoyer l'état de la zone de saisie après que le message ait été traité.
-    #    Cela empêche le message d'être traité à nouveau lors des redémarrages ultérieurs
-    #    (ex: interactions dans la sidebar) et vide le champ de saisie.
-    st.session_state.user_text = None
-
-# Streamlit redémarrera automatiquement le script lorsque st.session_state.chat_history change
-# ou lorsque l'utilisateur entre du texte, mettant à jour l'affichage dans output_container.
+# Display chat messages
+with output_container:
+    for message in st.session_state.chat_history:
+        if message["role"] == "system":
+            continue  # Skip system messages
+        with st.chat_message(
+            message["role"], avatar=st.session_state.avatars[message["role"]]
+        ):
+            st.markdown(message["content"])
+
+    # Handle new user message
+    if st.session_state.user_text:
+        # Show the user message immediately
+        with st.chat_message("user", avatar=st.session_state.avatars["user"]):
+            st.markdown(st.session_state.user_text)
+
+        # Generate and display assistant response
+        with st.chat_message(
+            "assistant", avatar=st.session_state.avatars["assistant"]
+        ):
+            with st.spinner("KolaChatBot réfléchit…"):
+                response_text, st.session_state.chat_history = get_response(
+                    system_message=st.session_state.system_message,
+                    user_text=st.session_state.user_text,
+                    chat_history=st.session_state.chat_history,
+                    max_new_tokens=st.session_state.max_response_length,
+                )
+                st.markdown(response_text)