app.py

# Chargement des librairies

# Pour créer et exécuter des applications Web interactives directement via des scripts Python.
import streamlit as st


# Pour charger des variables d'environnement à partir d'un fichier .env dans l'environnement du système pour un accès sécurisé et facile.
# Pour interagir avec l'API de Groq pour exécuter des modèles d'apprentissage automatique et gérer les opérations sur les données.
from groq import Groq



# Changement du logo et du titre de l'application
st.set_page_config(page_title="myChatbot", page_icon="left_speech_bubble", layout="centered", menu_items=None)


# # Load environment variables from .env at the project root
# project_root = Path(__file__).resolve().parent
# load_dotenv(project_root / ".env")

# Pour les parametres du menu
with st.sidebar:
    # Pour selectionner votre volet
    radio_option = st.radio("Select your pane", options=("Chatbot", "Text to Speech", "Speech to Text"))
    
    if radio_option == "Chatbot":
        # Pour les parametres du menu
        with st.sidebar:
            st.sidebar.subheader("🛠️Settings")
            temperature = st.slider("Temperature", 0.0, 5.0, 1.0)
            tokens =  st.slider("Max Tokens", 0, 8192, 900)
            stream = st.toggle("Stream", value=True)
            if stream:
                etat = True
            else:
                etat = False
                

        class GroqAPI:
            # Gère les opérations API avec Groq pour générer des réponses de chat
            def __init__(self, model_name: str):
                self.client = Groq(api_key="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")
                self.model_name = model_name

        # Méthode interne pour récupérer les réponses de l'API Groq
            def _response(self, message): 
                return self.client.chat.completions.create(
                    model=self.model_name,
                    messages=message,
                    temperature=temperature,
                    max_tokens=tokens,
                    stream=etat,
                    stop=None,
                )

        # Générateur pour diffuser les réponses de l'API
            def response_stream(self, message):        
                for chunk in self._response(message):
                    if chunk.choices[0].delta.content:
                        yield chunk.choices[0].delta.content


        class Message:
            # Gère les messages de discussion dans l'interface utilisateur Streamlit
            system_prompt = "You are a professional AI. Please generate responses in English to all user inputs."

        # Initialise l'historique des discussions s'il n'existe pas dans l'état de session
            def __init__(self):
                if "messages" not in st.session_state:
                    st.session_state.messages = [{"role": "system", "content": self.system_prompt}]

        # Ajoute un nouveau message à l'état de la session
            def add(self, role: str, content: str):
                st.session_state.messages.append({"role": role, "content": content})

        # Affiche tous les messages passés dans l'interface utilisateur, en ignorant les messages système
            def display_chat_history(self):
                for message in st.session_state.messages:
                    if message["role"] == "system":
                        continue
                    with st.chat_message(message["role"]):
                        st.markdown(message["content"])

        # Réponses de l'API Stream à l'interface utilisateur des messages de discussion Streamlit
            def display_stream(self, generater):
                with st.chat_message("assistant"):
                    return st.write(generater)


        class ModelSelector:
            # Permet à l'utilisateur de sélectionner un modèle dans une liste prédéfinie
            def __init__(self):
                # Liste des modèles disponibles au choix
                self.models = ["llama3-70b-8192", "llama3-8b-8192", "gemma-7b-it", "mixtral-8x7b-32768"]

        # Affiche la sélection de modèles dans une barre latérale avec un titre
            def select(self):
                with st.sidebar:
                    return st.selectbox("Model", self.models)


        # Point d'entrée de l'utilisateur pour l'application streamlit "myChatbot"
        def main():
            user_input = st.chat_input("Chat whit me...")
            model = ModelSelector()
            selected_model = model.select()
            message = Message()
            
        # S'il y a une entrée utilisateur, la traiter via le modèle sélectionné
            if user_input:
                llm = GroqAPI(selected_model)
                message.add("user", user_input)
                message.display_chat_history()
                response = message.display_stream(llm.response_stream(st.session_state.messages))
                message.add("assistant", response)
                
            with st.sidebar:
                st.markdown('''<br/>
                            <h6 style='text-align:center;color:grey;font-size:10px;'>
                            © myChatbot - TOUNDE - 2024
                            </h6>''',  
                            unsafe_allow_html=True
                )  
    
    
    
    
    

        
if __name__ == "__main__":
    main()