Update space

README.md

@@ -1,13 +1,122 @@
 ---
 title: Viti
 emoji: 💻
-colorFrom: green
-colorTo: red
+colorFrom: purple
+colorTo: indigo
 sdk: streamlit
-sdk_version: 1.38.0
+sdk_version: 1.39.0
 app_file: app.py
 pinned: false
 license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<!-- Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference -->
+
+# Application Template - README
+
+## Introduction
+
+Cette application sert de base/template pour en déployer d'autres sur le même modèle via Huggingface. Elle est facilement duplicable en dupliquant l'espace. Elle est décomposée en plusieurs sections pour offrir une gestion complète des documents et des dialogues avec une Intelligence Artificielle (IA).
+
+### Structure de l'application
+
+L'application est structurée en trois parties principales :
+
+- **Documents**
+  - *Communs*
+  - *Vos Documents*
+- **Configurations**
+  - *Prompt système*
+  - *Paramètres*
+- **Dialogue**
+  - *Chatbot*
+
+### Fonctionnement des sections
+
+#### 1. Documents
+
+- **Documents Communs** : 
+  Cette section permet de déposer des documents accessibles à tous les utilisateurs de l'application. Ces documents sont vectorisés et stockés dans une base de données vectorielle (voir section dédiée). Ils seront explorés lors des interactions avec l'IA.
+
+- **Vos Documents** : 
+  Chaque utilisateur peut uploader ses propres documents, qui seront pris en compte pendant sa session. Ces documents sont temporaires et ne sont accessibles que durant la session active de l'utilisateur.
+
+#### 2. Configurations
+
+- **Prompt système** :
+  Cette section permet de configurer le *prompt système* utilisé lors des conversations avec l'IA. Ce prompt influence le comportement de l'IA pendant le dialogue.
+
+- **Paramètres** :
+  Ici, vous pouvez ajuster les paramètres dynamiques de l'application, tels que les préférences utilisateurs ou les options spécifiques à votre usage.
+
+#### 3. Dialogue
+
+- **Chatbot** :
+  Une interface de discussion avec l'IA, où il est possible de choisir le modèle d'IA avec lequel interagir. Vous pouvez aussi commencer la conversation à partir d'un *prompt* pré-défini.
+
+## Base de Données Vectorielle
+
+La base de données vectorielle permet de stocker de manière permanente les différents vecteurs de documents, afin de faciliter leur recherche et leur utilisation dans les conversations avec l'IA.
+
+### Pinecone
+
+L'application utilise **Pinecone**, une solution cloud pour la gestion de bases de données vectorielles. Pinecone simplifie la gestion des vecteurs et permet une intégration efficace avec l'application.
+
+Pour que l'intégration fonctionne correctement, vous devez renseigner les variables d'environnement suivantes :
+
+- **PINECONE_API_KEY** : Clé d'API fournie par Pinecone pour l'accès à votre compte.
+- **PINECONE_INDEX_NAME** : Le nom de l'index Pinecone dans lequel les vecteurs seront stockés.
+- **PINECONE_NAMESPACE** : Un namespace unique propre à chaque application, utilisé pour organiser les vecteurs.
+
+Ces informations sont disponibles directement dans votre compte Pinecone, et doivent être correctement configurées pour permettre le fonctionnement de la base de données vectorielle.
+
+
+## Configuration de l'application
+
+Vous pouvez configurer votre application plus finement en la personalisant en fonction de vos besoins. Ces configurations se font dans le fichier *config.yaml* accessible dans la partie *Files* de votre espace Huggingface. La modification se fait ensuite via le bouton *'edit'*. 
+Une fois, vos modifications effectuées, cliquez sur *'Commit changes to main'* pour les enregistrer et relancer automatiquement l'application.
+
+#### Paramètres Dynamiques
+
+Les paramètres peuvent être ajustés dans la section **variables**, en mettant la liste des variables souhaitées.
+Pour chacune d'entre elles, un *label*, une *key* et optionnelement une valeur par défaut *value* sont nécessaires.
+Pour être prise en compte, ces variables doivent être implémenté dans le prompt template via leur *'key'* sous la forme **{ma_variable}**
+
+#### Prompt template
+
+Vous pouvez directement spécifier votre prompt template dans la section **prompt_template** du fichier de configuration
+
+#### Prompt system
+
+Egalement, vous pouvez renseigner un prompt système par défaut, dans la section **prompt_system** du fichier de configuration
+
+#### Prompts par Défaut
+
+Des *prompts* par défaut peuvent être définis pour démarrer les conversations avec l'IA. Ces *prompts* sont personnalisables dans la section **prompts**.
+La première tabulation correspond à une catégorie, permettant de faire des regroupements.
+Chaque '-' représente ensuite un prompt qui sera proposé.
+
+## Déploiement
+
+Pour déployer cette application sur Huggingface :
+
+1. Dupliquez l'espace Huggingface existant.
+2. Renseignez les variables d'environnements. Il vous sera demandé de rentrer toutes les variables d'environnements. Vous les variables qui seront propres à votre application : 
+ - **APP_NAME** : Nom de votre application
+ - **PINECONE_NAMESPACE** : Espace de stockage permanent de votre application
+3. Ajustez votre configuration dans le fichier *config.yaml* (voir section **Configuration de l'application**)
+
+
+## Variables d'environnements
+| Variable | Description 
+|----------|----------
+**APP_NAME**|Nom de l'application
+**ANTHROPIC_API_KEY**| Clé API Anthropic
+**MISTRAL_API_KEY**|Clé API Mistral
+**OPENAI_API_KEY**|Clé API OpenAI
+**LLAMA_API_KEY**|Clé Llama API
+**PINECONE_API_KEY**|Clé API Pinecone
+**PINECONE_INDEX_NAME**|Index/BDD Pinecone
+**PINECONE_NAMESPACE**|Espace de stockage propre à l'application
+
+

app.py

@@ -1,89 +1,66 @@
-import os
-import tempfile
 import streamlit as st
-from streamlit_chat import message
-from rag import ChatPDF
-
-title = "Simulateur IA Viti"
-subtitle = "Poser vos questions"
-description = "Demonstrateur Viti"
-LOGO = "images/agir.png"
-form_help ="Vous pouvez compléter les informations ci-dessous pour personnaliser votre expérience"
-placeholder = (
-    "Vous pouvez me posez une question sur vos attentes, appuyer sur Entrée pour valider"
-)
-placeholder_doc = (
-    "Vous pouvez charger un rapport de cout de production"
-)
-placeholder_url = "Récupérer les données de ce lien."
+import os
 
-# st.title(title)
+from dotenv import load_dotenv
+from rag import Rag
+from vectore_store.PineconeConnector import PineconeConnector
+from vectore_store.VectoreStoreManager import VectoreStoreManager
 
-st.set_page_config(page_title=title)
+from util import getYamlConfig
 
-def display_messages():
-    st.subheader(subtitle)
-    for i, (msg, is_user) in enumerate(st.session_state["messages"]):
-        message(msg, is_user=is_user, key=str(i))
-    st.session_state["thinking_spinner"] = st.empty()
+load_dotenv()
 
+GROUP_NAME = os.environ.get("APP_NAME")
+LOGO = "assets/logo.png"
 
-def process_input():
-    if st.session_state["user_input"] and len(st.session_state["user_input"].strip()) > 0:
-        user_text = st.session_state["user_input"].strip()
-        with st.session_state["thinking_spinner"], st.spinner(f"Je réfléchis"):
-            agent_text = st.session_state["assistant"].ask(user_text)
+def init_app():
 
-        st.session_state["messages"].append((user_text, True))
-        st.session_state["messages"].append((agent_text, False))
+    config = getYamlConfig()
 
+    if len(st.session_state) == 0:
+        # Define Vectore store strategy
+        pinecone_connector = PineconeConnector()
+        vs_manager = VectoreStoreManager(pinecone_connector)
 
-def read_and_save_file():
-    st.session_state["assistant"].clear()
-    st.session_state["messages"] = []
-    st.session_state["user_input"] = ""
+        st.session_state["messages"] = []
+        st.session_state["assistant"] = Rag(vectore_store=vs_manager)
+        st.session_state["data_dict"] = config['variables']
+        st.session_state["prompt_system"] = config['prompt_system']
 
-    for file in st.session_state["file_uploader"]:
-        with tempfile.NamedTemporaryFile(delete=False) as tf:
-            tf.write(file.getbuffer())
-            file_path = tf.name
 
-        with st.session_state["ingestion_spinner"], st.spinner(f"Chargement {file.name}"):
-            st.session_state["assistant"].ingest(file_path)
-        os.remove(file_path)
+def main():
 
+    init_app()
 
-def page():
-    if len(st.session_state) == 0:
-        st.session_state["messages"] = []
-        st.session_state["assistant"] = ChatPDF()
+    st.set_page_config(page_title=GROUP_NAME)
 
-    
     st.logo(LOGO)
-    st.sidebar.markdown(form_help)
-    info1 = st.sidebar.text_input("Info 1", type="default")
-    info1 = st.sidebar.text_input("Info 2", type="default")
-    info1 = st.sidebar.text_input("Info 3", type="default")
-
-    st.header(title)
-
-    st.subheader("Charger un ou plusieurs documents")
-    st.caption(placeholder_doc)
-    st.file_uploader(
-        "Charger un document",
-        type=["pdf"],
-        key="file_uploader",
-        on_change=read_and_save_file,
-        label_visibility="collapsed",
-        accept_multiple_files=True,
+    st.title(GROUP_NAME)
+
+    saved_documents = st.Page("pages/persistent_documents.py", title="Communs", icon="🗃️")
+    documents = st.Page("pages/documents.py", title="Vos documents", icon="📂")
+    prompt_system = st.Page("pages/prompt_system.py", title="Prompt système", icon="🖊️", default=True)
+    form = st.Page("pages/form.py", title="Paramètres", icon="📋")
+    chatbot = st.Page("pages/chatbot.py", title="Chatbot", icon="🤖")
+
+    pg = st.navigation(
+        {
+            "Documents": [
+                saved_documents,
+                documents,
+            ],
+            "Configurations": [
+                prompt_system,
+                form,
+            ],
+            "Dialogue": [
+                chatbot
+            ],
+        }
     )
 
-    st.session_state["ingestion_spinner"] = st.empty()
-
-    display_messages()
-    st.caption(placeholder)
-    st.text_input("Message", key="user_input", on_change=process_input)
+    pg.run()
 
 
 if __name__ == "__main__":
-    page()
+    main()

config.yaml

@@ -0,0 +1,38 @@
+prompts:
+  general:
+    - "Quels sont les principaux défis auxquels les agriculteurs sont confrontés aujourd'hui ?"
+    - "Explique-moi les différences entre l'agriculture biologique et l'agriculture conventionnelle."
+
+  techniques:
+    - "Comment fonctionne la rotation des cultures et pourquoi est-elle importante ?"
+    - "Explique les avantages de l'irrigation goutte à goutte pour les cultures."
+
+variables:
+  - label : Indicateur 1
+    key : param1
+    value :
+  - label : Indicateur 2
+    key : param2
+    value :
+
+prompt_system: "
+Tu es un système expert sur le pilotage des données d'une exploitation viticole sur la filière viticole du Bordelais-Libournais.
+Tu réponds toujours par rapport aux données du contexte. Si tu ne connais pas la réponse, ne réponds pas.
+Si cela est possible, réponds sous forme d'indicateurs et de tableaux. Tu répondras en Français.
+"
+
+prompt_template: "
+{prompt_system}
+
+Dans un premier temps, tu analysera l'indicateur suivant : {param1}
+de l’exploitation en les comparant avec les indicateurs équivalents dans les données de référence.
+
+Dans un second temps, tu analysera l'indicateur suivant : {param2}
+
+Données de référence : {commonContext}
+
+Document de l'utilisateur : {documentContext}
+
+Voici l'historique des messages : {messages}
+Les attentes de l'utilisateur sont : {query}
+"

model/ModelIntegrations.py

@@ -0,0 +1,42 @@
+import os
+
+from .ModelStrategy import ModelStrategy
+
+from langchain_openai import ChatOpenAI
+from langchain_mistralai.chat_models import ChatMistralAI
+from langchain_anthropic import ChatAnthropic
+
+from llamaapi import LlamaAPI
+from langchain_experimental.llms import ChatLlamaAPI
+
+class MistralModel(ModelStrategy):
+    def get_model(self, model_name):
+        return ChatMistralAI(model=model_name)
+    
+
+class OpenAIModel(ModelStrategy):
+    def get_model(self, model_name):
+        return ChatOpenAI(model=model_name)
+
+
+class AnthropicModel(ModelStrategy):
+    def get_model(self, model_name):
+        return ChatAnthropic(model=model_name)
+
+
+class LlamaAPIModel(ModelStrategy):
+    def get_model(self, model_name):
+        llama = LlamaAPI(os.environ.get("LLAMA_API_KEY"))
+        return ChatLlamaAPI(client=llama, model=model_name)
+
+class ModelManager():
+    def __init__(self):
+        self.models = {
+            "mistral": MistralModel(),
+            "openai": OpenAIModel(),
+            "anthropic": AnthropicModel(),
+            "llama": LlamaAPIModel()
+        }
+
+    def get_model(self, provider, model_name):
+        return self.models[provider].get_model(model_name)

model/ModelStrategy.py

@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+class ModelStrategy(ABC):
+    @abstractmethod
+    def get_model(self, model_name):
+        pass

model/selector.py

@@ -0,0 +1,42 @@
+import streamlit as st
+from .ModelIntegrations import ModelManager
+    
+def ModelSelector():
+    # Dictionnaire des modèles par fournisseur
+    model_providers = {
+        "Mistral": {
+            "mistral-large-latest": "mistral.mistral-large-latest",
+            "open-mixtral-8x7b": "mistral.open-mixtral-8x7b",
+        },
+        "OpenAI": {
+            "gpt-4o": "openai.gpt-4o",
+        },
+        "Anthropic": {
+            "claude-3-5-sonnet-20240620": "anthropic.claude-3-5-sonnet-20240620",
+            "claude-3-opus-20240229": "anthropic.claude-3-opus-20240229",
+            "claude-3-sonnet-20240229": "anthropic.claude-3-sonnet-20240229",
+        },
+        # "llama": {
+        #     "llama3.2-11b-vision": "llama.llama3.2-11b-vision",
+        #     "llama3.2-1b": "llama.llama3.2-1b",
+        #     "llama3.2-3b": "llama.llama3.2-3b"
+        # }
+    }
+
+    # Créer une liste avec les noms de modèle, groupés par fournisseur (fournisseur - modèle)
+    model_options = []
+    model_mapping = {}
+
+    for provider, models in model_providers.items():
+        for model_name, model_instance in models.items():
+            option_name = f"{provider} - {model_name}"
+            model_options.append(option_name)
+            model_mapping[option_name] = model_instance
+
+    # Sélection d'un modèle via un seul sélecteur
+    selected_model_option = st.selectbox("Choisissez votre modèle", options=model_options)
+
+    if(st.session_state["assistant"]):
+        splitter = model_mapping[selected_model_option].split(".")
+        st.session_state["assistant"].setModel(ModelManager().get_model(splitter[0], splitter[1]), splitter[1])
+    

pages/chatbot.py

@@ -0,0 +1,82 @@
+import streamlit as st
+from langchain_core.messages import AIMessage, HumanMessage
+from model import selector
+from util import getYamlConfig
+from st_copy_to_clipboard import st_copy_to_clipboard
+
+def display_messages():
+
+    for i, message in enumerate(st.session_state.chat_history):
+        if isinstance(message, AIMessage):
+            with st.chat_message("AI"):
+                # Display the model from the kwargs
+                model = message.kwargs.get("model", "Unknown Model")  # Get the model, default to "Unknown Model"
+                st.write(f"**Model :** {model}")
+                st.markdown(message.content)
+                st_copy_to_clipboard(message.content,key=f"message_{i}")
+        
+        elif isinstance(message, HumanMessage):
+            with st.chat_message("Moi"):
+                st.write(message.content)
+
+
+def launchQuery(query: str = None):
+
+    # Initialize the assistant's response
+    full_response = st.write_stream(
+        st.session_state["assistant"].ask(
+            query,
+            prompt_system=st.session_state.prompt_system,
+            messages=st.session_state["chat_history"] if "chat_history" in st.session_state else [],
+            variables=st.session_state["data_dict"]
+        ))
+
+    # Temporary placeholder AI message in chat history
+    st.session_state["chat_history"].append(AIMessage(content=full_response, kwargs={"model": st.session_state["assistant"].getReadableModel()}))
+    st.rerun()
+
+
+def show_prompts():
+    yaml_data = getYamlConfig()["prompts"]
+    
+    expander = st.expander("Prompts pré-définis")
+    
+    for categroy in yaml_data:
+        expander.write(categroy.capitalize())
+
+        for item in yaml_data[categroy]:
+            if expander.button(item, key=f"button_{item}"):
+                launchQuery(item)
+
+
+def page():
+    st.subheader("Posez vos questions")
+
+    if "assistant" not in st.session_state:
+        st.text("Assistant non initialisé")
+
+    if "chat_history" not in st.session_state:
+        st.session_state["chat_history"] = []
+
+    st.markdown("<style>iframe{height:50px;}</style>", unsafe_allow_html=True)
+
+    # Collpase for default prompts
+    show_prompts()
+
+    # Models selector
+    selector.ModelSelector()
+
+    # Displaying messages
+    display_messages()
+
+
+    user_query = st.chat_input("")
+    if user_query is not None and user_query != "":
+
+        st.session_state["chat_history"].append(HumanMessage(content=user_query))
+        
+        # Stream and display response
+        launchQuery(user_query)
+
+
+page()

pages/documents.py

@@ -0,0 +1,35 @@
+import os
+import tempfile
+import streamlit as st
+
+def read_and_save_file():
+    st.session_state["messages"] = []
+    st.session_state["user_input"] = ""
+
+    for file in st.session_state["file_uploader"]:
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            tf.write(file.getbuffer())
+            file_path = tf.name
+
+        with st.session_state["ingestion_spinner"], st.spinner(f"Chargement {file.name}"):
+            st.session_state["assistant"].ingest(file_path)
+        os.remove(file_path)
+
+
+
+def page():
+    st.subheader("Charger vos documents")
+
+    # File uploader
+    uploaded_file = st.file_uploader(
+        "Télécharger un ou plusieurs documents",
+        type=["pdf"],
+        key="file_uploader",
+        accept_multiple_files=True,
+        on_change=read_and_save_file,
+    )
+
+
+    st.session_state["ingestion_spinner"] = st.empty()
+
+page()

pages/form.py

@@ -0,0 +1,14 @@
+import streamlit as st
+
+def page():
+    st.subheader("Définissez vos paramètres")
+
+    # Boucle pour créer des inputs basés sur data_dict (qui est une liste ici)
+    for param in st.session_state.data_dict:
+        # Utilisation de la clé 'label' et 'value' pour afficher et récupérer les valeurs
+        value = st.text_input(label=param['label'], value=param['value'] if param['value'] else "")
+        
+        # Mettre à jour la valeur dans le dictionnaire après la saisie utilisateur
+        param['value'] = value
+
+page()

pages/persistent_documents.py

@@ -0,0 +1,35 @@
+import os
+import tempfile
+import streamlit as st
+
+def uploadToDb():
+
+    for file in st.session_state["file_uploader_commun"]:
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            tf.write(file.getbuffer())
+            file_path = tf.name
+
+        with st.session_state["ingestion_spinner"], st.spinner(f"Chargement {file.name}"):
+            st.session_state["assistant"].ingestToDb(file_path, filename=file.name)
+        os.remove(file_path)
+
+def page():
+    st.subheader("Montez des documents communs")
+    
+    st.file_uploader(
+        "Télécharger un documents",
+        type=["pdf"],
+        key="file_uploader_commun",
+        accept_multiple_files=True,
+        on_change=uploadToDb,
+    )
+
+    st.session_state["ingestion_spinner"] = st.empty()
+
+    st.divider()
+    st.write("Documents dans la base de données")
+    
+    for doc in st.session_state["assistant"].vector_store.getDocs():
+        st.write(" - "+doc)
+    
+page()

pages/prompt_system.py

@@ -0,0 +1,12 @@
+import streamlit as st
+
+def page():
+
+    st.subheader("Renseignez votre prompt système")
+
+    prompt = st.text_area("Prompt system", st.session_state.prompt_system if 'prompt_system' in st.session_state else "")
+
+    # Session State also supports attribute based syntax
+    st.session_state['prompt_system'] = prompt
+
+page()

rag.py

@@ -1,7 +1,5 @@
 import os
-# __import__('pysqlite3')
-# import sys
-# sys.modules['sqlite3'] = sys.modules.pop('pysqlite3')
+
 from dotenv import load_dotenv
 from langchain_community.vectorstores import FAISS
 from langchain_mistralai.chat_models import ChatMistralAI
@@ -12,47 +10,66 @@ from langchain.text_splitter import RecursiveCharacterTextSplitter
 from langchain.schema.runnable import RunnablePassthrough
 from langchain.prompts import PromptTemplate
 from langchain_community.vectorstores.utils import filter_complex_metadata
-#add new import
 from langchain_community.document_loaders.csv_loader import CSVLoader
 
+from util import getYamlConfig
+
+
 # load .env in local dev
 load_dotenv()
 env_api_key = os.environ.get("MISTRAL_API_KEY")
-llm_model = "open-mixtral-8x7b"
 
-class ChatPDF:
-    vector_store = None
+class Rag:
+    document_vector_store = None
     retriever = None
     chain = None
+    readableModelName = ""
 
-    def __init__(self):
-        # https://python.langchain.com/docs/integrations/chat/mistralai/
-        self.model = ChatMistralAI(model=llm_model)
-        self.text_splitter = RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=100)
-        self.prompt = PromptTemplate.from_template(
-            """
-            <s> [INST] You are an assistant for question-answering tasks. Use only the following pieces of retrieved context 
-            to build an answer for the user. If you don't know the answer, just say that you don't know. Use three sentences
-             maximum and keep the answer concise. [/INST] </s> 
-            [INST] 
-            Question: {question} Réponds en Français. Answer in French.
-            Context: {context} 
-            Answer: [/INST]
-            """
-        )
+    def __init__(self, vectore_store=None):
+        
+        # self.model = ChatMistralAI(model=llm_model)
+        self.embedding = MistralAIEmbeddings(model="mistral-embed", mistral_api_key=env_api_key)
+
+        self.text_splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=100, length_function=len)
+        
+        base_template = getYamlConfig()['prompt_template']
+        self.prompt = PromptTemplate.from_template(base_template)
+
+        self.vector_store = vectore_store
+
+    def setModel(self, model, readableModelName = ""):
+        self.model = model
+        self.readableModelName = readableModelName
+
+    def getReadableModel(self):
+        return self.readableModelName
+    
+    def ingestToDb(self, file_path: str, filename: str):
+
+        docs = PyPDFLoader(file_path=file_path).load()
+
+        # Extract all text from the document
+        text = ""
+        for page in docs:
+            text += page.page_content
+
+        # Split the text into chunks
+        chunks = self.text_splitter.split_text(text)
+        
+        return self.vector_store.addDoc(filename=filename, text_chunks=chunks, embedding=self.embedding)
+
+    def getDbFiles(self):
+        return self.vector_store.getDocs()
 
     def ingest(self, pdf_file_path: str):
         docs = PyPDFLoader(file_path=pdf_file_path).load()
        
-        
         chunks = self.text_splitter.split_documents(docs)
         chunks = filter_complex_metadata(chunks)
 
-        embeddings = MistralAIEmbeddings(model="mistral-embed", mistral_api_key=env_api_key)
-
-        vector_store = FAISS.from_documents(chunks, embeddings)
-        # vector_store = Chroma.from_documents(documents=chunks, embedding=embeddings)
-        self.retriever = vector_store.as_retriever(
+        document_vector_store = FAISS.from_documents(chunks, self.embedding)
+        
+        self.retriever = document_vector_store.as_retriever(
             search_type="similarity_score_threshold",
             search_kwargs={
                 "k": 3,
@@ -60,18 +77,43 @@ class ChatPDF:
             },
         )
 
-        self.chain = ({"context": self.retriever, "question": RunnablePassthrough()}
-                      | self.prompt
-                      | self.model
-                      | StrOutputParser())
+    def ask(self, query: str, prompt_system: str, messages: list, variables: list = None):
+        self.chain = self.prompt | self.model | StrOutputParser()
+        
+        # Retrieve the context document
+        if self.retriever is None:
+            documentContext = ''
+        else:
+            documentContext = self.retriever.invoke(query)
+
+        # Retrieve the VectoreStore
+        contextCommon = self.vector_store.retriever(query, self.embedding)
+
+        # Dictionnaire de base avec les variables principales
+        chain_input = {
+            "query": query,
+            "documentContext": documentContext,
+            "commonContext": contextCommon,
+            "prompt_system": prompt_system,
+            "messages": messages
+        }
 
-    def ask(self, query: str):
-        if not self.chain:
-            return "Ajouter un document PDF d'abord."
+        # Suppression des valeurs nulles (facultatif)
+        chain_input = {k: v for k, v in chain_input.items() if v is not None}
+
+        # Si des variables sous forme de liste sont fournies
+        if variables:
+            # Convertir la liste en dictionnaire avec 'key' comme clé et 'value' comme valeur
+            extra_vars = {item['key']: item['value'] for item in variables if 'key' in item and 'value' in item}
+            
+            # Fusionner avec chain_input
+            chain_input.update(extra_vars)
+        
 
-        return self.chain.invoke(query)
+        return self.chain.stream(chain_input)
 
     def clear(self):
+        self.document_vector_store = None
         self.vector_store = None
         self.retriever = None
         self.chain = None

requirements.txt

@@ -1,9 +1,21 @@
+streamlit==1.37.0
+streamlit_chat
+python-dotenv
+pymupdf
+pypdf
+python-multipart
+pydantic
+pinecone-notebooks
+pinecone-client[grpc]
+async-timeout
+typing-extensions
 langchain
-langchain_mistralai
+langchain-openai
 langchain-community
-pysqlite3-binary
-streamlit==1.38.0
-streamlit-chat 
-fastembed 
-faiss-gpu
-pypdf
+langchain-experimental
+langchain-pinecone
+langchain_mistralai
+langchain_anthropic
+llamaapi
+pyyaml
+st_copy_to_clipboard

util.py

@@ -0,0 +1,7 @@
+import os
+import yaml
+
+def getYamlConfig():
+    file_path = os.path.join(os.path.dirname(__file__), 'config.yaml')
+    with open(file_path, 'r', encoding='utf-8') as file:
+        return yaml.safe_load(file)

vectore_store/ConnectorStrategy.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+class ConnectorStrategy(ABC):
+    @abstractmethod
+    def getDocs(self):
+        pass
+    
+    @abstractmethod
+    def addDoc(self, filename, text_chunks, embedding):
+        pass
+    
+    @abstractmethod
+    def retriever(self, query, embedding):
+        pass

vectore_store/PineconeConnector.py

@@ -0,0 +1,100 @@
+import os 
+from dotenv import load_dotenv
+
+from .ConnectorStrategy import ConnectorStrategy
+
+from pinecone import Pinecone, ServerlessSpec
+from langchain_openai import OpenAIEmbeddings
+from langchain_pinecone import PineconeVectorStore
+from langchain_core.documents import Document
+
+import unicodedata
+import time
+
+class PineconeConnector(ConnectorStrategy):
+    def __init__(self):
+
+        load_dotenv()
+
+        pinecone_api_key = os.environ.get("PINECONE_API_KEY")
+
+        self.index_name = os.environ.get("PINECONE_INDEX_NAME")
+        self.namespace = os.environ.get("PINECONE_NAMESPACE")
+
+
+        pc = Pinecone(api_key=pinecone_api_key)
+
+        existing_indexes = [index_info["name"] for index_info in pc.list_indexes()]
+
+        if self.index_name not in existing_indexes:
+            pc.create_index(
+                name=self.index_name,
+                dimension=3072,
+                metric="cosine",
+                spec=ServerlessSpec(cloud="aws", region="us-east-1"),
+            )
+            while not pc.describe_index(self.index_name).status["ready"]:
+                time.sleep(1)
+
+        self.index = pc.Index(self.index_name)
+
+    
+    def getDocs(self):
+        # Simulate getting docs from Pinecone
+        
+        docs_names = []
+        for ids in self.index.list(namespace=self.namespace):
+            for id in ids:
+                name_doc = "_".join(id.split("_")[:-1])
+                if name_doc not in docs_names:
+                    docs_names.append(name_doc)
+
+        return docs_names
+    
+    
+    def addDoc(self, filename, text_chunks, embedding):
+        try:
+            vector_store = PineconeVectorStore(index=self.index, embedding=embedding,namespace=self.namespace)
+
+            file_name = filename.split(".")[0].replace(" ","_").replace("-","_").replace(".","_").replace("/","_").replace("\\","_").strip()
+
+            documents = []
+            uuids = []
+
+            for i, chunk in enumerate(text_chunks):
+                clean_filename = remove_non_standard_ascii(file_name)
+                uuid = f"{clean_filename}_{i}"
+
+                document = Document(
+                    page_content=chunk,
+                    metadata={ "filename":filename, "chunk_id":uuid },
+                )
+
+                uuids.append(uuid)
+                documents.append(document)
+            
+
+            vector_store.add_documents(documents=documents, ids=uuids)
+
+            return {"filename_id":clean_filename}
+        
+        except Exception as e:
+            print(e)
+            return False
+    
+    def retriever(self, query, embedding):
+
+        vector_store = PineconeVectorStore(index=self.index, embedding=embedding,namespace=self.namespace)
+
+        retriever = vector_store.as_retriever(
+            search_type="similarity_score_threshold",
+            search_kwargs={"k": 3, "score_threshold": 0.6},
+        )
+
+        return retriever.invoke(query)
+    
+
+def remove_non_standard_ascii(input_string: str) -> str:
+    normalized_string = unicodedata.normalize('NFKD', input_string)
+    return ''.join(char for char in normalized_string if 'a' <= char <= 'z' or 'A' <= char <= 'Z' or char.isdigit() or char in ' .,!?')
+

vectore_store/VectoreStoreManager.py

@@ -0,0 +1,15 @@
+from vectore_store import ConnectorStrategy
+
+
+class VectoreStoreManager:
+    def __init__(self, strategy: ConnectorStrategy):
+        self.strategy = strategy
+    
+    def getDocs(self):
+        return self.strategy.getDocs()
+    
+    def addDoc(self, filename, text_chunks, embedding):
+        self.strategy.addDoc(filename, text_chunks, embedding)
+    
+    def retriever(self, query, embedding):
+        return self.strategy.retriever(query, embedding)