Update with common

README.md

@@ -1,13 +1,117 @@
 ---
-title: GC
-emoji: 💻
-colorFrom: green
-colorTo: red
+title: Common
+emoji: 🏢
+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
+
+#### 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,65 @@
-import os
-import tempfile
 import streamlit as st
-from streamlit_chat import message
-from rag import ChatPDF
-
-title = "Simulateur IA Grandes cultures"
-subtitle = "Poser vos questions"
-description = "Demonstrateur GC"
-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 grand livre ou des écritures comptables au format PDF"
-)
-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))
+    data_dict = getYamlConfig()['variables']
 
+    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"] = data_dict
 
-    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,54 @@
+prompts:
+  cultures:
+    - "Quelle est le cout de production de 15 Ha de blé tendre dans la région Picardie ?"
+    - "Quelle est le cout de production du colza dans la région Picardie ?"
+  materiels:
+    - "Quel est le cout total avec carburant en €/h d'un tracteur 4 roues motrices de 200 ch ?"
+    - "Quel est le cout total avec carburant en €/h d'une moissonneuse batteuse avec une coupe de 7,5 m ?"
+
+variables:
+  - label : Mon paramètre 1
+    key : param1
+    value :
+  - label : Mon paramètre 2
+    key : param2
+    value :
+  - label : Mon paramètre 3
+    key : param3
+    value :
+
+prompt_template: "
+Paramètre 1 : {param1}
+Paramètre 2 : {param2}
+Paramètre 3 : {param3}
+
+Documents partagées : {commonContext}
+
+Document utilisateur : {documentContext}
+
+Tu es un expert en gestion agricole des grandes cultures dans les régions Centre, Ile de france, Hauts de france et Grand est.
+Tu sais calculer une marge brute par hectare et un coût de revient par hectare à partir de documents statistiques agricoles français.
+Si tu ne connais pas la réponse, ne réponds pas. Tu répondras toujours en Français.
+
+Le coût de production ou coût de revient (CR) est calculé en additionnant toutes les charges opérationnelles (engrais, produits phytosanitaires, semences) (CO) par hectare ainsi que les charges de structure (main d'œuvre, foncier, matériel, bâtiment) (CS) par hectare selon la formule : CR = CO + CS
+
+Le coût de production en grande culture se situe en moyenne entre 500 € / hectare et 2000 € / hectare.
+
+La marge brute (MB) est calculée en additionnant tous les produits (Ventes & indemnité, Aides couplées) (PR) issue de la culture et en soustrayant les charges opérationnelles (CO) selon la formule suivante : MB = PR - CO
+
+La marge brute (MB) en grande culture se situe en moyenne entre 300 € / hectare et 1500 € / hectare.
+
+La marge nette (MN) est calculée en additionnant tous les produits (Ventes & indemnité, Aides couplées) (PR) issue de la culture et en soustrayant le coût de revient (CR) selon la formule suivante : MN = PR - CR
+
+La marge nette (MN) en grande culture se situe en moyenne entre 100 € / hectare et 800 € / hectare.
+
+A partir des documents du contexte, tu vas produire des tableaux et des indicateurs de coût selon les cultures mentionnées par l'utilisateur.
+Pour le coût de production (CR), il est impératif de détailler l'ensemble des calculs poste par poste pour les charges opérationnelles (engrais, produits phytosanitaires, semences) (CO) et pour les charges de structure (main d'oeuvre, foncier, matériel, batiment) (CS).
+ 
+La présentation sera effectuée dès que possible en format tableau. Si une information est demandée pour une superficie précise, les tableaux devront fournir, sur la première colonne, une information à l'hectare et sur la seconde, une information pour la superficie indiquée par l'utilisateur. Si aucune superficie n'est précisée par le client, l'information sera donnée par hectare.
+
+{prompt_system}
+
+Voici l'historique des messages : {messages}
+La demande de l'utilisateur est : {query}
+"

model/ModelIntegrations.py

@@ -0,0 +1,42 @@
+import os
+
+from .ModelStrategy import ModelStrategy
+
+from langchain_community.chat_models 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]))
+    

pages/chatbot.py

@@ -0,0 +1,66 @@
+import streamlit as st
+import yaml
+import os
+from streamlit_chat import message
+from model import selector
+
+def display_messages():
+    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()
+
+
+# Charger les données YAML
+def load_yaml(file_path):
+    with open(file_path, 'r', encoding='utf-8') as file:
+        data = yaml.safe_load(file)
+    return data
+
+
+def process_input():
+    if "user_input" in st.session_state and st.session_state["user_input"] and len(st.session_state["user_input"].strip()) > 0:
+        user_text = st.session_state["user_input"].strip()
+
+        prompt_sys = st.session_state.prompt_system if 'prompt_system' in st.session_state and st.session_state.prompt_system != '' else ""
+    
+        with st.session_state["thinking_spinner"], st.spinner(f"Je réfléchis"):
+            agent_text = st.session_state["assistant"].ask(user_text, prompt_sys, st.session_state["messages"] if "messages" in st.session_state else [], variables=st.session_state["data_dict"])
+
+        st.session_state["messages"].append((user_text, True))
+        st.session_state["messages"].append((agent_text, False))
+
+@st.dialog("Choisissez votre question prédéfinie")
+def show_prompts():
+    file_path = os.path.join(os.path.dirname(__file__), '..', 'config.yaml')
+    yaml_data = load_yaml(file_path)
+        
+        # Boucle à travers les éléments YAML
+    for categroy in yaml_data['prompts']:  # Exemple avec la catégorie conversation
+        st.write(categroy.capitalize())
+
+        for item in yaml_data['prompts'][categroy]:
+            if st.button(item, key=f"button_{item}"):
+                st.session_state["user_input"] = item
+                st.rerun()
+
+def page():
+    st.subheader("Posez vos questions")
+
+    if "user_input" in st.session_state:
+        process_input()
+
+    if "assistant" not in st.session_state:
+        st.text("Assistant non initialisé")
+    
+    # Bouton pour ouvrir la modale
+    if st.button("Questions pré-définies"):
+        show_prompts()
+
+
+    selector.ModelSelector()
+
+    display_messages()
+
+    st.text_input("Message", key="user_input", on_change=process_input)
+
+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,51 +10,61 @@ 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
 
-    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] Vous échangez en français et avec précision.
-            Vous êtes un assistant comptable spécialisé dans la comptabilité agricole en grandes cultures.
-            Vous devez analyser les documents ci-dessous et calculer les couts de productions.
-            Les documents fournis représente la comptabilité de l'exploitation agricole.
-            Vous devez répondre sous forme de tableaux et de textes.
-            Vous devez répondre de façon synthétique et argumentée.
-            [/INST] </s> 
-            [INST] 
-            Question: {question} 
-            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):
+        self.model = model
+
+    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,
@@ -64,18 +72,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.invoke(chain_input)
 
     def clear(self):
+        self.document_vector_store = None
         self.vector_store = None
         self.retriever = None
         self.chain = None

requirements.txt

@@ -1,8 +1,20 @@
+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
-streamlit==1.38.0
-streamlit-chat
-pypdf
-fastembed
-faiss-gpu
+langchain-pinecone
+langchain_mistralai
+langchain_anthropic
+langchain-experimental
+llamaapi
+pyyaml

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)