Meilleur gestion du multiclient

.gitignore

@@ -1,6 +1,6 @@
+db/**
 venv/
 __pycache__/
 .vscode/
 .gradio/
 .env
-files/rag_app/

app.py

@@ -1,78 +1,72 @@
 from pathlib import Path
-# import base64
 import gradio as gr
 from src.rag import Rag
 from src.amodel import ModelType
 
-STORE_DIR = "./files/rag_app" # Le répertoire de la base
-MAX_DOCS = 4 # Le nombre max de documents dans la base
+STORE_DIR = "./db/rag_app" # Le répertoire de la base
+# STORE_DIR = None # Store éphémère
+MAX_DOCS = 6 # Le nombre max de documents dans la base
 
 def main():
-    # Création du rag
-    rag:Rag = Rag(ModelType.MTHUGGINGFACE, store_dir=STORE_DIR) 
-    # Reset de la base à chaque démarrage du serveur
-    rag.reset_store()
-
     # UI
     with gr.Blocks() as demo:
-
         def upload_file(file_path):
-            # Récupérer la liste des collections du store
-            names = list(rag.emb_store.get_collection_names())
-            # Supprimer la première s'il y en a déjà 4 (le max)
-            if len(names) == MAX_DOCS:
-                rag.delete_collection(names[0])
-            # Ajouter le pdf
             name:str = Path(file_path).name
+            names  = rag.emb_store.get_collection_names()
+            count = len(names)
+            if name in names:
+                rag.delete_collection(name)            
+            if count >= MAX_DOCS:
+                rag.delete_collection(names[0])
             rag.add_pdf_to_store(file_name=file_path, collection_name=name)
-            # Mettre à jour la liste des noms de collections
-            names = list(rag.emb_store.get_collection_names())
-            combo.choices = names
-            return gr.update(choices=names, value=name, interactive=True), gr.update(value="")
+            return name
 
-        def ask_rag(question:str, choice:str):
-            col_name:str = choice
-            if col_name == None:
+        def ask_rag(question:str, col_name:str):
+            if col_name == "Aucun fichier":
                 return "Aucun pdf actif, veuillez en uploader un !"
+            if question.strip() == "":
+                return "Veuillez poser une question."
+            names  = rag.emb_store.get_collection_names()
+            if not col_name in names:
+                return "'{name}' n'est plus sur le serveur, veuillez le recharger".format(name=col_name)
             prompt, resp, sources, ids = rag.ask_rag(question, col_name)
-            # print("choice:" + col_name, "RAG:" + resp)
             return resp
-            
+
         def on_temperature_change(temp):
-            rag.set_temperature(temp)
-        
-        
+            rag.set_temperature(temp)       
+            
+        # global State https://www.gradio.app/guides/state-in-blocks
+        rag:Rag = Rag(ModelType.MTHUGGINGFACE, store_dir=STORE_DIR) # Création du rag
+        # rag.reset_store() # Reset de la base à chaque démarrage du serveur
         with gr.Tab("RAG"):
-            # with gr.Row():
-            gr.Image("./files/drane.jpg", height=100, show_download_button=False, show_fullscreen_button=False, show_label=False)
-            # Le combo qui permet le choix du pdf
-            names:list[str] = rag.emb_store.get_collection_names()
-            combo = gr.Dropdown(names, label="PDFs", multiselect=False)
+            gr.Image("./files/drane.jpg", height=100, show_download_button=False, 
+                     show_fullscreen_button=False, show_label=False, show_share_button=False,
+                     interactive=False, container=False)
+            # Le label qui affiche le nom du pdf courant
+            pdf_name = gr.Markdown("Aucun fichier")
             # Le button qui permet d'uploader un pdf
-            upload_button = gr.UploadButton("Clique pour uploader un pdf", file_types=[".pdf"], file_count="single")
-                    
+            upload_button = gr.UploadButton("Clique pour ajouter un pdf", file_types=[".pdf"], file_count="single")
             # La zone où on pose une question au RAG
             ask_input = gr.Text(label="Pose une question à ton pdf")
             # La réponse du RAG (Markdown pour afficher les formules .tex)
             rag_output = gr.Markdown(label="Réponse")
-        
         with gr.Tab("Réglages"):
             gr.Markdown("## Modèles:")
             gr.Markdown("- " + rag.get_llm_name())
             gr.Markdown("- " + rag.get_feature_name())
             temperature_slider = gr.Slider(minimum=0,
                         maximum=1.0,
-                        value=0.5,
+                        value=0.0,
                         step=0.1,
                         label="Température")
-
+            
         # Réponses aux évènements
-        upload_button.upload(fn=upload_file, inputs=upload_button, outputs=[combo, rag_output], show_progress="full")
-        ask_input.submit(fn=ask_rag, inputs=[ask_input, combo], outputs=rag_output)
+        upload_button.upload(fn=upload_file, inputs=upload_button, outputs=[pdf_name], show_progress="full")
+        ask_input.submit(fn=ask_rag, inputs=[ask_input, pdf_name], outputs=rag_output, show_progress="full")
         temperature_slider.change(fn=on_temperature_change, inputs=temperature_slider)
+    
+    demo.launch()
 
-    # demo.launch(allowed_paths=["./file/"], share=True)
-    demo.launch(allowed_paths=["./file/"])
 
 if __name__ == "__main__":
     main()

git-commit-push.bat

@@ -0,0 +1,4 @@
+git add .
+git commit -a
+git push
+PAUSE

src/model_huggingface.py

@@ -53,7 +53,7 @@ class HuggingFaceModel(AModel):
         try:
             for chunk in chunks:
                 v = self.create_vector(chunk)
-                if not isinstance(v, np.ndarray):
+                if not isinstance(v, np.ndarray): # l'api renvoie des array numpy....
                     raise
                 vectors.append(v.tolist())
             return vectors

src/model_mistral.py

@@ -1,63 +0,0 @@
-import os
-import sys
-from dotenv import load_dotenv
-from .amodel import AModel
-from mistralai import Mistral
-
-class MistralModel(AModel):
-    '''
-        https://docs.mistral.ai/capabilities/completion/
-        https://docs.mistral.ai/capabilities/embeddings/
-        temperature entre 0.0 et 0.7
-    '''
-    
-    def __init__(self, llm_name:str, feature_name:str, temperature:float=0.0):
-        self.llm_name:str = llm_name
-        self.feature_name:str = feature_name
-        self.temperature = temperature
-        load_dotenv()
-        try:
-            self.model = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
-        except:
-            raise
-
-
-    def ask_llm(self, question:str)->str:
-        try:
-            response = self.model.chat.complete(
-                model=self.llm_name,
-                messages = [{ "role": "user", "content": question, },],
-                temperature=self.temperature
-            )
-            return response.choices[0].message.content
-        except:
-            raise
-
-    def create_vector(self, chunk:str)->list[float]:
-        '''
-            Renvoie un vecteur de taille 1024 à partir de chunk
-        '''
-        try:
-            response = self.model.embeddings.create(
-                model=self.feature_name,
-                # inputs=["Embed this sentence.", "As well as this one."],
-                inputs=[chunk]
-            )
-            return response.data[0].embedding 
-        except:
-            raise
-    
-    def create_vectors(self, chunks:list[str])->list[list[float]]:
-        '''
-            Renvoie n vecteurs de taille 1024 à partir de la liste chunks
-        '''
-        try:
-            response = self.model.embeddings.create(
-                model=self.feature_name,
-                inputs=chunks,
-            )
-            n:int = len(chunks)
-            result = [response.data[i].embedding for i in range(n)]
-            return result
-        except:
-            raise

src/model_ollama.py

@@ -1,49 +0,0 @@
-from .amodel import AModel
-import ollama
-import numpy as np
-
-class OllamaModel(AModel):
-    
-    def __init__(self, llm_name:str, feature_name:str, temperature:float=0.0):
-        self.llm_name:str = llm_name
-        self.feature_name:str = feature_name
-        self.temperature = temperature
-
-    def ask_llm(self, question:str)->str:
-        try:
-            resp = ollama.chat(
-                model=self.llm_name, 
-                messages=[{'role':'user', 'content':question}],
-                stream=False,
-                options={"temperature":self.temperature})
-            return resp.message.content
-        except:
-            raise
-        
-    def create_vector(self, chunk:str)->list[float]:
-        '''
-            TODO: Vérifier s'il ne faut pas utiliser 'embed' plutôt que 'embeddings'
-        '''
-        try:
-            resp = ollama.embeddings(
-                model=self.feature_name, 
-                prompt=chunk)
-            return self.normalize(resp.embedding).tolist()
-        except:
-            raise
-        
-    def normalize(self, v:list[float]):
-        norm = np.linalg.norm(v)
-        if norm == 0: 
-           return v
-        return v / norm        
-        
-    def create_vectors(self, chunks:list[str])->list[list[float]]:
-        try:
-            resp = ollama.embed(
-                model=self.feature_name, 
-                input=chunks)
-            # print(resp.embeddings)
-            return resp.embeddings
-        except:
-            raise

src/model_openai.py

@@ -1,65 +0,0 @@
-import os
-import sys
-from dotenv import load_dotenv
-from .amodel import AModel
-from openai import OpenAI
-
-class OpenAIModel(AModel):
-    '''
-        https://platform.openai.com/docs/guides/text-generation
-        
-    '''
-    
-    def __init__(self, llm_name:str, feature_name:str, temperature:float=0.0):
-        self.llm_name:str = llm_name
-        self.feature_name:str = feature_name
-        self.temperature = temperature
-        load_dotenv()
-        try:
-            self.model = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-        except:
-            raise
-
-    def ask_llm(self, question:str)->str:
-        try:
-            response = self.model.chat.completions.create(
-                # model="gpt-4o-mini",
-                model=self.llm_name,
-                messages=[
-                    {"role":"system", "content":""},
-                    {"role":"user", "content":question},
-                ],
-                temperature=self.temperature
-            )
-            return response.choices[0].message.content
-        except:
-            raise
-
-    def create_vector(self, chunk:str)->list[float]:
-        '''
-            8192 tokens max
-        '''
-        # les embeddings d'OpenAI sont normalisés à 1
-        try:
-            response = self.model.embeddings.create(
-                input=chunk,
-                model=self.feature_name
-            )
-            return response.data[0].embedding 
-        except:
-            raise
-    
-    def create_vectors(self, chunks:list[str])->list[list[float]]:
-        '''
-            Pas plus de 2048 chunks
-        '''
-        try:
-            response = self.model.embeddings.create(
-                input=chunks,
-                model=self.feature_name
-            )
-            n:int = len(chunks)
-            result = [response.data[i].embedding for i in range(n)]
-            return result
-        except:
-            raise

src/rag.py

@@ -1,7 +1,6 @@
 import sys
 
 from pypdf import PdfReader
-
 from .chunker import Chunker
 from .amodel import ModelType
 from .model_huggingface import HuggingFaceModel

src/store.py

@@ -230,9 +230,10 @@ class Store(AStore):
                 Si on ne peut pas créer le 'persist_dir'
         '''
         # Vérifier si le persist_dir existe, sinon le créer
-        print("Persist_dir:" + self.persist_dir)
+        # print("Persist_dir:" + self.persist_dir)
         try:
             if not os.path.exists(self.persist_dir):
+                print("Trying to recreate persist_dir", self.persist_dir)
                 os.mkdir(self.persist_dir)
         except:
             raise Exception("Unable to create the persit directory: {dir}".format(dir=self.persist_dir))