Upload folder using huggingface_hub

1934d09a-c249-4fe5-aa72-584f5845fb98/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9effed2377b339647f4386d54aef11d675e1b0cdae38a31f6be2532e4dafac06
+size 1676000

1934d09a-c249-4fe5-aa72-584f5845fb98/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e87a1dc8bcae6f2c4bea6d5dd5005454d4dace8637dae29bff3c037ea771411e
+size 100

1934d09a-c249-4fe5-aa72-584f5845fb98/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e9222c5dc2e55306044f19e34222731eaa4ea0851d32260729f57bd568a4aab
+size 4000

7495d102-62f8-4242-9219-87d4caee7813/data_level0.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a3c5ba4473d921018e74451b89232bb9154a25c602c5a6a6c211841416a634c5
+size 1676000

7495d102-62f8-4242-9219-87d4caee7813/header.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e87a1dc8bcae6f2c4bea6d5dd5005454d4dace8637dae29bff3c037ea771411e
+size 100

7495d102-62f8-4242-9219-87d4caee7813/length.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4934f5eefc80b2267d185fd33d3d1b33b53cd8c8247b25c40d4e45582a94ed93
+size 4000

README.md

@@ -1,12 +1,6 @@
 ---
-title: PHE Outil IA
-emoji: 🚀
-colorFrom: red
-colorTo: blue
+title: PHE_Outil_IA
+app_file: rag_chat_v3.py
 sdk: gradio
-sdk_version: 4.42.0
-app_file: app.py
-pinned: false
+sdk_version: 4.37.1
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

functions_rag_chat_v3.py

@@ -0,0 +1,456 @@
+import os
+
+import gradio as gr
+from gradio.themes.base import Base
+
+import glob
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import DirectoryLoader
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.document_loaders import TextLoader
+from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import GPT4AllEmbeddings
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+
+import getpass
+
+import json
+
+
+# Import necessary modules
+from langchain.retrievers import ContextualCompressionRetriever, EnsembleRetriever
+from langchain.retrievers.document_compressors import CrossEncoderReranker
+from langchain_community.cross_encoders import HuggingFaceCrossEncoder
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnableLambda, RunnableParallel, RunnablePassthrough
+
+from typing import Sequence, Any, Dict
+from langchain.schema import Document
+
+
+
+def chunks_from_pdf(pdf_directory):
+    """
+    Chunks all pdfs from a directory
+    :param pdf_directory: directory of pdfs
+    :return: list of chunks
+    """
+    # fetching all pdfs from the directory and storing them as strings in a list
+    docs = []
+    for file in glob.glob(pdf_directory + "/*.pdf"):
+        loader = PyPDFLoader(file)
+        doc = loader.load()
+        docs.extend(doc)
+
+    # split texts into chunks with overlap
+    splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(chunk_size=500, chunk_overlap=100)
+    splits = splitter.split_documents(docs)
+
+    print(f"Loaded {len(docs)} documents")
+    return splits
+
+
+def chunks_from_text(text_directory):
+    """
+    Chunks all text files from a directory
+    :param text_directory: directory of text files
+    :return: list of chunks
+    """
+    # fetch all txt files from the firectory and store them in a list
+    loader = DirectoryLoader(text_directory, loader_cls=TextLoader)  # , glob="**/*.txt")
+    docs = loader.load()
+
+    from langchain_community.document_transformers import LongContextReorder
+
+    reordering = LongContextReorder()
+    reordered_docs = reordering.transform_documents(docs)
+    
+
+    # split texts into chunks with overlap
+    splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(chunk_size=500, chunk_overlap=100)
+    splits = splitter.split_documents(reordered_docs)
+
+    return splits
+
+
+def chunking(data_directory, type):
+    """
+    Automatically calls the correct chunking function, either for pdfs or for txt files
+    :param data_directory: directory of data, either ../pdf or ../text
+    :return: result from the corresponding chunking function
+    """
+    if type == "pdf":
+        return chunks_from_pdf(data_directory)
+    else:
+        return chunks_from_text(data_directory)
+
+
+def create_vector_store(db_directory, chunks, embedding):
+    """
+    Creates a chromaDB vector embedding store for all chunks of the data
+    :param db_directory: directory to persistently store the resulting vector store
+    :param chunks: list of chunks of data
+    :param embedding: embedding function
+    :return: retriever on vector store
+    """
+    print("Creating vector store (this may take a while)")
+    print(f"Creating vector store with {len(chunks)} chunks")
+
+    # create vector store and index
+    vectorstore = Chroma.from_documents(documents=chunks, collection_name="chromemwah", embedding=embedding,
+                                        persist_directory=db_directory)
+
+    return vectorstore #.as_retriever(search_type="similarity")
+
+
+def fetch_vector_store(db_directory, embedding):
+    """
+    Fetches a chromaDB vector embedding store of the data
+    :param db_directory: directory where vector store is persistently stored
+    :param embedding: embedding function
+    :return: retriever on vector store
+    """
+    print("Fetching vector store")
+    print(f"Fetching vector store from {db_directory}")
+    vectorstore = Chroma(collection_name="chromemwah", embedding_function=embedding, persist_directory=db_directory)
+
+    return vectorstore #.as_retriever(search_type="similarity")
+
+
+def retrieve(retrieving, question):
+    """
+    Retrieve relevant documents from vector store based on query/question
+    :param retrieving: retriever
+    :param question: user query
+    :return: relevant documents
+    """
+    print("Retrieving")
+    documents = retrieving.get_relevant_documents(question)
+    print(f"Retrieved {len(documents)} documents for the question: {question}")
+    return documents
+
+
+def context_formatting(documents):
+    """
+    Formats retrieved documents to be used as context for the LLM
+    :param documents: retrieved documents
+    :return: formatted documents
+    """
+    content = ""
+    for index, document in enumerate(documents):
+        content = content + "[Extrait " + str(index + 1) + "]=" +"Type du document : " +  document.metadata["type"] +". Produit concerné : " + document.metadata["nom_med"] +". Texte extrait : "  +  document.page_content.replace("\n", " ") + "\n\n"
+    return content
+
+
+def source_formatting_v0(documents):
+    """
+    Formats retrieved documents to be used as sources for the user
+    :param documents: retrieved documents
+    :return: formatted documents
+    """
+    sources = ""
+    for i, document in enumerate(documents):
+        sources= sources + "Avis numéro " + str(i + 1)+ " (id de l'avis : " + str(document[0].metadata["avis_id"]) + ")\n\n"  + "Date de l'avis : " + document[0].metadata["date_avis"] + "\n"  +  "Medicament : " +  document[0].metadata["nom_med"]  + "\n" + "Exploitant : " +  document[0].metadata["exploitant"] + "\n" +  "Indication : " +  document[0].metadata["indication"] + "\n\n" #+ "Lien avis : " +  document[0].metadata["lien_avis"] +"\n\n"
+        for index, doc in enumerate(document):
+            sources = sources + "[extrait " + str(index + 1) + "] " + " [" +  doc.metadata["type"] + "] " + doc.page_content.replace("\n", " ").replace("+", " ") + "\n"
+        sources = sources + "---------------------------------------------------------------------------------- \n"
+    return sources.strip()
+
+def source_formatting(documents, scores, docs_ejected, scores_ejected):
+    """
+    Formats retrieved documents to be used as sources for the user
+    :param documents: retrieved documents
+    :param scores: scores associated with the documents
+    :param docs_ejected: documents that were not selected due to low scores
+    :param scores_ejected: scores of the rejected documents
+    :return: formatted documents
+    """
+    sources = ""
+    for i, (document_group, score_group) in enumerate(zip(documents, scores)):
+        sources += (f"Avis numéro {i + 1} (id de l'avis : {document_group[0].metadata['avis_id']})  \n"  # Deux espaces pour forcer le saut de ligne
+                    f"Date de l'avis : {document_group[0].metadata['date_avis']}  \n"
+                    f"Médicament : {document_group[0].metadata['nom_med']}  \n"
+                    f"Exploitant : {document_group[0].metadata['exploitant']}  \n"
+                    f"Lien de l'avis : [{document_group[0].metadata['lien_avis']}]"
+                    f"({document_group[0].metadata['lien_avis']})  \n"  # Lien cliquable en Markdown
+                    f"Indication : {document_group[0].metadata['indication']}  \n\n")
+        
+        for j, (doc, score) in enumerate(zip(document_group, score_group)):
+            sources += (f"[Extrait {j + 1}] (Score: {score}) [{doc.metadata['type']}]  \n"
+                        f"```\n{doc.page_content.replace('\n', ' ').replace('+', ' ')}\n```  \n")
+        sources += "----------------------------------------------------------------------------------  \n"
+    
+    # Adding ejected chunks
+    sources += "\n**Chunks non récupérés lors du scoring de pertinence :**\n"
+    for doc, score in zip(docs_ejected, scores_ejected):
+        sources += (f"\n(Score: {score})  \n"
+                    f"<div style='font-size:0.9em;'>\n{doc.page_content.replace('\n', ' ').replace('+', ' ')}\n</div>  \n")
+
+    return sources.strip()
+
+
+
+def generate_sous_questions(question):
+
+    use_llm = "mistral"
+
+    # Charger les données d'exemple
+    with open('/home/onyxia/phe/scripts/modeles/text_to_SQL/entrainement_initial.json', 'r') as f:
+        exemples = json.load(f)
+
+        # Construire le prompt avec les exemples
+    rag_prompt_template = """
+    Tu es un assistant pour générer des sous-questions à partir d'une question donnée. On veut séparer la question_donnée en deux parties :
+    1. La partie permettant de filtrer les documents sur leurs metadatas (question_to_sql).
+    2. La partie permettant de récupérer les éléments à analyser et à récupérer dans les textes (question_to_llm).
+
+    Pour la question_to_sql, il faut générer une question permettant de sélectionner les id des documents concernés par la question_posée, en spécifiant les matadatas à séléctionner cités dans question_posée. Les filtres appliqués ne doivent faire référence qu'à la maladie, l'aire thérapeutique, l'indication, la date, l'asmr, le smr ou le type.
+    Sachant que l'asmr ne peut prendre comme valeur que 'I','II','III','IV' ou'V'. Le smr ne peut prendre comme valeur que 'important','modéré','faible' ou 'insuffisant'. Le type ne peut prendre comme valeur que 'avis_ct','transcription_ct','avis_ceesp','transcription_ceesp','questionnaire' ou 'efficience'.
+    Dans question_to_sql, il ne doit pas faire mention des informations à chercher dans le texte, mais seulement des metadatas (maladie, l'aire thérapeutique, l'indication, la date, l'asmr, le smr, le type).
+    
+    Pour la question_to_llm, il faut récupérer le fond de la question et ce qui doit être récupéré dans le texte des documents sélectionnés, elle ne doit pas mentionner les informations relatives à la requête SQL, présentent dans question_sql.
+
+    Tu ne devras génerer des réponses qu'en minuscules, il ne doit y avoir aucune majuscule.
+
+    En te basant sur ces exemples d'entraînement, tu devras générer en output 'question_to_sql' et 'question_to_llm' en prenant en input 'question_posée'. Tu génereras l'output en suivant ce format : 'question_to_llm # question_to_sql'.
+
+    Exemples d'entraînement :
+
+    {examples}
+
+    Maintenant, à ton tour de générer question_to_llm et question_to_sql en suivant la mise en forme 'question_to_llm # question_to_sql' à partir de la question_posée suivante :
+
+    question_posée donnée en input : {question}
+    question_to_llm et question_to_sql générées en output en lettres minuscules, aucune majuscule :
+    """
+
+    examples = ""
+    for exemple in exemples[0:6]:
+        examples += (
+            f"question_posée donnée en input : {exemple['question_posee']}\n"
+            f"question_to_llm et question_to_sql générées en output: {exemple['question_to_llm']} # {exemple['question_to_sql']}\n\n"
+        )
+
+    rag_prompt = ChatPromptTemplate.from_template(rag_prompt_template)
+
+    # define LLM to be used and the temperature (creativity/randomness) of the model
+    print("llm")
+    llm = ChatOllama(model=use_llm, temperature=0.8, num_predict=500)
+    print("chain")
+    # define a LangChain chain
+    chain = rag_prompt | llm | StrOutputParser()
+    print("invoke")
+        
+    # invoke chain with retrieved documents and the question (user query)
+    output = chain.invoke({ "question": question, "examples": examples }).split("#")
+    
+    return output
+
+def generate(question, documents, use_llm):
+    """
+    LLM generates a response based on the question (user query), added context (retrieved documents), and a prompt
+    :param question: user query
+    :param documents: retrieved documents, formatted
+    :param use_llm: which llm to use
+    :return: LLM generated response
+    """
+    
+    # adapted from https://smith.langchain.com/hub/rlm/rag-prompt
+    
+    rag_prompt = ChatPromptTemplate.from_template("Tu es un assistant devant répondre à la question d'un client qui souhaîte récupérer et analyser des informations sur des documents de la Comission de la Transparence la Haute Autorité de Santé française,"
+                                                " qui est une réunion d'experts médicaux ayant en charge d'évaluer les nouveaux médicaments avant qu'ils ne soient mis sur le marché. Utilise les "
+                                              "extraits des documents récupérés en contexte pour répondre à la question. Si"
+                                              "l'extrait n'est pas utile pour répondre à la question, dis qu'il n'est pas utile. Garde la"
+                                              "réponse conçise, véridique et informative. Réponds toujours en français."
+                                              "Réponds plusieurs fois à la question, à chaque fois en considérant un seul extrait, puis agrège les différentes réponses en une conclusion. Base toi sur l'exemple de mise en forme de réponse pour rédiger la tienne."
+                                              "Chaque extrait donné en contexte est donné avec son titre, son type et son lien. Prends en considération le morceau de texte en considérant son type :"
+                                              "s'il s'agit d'un type avis_ct il s'agit d'une synthèse publiée après la Comission avec les avis finaux des experts sur le médicament. "
+                                              "S'il s'agit d'un type transcription_ct il s'agit d'une retranscription des dialogues ayants eut lieux pendant la comission, condidère alors qu'il s'agit de paroles à interpréter, tu dois donc répondre à la question en disant 'les experts disent --- donc nous pouvons en déduire que ---'."
+                                              "Les sources (extraits) sont indiquées dans le contexte par : "
+                                              "[doc<doc_number>]. TITRE DOCUMENT : ---  \n\n TYPE DU DOCUMENT : --- \n\n LIEN DOCUMENT : --- \n\n EXTRAIT : ---- \n\n\n"
+                                              "Exemple de mise en forme de réponse : \n"
+                                              "Dans l' [extrait1], [réponse à la question en ne considérant que l'extrait 1].\n"
+                                              "Dans l' [extrait2], [réponse à la question en ne considérant que l'extrait 2].\n"
+                                              "Dans l' [extrait3], [réponse à la question en ne considérant que l'extrait 3].\n"
+                                              "Ainsi, en considérant les différents extrait, on en déduit que [synthèse des trois réponses précédentes].\n\n\n\n"
+                                              "Question posée par le client : {question} \n"
+                                              "Contexte associé : {context} \n"
+                                              "Réponse générée en français et en suivant la mise en forme de l'exemple :")
+    # define LLM to be used and the temperature (creativity/randomness) of the model
+    
+    llm = ChatOllama(model=use_llm, temperature=0.5, num_predict=3000)
+    
+    # define a LangChain chain
+    chain = rag_prompt | llm | StrOutputParser()
+    
+    
+    # invoke chain with retrieved documents and the question (user query)
+    output = chain.invoke({"context": documents, "question": question})
+
+    return output
+
+
+def generate_agregated(reponses, use_llm):
+    """
+    LLM generates a response based on the question (user query), added context (retrieved documents), and a prompt
+    :param liste_rep: liste des réponses individuelles 
+    :param use_llm: which llm to use
+    :return: LLM generated response
+    """
+    
+    # adapted from https://smith.langchain.com/hub/rlm/rag-prompt
+    
+    rag_prompt = ChatPromptTemplate.from_template("Tu es un assistant qui doit synthétiser plusieurs réponses à une question donnée par un client qui souhaîte récupérer et analyser des informations sur des documents de la Comission de la Transparence la Haute Autorité de Santé française,"
+                                                " qui est une réunion d'experts médicaux ayant en charge d'évaluer les nouveaux médicaments avant qu'ils ne soient mis sur le marché sur la base d'un dossier d'étude qui leur est présenté." 
+                                              "Pour répondre tu as en contexte plusieurs réponses à la question qui t'ai posée, qui ont été générées par un llm en se basant à chaque fois sur 3 extraits d'un document donné."
+                                              "Ton rôle est de récupérer ces réponses, de vérifier si elles répondent bien à la question posée et d'agréger les informations issues de ces réponses en une petite synthèse pour répondre à la question."
+                                              "Les réponses sont indiquées dans le contexte par : "
+                                              "Document [titre_doc] : 1. [réponse en se basant sur le premier extrait du document [titre_doc]] 2. [réponse en se basant sur le deuxième extrait du document [titre_doc]] 3. [réponse en se basant sur le troisième extrait du document [titre_doc]] "
+                                              "Pour chaque document, vérifie que chaque réponse réponds bien à la question donnée et récupère les informations qui y répondent bien et font sens par rapport à la question."
+                                              " Réponds toujours en français."
+                                              "Question posée par le client : {question} \n"
+                                              "Contexte (réponses générées préalablement) : {context} \n"
+                                              "Synthèse générée en français pour répondre précisemment à la question et à rien d'autre :")
+    # define LLM to be used and the temperature (creativity/randomness) of the model
+    
+    llm = ChatOllama(model=use_llm, temperature=0.5, num_predict=3000)
+    
+    # define a LangChain chain
+    chain = rag_prompt | llm | StrOutputParser()
+    
+    
+    # invoke chain with retrieved documents and the question (user query)
+    output = chain.invoke({"context": reponses, "question": question})
+
+    return output
+
+def generate_2(question, documents, use_llm):
+    """
+    LLM generates a response based on the question (user query), added context (retrieved documents), and a prompt
+    :param question: user query
+    :param documents: retrieved documents, formatted
+    :param use_llm: which llm to use
+    :return: LLM generated response
+    """
+    
+    # adapted from https://smith.langchain.com/hub/rlm/rag-prompt
+    
+    rag_prompt = ChatPromptTemplate.from_template("Tu es un assistant devant répondre à la question d'un client qui souhaîte récupérer et analyser des informations sur des documents de la Comission de la Transparence la Haute Autorité de Santé française,"
+                                                " qui est une réunion d'experts médicaux ayant en charge d'évaluer les nouveaux médicaments avant qu'ils ne soient mis sur le marché. Utilise les "
+                                              "extraits de document récupéré en contexte pour répondre à la question."
+                                              "Réponds à la question, et seulement à la question. N'ajoute aucune information qui ne répond pas à la question. Sois concis et clair."
+                                              "Ne cite pas les extraits de document."
+                                              "Si les etraits donnés en contexte ne permettent pas de répondre à la question, renvoie 'Pas d'élément de réponse dans ces extraits'."
+                                              "Le ou les extraits de document sont indiqués dans le contexte par : "
+                                              "[Extrait num_doc]= Type du document : [type]. Produit concerné : [nom du médicament]. Texte extrait : [extrait  du document] "
+                                              "Question : {question} \n"
+                                              "Contexte : {context} \n"
+                                              "Réponse concise à la question '{question}', générée en français:")
+    # define LLM to be used and the temperature (creativity/randomness) of the model
+   
+    llm = ChatOllama(model=use_llm, temperature=0.35, num_predict=600)
+    
+    # define a LangChain chain
+    chain = rag_prompt | llm | StrOutputParser()
+    
+    
+    # invoke chain with retrieved documents and the question (user query)
+    output = chain.invoke({"context": documents, "question": question})
+
+    return output
+
+
+
+def generate_agregated_2(reponses, question, use_llm):
+    """
+    LLM generates a response based on the question (user query), added context (retrieved documents), and a prompt
+    :param liste_rep: liste des réponses individuelles 
+    :param use_llm: which llm to use
+    :return: LLM generated response
+    """
+    
+    # adapted from https://smith.langchain.com/hub/rlm/rag-prompt
+    
+    rag_prompt = ChatPromptTemplate.from_template("Tu es un assistant qui doit synthétiser plusieurs réponses à une question donnée par un client qui souhaîte récupérer et analyser des informations sur des documents de la Comission de la Transparence la Haute Autorité de Santé française,"
+                                                " qui est une réunion d'experts médicaux ayant en charge d'évaluer les nouveaux médicaments avant qu'ils ne soient mis sur le marché sur la base d'un dossier d'étude qui leur est présenté." 
+                                              "Pour répondre tu as en contexte plusieurs réponses à la question qui t'ai posée, qui ont été générées par un llm en se basant à chaque fois sur un extrait de document différent. "
+                                              "Tu as en contexte toutes les réponses générées individuellement sur chaque extrait de document, avec le type de document et le médicament concerné par ce document."
+                                              "Tu citeras les documents avec '[num_doc]' lorsque tu utiliseras une information provennant d'une réponse générée sur un document."
+                                              "Ton rôle est de récupérer ces réponses, de vérifier si elles répondent bien à la question posée et d'agréger les informations issues de ces réponses en une petite synthèse pour répondre à la question."
+                                              "Les réponses sont indiquées dans le contexte par : "
+                                              "Document numéro [num_doc] = Type du document : [type]. Produit concerné : [nom du médicament]. Réponse générée : [réponse générée par llm en se basant sur le document [num_doc]] "
+                                              "Pour chaque document, vérifie que chaque réponse réponds bien à la question donnée, si ce n'est pas le cas ne considère pas cette réponse pour ta synthèse. Récupère les informations qui répondent bien à la question et font sens par rapport à la question."
+                                              " Réponds toujours en français."
+                                              "Question posée par le client : {question} \n"
+                                              "Contexte (réponses générées préalablement) : {context} \n"
+                                              "Synthèse générée en français pour répondre précisemment à la question et à rien d'autre :")
+    # define LLM to be used and the temperature (creativity/randomness) of the model
+    
+    llm = ChatOllama(model=use_llm, temperature=0.5, num_predict=3000)
+    
+    # define a LangChain chain
+    chain = rag_prompt | llm | StrOutputParser()
+    
+    
+    # invoke chain with retrieved documents and the question (user query)
+    output = chain.invoke({"context": reponses, "question": question})
+
+    return output
+
+
+
+
+def ind_relevant_doc(question, documents, use_llm):
+    """
+    LLM generates a response based on the question (user query), added context (retrieved documents), and a prompt
+    :param question: user query
+    :param documents: retrieved documents, formatted
+    :param use_llm: which llm to use
+    :return: LLM generated response
+    """
+    
+    # adapted from https://smith.langchain.com/hub/rlm/rag-prompt
+    rag_prompt = ChatPromptTemplate.from_template("Juge la pertinence entre la requête et le document : le document permet-il de répondre à la question? Renvoie 'oui' ou 'non' et rien d'autre."
+                                              "Requête : {question} \n"
+                                              "Document : {context} \n"
+                                              "réponse :")
+    # define LLM to be used and the temperature (creativity/randomness) of the model
+    llm = ChatOllama(model=use_llm, temperature=0.7, num_predict=3)
+    # define a LangChain chain
+    chain = rag_prompt | llm | StrOutputParser()
+    
+    # invoke chain with retrieved documents and the question (user query)
+    output = chain.invoke({"context": documents, "question": question})
+
+    return output
+
+
+
+def generate_score(question, documents, use_llm):
+    """
+    LLM generates a response based on the question (user query), added context (retrieved documents), and a prompt
+    :param question: user query
+    :param documents: retrieved documents, formatted
+    :param use_llm: which llm to use
+    :return: LLM generated response
+    """
+    
+    # adapted from https://smith.langchain.com/hub/rlm/rag-prompt
+    rag_prompt = ChatPromptTemplate.from_template("Sur une échelle de 0 à 5, juge la pertinence entre la requête et le document. Ne renvoie que la note attribuée et rien d'autre."
+                                              "Requête : {question} \n"
+                                              "Document : {context} \n"
+                                              "réponse :")
+    # define LLM to be used and the temperature (creativity/randomness) of the model
+    llm = ChatOllama(model=use_llm, temperature=0.7, num_predict=1)
+    # define a LangChain chain
+    chain = rag_prompt | llm | StrOutputParser()
+    
+    # invoke chain with retrieved documents and the question (user query)
+    output = chain.invoke({"context": documents, "question": question})
+
+    return output
+
+

rag_chat_v3.py

@@ -0,0 +1,523 @@
+
+# pip install gradio langchain gpt4all chromadb pypdf tiktoken
+# pip install --quiet gradio langchain gpt4all chromadb pypdf tiktoken
+
+
+# imports
+import os
+
+import gradio as gr
+from gradio.themes.base import Base
+
+import glob
+
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.document_loaders import DirectoryLoader
+from langchain_community.document_loaders import PyPDFLoader
+from langchain_community.document_loaders import TextLoader
+from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import GPT4AllEmbeddings
+from langchain_community.chat_models import ChatOllama
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+
+import getpass
+
+import json
+
+from tqdm import tqdm
+
+# Import necessary modules
+from langchain.retrievers import ContextualCompressionRetriever, EnsembleRetriever
+from langchain.retrievers.document_compressors import CrossEncoderReranker
+from langchain_community.cross_encoders import HuggingFaceCrossEncoder
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnableLambda, RunnableParallel, RunnablePassthrough
+
+from typing import Sequence, Any, Dict
+from langchain.schema import Document
+
+
+import time
+
+
+
+from functions_rag_chat_v3 import *
+
+os.environ["LANGCHAIN_TRACING_V2"] = "true"
+os.environ["LANGCHAIN_API_KEY"] = os.getenv("LANGCHAIN_API_KEY")
+
+
+
+if __name__ == "__main__":
+    """
+    main function
+    """
+    print("Starting program")
+
+    start_time = time.time()
+
+    # define what LLM to use
+    use_llm = "mistral"
+    #use_llm = "phe-v2-gguf"
+
+    # define what embedding model to use
+    from langchain_community.embeddings import HuggingFaceEmbeddings
+
+
+    model_name = "clairedhx/autotrain-v2"
+
+    
+    token=os.getenv("hugging_face_token")
+    
+    model_kwargs = {'device': 'cuda', 'token': token}
+    encode_kwargs = {'normalize_embeddings': False}
+    embedding = HuggingFaceEmbeddings(
+        model_name=model_name,
+        model_kwargs=model_kwargs,
+        encode_kwargs=encode_kwargs
+    )
+    #print(embedding)
+
+    end_time = time.time()
+    print(f"Temps d'exécution pour l'initialisation des embeddings: {end_time - start_time} secondes")
+
+    # directory to persistently store the vector embedding store
+    db_directory = '/home/onyxia/phe/scripts/chroma_db'
+
+
+    #test a parir de dataframe pour avoir metadata
+
+    from datetime import datetime
+    import pandas as pd
+
+    #start_time = time.time()
+
+    #df = pd.read_csv('/home/onyxia/phe/scripts/gestion_base/documents_with_metadata_all_med_21_08_24.csv')
+    # Conversion de 'date_avis' en année
+    #df['année'] = pd.to_datetime(df['date_avis'], format='%Y-%m-%d').dt.year
+
+
+    from langchain_community.document_loaders import DataFrameLoader
+
+    #loader = DataFrameLoader(df, page_content_column="texte")
+
+    #docs= loader.load()
+
+    #splitter = RecursiveCharacterTextSplitter.from_tiktoken_encoder(separators=["\n\n", "\n","."], chunk_size=400, chunk_overlap=150)
+    #splits = splitter.split_documents(docs)
+    #print("splits : ", len(splits))
+
+    #vectordb= Chroma.from_documents(documents=splits, collection_name="chromemwah", embedding=embedding, persist_directory=db_directory)
+    #vectordb.persist()
+
+    #end_time = time.time()
+    print(f"Temps d'exécution pour le chargement des documents, split et créer base chromaDB: {end_time - start_time} secondes")
+
+
+    start_time = time.time()
+
+    vectordb = Chroma(persist_directory=db_directory, embedding_function=embedding, collection_name="chromemwah")
+
+    end_time = time.time()
+    print(f"Temps d'exécution pour le chargement de la base de données persistante: {end_time - start_time} secondes")
+
+
+    ###############################################
+    #RECUPERATION VANNA AI 
+    ###############################################
+
+    from dotenv import main
+    import os
+
+    print("Récupération des informations de connection")
+
+    start_time = time.time()
+
+    # Charger les variables d'environnement à partir du fichier .env
+    main.load_dotenv()
+
+    # Accéder aux variables d'environnement 
+    Hostname = os.getenv("Hostname")
+    Port = os.getenv("Port")
+    Database = os.getenv("Database")
+    Username = os.getenv("Username")
+    Password = os.getenv("Password")
+
+    from vanna.ollama import Ollama
+    from vanna.chromadb import ChromaDB_VectorStore
+
+    class MyVanna(ChromaDB_VectorStore, Ollama):
+        def __init__(self, config=None):
+            ChromaDB_VectorStore.__init__(self, config=config)
+            Ollama.__init__(self, config=config)
+
+    vn = MyVanna(config={'model': 'mistral'})
+    vn.connect_to_postgres(host=Hostname, dbname=Database, user=Username, password=Password, port=Port) # Connect to your database here
+    
+    vn.train(ddl="""
+            CREATE TABLE IF NOT EXISTS medicaments (
+                id SERIAL PRIMARY KEY,
+                nom VARCHAR(2555) NOT NULL,
+                nombre_avis INTEGER,
+                nombre_docs INTEGER,
+                DCI VARCHAR(2555),
+                exploitant VARCHAR(2555),
+                codes_ATC TEXT[],
+                cip TEXT[]
+            );
+
+            CREATE TABLE IF NOT EXISTS avis (
+                id SERIAL PRIMARY KEY,
+                numero_avis VARCHAR(255) NOT NULL,
+                maladie VARCHAR(255),
+                aires_therapeutiques TEXT[],
+                date_avis DATE,
+                nombre_docs INTEGER,
+                medicament_id INTEGER REFERENCES medicaments(id),
+                smr smr_type,
+                asmr asmr_type
+            );
+
+            CREATE TABLE IF NOT EXISTS documents (
+                id SERIAL PRIMARY KEY,
+                titre_doc VARCHAR(300) NOT NULL,
+                type document_type NOT NULL,
+                indication VARCHAR(100000),
+                medicament_id INTEGER REFERENCES medicaments(id),
+                avis_id INTEGER REFERENCES avis(id),
+                lien_doc VARCHAR(255),
+                transcription_ct_associee INTEGER[],
+                avis_ct_associe INTEGER[],
+                transcription_ceesp_associee INTEGER[],
+                avis_ceesp_associe INTEGER[],
+                questionnaire_associe INTEGER[],
+                texte TEXT  -- Nouveau champ pour stocker le texte extrait
+            );
+        """)
+
+    import json
+
+    # Load the JSON file
+    with open('/home/onyxia/phe/scripts/modeles/text_to_SQL/entrainement_augmented.json', 'r') as file:
+        data = json.load(file)
+
+    # Train Vanna with the SQL query pairs
+    for pair in data:
+        question = pair['question_to_sql']
+        sql = pair['sql']
+        vn.train(question=question.strip(), sql=sql.strip())
+
+    end_time = time.time()
+    print(f"Temps d'exécution pour la connexion à la base de données et l'entraînement de Vanna: {end_time - start_time} secondes")
+
+
+    ####################################################################
+    ####################################################################
+
+
+
+    RERANKER_CROSS_ENCODER = "BAAI/bge-reranker-base"
+    model_hf_cross = HuggingFaceCrossEncoder(model_name=RERANKER_CROSS_ENCODER)
+        
+   
+
+    def complete_rag(question, selected_types, year_start, year_end):
+        """
+        The process of retrieval augmented generation
+        :param question: user query
+        :return: sources and LLM ouput, generated using retrieved documents
+        """
+
+        start_time = time.time()
+
+        vn.connect_to_postgres(host=Hostname, dbname=Database, user=Username, password=Password, port=Port)
+        training_data = vn.get_training_data()
+        print("training_data")
+        print(training_data)
+
+        sous_questions =generate_sous_questions(question)
+        question_llm, question_sql = sous_questions[0], sous_questions[1]
+        print("question to sql : ",question_sql)
+        print("question to llm : ",question_llm)
+
+        sql=vn.generate_sql(question=question_sql, allow_llm_to_see_data=True)
+        print(' \n \n sql : ',sql)
+
+        # Récupération des IDs et des liens `lien_med`
+        result_sql = vn.run_sql(sql)
+        list_id = result_sql['id'].tolist()
+
+
+        print("\n \n list_id : ",list_id)
+
+        if list_id==[]:
+            print("No documents", "Aucun document pouvant répondre à cette question n'a été trouvé dans la base.")
+
+        end_time = time.time()
+        print(f"Temps d'exécution pour complete_rag [split questions, vanna ai]: {end_time - start_time} secondes")
+
+        start_time = time.time()
+
+        # Handle the selection of document types
+        if "tous" in selected_types:
+            selected_types = ['avis_ct', 'transcription_ct', 'avis_ceesp', 'transcription_ceesp', 'questionnaire']
+        else:
+            selected_types = [doc_type for doc_type in selected_types if doc_type != 'tous']
+
+        # Convertir les années sélectionnées en entiers
+        year_min = int(year_start)
+        year_max = int(year_end)
+        
+        # La plage d'années sélectionnée est définie par year_min et year_max
+        years = list(range(year_min, year_max + 1))
+
+        # search_kwargs avec le filtre des années
+        search_kwargs = {
+            "k": 500,
+            "filter": {
+                '$and': [
+                    {'id_doc': {'$in': list_id}},
+                    {'type': {'$in': selected_types}},
+                    {'année': {'$in': years}}  # Filtre sur les années sélectionnées
+                ]
+            }
+        }
+
+        retriever = vectordb.as_retriever(search_kwargs=search_kwargs) #{"k": 500, "filter":{'id_doc': {'$in': list_id},'type': {'$in': ['avis_ct', 'transcription_ct']}}})
+        compressor = CrossEncoderReranker(model=model_hf_cross, top_n=60)
+        retrieval_agent_hg_crossencoder = ContextualCompressionRetriever(base_compressor=compressor, base_retriever=retriever)
+
+        from langchain_community.retrievers import BM25Retriever
+        retrieval_agent_bm25 = BM25Retriever.from_documents(retriever.get_relevant_documents(question_llm), k=60)
+
+        from langchain.retrievers import EnsembleRetriever
+
+        # initialize the ensemble retriever
+        ensemble_retriever = EnsembleRetriever(
+            retrievers=[retrieval_agent_bm25, retrieval_agent_hg_crossencoder], weights=[0.95, 0.05]
+        )
+
+        end_time = time.time()
+        print(f"Temps d'exécution pour complete_rag [ensemble retriever]: {end_time - start_time} secondes")
+
+        start_time = time.time()
+
+        print("retriever")
+        documents = ensemble_retriever.get_relevant_documents(question_llm)
+        print(len(documents), " chunks retrouvés")
+
+        docs_scored=[]
+        scores=[]
+        all_scores =[]
+        for index, doc in enumerate(documents):
+            # Passer la liste de documents au lieu d'un seul document
+            output = generate_score(question, context_formatting([doc]), "mistral")
+            all_scores.append(int(output))
+            #if(int(output)>1):
+                #docs_scored.append(doc)
+                #scores.append(int(output))
+        #print(len(docs_scored), "retrouvés après scores")
+        print("All scores : ", all_scores)
+
+        # Trier les documents gardés en fonction des scores
+        #docs_with_scores = list(zip(docs_scored, scores))
+        #docs_sorted_by_score = sorted(docs_with_scores, key=lambda x: x[1], reverse=True)
+        #docs_scored_sorted = [doc for doc, score in docs_sorted_by_score]
+        #scores_sorted = [score for doc, score in docs_sorted_by_score]
+
+        # Trier tous les documents en fonction des scores
+        all_docs_with_scores = list(zip(documents, all_scores))
+        all_docs_sorted_by_score = sorted(all_docs_with_scores, key=lambda x: x[1], reverse=True)
+        all_docs_scored_sorted = [doc for doc, score in all_docs_sorted_by_score]
+        all_scores_sorted = [score for doc, score in all_docs_sorted_by_score]
+
+        docs_ejected=[]
+        scores_ejected=[]
+        for index, score in enumerate(all_scores_sorted):
+            if score>2:
+                docs_scored.append(all_docs_scored_sorted[index])
+                scores.append(score)
+            else:
+                docs_ejected.append(all_docs_scored_sorted[index])
+                scores_ejected.append(score)
+
+
+        docs_with_scores = list(zip(docs_scored, scores))
+
+        end_time = time.time()
+        print(f"Temps d'exécution pour complete_rag [scoring pertinence]: {end_time - start_time} secondes")
+
+
+        start_time = time.time()
+
+        from collections import defaultdict
+
+        # Initialisation des variables pour stocker les documents et les scores regroupés
+        from collections import defaultdict
+
+        grouped_documents = defaultdict(list)
+        grouped_scores = defaultdict(list)
+
+        # On suppose que chaque document a une clé 'avis_id' dans ses métadonnées
+        for doc, score in docs_with_scores:
+            avis_id = doc.metadata['avis_id']  # Assurez-vous que 'avis_id' est bien dans les métadonnées
+            grouped_documents[avis_id].append(doc)
+            grouped_scores[avis_id].append(score)
+
+        # Convertir les dictionnaires en listes de listes
+        documents_regroupes_sorted = []
+        scores_regroupes_sorted = []
+
+        for avis_id in grouped_documents.keys():
+            # Récupérer les documents et scores pour cet avis_id
+            docs = grouped_documents[avis_id]
+            scores = grouped_scores[avis_id]
+            
+            # Trier les paires (doc, score) en fonction des scores
+            sorted_pairs = sorted(zip(docs, scores), key=lambda x: x[1], reverse=True)
+            
+            # Séparer les documents et scores après tri
+            sorted_docs, sorted_scores = zip(*sorted_pairs)
+            
+            # Ajouter les listes triées aux résultats finaux
+            documents_regroupes_sorted.append(list(sorted_docs))
+            scores_regroupes_sorted.append(list(sorted_scores))
+
+        # Maintenant, documents_regroupes_sorted et scores_regroupes_sorted sont bien triés
+
+        # Afficher le nombre de groupes trouvés
+        print(f"{len(documents_regroupes_sorted)} avis retrouvés après regroupement des chunks")
+
+        end_time = time.time()
+        print(f"Temps d'exécution pour complete_rag [regroupement chunks par avis]: {end_time - start_time} secondes")
+
+
+        start_time = time.time()
+
+        # Appel de la fonction source_formatting avec les scores associés
+        sources = source_formatting(documents_regroupes_sorted, scores_regroupes_sorted, docs_ejected, scores_ejected)
+    
+
+
+        outputs = ""
+        outputs_for_last_llm =""
+
+        final_docs=documents_regroupes_sorted
+
+        for index, doc in enumerate(tqdm(final_docs, desc="question sur chaque chunk - mistral")):
+            output = generate_2(question_llm, context_formatting(doc), "mistral")
+            outputs += "Réponse à l'avis numéro " + str(index+1) + " : " + output + "\n\n"
+        
+        end_time = time.time()
+        print(f"Temps d'exécution pour complete_rag [boucle mistral question sur chaque avis]: {end_time - start_time} secondes")
+
+        start_time = time.time()
+
+        output_agreg = generate_agregated_2(outputs, question, "mistral")
+        synthese = "SYNTHESE : \n\n" +output_agreg + "\n\n\nREPONSE POUR CHAQUE AVIS : \n\n" + outputs
+
+        end_time = time.time()
+        print(f"Temps d'exécution pour complete_rag [question synthese]: {end_time - start_time} secondes")
+
+        start_time = time.time()
+
+        import psycopg2
+        
+        # Connexion à la base de données PostgreSQL
+        conn = psycopg2.connect(host=Hostname, dbname=Database, user=Username, password=Password, port=Port)
+        cursor = conn.cursor()
+
+        # Conversion de la liste en une chaîne compatible SQL
+        id_string = ','.join(map(str, list_id))
+
+        # Requête SQL pour obtenir les nombres uniques
+        query = f"""
+        SELECT 
+            COUNT(DISTINCT d.avis_id) AS unique_avis_count,
+            COUNT(DISTINCT d.medicament_id) AS unique_medicament_count,
+            COUNT(DISTINCT d.id) AS document_count
+        FROM 
+            documents d
+        WHERE 
+            d.id IN ({id_string});
+        """
+
+        query_lien_meds = f"""
+        SELECT DISTINCT m.lien_med
+        FROM documents as d
+        JOIN medicaments m ON d.medicament_id = m.id
+        WHERE 
+            d.id IN ({id_string});
+        """
+
+
+        # Exécution de la requête
+        cursor.execute(query)
+        result = cursor.fetchone()
+
+        # Exécution de la requête pour les liens `lien_med`
+        cursor.execute(query_lien_meds)
+        result_lien_meds = cursor.fetchall()
+
+        # Conversion des résultats de `lien_meds` en une liste
+        lien_meds = [row[0] for row in result_lien_meds if row[0]]  # Évite les valeurs nulles
+
+
+        # Affichage des résultats
+        unique_avis_count, unique_medicament_count, document_count = result
+        comptes = (f"Nombre de médicaments concernés par la question : {unique_medicament_count}<br>"
+           f"Nombre d'avis concernés par la question : {unique_avis_count}<br>"
+           f"Nombre de documents concernés par la question : {document_count}<br><br>"
+           "Liens des médicaments concernés :<br>" + 
+           "<br>".join([f"[{lien}]({lien})" for lien in lien_meds]))  # Conversion en liens Markdown cliquables avec balises HTML
+
+        # Fermeture de la connexion
+        cursor.close()
+        conn.close()
+
+        end_time = time.time()
+        print(f"Temps d'exécution pour complete_rag [recupération effectifs]: {end_time - start_time} secondes")
+
+
+        return sources, synthese, comptes
+
+
+    # for web view of prompting
+    # code below is copied from: https://www.youtube.com/watch?v=JEBDfGqrAUA (Project 2)
+    with gr.Blocks(theme=Base(), title="Q&A on your data with RAG") as demo:
+        gr.Markdown("# Q&A sur les documents de la HAS")
+        
+        # Sélection du type de document
+        doc_type_selection = gr.CheckboxGroup(
+            choices=["tous", "avis_ct", "transcription_ct", "avis_ceesp", "transcription_ceesp", "questionnaire"],
+            label="Sélectionnez les types de documents",
+            value=["tous"]  # Preselect "tous"
+        )
+        
+        # Boîte déroulante pour sélectionner l'année de début
+        year_start_dropdown = gr.Dropdown(
+            choices=[str(year) for year in range(2000, 2025)],  # De 2000 à 2024
+            value="2000",  # Valeur par défaut
+            label="Sélectionnez l'année de début"
+        )
+
+        # Boîte déroulante pour sélectionner l'année de fin
+        year_end_dropdown = gr.Dropdown(
+            choices=[str(year) for year in range(2000, 2025)],  # De 2000 à 2024
+            value="2024",  # Valeur par défaut
+            label="Sélectionnez l'année de fin"
+        )
+
+        textbox = gr.Textbox(label="Question:")
+        with gr.Row():
+            button = gr.Button("Entrée", variant="primary")
+        with gr.Column():
+            output3 = gr.Markdown(label="Effectifs")
+            output2 = gr.Textbox(lines=1, max_lines=1000, label="Réponse générée")
+            output1 = gr.Markdown(label="Sources")
+
+        # Mise à jour des inputs pour inclure les deux boîtes déroulantes
+        button.click(complete_rag, inputs=[textbox, doc_type_selection, year_start_dropdown, year_end_dropdown], outputs=[output1, output2, output3])
+
+    demo.launch(share=True)