test

.streamlit/config.toml

@@ -2,7 +2,7 @@
 maxUploadSize = 20
 
 [theme]
-base="light"
+base="dark"
 primaryColor="#63abdf"
 secondaryBackgroundColor="#fbf7f1"
 textColor="#011166"

app.py

@@ -8,21 +8,18 @@ def main():
 
     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)
+    # 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="📚")
+    # 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]
+            "Graphe de connaissance": [kg_page],
         }
     )
 

audit_page/dialogue_doc.py

@@ -8,6 +8,7 @@ from utils.kg.construct_kg import get_graph,get_advanced_graph
 from audit_page.knowledge_graph import *
 import json
 from time import sleep
+import pickle
 
 def graph_doc_to_json(graph):
     nodes = []
@@ -75,13 +76,17 @@ def format_cr(cr:report):
     formatted_cr = f"### Résumé :\n{cr.summary}\n\n### Notes :\n{cr.Notes}\n\n### Actions :\n{cr.Actions}"
     return formatted_cr
 
+def load_text_from_pkl(file_path:str):
+    with open(file_path,"rb") as f:
+        return pickle.load(f)
+    
+def load_graph_from_pkl(file_path:str):
+    with open(file_path,"rb") as f:
+        return pickle.load(f)
+
 
 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:
@@ -96,7 +101,7 @@ def doc_dialog_main():
         st.session_state.current_chunk_index = 0
         st.session_state.number_of_entities = 0
         st.session_state.number_of_relationships = 0
-    
+
     if "filter_views" not in st.session_state:
         st.session_state.filter_views = {}
     if "current_view" not in st.session_state:
@@ -108,6 +113,32 @@ def doc_dialog_main():
     if "chat_graph_history" not in st.session_state:
         st.session_state.chat_graph_history = []
     
+    global_graph = load_graph_from_pkl("./utils/assets/kg_ia_signature.pkl")
+    st.write("graphe global chargé")
+    st.session_state.graph = global_graph
+    st.write("graphe global assigné")
+    # st.session_state.current_chunk_index = 0
+    # st.session_state.filter_views = {}
+    # st.session_state.current_view = None
+    # st.session_state.node_types = None
+    # st.session_state.chat_graph_history = []
+    st.write("searching for node types")
+    node_types = get_node_types_advanced(st.session_state.graph)
+    st.write("types de noeuds obtenus")
+    list_node_types = list(node_types)
+    sorted_node_types = sorted(list_node_types,key=lambda x: x.lower())
+    print(sorted_node_types)
+    st.write("tri des types de noeuds effectué")
+    nodes_type_dict = list_to_dict_colors(sorted_node_types)
+    st.write("dictionnaire de types de noeuds créé")
+    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"
+    st.write("finished init")
+    #######################################################################
+
+    
+    
     #init a radio button for the choice
     if "radio_choice" not in st.session_state:
         st.session_state.radio_choice = None
@@ -122,15 +153,13 @@ def doc_dialog_main():
         st.session_state.radio_choice = options.index(choice)
         
     
-    audit = st.session_state.audit_simplified
-    content = st.session_state.audit["content"]
+    audit = {"Mots clés": ""}
+    content = {}
+
+    text = load_text_from_pkl("./utils/assets/scenes.pkl")
 
-    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
+    st.write(text)
+    
 
     prompt_cr = dedent(f'''
 
@@ -255,24 +284,20 @@ def doc_dialog_main():
                     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":
         # st.write(st.session_state.graph)
         if "graph" not in st.session_state or st.session_state.graph == None:
             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"]
-            with st.spinner("Synthétisation des informations..."):
-                    if st.session_state.cr == "":
-                        st.session_state.cr = generate_structured_response(prompt_cr2)
-                    entete = f"**RESUME:** {st.session_state.cr.summary} \n **MOTS CLES:** {keywords_list}" 
-
+            
             
             with st.spinner("Construction du graphe de connaissance..."):
                 
                 #graph = get_graph(text,allowed_nodes=allowed_nodes_types)
                 # chunk = st.session_state.chunks[st.session_state.current_chunk_index]
                 # print(chunk)
-                graph = get_advanced_graph(format_cr(st.session_state.cr),knowledge_graph=None)
+                graph = global_graph
                 st.session_state.graph = graph
                 st.session_state.current_chunk_index = 0
                 st.session_state.filter_views = {}

audit_page/knowledge_graph.py

@@ -1,410 +1,468 @@
 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 pickle
 import random
 import math
+from streamlit_agraph import agraph, Node, Edge, Config
+
+from utils.kg.construct_kg import get_graph  # if still needed for something else
+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 utils.audit.rag import get_vectorstore
 from langchain_core.messages import AIMessage, HumanMessage
 from langchain_core.prompts import PromptTemplate
+
 from itext2kg.models import KnowledgeGraph
 
-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.
+################################################################################
+# Utility Functions
+################################################################################
 
-    Returns:
-        return_value: True if the node exists, False otherwise.
-    """
+def if_node_exists(nodes, node_id):
+    """Check if a node with the given id already exists in a list of Node objects."""
     for node in nodes:
         if node.id == node_id:
             return True
     return False
 
 def generate_random_color():
+    """Generate a random pastel-ish RGB 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):
+    """Convert an (R, G, B) tuple to a hex string like '#aabbcc'."""
     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 get_node_types_advanced(graph:KnowledgeGraph):
-    node_types = set()
-    for node in graph.entities:
-        node_types.add(node.label)
-    for relationship in graph.relationships:
-        source = relationship.startEntity
-        target = relationship.endEntity
-        node_types.add(source.label)
-        node_types.add(target.label)
-    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)
+    """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):
+    """
+    Generate a list of distinct pastel-ish colors (in hex), ensuring each is
+    at least `min_distance` away from the others in RGB space.
+    """
     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):
+        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):
-
+def list_to_dict_colors(node_types):
+    """
+    Create a dict mapping each node type to a random (distinct) hex color.
+    """
     number_of_colors = len(node_types)
-    colors = generate_distinct_colors(number_of_colors)
+    color_hexes = generate_distinct_colors(number_of_colors)
+    return {typ: color_hexes[i] for i, typ in enumerate(node_types)}
 
-    node_colors = {}
-    for i, node_type in enumerate(node_types):
-        node_colors[node_type] = colors[i]
-    
-    return node_colors
+def get_node_types_advanced(graph: KnowledgeGraph):
+    """
+    Extract the set of node labels from an itext2kg KnowledgeGraph.
+    (graph.entities have .label, relationships have .startEntity, .endEntity)
+    """
+    node_types = set()
+    dict_node_colors = {}
+    for node in graph.entities:
+        node_types.add(node.label)
+    for relationship in graph.relationships:
+        node_types.add(relationship.startEntity.label)
+        node_types.add(relationship.endEntity.label)
 
+    dict_node_colors = {node:rgb_to_hex(generate_random_color()) for node in node_types}
+    return node_types, dict_node_colors
 
-def convert_neo4j_to_agraph(neo4j_graph, node_colors):
-    """
-    Converts a Neo4j graph into an Agraph format.
+################################################################################
+# Graph Conversion
+################################################################################
 
-    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.
+def get_node_types(graph):
+    """
+    Extract the set of node types from a graph that has:
+        graph.nodes -> [ Node(id, type) ... ]
+        graph.relationships -> [ Relationship(source, target, type) ... ]
+    """
+    node_types = set()
+    for node in graph.nodes:
+        node_types.add(node.type)
+    for rel in graph.relationships:
+        node_types.add(rel.source.type)
+        node_types.add(rel.target.type)
+    return node_types
 
-    Returns:
-        return_value: The Agraph visualization object.
+def convert_neo4j_to_agraph(neo4j_graph, node_colors):
+    """
+    Convert a “Neo4j-like” object into Agraph Nodes & Edges.
     """
     nodes = []
     edges = []
 
-    # Creating Agraph nodes
+    # Create 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
+        node_id = node.id.replace(" ", "_")
         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):
+        type_ = node.type
+
+        new_node = Node(
+            id=node_id,
+            title=type_,   # 'title' effectively becomes "type"
+            label=label,
+            size=25,
+            shape="circle",
+            color=node_colors.get(type_, "#cccccc")
+        )
+        if not if_node_exists(nodes, 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
-
+    # Create edges
+    for rel in neo4j_graph.relationships:
+        source_id = rel.source.id.replace(" ", "_")
+        target_id = rel.target.id.replace(" ", "_")
+
+        # Ensure nodes exist (if not from the loop above):
+        if not if_node_exists(nodes, source_id):
+            nodes.append(Node(
+                id=source_id,
+                title=rel.source.type,
+                label=rel.source.id,
+                size=25,
+                shape="circle",
+                color=node_colors.get(rel.source.type, "#cccccc")
+            ))
+        if not if_node_exists(nodes, target_id):
+            nodes.append(Node(
+                id=target_id,
+                title=rel.target.type,
+                label=rel.target.id,
+                size=25,
+                shape="circle",
+                color=node_colors.get(rel.target.type, "#cccccc")
+            ))
+
+        edges.append(Edge(
+            source=source_id,
+            label=rel.type,
+            target=target_id
+        ))
+
+    config = Config(
+        width=1200,
+        height=800,
+        directed=True,
+        physics=True,
+        hierarchical=True,
+        from_json="config.json"
+    )
     return edges, nodes, config
 
-def convert_advanced_neo4j_to_agraph(neo4j_graph:KnowledgeGraph, node_colors):
+def convert_advanced_neo4j_to_agraph(neo4j_graph: KnowledgeGraph, 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.
+    Same logic as above, but adapted to an itext2kg.models.KnowledgeGraph object
+    (graph.entities, graph.relationships). 
     """
     nodes = []
     edges = []
 
-    # Creating Agraph nodes
+    # Create nodes
     for node in neo4j_graph.entities:
-        # Use the node id as the Agraph node id
-        node_id = node.name.replace(" ", "_")  # Replace spaces with underscores for ids
+        node_id = node.name.replace(" ", "_")
         label = node.name
-        type = node.label
-        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)
-        nodes.append(new_node)
+        type_ = node.label
+        new_node = Node(
+            id=node_id,
+            title=type_,
+            label=label,
+            size=25,
+            shape="circle",
+            color=node_colors[type_]
+        )
+        if not if_node_exists(nodes, new_node.id):
+            nodes.append(new_node)
 
-    # Creating Agraph edges
+    # Create edges
     for relationship in neo4j_graph.relationships:
-        size = 25  # Default size, can be customized
-        shape = "circle"  # Default shape, can be customized
-
         source = relationship.startEntity
-        source_type = source.label
-        source_id = source.name.replace(" ", "_")
-        label_source = source.name
-        
-        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.endEntity
-        target_type = target.label
-        target_id = target.name.replace(" ", "_")
-        label_target = target.name
-        
-        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.name
-
-        edges.append(Edge(source=source_id, label=label, target=target_id))
 
+        source_id = source.name.replace(" ", "_")
+        target_id = target.name.replace(" ", "_")
 
-    # Define the configuration
-    config = Config(width=1200, height=800, directed=True, physics=True, hierarchical=True,from_json="config.json")
-    # Create the Agraph visualization
-
+        # Ensure existence of the source node
+        if not if_node_exists(nodes, source_id):
+            nodes.append(Node(
+                id=source_id,
+                title=source.label,
+                label=source.name,
+                size=25,
+                shape="circle",
+                color=node_colors.get(source.label, "#CCCCCC")
+            ))
+
+        # Ensure existence of the target node
+        if not if_node_exists(nodes, target_id):
+            nodes.append(Node(
+                id=target_id,
+                title=target.label,
+                label=target.name,
+                size=25,
+                shape="circle",
+                color=node_colors.get(target.label, "#CCCCCC")
+            ))
+
+        edges.append(Edge(
+            source=source_id,
+            label=relationship.name,
+            target=target_id
+        ))
+
+    config = Config(
+        width=1200, 
+        height=800, 
+        directed=True, 
+        physics=True, 
+        hierarchical=True,
+        from_json="config.json"
+    )
     return edges, nodes, config
 
 def display_graph(edges, nodes, config):
-    # Display the Agraph visualization
+    """Render Agraph."""
     return agraph(edges=edges, nodes=nodes, config=config)
 
 
+def filter_nodes_by_types(nodes, node_types_filter):
+    """
+    Filter out Agraph nodes by the node’s 'title' field (which is used as 'type' here).
+    """
+    if not node_types_filter:
+        return nodes
+    return [node for node in nodes if node.title in node_types_filter]
 
-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
 
+################################################################################
+# Dialog Components (same as your original code)
+################################################################################
 @st.dialog(title="Changer la vue")
 def change_view_dialog():
+    """
+    Dialog to rename or delete existing views from st.session_state.filter_views
+    and choose the active one (st.session_state.current_view).
+    """
     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])
 
+        # Delete the view (except for the default if you want)
         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()
+
+        # Choose the view
         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()
+
+        # Show details / rename
         if len(st.session_state.filter_views.keys()) > index:
             with col1.expander(item):
+                # Don’t allow renaming the default view (index=0) if you want
                 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 != "":
+                    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.strip():
                             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]))
+                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):
+    """
+    Dialog to add a new “view” to st.session_state.filter_views, specifying which types to filter by.
+    """
     st.write("Ajouter une vue")
     view_name = st.text_input("Nom de la vue")
-    st.markdown("les filtres actuels:")
+    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
+        if view_name.strip():
+            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():
+    """Dialog to interactively change colors of each node type via color pickers."""
     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
+    for node_type, color in st.session_state.node_types.items():
+        new_color = st.color_picker(
+            f"La couleur de l'entité **{node_type.strip()}**",
+            color
+        )
+        st.session_state.node_types[node_type] = new_color
     
     if st.button("Valider"):
         st.rerun()
 
 
+################################################################################
+# Main KG Function
+################################################################################
 
 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
+    # 1. Load your pickles (if not already loaded in session state)
+    if "scenes" not in st.session_state:
+        with open("./utils/assets/scenes.pkl", "rb") as f:
+            st.session_state.scenes = pickle.load(f)
+            st.session_state.vectorstore = get_vectorstore(st.session_state.scenes)
     
     if "graph" not in st.session_state:
-        st.session_state.graph = None
-    
+        with open("./utils/assets/kg_ia_signature.pkl", "rb") as f:
+            # Depending on how you stored it, it might be a tuple (graph, extra_info) 
+            # or directly a single object. Adjust as needed.
+            st.session_state.graph = pickle.load(f)
+            print("Graph loaded.")
+
+    # 2. Initialize other session keys if they don’t exist
     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)
+    st.title("Graphe de connaissance")
 
-    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
+    edges,nodes,config = None, None, None
+
+    # If we haven’t set up node types yet, do it now
+    if st.session_state.node_types is None:
+        # st.session_state.graph is presumably a list/tuple => st.session_state.graph[0]
+        # Or just st.session_state.graph if you stored it directly as a single obj
+        node_types, st.session_state.node_types = get_node_types_advanced(st.session_state.graph)
+        # st.write(f"Types d'entités trouvés : {node_types}")  
+        print("Couleurs attribuées")
+        # Initialize a default filter view
         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
+    # 3. Convert the graph to agraph format
+    edges, nodes, config = convert_advanced_neo4j_to_agraph(
+        st.session_state.graph,   # or st.session_state.graph[0] if needed
+        st.session_state.node_types
+    )
+    print("Graph converti en Agraph")
+
+    # 4. UI layout: (left) the graph itself, (right) the chat
+    col1, col2 = st.columns([3, 1])
 
-    if graph is not None:
-        #st.write(graph)
+    with col1.container(border=True,height=800):
+        st.write(f"#### 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()
+
+        # Currently selected filter for the chosen view
+        current_filters = st.session_state.filter_views.get(st.session_state.current_view, [])
+        filter_selection = filter_col.multiselect(
+            "Filtrer selon l'étiquette",
+            st.session_state.node_types.keys(),
+            default=current_filters,
+            label_visibility="collapsed"
+        )
         
-        edges,nodes,config = convert_neo4j_to_agraph(graph[0],st.session_state.node_types)
+        if add_view_col.button("➕", help="Ajouter une vue"):
+            add_view_dialog(filter_selection)
+
+        # Filter out nodes that don’t match the chosen types
+        filtered_nodes = filter_nodes_by_types(nodes, filter_selection)
         
-        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
-    
+        # Render the graph
+        selected_node_id = display_graph(edges, filtered_nodes, config)
+
+    # 5. Chat UI
+    with col2.container(border=True,height=800):
+        st.markdown("#### Dialoguer avec le graphe")
+        user_query = st.chat_input("Votre question ...")
+        if user_query:
+            st.session_state.chat_graph_history.append(HumanMessage(content=user_query))
+
+        with st.container():
+            # Display the existing chat
+            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)
+
+            # If the last message is from the user, we try to generate a response
+            if (len(st.session_state.chat_graph_history) > 0 and 
+                isinstance(st.session_state.chat_graph_history[-1], HumanMessage)):
+                last_message = st.session_state.chat_graph_history[-1]
+                with st.chat_message("AI"):
+                    # Example retrieval (if you have a vectorstore in session state)
+                    # and want to incorporate scenes or graph data:
+                    if "vectorstore" in st.session_state:
+                        retriever = st.session_state.vectorstore.as_retriever()
+                        context = retriever.invoke(last_message.content)
+                        prompt = (
+                            f"Contexte depuis les 'scenes': {st.session_state.scenes}\n"
+                            f"Contexte vectorstore: {context}\n"
+                            f"Question: {last_message.content}\n"
+                            f"Graph: {st.session_state.graph}\n"  # If you want to embed your entire graph
+                        )
+                        response = st.write_stream(
+                            generate_response_via_langchain(prompt, stream=True)
+                        )
+                        st.session_state.chat_graph_history.append(AIMessage(content=response))
+                    else:
+                        # Fallback if no vectorstore
+                        st.write("Aucune base de vecteurs disponible.")
+                        st.session_state.chat_graph_history.append(AIMessage(content="(Pas de vectorstore)"))
+
+            # If the user clicked on a node in the graph, we can propose quick prompts
+            if selected_node_id:
+                with st.chat_message("AI"):
+                    st.markdown(f"**Vous avez sélectionné**: `{selected_node_id}`")
+                    quick_prompts = [
+                        f"Donne-moi plus d'informations sur le noeud '{selected_node_id}'",
+                        f"Montre-moi les relations de '{selected_node_id}' dans ce graphe"
+                    ]
+                    for i, qprompt in enumerate(quick_prompts):
+                        if st.button(qprompt, key=f"qp_{i}"):
+                            st.session_state.chat_graph_history.append(HumanMessage(content=qprompt))
+
+kg_main()

utils/assets/kg_ia_signature.pkl

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

utils/assets/scenes.pkl

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