Upload 22 files

.gitattributes

@@ -34,3 +34,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 chroma_db/chroma.sqlite3 filter=lfs diff=lfs merge=lfs -text
+client/assets/avatar_bot_big.jpg filter=lfs diff=lfs merge=lfs -text
+client/assets/avatar_bot_medium.jpg filter=lfs diff=lfs merge=lfs -text
+client/assets/logo.png filter=lfs diff=lfs merge=lfs -text
+client/assets/membre1.jpg filter=lfs diff=lfs merge=lfs -text
+client/assets/membre2.jpg filter=lfs diff=lfs merge=lfs -text
+client/assets/membre3.jpg filter=lfs diff=lfs merge=lfs -text

client/pages/dashboard.py

@@ -0,0 +1,157 @@
+import streamlit as st
+import psycopg2
+import os
+import plotly.graph_objects as go
+import pandas as pd
+from dotenv import load_dotenv
+from server.db.db import (
+    get_recipes_count,
+    get_average_latency,
+    get_daily_requests,
+    get_total_cost,
+    get_total_impact
+)
+
+# Récupérer les données pour afficher sur le dashboard
+total_recipes = get_recipes_count()
+average_latency = get_average_latency()
+total_cost = get_total_cost()
+total_impact = get_total_impact()
+
+# Récupérer les données des requêtes par jour
+df_requests = get_daily_requests()
+
+# Affichage de la page dashboard avec Streamlit
+st.markdown(
+    """
+    <div class="title-container">
+        DASHBOARD
+    </div>
+    """,
+    unsafe_allow_html=True,
+)
+
+# Ajouter le CSS pour les cards avec animations et un design moderne
+st.markdown(""" 
+    <style>
+        .title-container {
+            background-color: #6A5ACD;
+            border-radius: 10px;
+            color: white;
+            text-align: center;
+            padding: 5px;
+            margin-bottom: 20px;
+            box-shadow: 0px 4px 6px rgba(0, 0, 0, 0.1);
+            font-family: New Icon;
+            font-size: 30px;
+        }
+
+        /* Style pour les cards */
+        .card {
+            border-radius: 15px;
+            padding: 20px;
+            background: linear-gradient(to top, #cae7d4, #a7d7b8);
+            box-shadow: 0 8px 16px rgba(0, 0, 0, 0.1);
+            margin-bottom: 20px;
+            text-align: center;
+            transition: transform 0.3s, box-shadow 0.3s;
+            animation: fadeInUp 0.5s ease-out;
+            height: 200px;
+        }
+
+        .card:hover {
+            transform: translateY(-10px);
+            box-shadow: 0 12px 24px rgba(0, 0, 0, 0.2);
+        }
+
+        @keyframes fadeInUp {
+            0% {
+                transform: translateY(20px);
+                opacity: 0;
+            }
+            100% {
+                transform: translateY(0);
+                opacity: 1;
+            }
+        }
+
+        .card-title {
+            font-size: 1.3em;
+            color: #2d3e50;
+            margin-bottom: 15px;
+            font-weight: bold;
+            font-family: New Icon;
+        }
+
+        .card-value {
+            font-size: 30px;
+            color: #0099cc;
+            font-weight: bold;
+        }
+
+        /* Add smooth transition for the hover effect */
+        .card .card-title, .card .card-value {
+            transition: color 0.3s ease;
+        }
+
+        .card:hover {
+            color: #FF9A76;
+        }
+        .card:hover .card-value {
+            color: #0086b3;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+
+# Créer des colonnes pour disposer les cards
+col1, col2, col3, col4 = st.columns(4)
+
+# Card 1
+with col1:
+    st.markdown(f"""
+        <div class="card">
+            <div class="card-title">🍲 Nombre de recettes suggerées</div>
+            <div class="card-value">{total_recipes}</div>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Card 2
+with col2:
+    st.markdown(f"""
+        <div class="card">
+            <div class="card-title">⏱️ Latence moyenne</div>
+            <div class="card-value">{average_latency}s</div>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Card 3
+with col3:
+    st.markdown(f"""
+        <div class="card">
+            <div class="card-title">💸 Coût total des requêtes</div>
+            <div class="card-value">${total_cost}</div>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Card 4
+with col4:
+    st.markdown(f"""
+        <div class="card">
+            <div class="card-title">🌱 Impact écologique estimé</div>
+            <div class="card-value">{total_impact} kg CO2</div>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Graphique des requêtes par jour
+st.markdown("### 📅 Nombre de requêtes par jour")
+
+fig = go.Figure(data=[go.Scatter(x=df_requests['date'], y=df_requests['nombre_requetes'], mode='lines+markers')])
+
+fig.update_layout(
+    xaxis_title="Date",
+    yaxis_title="Nombre de requêtes",
+    template="plotly_dark"
+)
+
+st.plotly_chart(fig)

client/pages/home.py

@@ -0,0 +1,204 @@
+import streamlit as st
+import os
+
+# def home_page():
+
+st.markdown("""
+    <style>
+        /*
+        body, .stApp {
+            background: linear-gradient(to right, #cae7d4, #a8d8b9);
+        }*/
+
+        @keyframes gradientAnimation {
+            0% { background-position: 0% 50%; }
+            50% { background-position: 100% 50%; }
+            100% { background-position: 0% 50%; }
+        }
+
+        .presentation {
+            background-color: #ffffff;
+            border-radius: 10px;
+            padding: 2rem;
+            box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+        }
+
+        .left-col, .right-col {
+            border-radius: 12px;
+            overflow: hidden;
+        }
+
+        h2 {
+            font-size: 2rem;
+            color: #2a4b47;
+        }
+
+        .welcome-title {
+            font-size: 2.5rem;
+            font-weight: 700;
+            color: #2a4b47;
+            text-align: center;
+            animation: fadeIn 2s ease-out;
+        }
+
+        @keyframes fadeIn {
+            0% { opacity: 0; }
+            100% { opacity: 1; }
+        }
+
+        .user-name {
+            color: #4e7a63;
+            font-size: 3rem;
+            font-weight: bold;
+            animation: nameAnimation 2s ease-out;
+        }
+
+        .presentation-text {
+            font-size: 1.3rem;
+            color: #4e7a63;
+            text-align: center;
+            font-style: italic;
+            animation: fadeIn 3s ease-out;
+        }
+
+        .feature-icon {
+            font-size: 2rem;
+            margin-right: 1rem;
+        }
+
+        .features {
+            background: linear-gradient(to right, #cae7d4, #a8d8b9);
+            padding: 1.5rem;
+            border-radius: 8px;
+            box-shadow: 0px 4px 10px rgba(0, 0, 0, 0.1);
+            animation: fadeIn 1s ease-out;
+            transition: transform 0.3s ease;
+            margin-bottom: 1rem;
+            height:250px;
+        }
+
+        .features:hover {
+            transform: translateY(-5px);
+            box-shadow: 0px 8px 16px rgba(0, 0, 0, 0.2);
+        }
+
+        .team-name-role {
+            color: #2a4b47;
+            font-size: 1.1rem;
+            margin-top: 0.5rem;
+            font-weight: 500;
+            font-style: italic;
+            text-align: center;
+        }
+
+        .team-name {
+            color: #2a4b47;
+            font-size: 1.3rem;
+            font-weight: 700;
+            text-align: center;
+        }
+
+    </style>
+""", unsafe_allow_html=True)
+
+st.markdown(f"""
+    <h2 class="welcome-title">
+        Bienvenue sur NutriGénie <span class="user-name">{st.session_state['user']}</span> 🍽️!
+    </h2>
+""", unsafe_allow_html=True)
+
+st.markdown("""
+    <br>
+    <div class="presentation-text">
+        " Laissez-nous vous guider à travers une expérience culinaire sur-mesure. Découvrez des recettes adaptées à vos préférences et suivez vos habitudes alimentaires en toute simplicité. "
+    </div>
+    <br>
+""", unsafe_allow_html=True)
+
+logo_path = os.path.join("client","assets","logo.png")
+
+# centrer le logo
+cola, colb, colc = st.columns(3)
+
+with cola:
+    pass 
+with colb:
+    st.image(logo_path, use_container_width=True, caption=None)
+with colc:
+    pass 
+
+st.markdown("""
+        <br>
+        <h3 style="color:#2a4b47; text-align:center;">🔧 Fonctionnalités principales de l'application :</h3>
+        <br>
+    """, unsafe_allow_html=True)
+
+# Fonctionnalités disposées horizontalement par paires
+col1, col2 = st.columns(2)
+
+with col1:
+
+    # Fonctionnalités 1 et 2
+    st.markdown("""
+        <div class="features">
+            <div style="display: flex; align-items: center;">
+                <span class="feature-icon">🍽️</span>
+                <h3><strong>Génération de recettes personnalisées</strong></h3>
+            </div>
+            <p>Créez des recettes adaptées à vos préférences et vos besoins alimentaires. Nous générons des suggestions personnalisées pour chaque utilisateur.</p>
+        </div>
+        <div class="features">
+            <div style="display: flex; align-items: center;">
+                <span class="feature-icon">📝</span>
+                <h3><strong>Suivi des repas</strong></h3>
+            </div>
+            <p>Consultez l'historique de vos repas consommés et suivez vos habitudes alimentaires au fil du temps.</p>
+        </div>
+    """, unsafe_allow_html=True)
+
+with col2:
+    # Fonctionnalités 3 et 4
+    st.markdown("""
+        <div class="features">
+            <div style="display: flex; align-items: center;">
+                <span class="feature-icon">🛒</span>
+                <h3><strong>Liste de courses</strong></h3>
+            </div>
+            <p>Générez automatiquement des listes de courses basées sur les recettes que vous avez choisies. Ne manquez plus d'ingrédients !</p>
+        </div>
+        <div class="features">
+            <div style="display: flex; align-items: center;">
+                <span class="feature-icon">🍴</span>
+                <h3><strong>Suggestions de repas</strong></h3>
+            </div>
+            <p>Obtenez des suggestions de repas en fonction de vos goûts et de vos besoins nutritionnels.</p>
+        </div>
+    """, unsafe_allow_html=True)
+
+# Présentation des membres de l'équipe
+st.markdown("<hr>", unsafe_allow_html=True)  # Ajoute une ligne de séparation
+
+st.subheader("Rencontrez notre équipe 👩‍🍳👨‍🍳")
+
+# Définition des 5 membres
+base_path = os.path.join("client","assets")
+membres = [
+    {"nom": "Souraya", "role": "M2 SISE", "photo": f"{os.path.join(base_path,'membre1.jpg')}", "emoji_role": "👩‍💻"},
+    {"nom": "Bertrand", "role": "M2 SISE", "photo": f"{os.path.join(base_path,'membre2.jpg')}", "emoji_role": "👩‍💻"},
+    {"nom": "Cyril", "role": "M2 SISE", "photo": f"{os.path.join(base_path,'membre3.jpg')}", "emoji_role": "👩‍💻"},
+    {"nom": "Linh Nhi", "role": "M2 SISE", "photo": f"{os.path.join(base_path,'membre4.jpg')}", "emoji_role": "👩‍💻"},
+    {"nom": "Daniella", "role": "M2 SISE", "photo": f"{os.path.join(base_path,'membre5.jpg')}", "emoji_role": "👩‍💻"}
+]
+
+# Création des colonnes pour chaque membre
+cols = st.columns(5)
+
+for i, membre in enumerate(membres):
+    with cols[i]:
+        st.image(membre["photo"], use_container_width=True, caption=None)
+        st.markdown(f"""
+            <div class="team-member">
+                <div class="team-name">{membre['nom']}</div>
+                <div class="team-name-role">{membre['emoji_role']} {membre['role']}</div>
+            </div>
+        """, unsafe_allow_html=True)

client/pages/nutri.py

@@ -0,0 +1,270 @@
+import streamlit as st
+import os
+import time
+from server.mistral.mistralapi import MistralAPI
+from server.security.prompt_guard import Guardrail
+import asyncio
+from typing import List, Dict
+from datetime import datetime
+from server.db.dbmanager import (
+    load_conversations,
+    load_messages, 
+    update_conversation,
+    create_conversation,
+    save_message,
+    get_conversation_title,
+    update_conversation_title,
+    delete_conversation,
+    load_chatbot_suggestions,
+    save_chatbot_suggestions
+)
+import logging
+logging.basicConfig(level=logging.INFO, handlers=[logging.StreamHandler()])
+logger = logging.getLogger(__name__)
+
+
+# 🔹 Chargement des variables de session pour éviter les rechargements inutiles
+if "id_conversation" not in st.session_state:
+    st.session_state.id_conversation = None
+
+if "mistral_model" not in st.session_state:
+    st.session_state["mistral_model"] = "mistral-large-latest"
+
+if "messages" not in st.session_state:
+    st.session_state.messages = []  # Initialise l'historique des messages
+
+
+
+
+# 🔹 Initialisation unique de MistralAPI
+if "mistral_instance" not in st.session_state:
+    print("🔄 Initialisation de MistralAPI...")
+    st.session_state.mistral_instance = MistralAPI(model=st.session_state["mistral_model"])
+    print("✅ MistralAPI initialisé avec succès.")
+
+mistral = st.session_state.mistral_instance  # Récupérer l'instance stockée
+
+# 🔹 Initialisation de la sécurité (Guardrail)
+try:
+    guardrail = Guardrail()
+except Exception as e:
+    st.error(f"❌ Guardrail introuvable. Veuillez relancer l'appli ou contacter l'équipe de développement. Détails : {e}")
+    st.stop()
+
+# 🔹 Chargement de la base de données
+db_manager = st.session_state["db_manager"]
+user_id = st.session_state["user_id"]
+
+if "chatbot_suggestions" not in st.session_state:
+    st.session_state["chatbot_suggestions"] = load_chatbot_suggestions(db_manager, user_id)
+
+# 🔹 Sidebar : Bouton "➕ Nouveau chat" en haut
+st.sidebar.title("🗂️ Historique")
+if st.sidebar.button("➕ Nouveau chat"):
+    title = "Nouvelle conversation"
+    new_conversation_id = create_conversation(db_manager, title, user_id)
+    st.session_state.id_conversation = new_conversation_id
+    st.session_state.messages = []  
+    st.rerun()
+
+# 🔹 Charger l'historique des conversations
+conversation_history = load_conversations(db_manager, user_id) or []
+
+# 🔹 Sidebar : Affichage de l'historique des conversations avec bouton de suppression
+for index, conversation in enumerate(conversation_history):
+    id_conversation = conversation['id_conversation']
+    title = conversation['title']
+    key = f"conversation_{id_conversation}_{index}"  # Clé unique
+
+    col1, col2 = st.sidebar.columns([0.8, 0.2])  # 🔹 Disposition pour aligner le bouton de suppression
+
+    with col1:
+        if "id_conversation" in st.session_state and st.session_state.id_conversation == id_conversation:
+            st.button(f"🟢 {title}", key=key, disabled=True)
+        else:
+            if st.button(title, key=key):
+                st.session_state.id_conversation = id_conversation
+                st.session_state.messages = load_messages(db_manager, id_conversation)
+                update_conversation(db_manager, id_conversation=st.session_state.id_conversation, id_utilisateur=user_id)
+                st.rerun()
+
+    with col2:
+        if st.button("🗑️", key=f"delete_{id_conversation}"):  # 🔥 Bouton de suppression
+            delete_conversation(db_manager, id_conversation)
+            st.rerun()  # Rafraîchir après suppression
+
+# 🔹 Affichage des messages précédents dans l'interface
+for message in st.session_state.messages:
+    timestamp = message["timestamp"]
+    latency = message["temps_traitement"]
+    latency_text = f"⏳ {latency} sec" if latency is not None else ""
+
+    if message["role"] == "user":
+        with st.chat_message("user"):
+            st.markdown(message["content"])
+            st.caption(f"📅 {timestamp} {latency_text}")
+
+    elif message["role"] == "assistant":
+        with st.chat_message("assistant", avatar="client/assets/avatar_bot_big.jpg"):
+            st.markdown(message["content"])
+            st.caption(f"📅 {timestamp} {latency_text}")  # 🔹 Ajout de l'heure et de la latence
+
+
+# 🔹 Interface utilisateur - Zone d'entrée utilisateur
+if prompt := st.chat_input("Dîtes quelque-chose"):
+
+    # Calcul du nombre de tokens avant d'envoyer le prompt
+    input_tokens = mistral.count_input_tokens([{"content": prompt}])
+    print(f"✅ Nombre de tokens en entrée : {input_tokens}")
+
+    # 🔸 Vérifier si le message est dans une langue supportée par le guardrail
+    is_supported = guardrail.analyze_language(prompt)
+    if not is_supported:
+        st.warning("⚠️ Votre message n'est pas rédigé dans les langues actuellement supportées (FR, EN, DE, ES).")
+        st.warning("Si votre message est pourtant dans une des langues supportées, le reformuler ou l'allonger peut être utile.")
+        st.stop()
+    
+    # 🔸 Vérifier la sécurité du message
+    is_safe = guardrail.analyze_query(prompt)
+
+    # 🔸 Afficher immédiatement le message de l'utilisateur
+    with st.chat_message("user"):
+        st.markdown(prompt)
+
+    if st.session_state.id_conversation is None:
+        # Générer un titre basé sur le premier message
+        title = mistral.auto_wrap(text=prompt, temperature=0.5)
+        st.session_state.id_conversation = create_conversation(db_manager, title, user_id)
+    else:
+        # Vérifier si le titre est encore "Nouvelle conversation" et le mettre à jour si nécessaire
+        current_title = get_conversation_title(db_manager, st.session_state.id_conversation)
+        if current_title == "Nouvelle conversation":
+            new_title = mistral.auto_wrap(text=prompt, temperature=0.5)
+            update_conversation_title(db_manager, st.session_state.id_conversation, new_title)
+
+    # 🔸 Ajouter le message à l'historique et l'enregistrer dans la base de données
+    st.session_state.messages.append({"role": "user", "content": prompt,  "temps_traitement":None, "total_cout":None, "impact_eco":None, "timestamp":datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
+    save_message(db_manager, st.session_state.id_conversation, role="user", content=prompt, temps_traitement=None, total_cout=None, impact_eco=None)
+
+    # 🔸 Si le message est interdit, afficher l'alerte mais NE PAS l'envoyer à Mistral
+    if not is_safe:
+        st.warning("⚠️ Votre message ne respecte pas nos consignes.")
+        st.stop()  # Arrêter l'exécution ici pour ne PAS envoyer à Mistral
+
+    retries = 0
+    max_retries = 3
+
+    # 🔹 Générer une réponse avec Mistral et RAG
+    with st.chat_message("assistant", avatar="client/assets/avatar_bot_big.jpg"):
+        retries = 0
+        max_retries = 3
+        while retries < max_retries:
+            response = ""
+            response_placeholder = st.empty()
+            try:
+                start_time = time.time()  # 🔹 Début du chronomètre
+
+                print("🔄 Génération de réponse en cours...")
+                stream_response = mistral.stream(st.session_state.messages, temperature=0.5)
+
+                # for chunk in stream_response:
+                #     response += chunk.data.choices[0].delta.content
+                # if response == "Injection":
+                #     st.warning("⚠️ Votre message ne respecte pas nos consignes.")
+                #     guardrail.incremental_learning(prompt, 1) # 1 car injection. Le tuning ne se fait que sur les injections
+                #     st.stop()
+                # else: # on réinitialise
+                #     response = ""
+
+                # Compteur pour les tokens de sortie
+                output_tokens = 0
+
+                for chunk in stream_response:
+                    response += chunk.data.choices[0].delta.content
+                    response_placeholder.markdown(response)
+                    # Calculer les tokens pour ce morceau de réponse
+                    output_tokens += mistral.count_output_tokens(chunk.data.choices[0].delta.content)
+                
+                    time.sleep(0.03)
+                
+                # 🔹 Vérifier si la réponse contient une suggestion de recette
+                
+                # 🔹 Vérifier si la réponse contient des suggestions de recettes
+                keywords = ["recette", "plat", "préparer", "ingrédients"]
+
+                for word in keywords:
+                    if word in response.lower():
+                        try:
+                            # 🔹 Extraire plusieurs titres de recettes
+                            suggested_recipes = mistral.extract_multiple_recipes(text=response, temperature=0.3)
+
+                            # Vérifier et initialiser la liste des suggestions
+                            if "chatbot_suggestions" not in st.session_state:
+                                st.session_state["chatbot_suggestions"] = []
+
+                            # Ajouter uniquement les recettes qui ne sont pas déjà stockées
+                            new_recipes = [recipe for recipe in suggested_recipes if recipe not in st.session_state["chatbot_suggestions"]]
+                            
+                            if new_recipes:
+                                st.session_state["chatbot_suggestions"].extend(new_recipes)  # Ajouter plusieurs recettes
+                                print(f"✅ {len(new_recipes)} nouvelles suggestions ajoutées.")
+                                
+                                # 🔹 Sauvegarder les suggestions dans la BDD
+                                save_chatbot_suggestions(db_manager, user_id, new_recipes)
+                        except Exception as e:
+                            print(f"❌ Erreur lors de l'extraction des suggestions : {e}")
+
+                        break  # On ne veut ajouter qu'une seule suggestion par réponse
+            
+
+
+
+                end_time = time.time()  # 🔹 Fin du chronomètre
+                latency = round(end_time - start_time, 2)  # 🔹 Calcul de la latence
+
+                print(f"✅ Réponse générée en {latency} secondes.")
+                print(f"✅ Nombre de tokens de sortie : {output_tokens}")
+            except Exception as e:
+                if hasattr(e, "status_code") and e.status_code == 429:
+                    retries += 1
+                    wait_time = 2 ** retries  
+                    stream_response = None
+                    print(f"⚠️ Rate limit atteint. Nouvel essai dans {wait_time} secondes...")
+                    time.sleep(wait_time)
+                else:
+                    st.error(f"❌ Erreur : Impossible de traiter votre demande. Détails : {str(e)}")
+                    response_placeholder.markdown("❌ Erreur lors de la génération de la réponse.")
+                    st.stop()
+
+            if response is not None:
+                break
+
+        if retries >= max_retries:
+            st.error("❌ Impossible d'obtenir une réponse après plusieurs tentatives.")
+            response = "❌ Erreur : Limite de requêtes atteinte."
+
+        # 🔹 Calcul du coût des tokens d'entrée et de sortie
+        input_cost_per_token = 0.0004  # Coût par token d'entrée
+        output_cost_per_token = 0.0005  # Coût par token de sortie
+
+        # Calcul du coût des tokens d'entrée et de sortie
+        input_cost = input_tokens * input_cost_per_token
+        output_cost = output_tokens * output_cost_per_token
+
+        # Calcul du coût total
+        total_cost = input_cost + output_cost
+        print(f"✅ Coût total de la requête : {total_cost} USD")
+
+        # Facteur d'émission (en grammes de CO₂ par token)
+        EMISSIONS_PER_TOKEN = 0.00005 # estimation
+
+        # Calcul de l'empreinte carbone pour les tokens d'entrée et de sortie
+        input_emissions = input_tokens * EMISSIONS_PER_TOKEN
+        output_emissions = output_tokens * EMISSIONS_PER_TOKEN
+        total_emissions = input_emissions + output_emissions
+        print(f"🌍 Impact écologique total de la requête : {total_emissions:.4f} g CO₂")
+                
+
+        # 🔹 Enregistrer la réponse de l'assistant
+        st.session_state.messages.append({"role": "assistant", "content": response, "temps_traitement":latency, "timestamp":datetime.now().strftime("%Y-%m-%d %H:%M:%S")})
+        save_message(db_manager, st.session_state.id_conversation, role="assistant", content=response, temps_traitement=latency, total_cout=total_cost, impact_eco=total_emissions)

client/pages/nutri_old.py

@@ -0,0 +1,148 @@
+import streamlit as st
+import time
+from server.mistral.mistralapi import MistralAPI
+from server.security.prompt_guard import Guardrail
+from projects.LLM_project.server.db.db_sqlite import (
+    load_conversations,
+    load_messages, 
+    update_conversation,
+    create_conversation,
+    save_message)
+
+
+def nutri_page():
+    # Interface Streamlit
+    # st.set_page_config(page_title="Nutrigénie", layout="wide")
+    # Section pour afficher l'historique de la conversation
+    conversation_history = load_conversations()
+    # st.sidebar.title("Navigation")
+    st.sidebar.title("Historique")
+
+    for conversation_id, _, title in conversation_history:
+        if "conversation_id" in st.session_state and st.session_state.conversation_id == conversation_id:
+            # Bouton désactivé pour la conversation active
+            st.sidebar.button(f"🟢 {title}", key=f"conversation_{conversation_id}", disabled=True)
+        else:
+            # Bouton actif pour les autres conversations
+            if st.sidebar.button(title, key=f"conversation_{conversation_id}"):
+                # Charger la conversation sélectionnée
+                st.session_state.conversation_id = conversation_id
+                st.session_state.messages = load_messages(conversation_id)
+                update_conversation(conversation_id=st.session_state.conversation_id)
+                st.rerun()
+
+    st.title("Parlez au Nutrigénie")
+    # Historique de la conversation
+    if "conversation_id" not in st.session_state:
+        st.session_state.conversation_id = None
+
+    # Affichage des messages précédents
+    if st.session_state.conversation_id:
+        st.session_state.messages = load_messages(st.session_state.conversation_id)
+
+    if "mistral_model" not in st.session_state:
+        st.session_state["mistral_model"] = "mistral-large-latest"
+
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+
+    for message in st.session_state.messages:
+        if message["role"] == "user":
+            with st.chat_message("user"):  # Utilisez votre avatar utilisateur
+                st.markdown(message["content"])
+        elif message["role"] == "assistant":
+            with st.chat_message("assistant", avatar="client/assets/avatar_bot_big.jpg"):  # Avatar personnalisé pour l'assistant
+                st.markdown(message["content"])
+
+
+
+    # Initialisation de Mistral
+    mistral = MistralAPI(model=st.session_state["mistral_model"])
+    if prompt := st.chat_input("Dîtes quelque-chose"):
+        if st.session_state.conversation_id is None:
+            retries = 0
+            max_retries = 3
+            while retries < max_retries:
+                try:
+                    title = mistral.auto_wrap(prompt) # Utiliser le début du message comme titre
+                except Exception as e:
+                    # Vérifier explicitement si l'erreur est une 429 (rate limit exceeded)
+                    if hasattr(e, "status_code") and e.status_code == 429:
+                        retries += 1
+                        wait_time = 2 ** retries  # Temps d'attente exponentiel
+                        st.warning(f"Limite de requêtes atteinte (429). Nouvel essai dans {wait_time} secondes...")
+                        time.sleep(wait_time)
+                    else:
+                        # Gérer d'autres types d'erreurs
+                        st.error(f"Erreur : Impossible de traiter votre demande (déetails : {str(e)})")
+                        st.stop()
+                if title is not None:
+                    break
+            # Si tous les retries échouent, retourner un message d'erreur
+            if title is None:
+                st.error("Impossible d'obtenir une réponse. Limite de requêtes atteinte après plusieurs tentatives.")
+                st.stop()
+
+
+            st.session_state.conversation_id = create_conversation(title=title)
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        save_message(conversation_id=st.session_state.conversation_id, role="user", content=prompt)
+        
+        with st.chat_message("user"):
+            st.markdown(prompt)
+
+        ###################
+        #### Guardrail ####
+        ###################
+
+        try:
+            guardrail = Guardrail()
+        except Exception as e:
+            st.error(f"Guardrail introuvable. Veuillez relancer le conteneur pour recréer le guardrail. Détails : {e}")
+            st.stop()
+        # is_supported = await guardrail.analyze_language(prompt)
+        # if not is_supported:
+        #     st.warning("To use our bot in a safe manner, you must do the conversation in either english, french, german or spanish. If necessary you may use an online translator.")
+        #     st.stop()
+        is_safe = guardrail.analyze_query(prompt)
+        if not is_safe:
+            st.warning("Le prompt semble violer nos considérations éthiques. Nous vous invitons à poser une autre question.")
+            st.stop()
+
+        ####################
+        ###### PROMPT ######
+        ####################
+
+        with st.chat_message("assistant", avatar = "client/assets/avatar_bot_big.jpg"):
+            retries = 0
+            max_retries = 3
+            while retries < max_retries:
+                response = ""
+                response_placeholder = st.empty()
+                try:
+                    stream_response = mistral.stream(st.session_state.messages) # Utiliser le début du message comme titr
+                    # Traiter la réponse en streaming
+                    for chunk in stream_response:
+                        response += chunk.data.choices[0].delta.content
+                        response_placeholder.markdown(response)
+                        time.sleep(0.03)  # Petit délai pour simuler le flux en temps réel
+                except Exception as e:
+                    if hasattr(e, "status_code") and e.status_code == 429:
+                        # Gestion explicite de l'erreur 429 (Rate Limit Exceeded)
+                        retries += 1
+                        wait_time = 2 ** retries  # Délai exponentiel : 2, 4, 8 secondes
+                        st.warning(f"Limite de requêtes atteinte (429). Nouvel essai dans {wait_time} secondes...")
+                        time.sleep(wait_time)
+                    else:
+                        # Gestion d'autres types d'erreurs
+                        st.error(f"Erreur : Impossible de traiter votre demande (détails : {str(e)})")
+                        response_placeholder.markdown("Erreur lors de la génération de la réponse.")
+                        st.stop()
+                if stream_response is not None:
+                    break  # Si le streaming réussit, on sort de la boucle
+            # Si toutes les tentatives échouent, message d'erreur final
+            if retries >= max_retries:
+                st.error("Impossible d'obtenir une réponse. Limite de requêtes atteinte après plusieurs tentatives.")
+                response = "Erreur : Limite de requêtes atteinte après plusieurs tentatives."
+            st.session_state.messages.append({"role": "assistant", "content": response})
+            save_message(conversation_id=st.session_state.conversation_id, role="assistant", content=response)

client/pages/sign_in.py

@@ -0,0 +1,133 @@
+import streamlit as st
+from werkzeug.security import check_password_hash
+import os
+from dotenv import load_dotenv
+
+def sign_in(navigate_to):
+
+    st.markdown(
+        """
+        <style>
+
+        @keyframes fadeIn {
+            0% { opacity: 0; }
+            100% { opacity: 1; }
+        }
+        .stImage {
+            animation: fadeIn 1s ease-in;
+        }
+
+        .stTextInput > div > div > input {
+            font-size: 16px;
+            border-radius: 8px;
+            border: 1px solid #6A5ACD;
+        }
+
+        .stButton > button {
+            background-color: #6A5ACD;
+            color: white;
+            font-size: 18px;
+            padding: 10px;
+            border-radius: 8px;
+            border: none;
+            cursor: pointer;
+            transition: 0.3s;
+        }
+        
+       
+
+        .stAlert {
+            text-align: center;
+            font-weight: bold;
+        }
+
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+
+    logo_path = "assets/logo.png"
+
+    #centrer le logo
+    col1, col2, col3 = st.columns([1.5, 1.5, 1])
+
+    with col2:
+        if os.path.exists(logo_path):
+            st.image(logo_path, width=150)
+
+    # Récupération du gestionnaire de base de données (déjà stocké en session)
+    db_manager = st.session_state.get("db_manager")
+
+    st.title("Connexion")
+
+    # Champs de connexion
+    login = st.text_input("👤 Pseudo")
+    password = st.text_input("🔒 Mot de passe", type="password")
+
+    
+    # Bouton de connexion
+    if st.button("Se connecter"):
+        # Vérification des identifiants en base de données
+        user = db_manager.fetch_by_condition("utilisateurs", "login = %s", (login,))
+        print("user",user)
+
+        if user:
+            user = user[0]
+            user_id = user["id_utilisateur"] # Récupération de l'ID utilisateur
+            hashed_password = user["mot_de_passe"]  # Récupération du mot de passe hashé
+
+            # Vérification du mot de passe
+            if check_password_hash(hashed_password, password):
+                # Stocker les infos utilisateur dans la session
+                st.session_state["logged_in"] = True
+                st.session_state["user"] = login
+                st.session_state["user_id"] = user_id
+
+                # Message de confirmation
+                st.success("✅ Connexion réussie !")
+                navigate_to("accueil")  # Redirige vers la page d'accueil
+            else:
+                st.error("❌ Mot de passe incorrect.")
+        else:
+            st.error("❌ Utilisateur non trouvé.")
+
+    # Lien vers l'inscription
+    if st.button("Pas de compte ? Inscrivez-vous.") :
+        navigate_to("inscription")  # Redirection vers l'inscription
+
+
+"""
+# Forcer la connexion pendant le développement (commenter cette partie si nécessaire)
+    if 'logged_in' not in st.session_state or not st.session_state['logged_in']:
+        # Simuler une connexion (utiliser des valeurs par défaut)
+        st.session_state["logged_in"] = True
+        st.session_state["user"] = "dev_user"
+        st.session_state["user_id"] = 1  # ID fictif pour le développement
+        st.success("✅ Connexion simulée pour le développement !")
+        navigate_to("accueil")  # Redirige vers la page d'accueil
+    else:
+        # Logique de connexion normale (en production)
+        login = st.text_input("👤 Pseudo")
+        password = st.text_input("🔒 Mot de passe", type="password")
+
+        if st.button("Se connecter"):
+            user = db_manager.fetch_by_condition("utilisateurs", "login = %s", (login,))
+
+            if user:
+                user_id = user[0][0]
+                hashed_password = user[0][2]
+
+                if check_password_hash(hashed_password, password):
+                    st.session_state["logged_in"] = True
+                    st.session_state["user"] = login
+                    st.session_state["user_id"] = user_id
+                    st.success("✅ Connexion réussie !")
+                    navigate_to("accueil")
+                else:
+                    st.error("❌ Mot de passe incorrect.")
+            else:
+                st.error("❌ Utilisateur non trouvé.")
+
+    if st.button("Pas de compte ? Inscrivez-vous."):
+        navigate_to("inscription")
+        """

client/pages/sign_up.py

@@ -0,0 +1,41 @@
+import streamlit as st
+from werkzeug.security import generate_password_hash
+import os
+from dotenv import load_dotenv
+
+import sys
+
+def sign_up(navigate_to):
+    db_manager = st.session_state.get("db_manager")
+    st.title("Inscription")
+    
+    # Champs obligatoires
+    login = st.text_input("Pseudo")
+    email = st.text_input("Email")
+    password = st.text_input("Mot de passe", type="password")
+    confirm_password = st.text_input("Confirmer le mot de passe", type="password")
+
+    # Lien pour rediriger vers la page de connexion
+    if st.button("Déjà un compte ? connectez-vous."):
+        navigate_to("connexion")
+    
+    # Vérification des champs obligatoires
+    if st.button("Créer un compte"):
+        if not login or not email or not password or not confirm_password:
+            st.error("Tous les champs sont obligatoires.")
+        elif password != confirm_password:
+            st.error("Les mots de passe ne correspondent pas.")
+        else:
+            hashed_password = generate_password_hash(password)
+            try:
+                # Insérer l'utilisateur dans la base de données
+                db_manager.insert_data_from_dict("utilisateurs", [{
+                    "login": login,
+                    "email": email,
+                    "mot_de_passe": hashed_password
+                }], "id_utilisateur")
+                
+                st.success("Compte créé avec succès. Vous pouvez vous connecter.")
+                st.session_state["current_page"] = "connexion"
+            except Exception as e:
+                st.error(f"Erreur lors de l'inscription : {e}")

client/pages/user.py

@@ -0,0 +1,74 @@
+import streamlit as st
+from client.pages.user__info_perso import info_perso
+from client.pages.user__mealplan import mealplan
+from client.pages.user__course_list import course_list
+from client.pages.user__favoris import favoris
+
+
+# Appliquer le style personnalisé aux headers
+st.markdown("""
+    <style>
+        /* Style global pour les headers */
+        h3 {
+            font-size: 20px;
+            font-family: New Icon;
+            font-weight: 700;
+        }
+            
+        h2 {
+            font-size: 2rem;
+            color: #2a4b47;
+        }
+
+        .welcome-title {
+            font-size: 2.5rem;
+            font-weight: 700;
+            color: #2a4b47;
+            text-align: center;
+            animation: fadeIn 2s ease-out;
+        }
+
+        @keyframes fadeIn {
+            0% { opacity: 0; }
+            100% { opacity: 1; }
+        }
+
+        .user-name {
+            color: #4e7a63;
+            font-size: 3rem;
+            font-weight: bold;
+            animation: nameAnimation 2s ease-out;
+            font-family: New Icon;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+# Affichage du message de bienvenue
+st.markdown(f"""
+    <h2 class="welcome-title">
+        Bienvenue sur NutriGénie <span class="user-name">{st.session_state['user']}</span> 🍽️!
+    </h2>
+""", unsafe_allow_html=True)
+
+# Définition des onglets horizontaux
+tabs = st.tabs(["🧑‍💼 Informations personnelles ", "🍽️ Meal Plan", "🛒 Liste des courses", "⭐ Favoris"])
+
+# Onglet 1 : Informations personnelles
+with tabs[0]:
+    st.markdown('<h3 class="stHeader">🧑‍💼 Informations personnelles</h3>', unsafe_allow_html=True)
+    info_perso()  # Charger la page `info_perso.py`
+
+# Onglet 2 : Meal Plan
+with tabs[1]:
+    st.markdown('<h3 class="stHeader">🍽️ Meal Plan</h3>', unsafe_allow_html=True)
+    mealplan()  # Charger la page `mealplan.py`
+
+# Onglet 3 : Liste des courses
+with tabs[2]:
+    st.markdown('<h3 class="stHeader">🛒 Liste des courses</h3>', unsafe_allow_html=True)
+    course_list()  # Charger la page `course_list.py`
+
+# Onglet 4 : Favoris
+with tabs[3]:
+    st.markdown('<h3 class="stHeader">⭐ Favoris</h3>', unsafe_allow_html=True)
+    favoris()  # Charger la page `favoris.py`

client/pages/user__course_list.py

@@ -0,0 +1,19 @@
+import streamlit as st
+from server.db.db import get_ingredients
+
+
+# Page des courses
+def course_list():
+    st.write("Voici votre liste des courses.")
+    
+    ingredients_list = get_ingredients()
+    
+    if ingredients_list:
+        for ingredient in ingredients_list:
+            st.write(f"🍎 {ingredient[0]}")
+    else:
+        st.write("Aucun ingrédient trouvé.")
+
+    st.checkbox("Ajouter un nouvel article")
+
+

client/pages/user__favoris.py

@@ -0,0 +1,6 @@
+import streamlit as st
+
+def favoris():
+    st.subheader("Favoris")
+    st.write("Voici vos recettes ou restaurants favoris.")
+    st.button("Ajouter aux favoris")

client/pages/user__info_perso.py

@@ -0,0 +1,76 @@
+import streamlit as st
+
+def info_perso():
+    # Récupérer le gestionnaire de base de données
+    db_manager = st.session_state.get("db_manager")
+
+    if db_manager is None:
+        st.error("Erreur : DBManager n'est pas initialisé.")
+    else:
+        # Récupérer les informations de l'utilisateur connecté
+        user_id = st.session_state['user_id'] 
+        query = f"SELECT * FROM utilisateurs WHERE id_utilisateur = {user_id}"
+        user_info = db_manager.query(query)
+        
+        
+        if not user_info:
+            st.error("Utilisateur non trouvé.")
+        else:
+            user_info = user_info[0]  # Récupérer la première ligne (unique utilisateur)
+            print(user_info)  # Récupérer et afficher les informations de l'utilisateur
+            
+            # Premier formulaire (Nom, Email, Mot de passe)
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                nom = st.text_input("Nom", user_info["login"])
+            with col2:
+                email = st.text_input("Email", user_info["email"])
+            
+
+            # Deuxième formulaire (Objectifs nutritionnels, Poids, Taille)
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                
+                objectifs_nutritionnels_val = user_info["objectifs_nutritionnels"] if user_info["objectifs_nutritionnels"] else "Vide"
+                objectifs_nutritionnels = st.selectbox(
+                    "Objectifs nutritionnels", 
+                    ["Prise de masse", "Tonification", "Perdre du poids", "Vide"],
+                    index=["Prise de masse", "Tonification", "Perdre du poids", "Vide"].index(objectifs_nutritionnels_val)
+                )
+            with col2:
+                poids = st.number_input("Poids (kg)", value=user_info["poids"], step=1)
+            with col3:
+                taille = st.number_input("Taille (cm)", value=user_info["taille"], step=1)
+
+            # Troisième formulaire (Régime particulier, Activité physique, Objectif calorique)
+            col1, col2, col3 = st.columns(3)
+            with col1:
+                regime_particulier = st.text_area("Régime particulier", user_info["regime_particulier"])
+            with col2:
+                # Traitement de la valeur vide pour l'activité physique
+                activite_physique_val = user_info["activite_physique"] if user_info["activite_physique"] else "Vide"
+                activite_physique = st.selectbox(
+                    "Activité physique",
+                    ["Sédentaire", "Légère", "Modérée", "Intense", "Vide"],
+                    index=["Sédentaire", "Légère", "Modérée", "Intense", "Vide"].index(activite_physique_val)
+                )
+            with col3:
+                objectif_calorique = st.text_input("Objectif calorique", user_info["objectif_calorique"])
+
+            # Bouton pour sauvegarder toutes les informations
+            if st.button("Tout mettre à jour"):
+                table_name = "utilisateurs"
+                
+                
+                set_clause = """login = %s, email = %s, objectifs_nutritionnels = %s, poids = %s, taille = %s,
+                                regime_particulier = %s, activite_physique = %s, objectif_calorique = %s"""
+                condition = "id_utilisateur = %s"
+
+                # Rassembler les paramètres à passer à la méthode
+                params = (nom, email, objectifs_nutritionnels, poids, taille, 
+                        regime_particulier, activite_physique, objectif_calorique, user_id)
+                
+                # Appel à la méthode update_data avec les bons paramètres
+                db_manager.update_data(table_name, set_clause, condition, params)
+
+                st.success("Informations mises à jour avec succès.")

client/pages/user__mealplan.py

@@ -0,0 +1,113 @@
+import streamlit as st
+import pandas as pd
+from datetime import datetime, timedelta
+from server.db.dbmanager import (
+    get_db_manager,
+    load_chatbot_suggestions
+)
+db_manager = get_db_manager()
+user_id = st.session_state["user_id"]
+
+
+def get_week_dates(year, week):
+    """Retourne les dates du Lundi au Dimanche pour une semaine donnée."""
+    first_day_of_year = datetime(year, 1, 1)
+    first_monday = first_day_of_year + timedelta(days=(7 - first_day_of_year.weekday()))  # Trouver le premier lundi
+    start_date = first_monday + timedelta(weeks=week - 1)  # Trouver le début de la semaine sélectionnée
+    return [(start_date + timedelta(days=i)).strftime("%Y-%m-%d") for i in range(7)]  # 7 jours (Lundi → Dimanche)
+
+def mealplan():
+    # 📆 Sélection de l'année et de la semaine
+    current_year = datetime.now().year
+    current_week = datetime.now().isocalendar()[1]
+
+    year_options = list(range(current_year, current_year - 3, -1))  # Années en ordre décroissant
+    col1, col2 = st.columns([0.5, 0.5])  # Réduction de la largeur des sélecteurs
+    with col1:
+        selected_year = st.selectbox("📅 Année", year_options, index=0)
+    with col2:
+        week_options = [f"Semaine {i}" for i in range(1, 53)]
+        selected_week_label = st.selectbox("📆 Semaine", week_options, index=week_options.index(f"Semaine {current_week}"))
+        selected_week = int(selected_week_label.split(" ")[1])
+
+    # 📌 Génération des 7 jours de la semaine sélectionnée
+    week_dates = get_week_dates(selected_year, selected_week)
+
+    # 📋 Initialisation des repas
+    if "meal_plan" not in st.session_state:
+        st.session_state["meal_plan"] = {}
+
+    for date in week_dates:
+        if date not in st.session_state["meal_plan"]:
+            st.session_state["meal_plan"][date] = {
+                "Petit-déjeuner": "", "Déjeuner": "", "Dîner": ""
+            }
+
+    # 📋 Affichage du planning pour 7 jours
+    st.subheader(f"📆 Planning des repas - {selected_week_label} ({selected_year})")
+    df = pd.DataFrame.from_dict({date: st.session_state["meal_plan"][date] for date in week_dates}, orient="index")
+    df.index = pd.to_datetime(df.index).strftime("%A %d %B")  # Affichage clair des jours
+    st.dataframe(df, use_container_width=True)
+
+    # ✅ **Message de validation persistant**
+    if "validation_msg" in st.session_state:
+        st.success(st.session_state["validation_msg"])
+        st.session_state.pop("validation_msg")  # Supprimer après affichage pour éviter la persistance infinie
+
+    # 🍽️ **Modification et Suppression d'un Repas**
+    st.subheader("✍️ Modifier un repas")
+
+    selected_day = st.selectbox("📅 Choisissez un jour", week_dates)
+    selected_meal = st.selectbox("🍽️ Sélectionnez le repas", ["Petit-déjeuner", "Déjeuner", "Dîner"])
+
+    # 📌 **Prévisualisation du repas existant**
+    existing_meal = st.session_state["meal_plan"][selected_day][selected_meal]
+    if existing_meal:
+        st.markdown(f"🔹 **Repas actuel pour {selected_meal} :**\n> {existing_meal}")
+
+    with st.form("meal_form"):
+        meal_input = st.text_area(f"Ajoutez un plat pour {selected_meal} ({selected_day})",
+                                  value=existing_meal)  # Pré-rempli avec le repas actuel
+
+        col1, col2 = st.columns([0.7, 0.3])
+        with col1:
+            submitted = st.form_submit_button("✅ Ajouter / Modifier")
+        with col2:
+            deleted = st.form_submit_button("❌ Supprimer le plat")
+
+        if submitted:
+            st.session_state["meal_plan"][selected_day][selected_meal] = meal_input
+            st.session_state["validation_msg"] = f"✅ {selected_meal} ajouté/modifié pour le {selected_day} avec succès !"
+            st.rerun()
+
+        if deleted:
+            st.session_state["meal_plan"][selected_day][selected_meal] = ""
+            st.session_state["validation_msg"] = f"❌ {selected_meal} supprimé pour le {selected_day} !"
+            st.rerun()
+
+    # 🤖 Ajout des suggestions du chatbot
+    st.subheader("🤖 Suggestions du Chatbot")
+
+    # 🔹 Charger les suggestions enregistrées si elles ne sont pas déjà en mémoire
+    if "chatbot_suggestions" not in st.session_state:
+        st.session_state["chatbot_suggestions"] = load_chatbot_suggestions(db_manager, user_id)
+
+
+    if st.session_state["chatbot_suggestions"]:
+        with st.form("chatbot_form"):
+            selected_recipe = st.selectbox("🔍 Sélectionnez une recette", st.session_state["chatbot_suggestions"])
+            selected_day_for_recipe = st.selectbox("📅 Assigner à quel jour ?", week_dates)
+            selected_meal_for_recipe = st.selectbox("🍽️ Assigner à quel repas ?", ["Petit-déjeuner", "Déjeuner", "Dîner"])
+
+            add_recipe = st.form_submit_button("➕ Ajouter la recette au planning")
+            if add_recipe:
+                st.session_state["meal_plan"][selected_day_for_recipe][selected_meal_for_recipe] += f"\n- {selected_recipe}"
+                st.session_state["validation_msg"] = f"✅ Recette ajoutée à {selected_meal_for_recipe} ({selected_day_for_recipe}) avec succès !"
+                st.rerun()
+    else:
+        st.write("⚠️ Aucune suggestion du chatbot pour le moment.")
+
+    # 📤 Exportation du planning en CSV
+    if st.button("📥 Exporter en CSV"):
+        df.to_csv("meal_plan.csv")
+        st.success("✅ Plan exporté en CSV avec succès !")