First commit

.gitignore

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

.python-version

@@ -0,0 +1 @@
+3.11

requirements.txt

@@ -0,0 +1,5 @@
+pypdf
+openai
+huggingface-hub
+ollama
+mistralai

src/amodel.py

@@ -0,0 +1,58 @@
+from abc import ABC, abstractmethod
+from enum import Enum
+
+class ModelType(Enum):
+    ''' Les différentes technos de models '''
+    MTOPENAI = 1
+    MTOLLAMA = 2
+    MTHUGGINGFACE = 3
+    MTMISTRAL = 4
+
+    @classmethod
+    def to_str(self, mt:int)->str:
+        match mt:
+            case 1: return "MTOPENAI"
+            case 2: return "MTOLLAMA"
+            case 3: return "MTHUGGINGFACE"
+            case 4: return "MTMISTRAL"
+            case _: return "UNKNOWN"
+
+class AModel(ABC):
+    '''
+        Classe abstraite de base pour tous les models :
+            Ollama en local
+            OpenAI distant
+            HuggingFace distant
+            HuggingFace dans une app
+            ...
+    '''
+
+    @abstractmethod
+    def ask_llm(self, question:str)->str:
+        pass
+
+    @abstractmethod
+    def create_vector(self, chunk:str)->list[float]:
+        pass
+
+    @abstractmethod
+    def create_vectors(self, chunks:list[str])->list[list[float]]:
+        pass
+
+    def get_llm_name(self):
+        return self.llm_name
+
+    def set_llm_name(self, llm_name:str):
+        self.llm_name = llm_name
+
+    def get_feature_name(self):
+        return self.feature_name
+
+    def set_feature_name(self, feature_name:str):
+        self.feature_name = feature_name
+
+    def get_temperature(self):
+        return self.temperature
+
+    def set_temperature(self, temperature:float):
+        self.temperature = temperature

src/astore.py

@@ -0,0 +1,39 @@
+from abc import ABC, abstractmethod
+
+
+class AStore(ABC):
+    '''
+        Classe abstraite de base pour tous les stores :
+            Chroma
+            Perso
+            ...
+    '''
+    
+    @abstractmethod
+    def reset(self)->None:
+        pass
+        
+    @abstractmethod
+    def print_infos(self)->None:
+        pass
+    
+    @abstractmethod    
+    def add_to_collection(self, collection_name:str, source:str, vectors:list[list[float]], chunks:list[str])->None:
+        pass
+    
+    @abstractmethod  
+    def delete_collection(self, name:str)->None:
+        pass
+    
+    @abstractmethod
+    def get_similar_vector(self, vector:list[float], collection_name:str)->list[float]:
+        pass
+        
+    @abstractmethod
+    def get_similar_chunk(self, query_vector:list[float], collection_name:str)->tuple[str, str]:
+        pass
+        
+    @abstractmethod
+    def get_similar_chunks(self, query_vector:list[float], count:int, collection_name:str):
+        pass
+        

src/chunker.py

@@ -0,0 +1,36 @@
+
+
+class Chunker:
+    '''
+        Tronçonnage d'un texte en chunks
+    '''
+
+    def __init__(self):
+        pass
+
+    def split_basic(self, text:str, char_count:int, overlap:int)->list[str]:
+        '''
+            Découpe le texte avec des '\n'. 
+            La taille d'un chunk est de max count + 2 * overlap
+            chunk = o1-c-o2
+                o1: les mots du chunk précédent ajoutés, il y en a 'overlap' ou 0 pour le premier chunk
+                c: partie centrale du chunk
+                o2: les mots du chunk suivant ajoutés, il y en a 'overlap' ou 0 pour le dernier chunk
+            Args:
+                char_count: le nombre de caractères dans un chunk (sans compter les mots ajoutés par recouvrement)
+                overlap: le nombre de caractères du chunk précédent (et suivant) ajoutés au début (et à la fin) du chunk
+            Return:
+                La liste des chunks
+        '''
+        # La liste qui sera renvoyée
+        chunks:list[str] = [] # la liste qui sera renvoyée
+        # Découpage du texte en morceaux de 'char_count' caractères
+        n:int = len(text)
+        size:int = n // char_count + 1 # nombre de chunks
+        for i in range(size):
+            start = i*char_count if i == 0 else i*char_count - overlap
+            stop = (i+1)*char_count if i == size - 1 else (i+1)*char_count + overlap
+            s = slice(start, stop)
+            chunk:str = text[s]
+            chunks.append(chunk)
+        return chunks

src/model_huggingface.py

@@ -0,0 +1,61 @@
+import os
+from .amodel import AModel
+from huggingface_hub import InferenceClient
+import numpy as np # feature_extraction renvoie un array numpy...
+
+
+class HuggingFaceModel(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
+        # La variable HF_ACTIVE a été créée dans les settings de l'app sur HuggingFace
+        if (os.getenv("HF_ACTIVE")): # Lancement depuis l'app sur HuggingFace
+            api_token = os.getenv("HF_TOKEN") 
+        else: # Lancement depuis mon ordi
+            # print("Launch Rag in HuggingFace local")
+            from dotenv import load_dotenv # Trick: ne passe pas dans une app sur HuggingFace
+            load_dotenv()
+            api_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
+        try:
+            self.model = InferenceClient(api_key=api_token) 
+        except:
+            raise
+
+    def ask_llm(self, question:str)->str:
+        messages = [{"role": "user", "content": question}]
+        try:
+            resp = self.model.chat.completions.create(
+                model=self.llm_name,                     
+                messages=messages, 
+                max_tokens=500,
+                temperature=self.temperature,
+                # stream=True
+            )
+            return resp.choices[0].message.content
+        except:
+            raise
+
+    def create_vector(self, chunk:str)->list[float]:
+        resp = self.model.feature_extraction(
+            text=chunk,
+            # normalize=True, # Only available on server powered by Text-Embedding-Inference.
+            model=self.feature_name, # normalisé ??
+        )
+        return resp
+    
+    def create_vectors(self, chunks:list[str])->list[list[float]]:
+        '''
+            Pas de batch pour la création de vectors sur HuggingFace, on les passe un par un
+        '''
+        vectors = []
+        try:
+            for chunk in chunks:
+                v = self.create_vector(chunk)
+                if not isinstance(v, np.ndarray):
+                    raise
+                vectors.append(v.tolist())
+            return vectors
+        except:
+            raise

src/model_mistral.py

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,65 @@
+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

@@ -0,0 +1,249 @@
+import sys
+
+from pypdf import PdfReader
+
+from .chunker import Chunker
+from .amodel import ModelType
+from .model_openai import OpenAIModel
+from .model_huggingface import HuggingFaceModel
+from .model_ollama import OllamaModel
+from .model_mistral import MistralModel
+from .store import Store
+
+
+class Rag:
+    '''
+        Classe qui s'occupe de toute la chaine du RAG.
+        Elle permet :
+            d'interroger un llm directement (sans RAG) avec ask_llm()
+            d'interroger le RAG lui même avec ask_rag()
+            d'ajouter des documents à la base de données du RAG
+            de remettre la base à zéro
+            de créer des vecteurs
+            de charger des pdf
+    '''
+
+    # Le prompt qui sera utilisé uniquement avec le RAG
+    prompt_template = """
+        En vous basant **uniquement** sur les informations fournies dans le contexte 
+        ci-dessous, répondez à la question posée.
+        Les équations seront écrites en latex.
+        Si vous ne trouvez pas la réponse dans le contexte, répondez "Je ne sais pas".
+        Contexte : {context}
+        Question : {question}
+    """
+
+    def __init__(self, model_type:ModelType, store_dir:str) -> None:
+        ''' 
+            Constructeur du Rag
+            Args: 
+                model_type: la techno utilisée
+                store_dir: le répertoire de persistance de la base de données ou None
+            Exception:
+                Si le model ne peut pas être créé
+                Si le type de model est inconnu
+        '''
+        self.model_type = model_type
+        try:
+            match model_type:
+                case ModelType.MTOPENAI:
+                    self.model = OpenAIModel("gpt-4o-mini", "text-embedding-3-small", 0)
+                case ModelType.MTHUGGINGFACE:
+                    self.model = HuggingFaceModel("meta-llama/Meta-Llama-3-8B-Instruct", "sentence-transformers/all-MiniLM-l6-v2", 0)
+                case ModelType.MTOLLAMA:
+                    self.model = OllamaModel("llama3.2:1b", "nomic-embed-text", 0.0)
+                case ModelType.MTMISTRAL:
+                    self.model = MistralModel("mistral-large-latest", "mistral-embed", 0.0)
+                case _:
+                    raise Exception("Rag.__init__: Unknown model type: {mt} : {v}".format(mt=ModelType.to_str(model_type), v=model_type))
+            self.emb_store = Store(store_dir) # persistant
+            # self.emb_store = Store(None) # éphémère
+        except Exception as e:
+            raise
+
+    def get_llm_name(self):
+        return self.model.get_llm_name()
+    
+    def get_feature_name(self):
+        return self.model.get_feature_name()
+    
+    def get_temperature(self):
+        return self.model.get_temperature()
+    
+    def set_temperature(self, temperature:float):
+        self.model.set_temperature(temperature)
+
+    def reset_store(self):
+        self.emb_store.reset()
+
+    def delete_collection(self, name:str)->None:
+        self.emb_store.delete_collection(name)
+
+    def create_vectors(self, chunks:list[str])->list[list[float]]:
+        '''
+            Renvoie les vecteurs correspondant à 'chunks', calculés par 'emb_model'
+            Args:
+                chunks: les extraits de texte à calculer
+            Return:
+                la liste des vecteurs calculés
+        '''        
+        vectors:list = []
+        tokens:int = 0
+        vectors:list[list[float]] = self.model.create_vectors(chunks) # batch si le model le permet
+        # for chunk in chunks:
+        #     vector:list[float] = self.model.create_vector(chunk=chunk)
+        #     vectors.append(vector)
+        return vectors
+
+    def load_pdf(self, file_name:str)->str:
+        ''' Charge le fichier 'file_name' et renvoie son contenu sous forme de texte. '''
+        reader = PdfReader(file_name)
+        content = ""
+        for page in reader.pages:
+            content += page.extract_text() + "\n"
+        return content
+    
+    def get_chunks(self, text:str)->list:
+        '''
+            Découpe le 'text' en chunks de taille chunk_size avec un recouvrement
+            Args:
+                text: Le texte à découper
+            Return:
+                La liste des chunks
+        '''
+        # splitter = RecursiveCharacterTextSplitter(
+        #     # separator="\n",
+        #     chunk_size=1000,
+        #     chunk_overlap=200,
+        #     length_function=len,
+        #     is_separator_regex=False
+        # )
+        # chunks = splitter.split_text(text)
+        # print("get_chunks: " + str(len(chunks)))
+        chunker = Chunker()
+        chunks = chunker.split_basic(text=text, char_count=1000, overlap=200)
+        return chunks
+
+    def add_pdf_to_store(self, file_name:str, collection_name:str)->None:
+        '''
+            Ajoute un pdf à la base de données du RAG.
+            Args:
+                file_name: le chemin vers le fichier à ajouter
+                collection_name: Le nom de la collection dans laquelle il faut ajouter les chunks
+                    La collection est créée si elle n'existe pas.
+        '''
+        text:str = self.load_pdf(file_name)
+        chunks:list[str] = self.get_chunks(text)
+        self.add_chunks_to_store(chunks=chunks, collection_name=collection_name, source=file_name)
+
+    def add_pdf_stream_to_store(self, stream, collection_name:str)->None:
+        '''
+            Ajoute un stream provenant de file_uploader de streamlit par exemple
+        '''
+        text:str = self.load_pdf(stream)
+        chunks:list[str] = self.get_chunks(text)
+        self.add_chunks_to_store(chunks=chunks, collection_name=collection_name, source="stream")
+
+    def add_chunks_to_store(self, chunks:list[str], collection_name:str, source:str)->None:
+        '''
+            Ajoute des chunks à la base de données du RAG.
+            Args:
+                chunks: les chunks à ajouter
+                collection_name: Le nom de la collection dans laquelle il faut ajouter les chunks
+                    La collection est créée si elle n'existe pas.
+                source: la source des chunks (nom du fichier, url ...)
+        '''        
+        vectors = self.create_vectors(chunks=chunks)
+        self.emb_store.add_to_collection(
+            collection_name=collection_name, 
+            source=source, 
+            vectors=vectors,
+            chunks=chunks
+        )
+
+
+    def ask_llm(self, question:str)->str:
+        '''
+            Pose une question au llm_model, attend sa réponse et la renvoie.
+            Args:
+                question: La question qu'on veut lui poser
+            Returns:
+                La réponse du llm_model
+        '''
+        return self.model.ask_llm(question=question)
+
+    def ask_rag(self, question:str, collection_name:str)->tuple[str, str, list[str], list[str]]:
+        '''
+            Pose une question au RAG, attend sa réponse et la renvoie.
+            Args:
+                question: La question qu'on veut lui poser
+                collection_name: le nom de la collection que l'on veut interroger
+            Returns:
+                Le prompt effectivement donné au llm_model
+                La réponse du llm_model
+                Les sources du RAG utilisées
+                Les ids des documents du RAG
+        '''
+        if not question:
+            return "", "Error: No question !", [], []
+        if not collection_name:
+            return "", "Error: No collection specified !", [], []
+        if not collection_name in self.emb_store.get_collection_names():
+            return "", "Error: {name} is no more in the database !".format(name=collection_name), [], []
+        # Transformer la 'question' en vecteur avec emb_model
+        query_vector:list[float] = self.model.create_vector(question) 
+        # Récupérer les chunks du store similaires à la question
+        chunks, sources, ids = self.emb_store.get_similar_chunks( 
+            query_vector=query_vector, 
+            count=2, 
+            collection_name=collection_name
+        )
+        # Préparer le prompt final à partir du prompt_template
+        prompt:str = self.prompt_template.format( 
+            context="\n\n\n".join(chunks),
+            question=question
+        )
+        # demander au llm_model de répondre
+        resp:str = self.ask_llm(question=prompt)
+
+        return prompt, resp, sources, ids
+
+def test_cours_TSTL()->None:
+    # Test placé ici pendant la mise au point
+    STORE_DIR = "./db/chroma_vectors"
+    # rag = Rag(ModelType.MTOPENAI, store_dir=STORE_DIR)
+    rag = Rag(ModelType.MTHUGGINGFACE, store_dir=STORE_DIR)
+    # rag = Rag(llm_type=ModelType.MTHUGGINGFACE, emb_type=ModelType.MTHUGGINGFACE, store_dir=STORE_DIR)
+    
+    rag.reset_store()
+    rag.add_pdf_to_store("chap-1-Statique.pdf", "T_SPCL")
+    # rag.add_pdf_to_store("chap-2-Regulation.pdf", "T_SPCL")
+    # rag.add_pdf_to_store("chap-3-Dynamique.pdf", "T_SPCL")
+    # rag.add_pdf_to_store("chap-4-Echangeurs.pdf", "T_SPCL")
+
+    rag.emb_store.print_infos()
+
+    prompt, resp, sources, ids = rag.ask_rag( 
+        question="Quelle est la différence entre une pression relative et une pression absolue?",
+        # question="Qu'est-ce qu'un échangeur à contre-courant?",
+        # question="Quelle est la formule de la résistance thermique? Réponds brièvement",
+        # question="Quelle est l'équation de Bernouilli avec les termes de pompe et pertes de charges? Réponds brièvement",
+        # question="Que signifie le terme de vitesse dans l'équation de Bernouilli ?",
+        # question="Transforme 1 bar en mètre de colonne d'eau",
+        # question="A quoi correspond HMT d'une pompe?",
+        collection_name="T_SPCL"
+    )
+    print(prompt)
+    print("---------------------------")
+    print(resp)
+    print("---------------------------")
+    print("sources:", sources)
+    print("ids=", ids)
+
+    # print(rag.ask_llm("Quelle est l'équation de Bernouilli avec les termes de pompe et pertes de charges? Réponds brièvement"))
+
+if __name__ == "__main__":
+    test_cours_TSTL()
+
+
+

src/store.py

@@ -0,0 +1,411 @@
+from math import sqrt
+import operator
+import json
+import os
+from pathlib import Path
+from .astore import AStore
+
+class Document:
+    '''
+        Un document est :
+            une chaîne de caractère, le chunk
+            une source, livre ou page ou chapitre
+            un vecteur issu d'un modèle d'embedding
+            un id, calculé automatiquement par la collection
+    '''
+    def __init__(self, chunk:str, source:str, vec:list[float], idd:int):
+        self.chunk = chunk
+        self.source = source
+        self.vec = vec
+        self.idd = idd
+
+    def get_json(self):
+        json = {
+            'c':self.chunk,
+            's':self.source,
+            'v':self.vec
+        }
+
+        return json
+
+class Collection:
+    '''
+        Une Collection est :
+            un nom
+            une liste de documents
+            un id, calculé automatiquement par le Store
+        Une collection est sauvée dans un fichier idc.col
+            le nom de la collection
+            la liste des documents:
+                chunk
+                source
+                vector
+    '''
+    def __init__(self, 
+                name:str, 
+                docs:list[Document],
+                idc:int):
+        self.name = name
+        self.docs = docs
+        self.idc = idc
+        
+    def add_document(self, chunk:str, source:str, vec:list[float])->Document:
+        '''
+            Ajoute un document à la collection
+            Args:
+                chunk: le texte du document
+                source: la source du document (livre, chap...)
+                vec: la représentation vectorielle du document
+            Returns:
+                un Document ou None si problème rencontré
+            Raise:
+                si un des paramètres n'est pas défini
+        '''
+        if chunk == None or source == None or vec == None:
+            raise Exception("Document error: chunk, source or vec is None !")
+        idd:int = len(self.docs) + 1
+        doc:Document = Document(chunk, source, vec, idd)
+        self.docs.append(doc)
+        return doc
+    
+    def get_length_octets(self)->int:
+        '''
+            Return la taille en octets de la collection
+        '''
+        if len(self.docs) == 0:
+            return 0
+        vector_size = len(self.docs[0])
+        return len(self.docs) * vector_size * 4 # un float sur 4 octets
+    
+    @classmethod
+    def from_disk(self, file_path:str):
+        '''
+            Méthode de classe qui renvoie une Collection à partir d'un fichier de la base
+            Args:
+                file_path: le chemin vers le fichier
+            Return:
+                la Collection
+            Exception:
+                si le fichier n'existe pas ou qu'on ne peut pas le lire
+        '''
+        if not os.path.exists(file_path):
+            raise Exception("File {file} doesn't exist !".format(file=file_path))
+        idc:int = int(Path(file_path).stem)
+        # print("Collection.from_disk, reading : ", idc)
+        try:
+            with open(file_path, "r") as f:
+                datas = json.load(f)
+                name:str = datas['name']
+                docs = []
+                idd: int = 1
+                for d in datas['docs']:
+                    doc:Document = Document(d['c'], d['s'], d['v'], idd)
+                    docs.append(doc)
+                    idd += 1
+                return Collection(name, docs, idc)
+        except:
+            raise Exception("Unable to read {file_path} !".format(file_path=file_path))
+        
+    def save(self, persist_dir:str):
+        '''
+            La collection est enregistrée avec le nom idc.col dans le persist_dir
+            Args:
+                persist_dir: le chemin du repertoire de la bdd
+            Exception:
+                Si on ne peut pas sauver sur le disque
+        '''
+
+        file_path:str = os.path.join(persist_dir, str(self.idc)) + ".col"
+        # print("Collection.save : ", file_path)
+        json_object = {
+            'name':self.name,
+            'docs':[]
+        }
+        for doc in self.docs:
+            json_object['docs'].append(doc.get_json())
+        json_object = json.dumps(json_object)
+        try:
+            with open(file_path, "w+") as f:
+                f.write(json_object)
+        except:
+            raise Exception("Unable to save the collection {name}, id={id} !".format(name=self.name, id=self.idc))
+
+    def delete(self, persist_dir:str)->None:
+        '''
+            Supprime la collection de la bdd
+            Args:
+                persist_dir: le chemin du repertoire de la bdd
+            Exception:
+                Si on ne peut pas supprimer du disque
+        '''
+        self.docs.clear()
+        file_path:str = os.path.join(persist_dir, str(self.idc)) + ".col"
+        try:
+            os.remove(file_path)
+        except:
+            raise Exception("Unable to delete the collection {name}, id={id} !".format(name=self.name, id=self.idc))
+        
+class Store(AStore):   
+    '''
+        Un store est une liste de collections.
+        A chaque création, ajout ou suppression d'un élément, la base est sauvée si elle est persistante
+        Sur le disque, dans store_dir:
+            Un sous-repertoire par collection, portant le nom de la collection
+            Dans chaque sous-repertoire d'une collection : la liste des vecteurs
+            
+    '''
+    def __init__(self, persist_dir:str):
+        ''' Constructeur de Store 
+            Args:
+                dir_name: le répertoire persistant de la base de données ou None
+            Exception:
+                Dans le cas d'une base persistante:
+                    Impossible de créer le répertoire persistant
+                    Impossible de lire les collections
+        '''         
+        self.persist_dir = persist_dir
+        self.collections = []
+        if persist_dir == None: # store éphémère
+            pass # Rien à faire
+        else:
+            # Charger la liste des collections
+            try:
+                self._create_persist_dir()
+                files = [os.path.join(persist_dir, f) for f in os.listdir(persist_dir) if os.path.isfile(os.path.join(persist_dir, f))]
+                for f in files:
+                    col: Collection = Collection.from_disk(f)
+                    self.collections.append(col)
+            except Exception as e:
+                raise
+            
+    def reset(self)->None:
+        ''' 
+            Vide la base et l'efface du disque si elle est persistante 
+            Exception:
+                Dans le cas d'une base persistante:
+                    Impossible de créer le répertoire persistant
+                    Impossible de lire les collections
+        '''
+        self.collections = []
+        if self.persist_dir == None: # store éphémère
+            pass
+        else:
+            try:
+                # Supprimer les fichiers du disque
+                if os.path.exists(self.persist_dir):
+                    files = [os.path.join(self.persist_dir, f) for f in os.listdir(self.persist_dir) if os.path.isfile(os.path.join(self.persist_dir, f))]
+                    # print(files)
+                    for f in files:
+                        os.remove(f)
+                    os.rmdir(self.persist_dir)
+            except Exception as e:
+                raise
+    
+    def get_collection_names(self)->list[str]:
+        return [col.name for col in self.collections]
+
+    def print_infos(self)->None:
+        ''' Affiche le nombre de collections et pour chaque collection, affiche son nom et son nombre de documents '''
+        print("-------- STORE INFOS ---------------")
+        for col in self.collections:
+            print(col.name)
+            # idds = [doc.idd for doc in col.docs]
+            # print("\t", idds)
+            print("\tdocuments:", len(col.docs))
+        print("-------- /STORE INFOS ---------------")
+
+    def get_collection(self, collection_name:str)->Collection:
+        ''' 
+            Renvoie la collection dont le nom est 'collection_name' ou None si elle n'existe pas
+        '''
+        for col in self.collections:
+            if col.name == collection_name:
+                return col
+        return None
+    
+    def _create_persist_dir(self):
+        '''
+            Recrée le répertoir persistant s'il a disparu après un reset par exemple
+            Exception:
+                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)
+        try:
+            if not os.path.exists(self.persist_dir):
+                os.mkdir(self.persist_dir)
+        except:
+            raise Exception("Unable to create the persit directory: {dir}".format(dir=self.persist_dir))
+
+    def create_collection(self, name:str)->Collection:
+        ''' 
+            Crée et renvoie une nouvelle collection vide de documents 
+            Args:
+                name: le nom de la création à créer
+            Exception:
+                Dans le cas d'une base persistante:
+                    Impossible de créer le répertoire persistant
+                    Impossible de sauver la collection    
+        '''
+        idc:int = len(self.collections) + 1
+        col:Collection = Collection(name, [], idc)
+        if self.persist_dir != None:
+            try:
+                self._create_persist_dir()
+                col.save(self.persist_dir)
+            except:
+                raise
+        return col
+    
+    
+    def add_to_collection(self, collection_name:str, source:str, vectors:list[list[float]], chunks:list[str])->None:
+        '''
+            Ajoute une liste de vecteurs à la collection 'collection_name'
+            Args:
+                collection_name: le nom de la collection
+                source: la source unique des chunks, par exemple un nom de fichier, une url ...
+                vectors: la liste des vecteurs obtenus à l'aide d'un modèle d'embeddings
+                chunks: la liste des chunks (documents) correspondant aux vecteurs
+            Exception:
+                Dans le cas d'une base persistante:
+                    Impossible de créer le répertoire persistant
+                    Impossible de sauver la collection  
+        '''        
+        col:Collection = self.get_collection(collection_name)
+        if col == None:
+            col = self.create_collection(collection_name)
+            self.collections.append(col)
+        for i in range(len(chunks)):
+            col.add_document(chunks[i], source, vectors[i])
+        if self.persist_dir != None:
+            try:
+                self._create_persist_dir()
+                col.save(self.persist_dir)
+            except:
+                raise
+        
+    def delete_collection(self, name:str)->None:
+        ''' Vide et supprime la collection dont le nom est 'name', et la supprime du disque si elle est persistante '''
+        col = self.get_collection(name)
+        if col != None:
+            self.collections.remove(col)
+            if self.persist_dir != None:
+                try:
+                    self._create_persist_dir()
+                    col.delete(self.persist_dir)
+                except:
+                    raise
+    
+    def normalize(self, v:list[float])->list[float]:
+        ''' 
+            Normalement les LLMs renvoient des vecteurs normalisés mais:
+                c'est pas sûr pour ceux que je n'ai pas testés
+                c'est pratique d'avoir cette méthode pour 'test_store.py'
+            Args:
+                v: le vecteur à normaliser
+            Returns:
+                le vecteur normalisé
+        '''
+        norm = 0.0
+        for i in range(len(v)):
+            norm += v[i] * v[i]
+        norm = sqrt(norm)
+        if norm == 0.0:
+            return v.copy()
+        result = [None] * len(v)
+        for i in range(len(v)):
+            result[i] = v[i] / norm
+        return result
+    
+    def dot_product(self, v1:list[float], v2:list[float])->float:
+        '''
+            Le produit scalaire est utilisé pour une similarité en cosinus:
+            cos(a) = (vecA dot vecB) / (A.B)
+            si les vecteurs A et B sont normalisés, le cos est simplement le produit scalaire
+            Args:
+                v1, v2: les deux vecteurs à multiplier
+            Returns:
+                Un float égal à v1 dot v2
+        '''
+        result = 0.0
+        for i in range(len(v1)):
+            result += v1[i] * v2[i]
+        return result
+    
+    def get_similar_vector(self, vector:list[float], collection_name:str)->list[float]:
+        '''
+            Renvoie le vecteur de 'collection' le pus similaire à 'vector'.
+            Args:
+                vector: un vecteur obtenu avec le même modèle d'embeddings que les vecteurs de la 'collection'
+                collection_name: le nom de la collection de la base dans laquelle on cherche une similarité
+            Return:
+                Le vecteur le plus similaire 'vector'
+        '''        
+        col:Collection = self.get_collection(collection_name)
+        best_doc:Document = None
+        best_dp: float = -20.0
+        if col != None:
+            for doc in col.docs:
+                dp:float = self.dot_product(vector, doc.vec)
+                if dp > best_dp:
+                    best_dp = dp
+                    best_doc = doc
+            return best_doc.vec
+        else:
+            return None
+       
+    def get_similar_chunk(self, query_vector:list[float], collection_name:str)->tuple[str, str]:
+        '''
+            Renvoie le document de la 'collection' le plus similaire à 'query_vector'.
+            Args:
+                query_vector: un vecteur obtenu avec le même modèle d'embeddings que les vecteurs de la 'collection'
+                collection: la collection de la base dans laquelle on cherche une similarité
+            Returns:
+                Un tuple contenant:
+                    le document
+                    la source du document
+        '''        
+        col:Collection = self.get_collection(collection_name)
+        best_doc:Document = None
+        best_dp: float = -20.0
+        if col != None:
+            for doc in col.docs:
+                dp:float = self.dot_product(query_vector, doc.vec)
+                print(dp)
+                if dp > best_dp:
+                    best_dp = dp
+                    best_doc = doc
+            return best_doc.chunk, best_doc.source
+        else:
+            return None, None
+        
+    def get_similar_chunks(self, query_vector:list[float], count:int, collection_name:str):
+        '''
+            Returns:
+                Un tuple contenant:
+                    les documents
+                    la source des documents
+                    les ids des documents
+            a[0:count-1]
+        '''
+        # start:int = time.time()
+        col:Collection = self.get_collection(collection_name)
+        if col == None:
+            return None, None, None
+        bests:list[dict] = []
+        # Ajouter tous les docs avec leur dotproduct à la liste bests
+        for doc in col.docs:
+            dp:float = self.dot_product(query_vector, doc.vec)
+            bests.append({'doc':doc, 'dp':dp})
+        # Trier la liste en reverse à partir de la clé 'dp' 
+        bests.sort(key=operator.itemgetter('dp'), reverse=True)
+        # Adapter le nombre de documents à renvoyer s'il n'y a pas assez de chunks
+        n:int = count if len(bests) >= count else len(bests)
+        # print("get_similar_chunks, count=", count, ", n=", n)
+        # Créer les variables de retour
+        docs = [b['doc'].chunk for b in bests[0:n]]
+        source = bests[0]['doc'].source if n > 0 else None
+        ids = [b['doc'].idd for b in bests[0:n]]
+        # print("my_store.get_similar_chunks:", time.time() - start, "s")
+        return docs, source, ids
+