first push

.gitattributes copy

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+__pycache__/
+.env
+.streamlit/.env

.streamlit/config.toml

@@ -0,0 +1,8 @@
+[server]
+maxUploadSize = 20
+
+[theme]
+base="light"
+primaryColor="#63abdf"
+secondaryBackgroundColor="#fbf7f1"
+textColor="#011166"

README copy.md

@@ -0,0 +1,12 @@
+---
+title: Théo Pratik
+emoji: ⚡
+colorFrom: purple
+colorTo: blue
+sdk: streamlit
+sdk_version: 1.37.1
+app_file: app.py
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

agents_page/catalogue.py

@@ -0,0 +1,5 @@
+import streamlit as st
+
+#st.set_page_config(page_title="Catalogue des agents (via bziiit.com)", page_icon="", layout="wide")
+
+st.title("Catalogue des agents (via bziiit.com)")

agents_page/recommended_agent.py

@@ -0,0 +1,187 @@
+import streamlit as st
+from utils.audit.response_llm import generate_response_via_langchain
+from textwrap import dedent
+import streamlit as st
+from langchain_openai import ChatOpenAI
+from langchain_mistralai import ChatMistralAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.messages import AIMessage, HumanMessage
+
+#st.set_page_config(page_title="Agents recommandés", page_icon="", layout="wide")
+def remove_images_from_content(content):
+    filtered_content = {}
+    
+    for page, data in content.items():
+        # Create a new dictionary excluding the "images" key
+        filtered_data = {key: value for key, value in data.items() if key != "images"}
+        filtered_content[page] = filtered_data
+    
+    return filtered_content
+
+def get_response(user_query, chat_history, db,llm=None,history_limit=10,stream=True):
+    retriever = db.as_retriever()
+    context = retriever.invoke(user_query)
+    template = """
+    Étant donné l'historique de la conversation : {chat_history}, le contexte qui est le document  : {context}, et la question de l'utilisateur : {user_question}, repond comme un expert en agent IA.
+    Assurez-vous que la réponse soit adaptée au niveau d'expertise de l'utilisateur et aux spécificités du contexte fourni.
+
+    """
+
+    prompt = ChatPromptTemplate.from_template(template)
+
+    #llm = ChatOpenAI(model="gpt-4o")
+    if not llm:
+        llm = ChatOpenAI(model="gpt-4o-mini")
+    elif llm == "GPT-4o":
+        llm = ChatOpenAI(model="gpt-4o")
+    elif llm == "Mistral Large 2 (FR)":
+        llm = ChatMistralAI(model_name="mistral-large-2407")
+    elif llm == "GPT-4o-mini":
+        llm = ChatOpenAI(model="gpt-4o-mini")
+    elif llm == "Mistral Nemo (FR)":
+        llm = ChatMistralAI(model_name="open-mistral-nemo-2407")
+    
+        
+    chain = prompt | llm
+
+    if not stream:
+        return chain.invoke({
+            "context": context,
+            "chat_history": chat_history[-history_limit:],
+            "user_question": user_query,
+        })
+    
+    chain = chain | StrOutputParser()
+
+    if history_limit:
+        return chain.stream({
+            "context": context,
+            "chat_history": chat_history[-history_limit:],
+            "user_question": user_query,
+        })
+    
+    return chain.stream({
+        "context": context,
+        "chat_history": chat_history,
+        "user_question": user_query,
+    })
+
+def handle_display_models(index, models_names):
+    model = st.radio("Choisir un modèle",models_names, index=index)
+    return model
+
+def recommended_agent_main():
+    st.title("Agents recommandés")
+    models_names = ["GPT-4o", "GPT-4o-mini","Mistral Nemo (FR)","Mistral Large 2 (FR)"]
+
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = [
+        ]
+
+    if "model" not in st.session_state:
+        st.session_state.model = "GPT-4o-mini"
+
+    header = st.container()
+    col1, col2 = header.columns([1, 2])
+
+    with col1.popover("Modèles disponibles"):
+        new_model = handle_display_models(models_names.index(st.session_state.model), models_names)
+
+    st.session_state.model = new_model
+    
+    st.markdown(f"- **{st.session_state.model}**")
+
+    if "audit" not in st.session_state or st.session_state.audit == {}:
+        st.error("Veuillez d'abord effectuer un audit pour obtenir des recommandations d'agents.")
+        return
+    
+    audit = st.session_state.audit_simplified
+    content = st.session_state.audit["content"]
+
+    if "response_llm" not in st.session_state:
+        st.session_state.response_llm = ""
+
+
+    #filter content, delete images if type is pdf
+    if audit["type de fichier"] == "pdf":
+        content = remove_images_from_content(content)
+    #delete audio if type is audio and keep transcript
+    elif audit["type de fichier"] == "audio":
+        content = content["transcription"]
+
+    ressources = content
+
+    prompt = '''
+    Tu es designer en intelligence artificielle (IA) spécialisé dans la création d'agents IA autonomes et performants.
+
+    A partir de ressources fournies par l'utilisateur (texte, documents, images, audio), tu es chargé de réaliser les tâches suivantes :
+
+    A/ Faire un résumé des ressources fournies en 500 caractères maximum
+
+    B/ Suggérer la création d'agents autonomes pour mettre en pratique les informations contenues dans les ressources fournies.
+
+    Tu proposes deux solutions :
+
+    Sol. A : 1 seul agent IA dont tu suggéreras :
+            * Nom
+            * Rôle
+            * Objectifs
+            * Outils utilisés par l'agent
+            * Tâches réalisées par l'agents
+            * Compétences de l'agent (backstory)
+
+    Sol. B : 1 équipe d'agents tu suggéreras :
+            * Le nombre d'agents
+            * Pour chacune d'eux [Nom, Rôle, Objectifs, Outils utilisés par l'agent, Tâches réalisées par l'agents, Compétences de l'agent (backstory)]
+
+    Une fois ce travail réalisé, tu proposes une série de 3 missions avec objectifs SMART pour chacun des agents  Sol. A et Sol. B en présentation les résultats dans un tableau contenant :
+            * Nom de l’agent
+            * Objectifs à atteindre
+
+        '''
+    
+    #display prompt and modify it 
+    prompt_modified = st.text_area("Prompt par défaut (que vous pouvez modifier, compléter)", prompt, height=300)
+    prompt_modified = dedent(prompt_modified)
+
+    if st.button("Générer les recommandations"):
+        resource_prompt = f'''Ressources fournies par l'utilisateur :{ressources}'''
+        prompt_modified = f"{prompt_modified}\n{resource_prompt}"
+        st.session_state.chat_history = []
+        with st.chat_message("AI"):
+            st.session_state.response_llm = st.write_stream(generate_response_via_langchain(query=prompt_modified,stream=True))
+        
+        st.session_state.chat_history.append(AIMessage(content=st.session_state.response_llm))
+    
+    elif st.session_state.response_llm:
+        st.info("la dernière réponse générée est affichée ci-dessous")
+        with st.chat_message("AI"):
+            st.write(st.session_state.response_llm)
+    
+    for message in st.session_state.chat_history[1:]:
+        if isinstance(message, AIMessage):
+            with st.chat_message("AI"):
+                st.markdown(message.content)
+        elif isinstance(message, HumanMessage):
+            with st.chat_message("Moi"):
+                st.write(message.content)
+
+    user_query = st.chat_input("Par ici ...")
+    if user_query is not None and user_query != "":
+        st.session_state.chat_history.append(HumanMessage(content=user_query))
+
+        with st.chat_message("Moi"):
+            st.markdown(user_query)
+        
+        with st.chat_message("AI"):
+            st.markdown(f"**{st.session_state.model}**")
+    
+
+            response = st.write_stream(get_response(user_query, st.session_state.chat_history,db=st.session_state.vectorstore, llm=st.session_state.model, stream=True))
+            st.session_state.chat_history.append(AIMessage(content=response))
+
+
+
+
+recommended_agent_main()

app.py

@@ -0,0 +1,33 @@
+import streamlit as st
+import dotenv
+import os
+
+def main():
+    
+    dotenv.load_dotenv(dotenv_path=os.path.join('.streamlit', '.env'))
+
+    st.set_page_config(page_title="RAG Agent", page_icon="🤖", layout="wide")
+
+    audit_page = st.Page("audit_page/audit.py", title="Audit", icon="📋", default=True)
+    dialog_page = st.Page("audit_page/dialogue_doc.py", title="Dialoguer avec le document", icon="💬")
+    kg_page = st.Page("audit_page/knowledge_graph.py", title="Graphe de connaissance", icon="🧠")
+    agents_page = st.Page("agents_page/catalogue.py", title="Catalogue des agents", icon="📇")
+    compte_rendu = st.Page("audit_page/compte_rendu.py", title="Compte rendu", icon="📝")
+    recommended_agents = st.Page("agents_page/recommended_agent.py", title="Agents recommandés", icon="⭐")
+    chatbot = st.Page("chatbot_page/chatbot.py", title="Chatbot", icon="💬")
+    documentation = st.Page("doc_page/documentation.py", title="Documentation", icon="📚")
+
+    pg = st.navigation(
+        {
+            "Audit de contenus": [audit_page,dialog_page],
+            "Equipe d'agents IA": [recommended_agents],
+            "Chatbot": [chatbot],
+            "Documentation": [documentation]
+        }
+    )
+
+    pg.run()
+
+
+if __name__ == "__main__":
+    main()

audit_page/audit.py

@@ -0,0 +1,259 @@
+import streamlit as st
+import pymupdf as fitz
+import pyperclip
+import clipboard
+from utils.audit.audit_doc import audit_descriptif_pdf,audit_text
+from utils.audit.rag import setup_rag
+import dotenv
+from utils.audit.audit_audio import evaluate_audio_quality
+from PIL import Image
+from io import BytesIO
+import st_copy_to_clipboard
+import os
+
+
+# Function to classify file type
+def classify_file(file):
+    if file.type.startswith("image/"):
+        return "image"
+    elif file.type == "application/pdf":
+        return "pdf"
+    elif file.type == "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
+        return "word"
+    elif file.type.startswith("audio/"):
+        return "audio"
+    elif file.type.startswith("text/"):
+        return "text"
+    else:
+        return "unknown"
+    
+#display content
+def display_content_doc(content:dict,col:st):
+    number_of_pages = len(content)
+    col.info("Note : Si vous choisissez 0, vous verrez le contenu de toutes les pages")
+    
+    number = col.number_input("Numéro de page", min_value=0, max_value=number_of_pages, value=0,key="number_page_content")
+    #0 means all pages
+    if number > 0:
+        page : dict = content[f"page_{number-1}"]
+
+    option = col.radio("Type de contenu",list(content[f"page_0"].keys()), index=0,horizontal=True)
+
+    if option == "images":
+        if number == 0:
+            images = [img for page in content.values() for img in page["images"]]
+        else:
+            images = page["images"]
+        col1,col2,col3 = col.columns(3)
+        for i, (img_bytes, img_width, img_height) in enumerate(images):
+            try:
+                if i%3 == 0:
+                    col1.image(Image.open(BytesIO(img_bytes)), caption=f'', width=img_width)
+                elif i%3 == 1:
+                    col2.image(Image.open(BytesIO(img_bytes)), caption=f'', width=img_width)
+                else:
+                    col3.image(Image.open(BytesIO(img_bytes)), caption=f'', width=img_width)
+            except:
+                pass
+
+    elif option == "texte":
+        if number == 0:
+            text = "-------------------\n".join([page["texte"] for page in content.values()])
+        else:
+            text = page["texte"]
+        
+        col.code(text,language="text")
+    
+    elif option == "liens":
+        if number == 0:
+            links = [link for page in content.values() for link in page["liens"]]
+        else:
+            links = page["liens"]
+        
+        for i, link in enumerate(links):
+            col.markdown(f"- {i+1}: [{link['uri']}]({link['uri']}) (page {link['page']})")
+    
+    elif option == "tableaux":
+        if number == 0:
+            tables = [table for page in content.values() for table in page["tableaux"]]
+        else:
+            tables = page["tableaux"]
+        
+        for i, table in enumerate(tables):
+            col.write(f"Tableau {i+1}")
+            col.write(table)
+
+def display_content_audio(content:dict,col:st):
+    st.write("##### Transcription")
+    st.write(content["transcription"])
+    # if st.button("📋",key="copy_transcription"):
+    st_copy_to_clipboard(content["transcription"])
+        # st.success("Transcription copiée dans le presse-papier")
+    
+    st.audio(content["audio_data"],sample_rate=content["frame_rate"]*2)
+
+def display_content_text(content,col:st):
+    st.text_area("Texte",content,height=200)
+        
+def handle_display_content(col:st):
+    audit = st.session_state.audit
+    type = st.session_state.audit_simplified["type de fichier"]
+    if type == "pdf":
+        with col.expander("Contenu"):
+            display_content_doc(audit["content"],st)
+    elif type == "audio":
+        with col.expander("Contenu"):
+            display_content_audio(audit["content"],col)
+    elif type == "text":
+        with col.expander("Contenu"):
+            display_content_text(audit["content"],col)
+
+
+
+def handle_audit(uploaded_file,type:str):
+    if type == "pdf":
+        if st.session_state.name_file != uploaded_file.name:
+            st.session_state.name_file = uploaded_file.name
+            with st.spinner("Analyse du document..."):
+                st.session_state.audit = {}
+                
+                st.session_state.audit = audit_descriptif_pdf(uploaded_file,100)
+            with st.spinner("Préparation de la DB..."):
+                vectorstore = setup_rag(type,st.session_state.audit["content"])
+                st.session_state.vectorstore = vectorstore
+                st.session_state.graph = None
+                st.session_state.cr = ""
+
+        audit = st.session_state.audit["audit"]
+        #global audit
+        audit_simplified = {
+            "type de fichier": type,
+            "Nombre de pages": audit["number_of_pages"],
+            "Nombre d'images": audit["number_of_images"],
+            "Nombre de liens": audit["number_of_links"],
+            "Nombre de tableaux": audit["number_of_tables"],
+            "Nombre de tokens": audit["number_of_tokens"],
+            "Nombre de mots": audit["number_of_words"],
+            "Mots clés": audit["key_words"]
+        }
+        st.session_state.audit_simplified = audit_simplified
+    
+    elif type == "audio":
+        if st.session_state.name_file != uploaded_file.name:
+            st.session_state.name_file = uploaded_file.name
+            with st.spinner("Analyse de l'audio..."):
+                st.session_state.audit = {}
+                st.session_state.audit = evaluate_audio_quality(uploaded_file)
+            with st.spinner("Préparation de la DB..."):
+                vectorstore = setup_rag(type,st.session_state.audit["content"])
+                st.session_state.vectorstore = vectorstore
+                st.session_state.graph = None
+                st.session_state.cr = ""
+
+        audit = st.session_state.audit["audit"]
+        #audit global simplifié
+        audit_simplified = {
+            "type de fichier": type,
+            "Durée": f"{audit['duration']:0.2f} minutes",
+            "Nombre de mots": audit["number_of_words"],
+            "Nombre de tokens": audit["number_of_tokens"],
+            "Volume": f"{audit['volume']:0.2f} dBFS (déciBels Full Scale)",
+            "SNR": f"{max(audit['SNR'],0):0.2f} dB (Ratio Signal / Bruit)", 
+        }
+        st.session_state.audit_simplified = audit_simplified
+    
+    elif type == "text":
+        text = uploaded_file.read().decode("utf-8")
+        if st.session_state.name_file != uploaded_file.name:
+            st.session_state.name_file = uploaded_file.name
+            with st.spinner("Analyse du texte..."):
+                st.session_state.audit = {}
+                st.session_state.audit = audit_text(text)
+        audit = st.session_state.audit["audit"]
+        #audit global simplifié
+        audit_simplified = {
+            "type de fichier": type,
+            "Nombre de tokens": audit["number_of_tokens"],
+            "Nombre de mots": audit["number_of_words"],
+            "Mots clés": audit["key_words"]
+        }
+        st.session_state.audit_simplified = audit_simplified
+    
+
+    
+    
+def display_audit(col:st):
+    #audit global simplifié
+    audit_simplified = st.session_state.audit_simplified
+    audit = st.session_state.audit["audit"]
+
+    well_formatted_audit = "Contenus audités\n"
+    for key, value in audit_simplified.items():
+        well_formatted_audit += f"- {key}: {value}\n"
+
+    col.code(well_formatted_audit)
+
+    if audit_simplified["type de fichier"] == "pdf": #cad un type qui contient des pages
+        #audit par page
+        with col.expander("Audit par page"):
+            number = st.number_input("Numéro de page", min_value=1, max_value=audit["number_of_pages"], value=1,key="number_page_audit")
+            audit_page = audit[f"page_{number-1}"]
+            audit_page = {
+                
+                "Nombre d'images": audit_page["number_of_images"],
+                "Nombre de liens": audit_page["number_of_links"],
+                "Nombre de tableaux": audit_page["number_of_tables"],
+                "Nombre de tokens": audit_page["number_of_tokens"],
+                "Nombre de mots": audit_page["number_of_words"],
+            }
+            well_formatted_audit_page = "Audit descriptif\n"
+            for key, value in audit_page.items():
+                well_formatted_audit_page += f"- {key}: {value}\n"
+            
+            st.code(well_formatted_audit_page)
+    
+
+
+def audit_main():
+
+    #st.set_page_config(page_title="Audit des documents", page_icon=":page_with_curl:", layout="wide")
+    # Streamlit app
+    st.title("Audit des documents")
+
+    notice = "Les formats autorisés sont les suivants :\n- **format texte** : txt, word, pdf\n- **format image** : png, jpg\n- **format audio** : wav, MP3"
+    
+    col1, col2 = st.columns([4, 3])
+    col1.markdown(notice)
+
+    if "audit" not in st.session_state:
+        st.session_state.audit = {}
+    if "name_file" not in st.session_state:
+        st.session_state.name_file = ""
+    if "audit_simplified" not in st.session_state:
+        st.session_state.audit_simplified = {}
+    if "vectorstore" not in st.session_state:
+        st.session_state.vectorstore = None
+    if "cr" not in st.session_state:
+        st.session_state.cr = ""
+    if "graph" not in st.session_state:
+        st.session_state.graph = None
+
+    # File uploader
+    uploaded_file = col1.file_uploader("Télécharger un ou plusieurs documents")
+
+    if uploaded_file is not None:
+        type = classify_file(uploaded_file)
+        handle_audit(uploaded_file,type)
+
+        col1.write(f"Type de fichier: {type}")
+
+        col1.write("### Synthèse audit de(s) document(s) téléchargé(s)")
+
+    if "audit" in st.session_state and st.session_state.audit != {}:
+        display_audit(col1)
+        handle_display_content(col2)
+        
+        #init graph and cr
+        
+        
+audit_main()

audit_page/compte_rendu.py

@@ -0,0 +1,130 @@
+import streamlit as st
+from textwrap import dedent
+from utils.audit.rag import get_text_from_content_for_doc,get_text_from_content_for_audio
+from utils.audit.response_llm import generate_response_via_langchain
+from langchain_core.messages import AIMessage, HumanMessage
+import pyperclip
+
+
+def cr_main():
+    st.title("Compte rendu")
+
+    if "audit" not in st.session_state or st.session_state.audit == {}:
+        st.error("Veuillez d'abord effectuer un audit pour générer un compte rendu.")
+        return
+    
+    if "cr" not in st.session_state:
+        st.session_state.cr = ""
+    
+    if "cr_chat_history" not in st.session_state:
+        st.session_state.cr_chat_history = [
+        ]
+    
+    audit = st.session_state.audit_simplified
+    content = st.session_state.audit["content"]
+
+    if audit["type de fichier"] == "pdf":
+        text = get_text_from_content_for_doc(content)
+    elif audit["type de fichier"] == "audio":
+        text = get_text_from_content_for_audio(content)
+
+    prompt_cr = dedent(f'''
+
+    À partir du document ci-dessous, générez un compte rendu détaillé contenant les sections suivantes :
+
+    2. **Résumé** : Fournissez une synthèse du document, en mettant en avant les points principaux, les relations essentielles, les concepts , les dates et les lieux, les conclusions et les détails importants.
+
+    3. **Notes** :
+    - Présentez les points clés sous forme de liste à puces avec des émojis pertinents pour souligner la nature de chaque point.
+    - N'oubliez pas de relever tout les entités et les relations.
+    - Incluez des sous-points (sans émojis) sous les points principaux pour offrir des détails ou explications supplémentaires.
+
+    4. **Actions** : Identifiez et listez les actions spécifiques, tâches ou étapes recommandées ou nécessaires selon le contenu du document.
+
+    **Document :**
+                       
+    {text}
+
+    **Format de sortie :**
+
+
+    ### Résumé :
+    [Fournissez un résumé concis du document ici;n'oubliez pas de relever tout les entités et les relations.]
+
+    ### Notes :
+    - 📌 **Point Principal 1**
+    - Sous-point A
+    - Sous-point B
+    - 📈 **Point Principal 2**
+    - Sous-point C
+    - Sous-point D
+    - 📝 **Point Principal 3**
+    - Sous-point E
+    - Sous-point F
+
+    ### Actions :
+    1. [Action 1]
+    2. [Action 2]
+    3. [Action 3]
+    4. ...
+
+    ---
+    ''')
+
+    
+
+    if st.button("Générer compte rendu"):
+
+        with st.spinner("Génération du compte rendu..."):
+            cr = generate_response_via_langchain(prompt_cr,stream=False,model="gpt-4o")
+            st.session_state.cr =  cr
+            st.session_state.cr_chat_history = []
+
+    else: 
+        cr = st.session_state.cr
+    
+    if cr:
+        col1, col2 = st.columns([2.5, 1.5])
+
+        with col1.container(border=True,height=800):
+            st.markdown("##### Compte rendu")
+            st.markdown("### Mots clés extraits:")
+            st.write(f"- {audit['Mots clés'].strip()}")
+            st.write(cr)
+            # if st.button("📋",key="copy_transcription"):
+            #     #pyperclip.copy(cr)
+            #     st.success("Transcription copiée dans le presse-papier")
+            
+        with col2.container(border=True,height=800):
+            st.markdown("##### Dialoguer avec le CR")
+
+            user_query = st.chat_input("Par ici ...")
+            if user_query is not None and user_query != "":
+                st.session_state.cr_chat_history.append(HumanMessage(content=user_query))
+
+            with st.container(height=650, border=False):
+                for message in st.session_state.cr_chat_history:
+                    if isinstance(message, AIMessage):
+                        with st.chat_message("AI"):
+                            st.markdown(message.content)
+                    elif isinstance(message, HumanMessage):
+                        with st.chat_message("Moi"):
+                            st.write(message.content)
+            
+                #check if last message is human message
+                if len(st.session_state.cr_chat_history) > 0:
+                    last_message = st.session_state.cr_chat_history[-1]
+                    if isinstance(last_message, HumanMessage):
+                        with st.chat_message("AI"):
+                            retreive = st.session_state.vectorstore.as_retriever()
+                            context = retreive.invoke(last_message.content)
+                            wrapped_prompt = f'''Étant donné le contexte suivant {context} et le compte rendu du document {cr}, {last_message.content}'''
+                            response = st.write_stream(generate_response_via_langchain(wrapped_prompt,stream=True))
+                            st.session_state.cr_chat_history.append(AIMessage(content=response))
+
+                
+cr_main()
+
+
+
+    

audit_page/dialogue_doc.py

@@ -0,0 +1,337 @@
+import streamlit as st
+from textwrap import dedent
+from utils.audit.rag import get_text_from_content_for_doc,get_text_from_content_for_audio
+from utils.audit.response_llm import generate_response_via_langchain
+from langchain_core.messages import AIMessage, HumanMessage
+from st_copy_to_clipboard import st_copy_to_clipboard
+from utils.kg.construct_kg import get_graph
+from audit_page.knowledge_graph import *
+import json
+import clipboard
+from time import sleep
+
+def graph_doc_to_json(graph):
+    nodes = []
+    edges = []
+    for node in graph.nodes:
+        node_id = node.id.replace(" ", "_")
+        label = node.id
+        type = node.type
+        nodes.append({"id": node_id, "label": label, "type": type})
+    for relationship in graph.relationships:
+        source = relationship.source
+        source_id = source.id.replace(" ", "_")
+        target = relationship.target
+        target_id = target.id.replace(" ", "_")
+        label = relationship.type
+        edges.append({"source": source_id, "label": label, "cible": target_id})
+    return {"noeuds": nodes, "relations": edges}
+
+def chat_history_formatter(chat_history):
+    formatted_chat = ""
+    for message in chat_history:
+        if isinstance(message, AIMessage):
+            formatted_chat += f"AI:{message.content}\n\n"
+        elif isinstance(message, HumanMessage):
+            formatted_chat += f"Human:{message.content}\n\n"
+    return formatted_chat
+
+def filter_correspondance(source_list:list[str],ref_dict:dict,reverse=False):
+    source_list = [item.lower().strip() for item in source_list]
+    if reverse:
+        return [key for key, value in ref_dict.items() if value.lower().strip() in source_list]
+    else:
+        # st.write(source_list)
+        # st.write(ref_dict.keys())
+        return [value for key, value in ref_dict.items() if key.lower().strip() in source_list]
+    
+@st.fragment()
+def radio_choice():
+    options = ["compte_rendu","graphe de connaissance"]
+    choice = st.radio("Choisissez une option",options,index=st.session_state.radio_choice,horizontal=True,label_visibility="collapsed")
+    sleep(1)
+    if choice and options.index(choice) != st.session_state.radio_choice:
+        sleep(1)
+        st.session_state.radio_choice = options.index(choice)
+    return choice
+
+
+def doc_dialog_main():
+    st.title("Dialogue avec le document")
+
+    if "audit" not in st.session_state or st.session_state.audit == {}:
+        st.error("Veuillez d'abord effectuer un audit pour générer le compte rendu ou le graphe de connaissance.")
+        return
+    
+    #init cr and chat history cr
+    if "cr" not in st.session_state:
+        st.session_state.cr = ""
+    if "cr_chat_history" not in st.session_state:
+        st.session_state.cr_chat_history = [
+        ]
+
+    #init graph and filter views
+    if "graph" not in st.session_state:
+        st.session_state.graph = None
+    
+    if "filter_views" not in st.session_state:
+        st.session_state.filter_views = {}
+    if "current_view" not in st.session_state:
+        st.session_state.current_view = None
+    if "node_types" not in st.session_state:
+        st.session_state.node_types = None
+    # if "summary" not in st.session_state:
+    #     st.session_state.summary = None
+    if "chat_graph_history" not in st.session_state:
+        st.session_state.chat_graph_history = []
+    
+    #init a radio button for the choice
+    if "radio_choice" not in st.session_state:
+        st.session_state.radio_choice = None
+    # if "choice" not in st.session_state:
+    #     st.session_state.choice = st.radio("Choisissez une option",["compte_rendu","graphe de connaissance"],index=st.session_state.radio_choice,horizontal=True,label_visibility="collapsed")
+
+    # choice = radio_choice()
+    
+    options = ["compte_rendu","graphe de connaissance"]
+    choice = st.radio("Choisissez une option",options,index=st.session_state.radio_choice,horizontal=True,label_visibility="collapsed")
+    if choice and options.index(choice) != st.session_state.radio_choice:
+        st.session_state.radio_choice = options.index(choice)
+        
+    
+    audit = st.session_state.audit_simplified
+    content = st.session_state.audit["content"]
+
+    if audit["type de fichier"] == "pdf":
+        text = get_text_from_content_for_doc(content)
+    elif audit["type de fichier"] == "audio":
+        text = get_text_from_content_for_audio(content)
+    elif audit["type de fichier"] == "text":
+        text = content
+
+    prompt_cr = dedent(f'''
+
+                À partir du document ci-dessous, générez un compte rendu détaillé contenant les sections suivantes :
+
+                2. **Résumé** : Fournissez une synthèse complète du document, en mettant en avant les points principaux, les relations essentielles, les concepts , les dates et les lieux, les conclusions et les détails importants.
+
+                3. **Notes** :
+                - Présentez les points clés sous forme de liste à puces avec des émojis pertinents pour souligner la nature de chaque point.
+                - N'oubliez pas de relever tout les entités et les relations.
+                - Incluez des sous-points (sans émojis) sous les points principaux pour offrir des détails ou explications supplémentaires.
+
+                4. **Actions** : Identifiez et listez les actions spécifiques, tâches ou étapes recommandées ou nécessaires selon le contenu du document.
+
+                **Document :**
+                                
+                {text}
+
+                **Format de sortie :**
+
+
+                ### Résumé :
+                [Fournissez un résumé concis du document ici;n'oubliez pas de relever tout les entités et les relations.]
+
+                ### Notes :
+                - 📌 **Point Principal 1**
+                - Sous-point A
+                - Sous-point B
+                - 📈 **Point Principal 2**
+                - Sous-point C
+                - Sous-point D
+                - 📝 **Point Principal 3**
+                - Sous-point E
+                - Sous-point F
+
+                ### Actions :
+                1. [Action 1]
+                2. [Action 2]
+                3. [Action 3]
+                4. ...
+
+                ---
+                ''')
+
+
+    if choice == "compte_rendu":
+        if "cr" not in st.session_state or st.session_state.cr == "":
+            with st.spinner("Génération du compte rendu..."):
+                cr = generate_response_via_langchain(prompt_cr,stream=False,model="gpt-4o")
+                st.session_state.cr =  cr
+                st.session_state.cr_chat_history = []
+        else:
+            cr = st.session_state.cr
+
+        if cr:
+            col1, col2 = st.columns([2.5, 1.5])
+
+            with col1.container(border=True,height=850):
+                st.markdown("##### Compte rendu")
+                keywords_paragraph = f"### Mots clés extraits:\n- {audit['Mots clés'].strip()}"
+                with st.container(height=650,border=False):
+                    st.markdown(keywords_paragraph)
+                    st.write(cr)
+                # col_copy , col_success = st.columns([1,11])
+                # if col_copy.button("📋",key="copy_cr"):
+                with st.container(height=50,border=False):
+                    st_copy_to_clipboard(keywords_paragraph+"\n\n"+cr,key="cp_but_cr")
+                    # col_success.success("Compte rendu copié dans le presse-papier")
+                
+            with col2.container(border=True,height=850):
+                st.markdown("##### Dialoguer avec le CR")
+
+                user_query = st.chat_input("Par ici ...")
+                if user_query is not None and user_query != "":
+                    st.session_state.cr_chat_history.append(HumanMessage(content=user_query))
+
+                with st.container(height=600, border=False):
+                    for message in st.session_state.cr_chat_history:
+                        if isinstance(message, AIMessage):
+                            with st.chat_message("AI"):
+                                st.markdown(message.content)
+                        elif isinstance(message, HumanMessage):
+                            with st.chat_message("Human"):
+                                st.write(message.content)
+                
+                    #check if last message is human message
+                    if len(st.session_state.cr_chat_history) > 0:
+                        last_message = st.session_state.cr_chat_history[-1]
+                        if isinstance(last_message, HumanMessage):
+                            with st.chat_message("AI"):
+                                retreive = st.session_state.vectorstore.as_retriever()
+                                context = retreive.invoke(last_message.content)
+                                wrapped_prompt = f'''Étant donné le contexte suivant {context} et le compte rendu du document {cr}, {last_message.content}'''
+                                response = st.write_stream(generate_response_via_langchain(wrapped_prompt,stream=True))
+                                st.session_state.cr_chat_history.append(AIMessage(content=response))
+                # col_copy_c , col_success_c = st.columns([1,7])
+                # if col_copy_c.button("📋",key="copy_cr_chat"):
+                with st.container(height=50,border=False):
+                    chat_formatted = chat_history_formatter(st.session_state.cr_chat_history)
+                    st_copy_to_clipboard(chat_formatted,key="cp_but_cr_chat",show_text=False)
+                # col_success_c.success("Historique copié !")
+
+    elif choice == "graphe de connaissance":
+        if "graph" not in st.session_state or st.session_state.graph == None:
+            with st.spinner("Génération du graphe..."):
+                keywords_list = [keyword.strip() for keyword in audit["Mots clés"].strip().split(",")]
+                allowed_nodes_types =keywords_list+ ["Person","Organization","Location","Event","Date","Time","Ressource","Concept"]
+
+                number_tokens = audit["Nombre de tokens"]
+                if number_tokens > 10000:
+                    if st.session_state.cr == "":
+                        st.session_state.cr = generate_response_via_langchain(prompt_cr,stream=False,model="gpt-4o")
+                    text = st.session_state.cr
+                
+                graph = get_graph(text,allowed_nodes=allowed_nodes_types)
+                st.session_state.graph = graph
+                st.session_state.filter_views = {}
+                st.session_state.current_view = None
+                st.session_state.node_types = None
+                st.session_state.chat_graph_history = []
+            
+            node_types = get_node_types(graph[0])
+            list_node_types = list(node_types)
+            sorted_node_types = sorted(list_node_types,key=lambda x: x.lower())
+            print(sorted_node_types)
+            nodes_type_dict = list_to_dict_colors(sorted_node_types)
+            st.session_state.node_types = nodes_type_dict
+            st.session_state.filter_views["Vue par défaut"] = list(node_types)
+            st.session_state.current_view = "Vue par défaut"
+        else:
+            graph = st.session_state.graph
+        
+        if graph is not None:
+            #st.write(graph)
+            
+            edges,nodes,config = convert_neo4j_to_agraph(graph[0],st.session_state.node_types)
+            
+            col1, col2 = st.columns([2.5, 1.5])
+
+            with col1.container(border=True,height=850):
+                st.write("##### Visualisation du graphe (**"+st.session_state.current_view+"**)")
+                filter_col,add_view_col,change_view_col,color_col = st.columns([9,1,1,1])
+                
+                if color_col.button("🎨",help="Changer la couleur"):
+                    change_color_dialog()
+                    
+                if change_view_col.button("🔍",help="Changer de vue"):
+                    change_view_dialog()
+
+                
+                #add mots cles to evry label in audit["Mots clés"]
+                #filter_labels = [ label + " (mot clé)" if label.strip().lower() in audit["Mots clés"].strip().lower().split(",") else label for label in st.session_state.filter_views[st.session_state.current_view] ]
+                keywords_list = [keyword.strip().lower() for keyword in audit["Mots clés"].strip().split(",")]
+                dict_filters = {label: "Mot clé : "+label if label.strip().lower() in keywords_list else label for label in st.session_state.filter_views[st.session_state.current_view]}
+                
+                default_target_filter = filter_correspondance(st.session_state.filter_views[st.session_state.current_view],dict_filters)
+                # st.write(default_target_filter)
+                # st.write(dict_filters)
+                sorted_default_target_filter = sorted(default_target_filter,key=lambda x: x.lower())
+                target_filter = filter_correspondance(list(st.session_state.node_types.keys()),dict_filters)
+                target_filter = sorted(target_filter,key=lambda x: x.lower())
+                filter = filter_col.multiselect("Filtrer selon l'étiquette",target_filter,placeholder="Sélectionner une ou plusieurs étiquettes",default=default_target_filter,label_visibility="collapsed")
+                filter = filter_correspondance(filter,dict_filters,reverse=True)
+                if add_view_col.button("➕",help="Ajouter une vue"):
+                    add_view_dialog(filter)
+                if filter:
+                    nodes = filter_nodes_by_types(nodes,filter) 
+
+                selected = display_graph(edges,nodes,config)
+
+                # col_copy , col_success = st.columns([1,11])
+                # if col_copy.button("📋",key="copy_graph"):
+                with st.container(height=50,border=False):
+                    graph_json = graph_doc_to_json(graph[0])
+                    st_copy_to_clipboard(json.dumps(graph_json),key="cp_but_graph")
+                    # col_success.success("Graphe copié dans le presse-papier")
+
+            with col2.container(border=True,height=850):
+                st.markdown("##### Dialoguer avec le graphe")
+
+                user_query = st.chat_input("Par ici ...")
+                if user_query is not None and user_query != "":
+                    st.session_state.chat_graph_history.append(HumanMessage(content=user_query))
+
+                with st.container(height=600, border=False):
+                    for message in st.session_state.chat_graph_history:
+                        if isinstance(message, AIMessage):
+                            with st.chat_message("AI"):
+                                st.markdown(message.content)
+                        elif isinstance(message, HumanMessage):
+                            with st.chat_message("Human"):
+                                st.write(message.content)
+                    
+                    #check if last message is human message
+                    if len(st.session_state.chat_graph_history) > 0:
+                        last_message = st.session_state.chat_graph_history[-1]
+                        if isinstance(last_message, HumanMessage):
+                            with st.chat_message("AI"):
+                                retreive = st.session_state.vectorstore.as_retriever()
+                                context = retreive.invoke(last_message.content)
+                                wrapped_prompt = f"Étant donné le contexte suivant {context}, et le graph de connaissance: {graph}, {last_message.content}"
+                                response = st.write_stream(generate_response_via_langchain(wrapped_prompt,stream=True))
+                                st.session_state.chat_graph_history.append(AIMessage(content=response))
+
+                    if selected is not None:
+                            with st.chat_message("AI"):
+                                st.markdown(f" EXPLORER LES DONNEES CONTENUES DANS **{selected}**")
+
+                                prompts = [f"Extrait moi toutes les informations du noeud ''{selected}'' ➡️",
+                                        f"Montre moi les conversations autour du noeud ''{selected}'' ➡️"]
+                                
+                                for i,prompt in enumerate(prompts):
+                                    button = st.button(prompt,key=f"p_{i}",on_click=lambda i=i: st.session_state.chat_graph_history.append(HumanMessage(content=prompts[i])))
+                
+                # col_copy_c , col_success_c = st.columns([1,7])
+                # if col_copy_c.button("📋",key="copy_graph_chat"):
+                with st.container(height=50,border=False):
+                    st_copy_to_clipboard(chat_history_formatter(st.session_state.chat_graph_history),key="cp_but_graph_chat",show_text=False)   
+                    # col_success_c.success("Historique copié !")
+            
+
+
+doc_dialog_main()
+
+
+
+    

audit_page/knowledge_graph.py

@@ -0,0 +1,333 @@
+import streamlit as st
+from utils.kg.construct_kg import get_graph
+from utils.audit.rag import get_text_from_content_for_doc,get_text_from_content_for_audio
+from streamlit_agraph import agraph, Node, Edge, Config
+import random
+import math
+from utils.audit.response_llm import generate_response_via_langchain
+from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.prompts import PromptTemplate
+
+def if_node_exists(nodes, node_id):
+    """
+    Check if a node exists in the graph.
+
+    Args:
+        graph (dict): A dictionary representing the graph with keys 'nodes' and 'relationships'.
+        node_id (str): The id of the node to check.
+
+    Returns:
+        return_value: True if the node exists, False otherwise.
+    """
+    for node in nodes:
+        if node.id == node_id:
+            return True
+    return False
+
+def generate_random_color():
+    r = random.randint(180, 255)
+    g = random.randint(180, 255)
+    b = random.randint(180, 255)
+    return (r, g, b)
+
+def rgb_to_hex(rgb):
+    return '#{:02x}{:02x}{:02x}'.format(rgb[0], rgb[1], rgb[2])
+
+def get_node_types(graph):
+    node_types = set()
+    for node in graph.nodes:
+        node_types.add(node.type)
+    for relationship in graph.relationships:
+        source = relationship.source
+        target = relationship.target
+        node_types.add(source.type)
+        node_types.add(target.type)
+    return node_types
+
+def color_distance(color1, color2):
+    # Calculate Euclidean distance between two RGB colors
+    return math.sqrt((color1[0] - color2[0]) ** 2 + (color1[1] - color2[1]) ** 2 + (color1[2] - color2[2]) ** 2)
+
+def generate_distinct_colors(num_colors, min_distance=30):
+    colors = []
+    while len(colors) < num_colors:
+        new_color = generate_random_color()
+        if all(color_distance(new_color, existing_color) >= min_distance for existing_color in colors):
+            colors.append(new_color)
+    return [rgb_to_hex(color) for color in colors]
+
+def list_to_dict_colors(node_types:set):
+
+    number_of_colors = len(node_types)
+    colors = generate_distinct_colors(number_of_colors)
+
+    node_colors = {}
+    for i, node_type in enumerate(node_types):
+        node_colors[node_type] = colors[i]
+    
+    return node_colors
+
+
+def convert_neo4j_to_agraph(neo4j_graph, node_colors):
+    """
+    Converts a Neo4j graph into an Agraph format.
+
+    Args:
+        neo4j_graph (dict): A dictionary representing the Neo4j graph with keys 'nodes' and 'relationships'.
+                            'nodes' is a list of dicts with each dict having 'id' and 'type' keys.
+                            'relationships' is a list of dicts with 'source', 'target', and 'type' keys.
+
+    Returns:
+        return_value: The Agraph visualization object.
+    """
+    nodes = []
+    edges = []
+
+    # Creating Agraph nodes
+    for node in neo4j_graph.nodes:
+        # Use the node id as the Agraph node id
+        node_id = node.id.replace(" ", "_")  # Replace spaces with underscores for ids
+        label = node.id
+        type = node.type
+        size = 25  # Default size, can be customized
+        shape = "circle"  # Default shape, can be customized
+        
+        # For example purposes, no images are added, but you can set 'image' if needed.
+        new_node = Node(id=node_id,title=type, label=label, size=size, shape=shape,color=node_colors[type])
+        if not if_node_exists(nodes, new_node.id):
+            nodes.append(new_node)
+
+    # Creating Agraph edges
+    for relationship in neo4j_graph.relationships:
+        size = 25  # Default size, can be customized
+        shape = "circle"  # Default shape, can be customized
+
+        source = relationship.source
+        source_type = source.type
+        source_id = source.id.replace(" ", "_")
+        label_source = source.id
+        
+        source_node = Node(id=source_id,title=source_type, label=label_source, size=size, shape=shape,color=node_colors[source_type])
+        if not if_node_exists(nodes, source_node.id):
+            nodes.append(source_node)
+
+        target = relationship.target
+        target_type = target.type
+        target_id = target.id.replace(" ", "_")
+        label_target = target.id
+        
+        target_node = Node(id=target_id,title=target_type, label=label_target, size=size, shape=shape,color=node_colors[target_type])
+        if not if_node_exists(nodes, target_node.id):
+            nodes.append(target_node)
+
+        label = relationship.type
+
+        edges.append(Edge(source=source_id, label=label, target=target_id))
+
+    # Define the configuration for Agraph
+    config = Config(width=1200, height=800, directed=True, physics=True, hierarchical=True,from_json="config.json")
+    # Create the Agraph visualization
+
+    return edges, nodes, config
+
+def display_graph(edges, nodes, config):
+    # Display the Agraph visualization
+    return agraph(edges=edges, nodes=nodes, config=config)
+
+
+
+def filter_nodes_by_types(nodes:list[Node], node_types_filter:list) -> list[Node]:
+    filtered_nodes = []
+    for node in nodes:
+        if node.title in node_types_filter: #the title represents the type of the node
+            filtered_nodes.append(node)
+    return filtered_nodes
+
+@st.dialog(title="Changer la vue")
+def change_view_dialog():
+    st.write("Changer la vue")
+    
+    for index, item in enumerate(st.session_state.filter_views.keys()):
+        emp = st.empty()
+        col1, col2, col3 = emp.columns([8, 1, 1])
+
+        if index > 0 and col2.button("🗑️", key=f"del{index}"):
+            del st.session_state.filter_views[item]
+            st.session_state.current_view = "Vue par défaut"
+            st.rerun()
+        but_content = "🔍" if st.session_state.current_view != item else "✅"
+        if col3.button(but_content, key=f"valid{index}"):
+            st.session_state.current_view = item
+            st.rerun()
+        if len(st.session_state.filter_views.keys()) > index:
+            with col1.expander(item):
+                if index > 0:
+                    change_name = st.text_input("Nom de la vue", label_visibility="collapsed", placeholder="Changez le nom de la vue",key=f"change_name{index}")
+                    if st.button("Renommer",key=f"rename{index}"):
+                        if change_name != "":
+                            st.session_state.filter_views[change_name] = st.session_state.filter_views.pop(item)
+                            st.session_state.current_view = change_name
+                            st.rerun()
+                st.markdown("\n".join(f"- {label.strip()}" for label in st.session_state.filter_views[item]))
+        else:
+            emp.empty()
+
+@st.dialog(title="Ajouter une vue")
+def add_view_dialog(filters):
+    st.write("Ajouter une vue")
+    view_name = st.text_input("Nom de la vue")
+    st.markdown("les filtres actuels:")
+    st.write(filters)
+    if st.button("Ajouter la vue"):
+        st.session_state.filter_views[view_name] = filters
+        st.session_state.current_view = view_name
+        st.rerun()
+
+@st.dialog(title="Changer la couleur")
+def change_color_dialog():
+    st.write("Changer la couleur")
+    for node_type,color in st.session_state.node_types.items():
+        color = st.color_picker(f"La couleur de l'entité **{node_type.strip()}**",color)
+        st.session_state.node_types[node_type] = color
+    
+    if st.button("Valider"):
+        st.rerun()
+
+
+
+def kg_main():
+    #st.set_page_config(page_title="Graphe de connaissance", page_icon="", layout="wide")
+    
+
+    
+    if "audit" not in st.session_state or st.session_state.audit == {}:
+        st.error("Veuillez d'abord effectuer un audit pour visualiser le graphe de connaissance.")
+        return
+    
+    if "cr" not in st.session_state:
+        st.error("Veuillez d'abord effectuer un compte rendu pour visualiser le graphe de connaissance.")
+        return
+    
+    if "graph" not in st.session_state:
+        st.session_state.graph = None
+    
+    if "filter_views" not in st.session_state:
+        st.session_state.filter_views = {}
+    if "current_view" not in st.session_state:
+        st.session_state.current_view = None
+
+    st.title("Graphe de connaissance")
+
+    if "node_types" not in st.session_state:
+        st.session_state.node_types = None
+    
+    if "summary" not in st.session_state:
+        st.session_state.summary = None
+
+    if "chat_graph_history" not in st.session_state:
+        st.session_state.chat_graph_history = []
+    
+    audit = st.session_state.audit_simplified
+    # content = st.session_state.audit["content"]
+
+    # if audit["type de fichier"] == "pdf":
+    #     text = get_text_from_content_for_doc(content)
+    # elif audit["type de fichier"] == "audio":
+    #     text = get_text_from_content_for_audio(content)
+
+    text = st.session_state.cr + "mots clés" + audit["Mots clés"]
+    
+    #summary_prompt = f"Voici un ensemble de documents : {text}. À partir de ces documents, veuillez fournir des résumés concis en vous concentrant sur l'extraction des relations essentielles et des événements. Il est crucial d'inclure les dates des actions ou des événements, car elles seront utilisées pour l'analyse chronologique. Par exemple : 'Sam a été licencié par le conseil d'administration d'OpenAI le 17 novembre 2023 (17 novembre, vendredi)', ce qui illustre la relation entre Sam et OpenAI ainsi que la date de l'événement."
+
+    if st.button("Générer le graphe"):
+        # with st.spinner("Extractions des relations..."):
+        #     sum = generate_response_openai(summary_prompt,model="gpt-4o")
+        #     st.session_state.summary = sum
+
+        with st.spinner("Génération du graphe..."):
+            keywords_list = audit["Mots clés"].strip().split(",")
+            allowed_nodes_types =keywords_list+ ["Person","Organization","Location","Event","Date","Time","Ressource","Concept"]
+            graph = get_graph(text,allowed_nodes=allowed_nodes_types)
+            st.session_state.graph = graph
+        
+        node_types = get_node_types(graph[0])
+        nodes_type_dict = list_to_dict_colors(node_types)
+        st.session_state.node_types = nodes_type_dict
+        st.session_state.filter_views["Vue par défaut"] = list(node_types)
+        st.session_state.current_view = "Vue par défaut"
+
+    else:
+        graph = st.session_state.graph
+
+    if graph is not None:
+        #st.write(graph)
+        
+        edges,nodes,config = convert_neo4j_to_agraph(graph[0],st.session_state.node_types)
+        
+        col1, col2 = st.columns([2.5, 1.5])
+
+        with col1.container(border=True,height=800):
+            st.write("##### Visualisation du graphe (**"+st.session_state.current_view+"**)")
+            filter_col,add_view_col,change_view_col,color_col = st.columns([9,1,1,1])
+            
+            if color_col.button("🎨",help="Changer la couleur"):
+                change_color_dialog()
+                
+            if change_view_col.button("🔍",help="Changer de vue"):
+                change_view_dialog()
+
+            
+            #add mots cles to evry label in audit["Mots clés"]
+            #filter_labels = [ label + " (mot clé)" if label.strip().lower() in audit["Mots clés"].strip().lower().split(",") else label for label in st.session_state.filter_views[st.session_state.current_view] ]
+            filter = filter_col.multiselect("Filtrer selon l'étiquette",st.session_state.node_types.keys(),placeholder="Sélectionner une ou plusieurs étiquettes",default=st.session_state.filter_views[st.session_state.current_view],label_visibility="collapsed")
+            
+            if add_view_col.button("➕",help="Ajouter une vue"):
+                add_view_dialog(filter)
+            
+            if filter:
+                nodes = filter_nodes_by_types(nodes,filter) 
+
+            selected = display_graph(edges,nodes,config)
+
+        with col2.container(border=True,height=800):
+            st.markdown("##### Dialoguer avec le graphe")
+
+            user_query = st.chat_input("Par ici ...")
+            if user_query is not None and user_query != "":
+                st.session_state.chat_graph_history.append(HumanMessage(content=user_query))
+
+            with st.container(height=650, border=False):
+                for message in st.session_state.chat_graph_history:
+                    if isinstance(message, AIMessage):
+                        with st.chat_message("AI"):
+                            st.markdown(message.content)
+                    elif isinstance(message, HumanMessage):
+                        with st.chat_message("Moi"):
+                            st.write(message.content)
+                
+                #check if last message is human message
+                if len(st.session_state.chat_graph_history) > 0:
+                    last_message = st.session_state.chat_graph_history[-1]
+                    if isinstance(last_message, HumanMessage):
+                        with st.chat_message("AI"):
+                            retreive = st.session_state.vectorstore.as_retriever()
+                            context = retreive.invoke(last_message.content)
+                            wrapped_prompt = f"Étant donné le contexte suivant {context}, et le graph de connaissance: {graph}, {last_message.content}"
+                            response = st.write_stream(generate_response_via_langchain(wrapped_prompt,stream=True))
+                            st.session_state.chat_graph_history.append(AIMessage(content=response))
+
+                if selected is not None:
+                        with st.chat_message("AI"):
+                            st.markdown(f" EXPLORER LES DONNEES CONTENUES DANS **{selected}**")
+
+                            prompts = [f"Extrait moi toutes les informations du noeud ''{selected}'' ➡️",
+                                    f"Montre moi les conversations autour du noeud ''{selected}'' ➡️"]
+                            
+                            for i,prompt in enumerate(prompts):
+                                button = st.button(prompt,key=f"p_{i}",on_click=lambda i=i: st.session_state.chat_graph_history.append(HumanMessage(content=prompts[i])))
+            
+            
+
+
+    node_types = st.session_state.node_types
+    

chatbot_page/chatbot.py

@@ -0,0 +1,119 @@
+import streamlit as st
+from langchain_openai import ChatOpenAI
+from langchain_mistralai import ChatMistralAI
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.messages import AIMessage, HumanMessage
+
+def get_response(user_query, chat_history, context,llm=None,history_limit=5,stream=True):
+
+    template = """
+    Étant donné l'historique de la conversation : {chat_history}, le contexte : {context}, et la question de l'utilisateur : {user_question}, veuillez fournir une réponse détaillée et complète. La réponse doit inclure un ou plusieurs des éléments suivants :
+
+    1. Une explication claire des concepts clés et des termes liés au sujet.
+    2. Un aperçu des meilleures pratiques, des stratégies courantes ou des cadres de référence pertinents pour la discussion.
+    3. Des exemples spécifiques ou des études de cas illustrant les principes abordés.
+    4. Les défis potentiels ou les considérations à prendre en compte.
+    5. Des suggestions de ressources supplémentaires ou des actions que l'utilisateur peut entreprendre pour approfondir sa compréhension.
+
+    Assurez-vous que la réponse soit adaptée au niveau d'expertise de l'utilisateur et aux spécificités du contexte fourni.
+
+    """
+
+    prompt = ChatPromptTemplate.from_template(template)
+
+    #llm = ChatOpenAI(model="gpt-4o")
+    if not llm:
+        llm = ChatOpenAI(model="gpt-4o-mini")
+    elif llm == "GPT-4o":
+        llm = ChatOpenAI(model="gpt-4o")
+    elif llm == "Mistral Large 2 (FR)":
+        llm = ChatMistralAI(model_name="mistral-large-2407")
+    elif llm == "GPT-4o-mini":
+        llm = ChatOpenAI(model="gpt-4o-mini")
+    elif llm == "Mistral Nemo (FR)":
+        llm = ChatMistralAI(model_name="open-mistral-nemo-2407")
+    
+        
+    chain = prompt | llm
+
+    if not stream:
+        return chain.invoke({
+            "context": context,
+            "chat_history": chat_history[-history_limit:],
+            "user_question": user_query,
+        })
+    
+    chain = chain | StrOutputParser()
+
+    if history_limit:
+        return chain.stream({
+            "context": context,
+            "chat_history": chat_history[-history_limit:],
+            "user_question": user_query,
+        })
+    
+    return chain.stream({
+        "context": context,
+        "chat_history": chat_history,
+        "user_question": user_query,
+    })
+
+def handle_display_models(index, models_names):
+    model = st.radio("Choisir un modèle",models_names, index=index)
+    return model
+
+
+def chatbot_main():
+    st.title("Chatbot")
+    models_names = ["GPT-4o", "GPT-4o-mini"]
+
+    if "chat_history" not in st.session_state:
+        st.session_state.chat_history = [
+            AIMessage(content="Salut, Que puis-je faire pour vous ?"),
+        ]
+
+    if "model" not in st.session_state:
+        st.session_state.model = "GPT-4o-mini"
+
+    header = st.container()
+    col1, col2 = header.columns([1, 2])
+
+    with col1.popover("Modèles disponibles"):
+        new_model = handle_display_models(models_names.index(st.session_state.model), models_names)
+
+    st.session_state.model = new_model
+    
+    st.markdown(f"- **{st.session_state.model}**")
+
+    for message in st.session_state.chat_history:
+        if isinstance(message, AIMessage):
+            with st.chat_message("AI"):
+                st.markdown(message.content)
+        elif isinstance(message, HumanMessage):
+            with st.chat_message("Moi"):
+                st.write(message.content)
+    
+    if "response_llm" not in st.session_state:
+        st.session_state.response_llm = ""
+    
+    user_query = st.chat_input("Par ici ...")
+    if user_query is not None and user_query != "":
+        st.session_state.chat_history.append(HumanMessage(content=user_query))
+
+        with st.chat_message("Moi"):
+            st.markdown(user_query)
+        
+        with st.chat_message("AI"):
+            st.markdown(f"**{st.session_state.model}**")
+    
+
+            response = st.write_stream(get_response(user_query, st.session_state.chat_history, context=st.session_state.response_llm, llm=st.session_state.model, stream=True))
+            st.session_state.chat_history.append(AIMessage(content=response))
+
+        
+
+
+
+
+chatbot_main()

config.json

@@ -0,0 +1,26 @@
+{
+    "height": "600px",
+    "width": "1200px",
+    "autoResize": true,
+
+    "physics":{
+        "enabled": true,
+
+        "barnesHut": {
+            "avoidOverlap": 1,
+            "theta": 0.1,
+            "gravitationalConstant": -10000,
+            "centralGravity": 1,
+            "springLength": 50,
+            "springConstant": 0,
+            "damping": 0.5
+        },
+        "stabilization": {
+            "enabled": true,
+            "iterations": 1000,
+            "updateInterval": 50,
+            "onlyDynamicEdges": false,
+            "fit": true
+        }
+      }
+}

doc_page/documentation.py

@@ -0,0 +1,3 @@
+import streamlit as st
+
+st.title("Documentation")

packages.txt

@@ -0,0 +1,3 @@
+xclip
+xsel
+python3-pyperclip

requirements.txt

@@ -0,0 +1,28 @@
+streamlit==1.37.0
+pyperclip
+tiktoken
+pydub 
+numpy 
+scipy
+textstat
+pymupdf
+openai
+nltk
+rake_nltk
+python-docx
+pillow
+pandas
+langchain
+langchain-core
+langchainhub
+langchain-openai
+langchain-mistralai
+faiss-cpu
+langchain-community
+python-dotenv
+langchain-experimental 
+neo4j
+streamlit-agraph
+st-copy-to-clipboard
+clipboard
+

utils/audit/audit_audio.py

@@ -0,0 +1,72 @@
+
+import numpy as np
+import scipy.io.wavfile as wavfile
+from pydub import AudioSegment
+import io
+import tiktoken
+from openai import OpenAI
+
+def transcript_audio_func(audio_file):
+    client = OpenAI()
+    transcription = client.audio.transcriptions.create(
+        model="whisper-1",
+        file=audio_file
+    )
+
+    return transcription.text
+
+def count_tokens(input_string: str) -> int:
+    tokenizer = tiktoken.get_encoding("cl100k_base")
+    tokens = tokenizer.encode(input_string)
+    return len(tokens)
+
+# Function to calculate SNR
+def calculate_snr(audio_data):
+    signal = audio_data
+    noise = audio_data - np.mean(audio_data)
+    signal_power = np.mean(signal ** 2)
+    noise_power = np.mean(noise ** 2)
+    snr = 10 * np.log10(signal_power / noise_power)
+    return snr
+
+# Function to evaluate audio quality
+def evaluate_audio_quality(file) -> dict:
+    try:
+        audio = AudioSegment.from_file(file)
+    except:
+        audio = AudioSegment.from_file(io.BytesIO(file.read()))
+
+    audio_data = np.array(audio.get_array_of_samples())
+
+    #number of minutes
+    duration = len(audio_data) / audio.frame_rate*2 / 60
+
+    # Calculate volume
+    volume = audio.dBFS
+    
+    # Calculate SNR
+    snr = calculate_snr(audio_data)
+
+    #get the transcription of the audio
+    transcription = transcript_audio_func(file)
+
+    audit = {
+        "volume": volume,
+        "SNR": snr,
+        "duration": duration,
+        "number_of_tokens": count_tokens(transcription),
+        "number_of_words": len(transcription.split())
+    }
+
+    content = {
+        "transcription": transcription,
+        "audio_data": audio_data,
+        "frame_rate": audio.frame_rate
+    }
+
+    audit_global = {
+        "audit": audit,
+        "content": content
+    }
+    
+    return audit_global

utils/audit/audit_doc.py

@@ -0,0 +1,217 @@
+
+import pymupdf
+import tiktoken
+import textstat
+from docx import Document
+import io
+# from rake_nltk import Rake
+# import nltk
+# from nltk.corpus import stopwords
+from openai import OpenAI
+
+# Download NLTK stopwords
+# nltk.download('stopwords')
+# nltk.download('punkt')
+
+#function to use gpt4o-mini
+def extract_relevant_keywords(prompt: str) -> str:
+    client = OpenAI()
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
+            {"role": "user", "content": prompt}
+        ]
+    )
+    return response.choices[0].message.content
+
+
+def evaluate_text_quality(text: str) -> dict:
+    # Calculate readability metrics
+    flesch_reading_ease = textstat.flesch_reading_ease(text)
+    flesch_kincaid_grade = textstat.flesch_kincaid_grade(text)
+    gunning_fog = textstat.gunning_fog(text)
+    smog_index = textstat.smog_index(text)
+    automated_readability_index = textstat.automated_readability_index(text)
+
+    # Normalize readability scores to a 0-1 scale
+    def normalize_score(score, min_score, max_score):
+        return (score - min_score) / (max_score - min_score)
+
+    # Normalize each readability score
+    n_flesch_reading_ease = normalize_score(flesch_reading_ease, 0, 100)
+    n_flesch_kincaid_grade = 1 - normalize_score(flesch_kincaid_grade, 0, 18)  # Higher is more difficult
+    n_gunning_fog = 1 - normalize_score(gunning_fog, 0, 18)  # Higher is more difficult
+    n_smog_index = 1 - normalize_score(smog_index, 0, 18)  # Higher is more difficult
+    n_automated_readability_index = 1 - normalize_score(automated_readability_index, 0, 18)  # Higher is more difficult
+
+    # Weights for each metric (adjust these as needed)
+    weights = {
+        "flesch_reading_ease": 0.25,
+        "flesch_kincaid_grade": 0.25,
+        "gunning_fog": 0.2,
+        "smog_index": 0.15,
+        "automated_readability_index": 0.15
+    }
+
+    # Calculate the global readability score
+    global_score = (
+        n_flesch_reading_ease * weights["flesch_reading_ease"] +
+        n_flesch_kincaid_grade * weights["flesch_kincaid_grade"] +
+        n_gunning_fog * weights["gunning_fog"] +
+        n_smog_index * weights["smog_index"] +
+        n_automated_readability_index * weights["automated_readability_index"]
+    )
+
+    # Scale the global score to 0-5
+    global_score_0_5 = global_score * 5
+
+# def extract_keywords(text):
+#     rake = Rake(stopwords.words('french'))
+#     rake.extract_keywords_from_text(text)
+#     return rake.get_ranked_phrases()
+
+
+
+def count_tokens(input_string: str) -> int:
+    tokenizer = tiktoken.get_encoding("cl100k_base")
+    tokens = tokenizer.encode(input_string)
+    return len(tokens)
+
+def audit_descriptif_pdf(file,max_img_width) -> dict:
+    document = pymupdf.open(stream=file.read())
+
+    audit_dict_doc = {
+        "number_of_pages": len(document),
+        "number_of_images": 0,
+        "number_of_links": 0,
+        "number_of_tables": 0,
+        "number_of_tokens": 0,
+        "number_of_words": 0,
+        "key_words": []
+    }
+
+    doc_content = dict()
+
+    for page in document:
+
+        audit_dict_page = {}
+        page_content = {
+            "images": [],
+            "texte": "",
+            "liens": [],
+            "tableaux": []
+        }
+
+        #number of images
+        images = page.get_images()
+        number_images = len(images)
+        audit_dict_page["number_of_images"] = number_images
+        audit_dict_doc["number_of_images"] += number_images
+        
+        #get images
+        for _, img in enumerate(images):
+            xref = img[0]
+            base_image = document.extract_image(xref)
+
+            image_bytes = base_image["image"]
+            image_width = base_image["width"]
+            image_height = base_image["height"]
+            
+            # Adjust image size if it exceeds the maximum width
+            if image_width > max_img_width:
+                ratio = max_img_width / image_width
+                image_width = max_img_width
+                image_height = int(image_height * ratio)
+            
+            page_content["images"].append((image_bytes, image_width, image_height))
+
+
+        
+        #get links with uri
+        links = []
+        for link in page.get_links():
+            if link['kind'] == pymupdf.LINK_URI and 'uri' in link:
+                links.append({"uri": link["uri"], "page": page.number})
+        
+        page_content["liens"] = links
+
+        #number of links
+        number_links = len(links)
+        audit_dict_page["number_of_links"] = number_links
+        audit_dict_doc["number_of_links"] += number_links
+
+        #number of tables
+        tables = page.find_tables().tables
+        number_tables = len(tables)
+        for tab in tables:
+            page_content["tableaux"].append(tab.to_pandas())
+        audit_dict_page["number_of_tables"] = number_tables
+        audit_dict_doc["number_of_tables"] += number_tables
+
+        #number of tokens and words
+        text = page.get_text("text")
+        number_tokens = count_tokens(text)
+        number_words = len(text.split())
+
+        audit_dict_page["number_of_tokens"] = number_tokens
+        audit_dict_page["number_of_words"] = number_words
+
+        #get text
+        page_content["texte"] = text
+
+        audit_dict_doc["number_of_tokens"] += number_tokens
+        audit_dict_doc["number_of_words"] += number_words
+
+        audit_dict_doc[f"page_{page.number}"] = audit_dict_page
+
+        doc_content[f"page_{page.number}"] = page_content
+    
+    # Extract key words from the document
+    text = " ".join([page["texte"] for page in doc_content.values()])
+    # key_words = extract_keywords(text)
+    # list_key_words_text = "\n".join(key_words[:10])
+    prompt = f'''Voici le document:
+        - {text}
+        Veuillez extraire les cinq mots clés les plus pertinents de cette liste. Chaque mot clé doit contenir au maximum deux mots.
+
+        TA REPONSE DOIT RESPECTER LE FORMAT SUIVANT :
+        key_word1, key_word2, key_word3, key_word4, key_word5
+    '''
+    key_words_extracted = extract_relevant_keywords(prompt)
+    audit_dict_doc["key_words"] = "\n" + key_words_extracted
+
+    #merge 2 dicts
+    global_audit = {
+        "audit": audit_dict_doc,
+        "content": doc_content
+    }
+
+    return global_audit
+
+def audit_text(text: str) -> dict:
+
+    prompt = f'''Voici le document:
+        - {text}
+        Veuillez extraire les cinq mots clés les plus pertinents de cette liste. Chaque mot clé doit contenir au maximum deux mots.
+
+        TA REPONSE DOIT RESPECTER LE FORMAT SUIVANT :
+        key_word1, key_word2, key_word3, key_word4, key_word5
+    '''
+    key_words_extracted = extract_relevant_keywords(prompt)
+    
+
+    audit_dict = {
+        "number_of_tokens": count_tokens(text),
+        "number_of_words": len(text.split()),
+    }
+
+    audit_dict["key_words"] = "\n" + key_words_extracted
+
+    global_audit = {
+        "audit": audit_dict,
+        "content": text
+    }
+
+    return global_audit
+
+

utils/audit/rag.py

@@ -0,0 +1,44 @@
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_openai import OpenAIEmbeddings
+from langchain_community.vectorstores import FAISS
+
+
+
+def get_text_from_content_for_doc(content):
+    text = ""
+    for page in content:
+        text += content[page]["texte"]
+    return text
+
+def get_text_from_content_for_audio(content):
+    return content["transcription"]
+
+
+def get_text_chunks(text):
+    text_splitter = RecursiveCharacterTextSplitter(
+        chunk_size=500, # the character length of the chunck
+        chunk_overlap=100, # the character length of the overlap between chuncks
+        length_function=len # the length function - in this case, character length (aka the python len() fn.)
+    )
+    chunks = text_splitter.split_text(text)
+    return chunks
+
+def get_vectorstore(text_chunks):
+    embedding = OpenAIEmbeddings(model="text-embedding-3-small")
+    vectorstore = FAISS.from_texts(texts=text_chunks, embedding=embedding)
+    return vectorstore
+
+def setup_rag(file_type,content):
+    if file_type == "pdf":
+        text = get_text_from_content_for_doc(content)
+    elif file_type == "audio":
+        text = get_text_from_content_for_audio(content)
+    
+
+    chunks = get_text_chunks(text)
+
+    vectorstore = get_vectorstore(chunks)
+    
+    return vectorstore
+
+

utils/audit/response_llm.py

@@ -0,0 +1,35 @@
+from openai import OpenAI
+from langchain_openai import ChatOpenAI
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import PromptTemplate
+
+def generate_response_openai(prompt: str,stream:bool = False,model = "gpt-4o-mini") -> str:
+    client = OpenAI()
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "user", "content": prompt}
+        ],
+        stream=stream
+    )
+    
+    return response.choices[0].message.content
+
+
+def generate_response_via_langchain(query: str, stream: bool = False, model: str = "gpt-4o-mini") :
+    # Define the prompt template
+    template = "{query}"
+    prompt = PromptTemplate.from_template(template)
+    
+    # Initialize the OpenAI LLM with the specified model
+    llm = ChatOpenAI(model=model)
+    
+    # Create an LLM chain with the prompt and the LLM
+    llm_chain = prompt | llm | StrOutputParser()
+
+    if stream:
+        # Return a generator that yields streamed responses
+        return llm_chain.stream({"query": query})
+    
+    # Invoke the LLM chain and return the result
+    return llm_chain.invoke({"query": query})

utils/audit/transcript_audio.py

@@ -0,0 +1,10 @@
+from openai import OpenAI
+
+def transcript_audio_func(audio_file):
+    client = OpenAI()
+    transcription = client.audio.transcriptions.create(
+        model="whisper",
+        file=audio_file
+    )
+
+    return transcription.text

utils/kg/barnes_algo.py

@@ -0,0 +1,211 @@
+from __future__ import division
+import numpy as np
+import math
+import matplotlib.pyplot as plt
+import matplotlib.animation as animation
+import matplotlib.patches as patches
+import random
+
+theta = 0.5
+AU = (149.6e6 * 1000)     # 149.6 million km, in meters.
+G = 6.67408e-11 #m^3 kg^-1 s^-2
+fig1 = plt.figure()
+sim = fig1.add_subplot(111, aspect='equal')
+fig2 = plt.figure()
+quadt = fig2.add_subplot(111, aspect='equal')
+
+class Node:
+    children = None
+    mass = None
+    center_of_mass = None
+    bbox = None
+    vx = vy = None
+
+def quad_insert(root, x, y, m):
+    if root.mass is None:   #when the root is empty, add the first particle
+        root.mass = m
+        root.center_of_mass = [x,y]
+        return
+    elif root.children is None:
+        root.children = [None,None,None,None]
+        old_quadrant = quadrant_of_particle(root.bbox, root.center_of_mass[0], root.center_of_mass[1])
+        if root.children[old_quadrant] is None:
+            root.children[old_quadrant] = Node()
+            root.children[old_quadrant].bbox = quadrant_bbox(root.bbox,old_quadrant)
+        quad_insert(root.children[old_quadrant], root.center_of_mass[0], root.center_of_mass[1], root.mass)
+        new_quadrant = quadrant_of_particle(root.bbox, x, y)
+        if root.children[new_quadrant] is None:
+            root.children[new_quadrant] = Node()
+            root.children[new_quadrant].bbox = quadrant_bbox(root.bbox,new_quadrant)
+        quad_insert(root.children[new_quadrant], x, y, m)
+        root.center_of_mass[0] = (root.center_of_mass[0]*root.mass + x*m) / (root.mass + m)
+        root.center_of_mass[1] = (root.center_of_mass[1]*root.mass + y*m) / (root.mass + m)
+        root.mass = root.mass + m
+    else:
+        new_quadrant = quadrant_of_particle(root.bbox, x, y)
+        if root.children[new_quadrant] is None:
+            root.children[new_quadrant] = Node()
+            root.children[new_quadrant].bbox = quadrant_bbox(root.bbox, new_quadrant)
+        quad_insert(root.children[new_quadrant], x, y, m)
+        root.center_of_mass[0] = (root.center_of_mass[0]*root.mass + x*m) / (root.mass + m)
+        root.center_of_mass[1] = (root.center_of_mass[1]*root.mass + y*m) / (root.mass + m)
+        root.mass = root.mass + m
+
+def display(root):
+    if root.mass is None:
+        return
+    if root.children is not None:
+        x = (root.bbox[0] + root.bbox[1]) / 2
+        y = (root.bbox[2] + root.bbox[3]) / 2
+        width = x-root.bbox[0]
+        plt_node(root.bbox[0], root.bbox[2], width)
+        plt_node(root.bbox[0], y, width)
+        plt_node(x, root.bbox[2], width)
+        plt_node(x, y, width)
+        for i in xrange(4):
+            if root.children[i] is not None:
+                display(root.children[i])
+    else:
+        quadt.scatter(root.center_of_mass[0], root.center_of_mass[1])
+
+def integrate(particles):
+    bodies = particles
+    n = len(bodies)
+    timestep = 24*3600 #one day
+    years = 2 * 365 #how many Earth years that simulate
+    for day in xrange(years):
+        particles_force = {}
+        root = Node()
+        root.center_of_mass = []
+        root.bbox = find_root_bbox(bodies)
+        for i in xrange(n):
+            quad_insert(root, bodies[i][3], bodies[i][4], bodies[i][2])
+        for i in xrange(n):
+            total_fx, total_fy = compute_force(root,bodies[i][3],bodies[i][4],bodies[i][2])
+            particles_force[bodies[i][0]] = (total_fx, total_fy)
+        for i in xrange(n):
+            fx, fy = particles_force[bodies[i][0]]
+            bodies[i][5] += fx / bodies[i][2] * timestep
+            bodies[i][6] += fy / bodies[i][2] * timestep
+
+            bodies[i][3] += bodies[i][5] * timestep
+            bodies[i][4] += bodies[i][6] * timestep
+            sim.scatter(bodies[i][3], bodies[i][4], c=bodies[i][1])
+    display(root)
+    quadt.scatter(root.center_of_mass[0], root.center_of_mass[1], c='red', marker='x')
+
+def compute_force(root,x,y,m):
+    if root.mass is None:
+        return 0, 0
+    if root.center_of_mass[0] == x and root.center_of_mass[1] == y and root.mass == m:
+        return 0, 0
+    d = root.bbox[1]-root.bbox[0]
+    r = distance(x,y, root.center_of_mass[0], root.center_of_mass[1])
+    if d/r < theta or root.children is None:
+        return force(m, x, y, root.mass, root.center_of_mass[0], root.center_of_mass[1])
+    else:
+        fx = 0.0
+        fy = 0.0
+        for i in xrange(4):
+            if root.children[i] is not None:
+                fx += compute_force(root.children[i],x,y,m)[0]
+                fy += compute_force(root.children[i],x,y,m)[1]
+        return fx, fy
+
+################################################# SUPPORTING FUNCTION ##############################################################
+
+def force(m, x, y, mcm, xcm, ycm):
+    d = distance(x, y, xcm, ycm)
+    f = G*m*mcm/(d**2)
+    dx = xcm - x
+    dy = ycm - y
+    angle = math.atan2(dy, dx)
+    fx = math.cos(angle) * f
+    fy = math.sin(angle) * f
+    return fx, fy
+
+def distance(x1, y1, x2, y2):
+    return math.sqrt((x2-x1)**2+(y2-y1)**2)
+
+def plt_node(x, y, width):
+    quadt.add_patch(patches.Rectangle((x, y), width, width, fill = False))
+
+def find_root_bbox(array):
+    """ Create a suitable square boundary box for the input particles
+    """
+    if len(array) == 0 or len(array) == 1:
+        return None
+    xmin, xmax, ymin, ymax = array[0][3], array[0][3], array[0][4], array[0][4]
+    for i in xrange(len(array)):
+        if array[i][3] > xmax:
+            xmax = array[i][3]
+        if array[i][3] < xmin:
+            xmin = array[i][3]
+        if array[i][4] > ymax:
+            ymax = array[i][4]
+        if array[i][4] < ymin:
+            ymin = array[i][4]
+    if xmax - xmin == ymax - ymin:
+        return xmin, xmax, ymin, ymax
+    elif xmax - xmin > ymax - ymin:
+        return xmin, xmax, ymin, ymax+(xmax-xmin-ymax+ymin)
+    else:
+        return xmin, xmax+(ymax-ymin-xmax+xmin), ymin, ymax
+
+def quadrant_of_particle(bbox, x, y):
+    """Return position of quadrant of the particle (x,y)
+    """
+    if y >= (bbox[3] + bbox[2])/2:
+        if x <= (bbox[1] + bbox[0])/2:
+            return 0
+        else:
+            return 1
+    else:
+        if x >= (bbox[1] + bbox[0])/2:
+            return 2
+        else:
+            return 3
+
+def quadrant_bbox(bbox,quadrant):
+    """Return the coordinate of the quadrant
+    """
+    x = (bbox[0] + bbox[1]) / 2
+    y = (bbox[2] + bbox[3]) / 2
+    #Quadrant 0: (xmin, x, y, ymax)
+    if quadrant == 0:
+        return bbox[0], x, y, bbox[3]
+    #Quadrant 1: (x, xmax, y, ymax)
+    elif quadrant == 1:
+        return x, bbox[1], y, bbox[3]
+    #Quadrant 2: (x, xmax, ymin, y)
+    elif quadrant == 2:
+        return x, bbox[1], bbox[2], y
+    #Quadrant 3: (xmin, x, ymin, y)
+    elif quadrant == 3:
+        return bbox[0], x, bbox[2], y
+
+def data_from_file(filename, array):
+    with open(filename) as f:
+        for line in f:
+            if line[0] == '#':
+                continue
+            else:
+                name,color,m,x,y,vx,vy = line.split(',')
+                array.append([name,color,float(m),float(x)*AU,float(y)*AU,float(vx)*1000,float(vy)*1000])
+
+if __name__ == '__main__':
+    filename = ('solar-system.txt')
+    particles = []
+    data_from_file(filename, particles)
+    #root = Node()
+    #root.center_of_mass = []
+    #root.bbox = find_root_bbox(particles)
+    #for i in xrange(len(particles)):
+    #    quad_insert(root, particles[i][3], particles[i][4], particles[i][2])
+    #print 'Boundary box: ',root.bbox
+    #print 'Total mass: ',root.mass
+    #print 'Coordinate of center of mass: ',root.center_of_mass
+    #plt.scatter(root.center_of_mass[0], root.center_of_mass[1], c='r', marker='x', s=50)
+    #print 'Theta: ', theta
+    integrate(particles)
+    plt.show()

utils/kg/construct_kg.py

@@ -0,0 +1,20 @@
+from langchain_community.graphs import Neo4jGraph
+from langchain_experimental.graph_transformers import LLMGraphTransformer
+from langchain_openai import ChatOpenAI
+from langchain_core.documents import Document
+
+def get_graph(text,allowed_nodes=None,prompt=None):
+    
+    llm = ChatOpenAI(temperature=0, model_name="gpt-4o-2024-08-06")
+
+    if allowed_nodes:
+        llm_transformer =   LLMGraphTransformer(llm=llm,allowed_nodes=allowed_nodes)
+    else:
+        llm_transformer = LLMGraphTransformer(llm=llm)
+    documents = [Document(page_content=text)]
+
+    graph_documents = llm_transformer.convert_to_graph_documents(documents)
+    
+    return graph_documents
+
+