interface updates

.env

@@ -4,6 +4,9 @@ LANGSMITH_TRACING=true
 LANGSMITH_ENDPOINT="https://api.smith.langchain.com"
 LANGSMITH_API_KEY="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"
 LANGSMITH_PROJECT="rag_architecture"
-#OPENAI_API_KEY="<your-openai-api-key>"
 
-PINECONE_API_KEY="pcsk_4cofG5_Uk93QCMSKiPvf7btHrPtuhvK71HmcSwfp5g3hHMZTWfapyjs8tvDCYcQteB51Z"
+PINECONE_API_KEY="pcsk_4cofG5_Uk93QCMSKiPvf7btHrPtuhvK71HmcSwfp5g3hHMZTWfapyjs8tvDCYcQteB51Z"
+
+NEO4J_URI="neo4j+s://e50baf05.databases.neo4j.io"
+NEO4J_USERNAME="neo4j"
+NEO4J_PASSWORD="uu6scz4Hf9SwY6SlJgHxk58SHv1m3YNz_RwxAYQKaJc"

app.py

@@ -1,10 +1,8 @@
 import streamlit as st
-from pdf_processing import get_existing_pdf, load_and_preprocess_pdf, split_text
 from graph_agentA import agent as agent_A
 from graph_agentB import agent as agent_B
 from config import *
 from dotenv import load_dotenv
-from initIndex import *
 from pinecone_utilsB import *
 
 
@@ -76,9 +74,13 @@ def process_query_B(query):
 def display_sidebar():
     """Affiche la barre latérale."""
     with st.sidebar:
-        st.title("📄 La confession muette")
-        st.write("Posez vos questions sur le document.")
-        st.image(agent_B.get_graph().draw_mermaid_png(), caption="Workflow Graph (Architecture B)")
+        lien_ressource = "https://www.fnac.com/livre-numerique/a21290809/Gaspard-Boreal-La-Confession-muette"
+        #st.title("📄 La confession muette")
+        #st.write("Posez vos questions sur le document.")
+        st.image(agent_B.get_graph().draw_mermaid_png(), caption="Workflow Graph")
+        st.markdown("Document de référence 📄 : \nLa confession muette ()2025")
+        st.markdown("Avec l'aimable autorisation de Gaspard Boréal: \n[Récit d'origine]({})".format(lien_ressource))
+
 
 def display_chat_history():
     """Affiche l'historique de chat."""
@@ -96,20 +98,31 @@ def main():
     if not check_indexes_ready():
         return
 
-    st.title("Architecture A et B")
-    use_architecture_B = st.checkbox("Utiliser l'architecture B (avancée)")
-        
+    st.title("RAG architectures")
+    st.markdown(
+        """
+        <style>
+        div[data-testid="stSelectbox"] {
+            width: 200px !important;  
+        }
+        </style>
+        """,
+        unsafe_allow_html=True
+    )
+    architecture = st.selectbox(
+        "Sélectionnez une architecture :", 
+        ["Basic", "Intermédiaire", "Avancée"]
+    )        
     display_sidebar()
     display_chat_history()
     
     query = st.chat_input("Posez votre question ici:")
     if query:
-        if use_architecture_B:
+        if architecture == "Intermédiaire":
             process_query_B(query)
         else:
             process_query_A(query)
         st.rerun()
 
 if __name__ == "__main__":
-    main()
-
+    main()

config.py

@@ -4,7 +4,7 @@ from dotenv import load_dotenv
 from pinecone import Pinecone, ServerlessSpec, Index
 from langsmith import Client
 from langchain_mistralai.chat_models import ChatMistralAI
-from pdf_processing import get_existing_pdf, load_and_preprocess_pdf, split_text
+from neo4j import GraphDatabase
 
 # Charger les variables d'environnement
 load_dotenv()
@@ -30,6 +30,15 @@ client = Client(
     api_key=langsmith_api_key,
 )
 
+# Initialize Neo4j connection
+neo4j_uri = os.getenv("NEO4J_URI")
+neo4j_username = os.getenv("NEO4J_USERNAME")
+neo4j_password = os.getenv("NEO4J_PASSWORD")
+neo4j_driver = GraphDatabase.driver(
+    neo4j_uri,
+    auth=(neo4j_username, neo4j_password)
+)
+
 # Mistral AI configuration
 mistral_api_key = os.getenv("MISTRAL_API_KEY")
 llm = ChatMistralAI(

index_documents.py

@@ -1,5 +1,4 @@
 # index_documents.py
-from config import sparse_index, dense_index
 from pinecone_utilsA import index_pdf as index_pdf_A
 from pinecone_utilsB import *
 from pdf_processing import get_existing_pdf, load_and_preprocess_pdf, split_text

initIndex.py

@@ -1,28 +0,0 @@
-from config import *
-import os
-from dotenv import load_dotenv
-from pinecone import Pinecone, ServerlessSpec
-from pdf_processing import get_existing_pdf, load_and_preprocess_pdf, split_text
-from pinecone_utilsA import index_pdf as index_pdf_A
-from pinecone_utilsB import *
-
-
-#pdf_path = get_existing_pdf()
-
-def index_pdf(pdf_path, use_architecture_B=False):
-    """Indexe un PDF dans Pinecone."""
-    if not pdf_path:
-        print("Aucun fichier PDF trouvé.")
-        return
-
-    text = load_and_preprocess_pdf(pdf_path)
-    texts = split_text(text)
-
-    if use_architecture_B:
-        print("Indexation pour l'architecture B en cours...")
-        index_pdf_B(texts)
-        print("Indexation pour l'architecture B terminée.")
-    else:
-        print("Indexation pour l'architecture A en cours...")
-        index_pdf_A(texts)
-        print("Indexation pour l'architecture A terminée.")

neo4j_initialize.py

@@ -0,0 +1,102 @@
+from langchain_community.graphs import Neo4jGraph
+from config import *
+from neo4j_graphrag.experimental.components.text_splitters.fixed_size_splitter import FixedSizeSplitter
+from neo4j_graphrag.experimental.pipeline.kg_builder import SimpleKGPipeline
+from langchain.embeddings import HuggingFaceEmbeddings
+from pdf_processing import get_existing_pdf, load_and_preprocess_pdf, split_text
+from neo4j_graphrag.experimental.pipeline.kg_builder import SimpleKGPipeline
+from neo4j import GraphDatabase
+
+try:
+    with neo4j_driver.session() as session:
+        result = session.run("RETURN 1 AS test")
+        print("Connexion à Neo4j réussie :", result.single()["test"])
+except Exception as e:
+    print("Erreur de connexion à Neo4j :", e)
+
+graph = Neo4jGraph()
+
+def generate_graph():
+
+    basic_node_labels = ["Personnage", "Objet", "Lieu", "Événement", "PériodeTemporelle"]
+    story_node_labels = ["Protagoniste", "Antagoniste", "PersonnageSecondaire", "CréatureMythique",
+                        "FigureHistorique", "Narrateur"]
+    literary_node_labels = ["Thème", "Motif", "Symbole"]
+
+    node_labels = basic_node_labels + story_node_labels + literary_node_labels
+
+    rel_types = ["CONNAÎT", "SITUE_DANS", "FAIT_PARTIE_DE", "SE_PRODUIT_PENDANT", "IMPLIQUE", 
+                "S'OPPOSE_À", "CRÉÉ_PAR", "INSPIRÉ_PAR", "REPRÉSENTE", "TRANSFORME"]
+
+    embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
+
+    prompt_template = '''
+    Vous êtes un expert en analyse de texte chargé d'extraire des informations à partir d'un récit et de les structurer sous forme de graphe de propriétés pour faciliter la compréhension et l'analyse du texte.
+
+    Extrayez les entités (nœuds) et spécifiez leur type à partir du texte d'entrée suivant.
+    Extrayez également les relations entre ces nœuds. La direction de la relation va du nœud de départ au nœud d'arrivée.
+
+    Retournez le résultat au format JSON en utilisant le modèle suivant :
+    {{
+      "nodes": [
+        {{
+          "id": "0",
+          "label": "type d'entité",
+          "properties": {{
+            "name": "nom de l'entité"
+          }}
+        }}
+      ],
+      "relationships": [
+        {{
+          "type": "TYPE_DE_RELATION",
+          "start_node_id": "0",
+          "end_node_id": "1",
+          "properties": {{
+            "details": "Description de la relation"
+          }}
+        }}
+      ]
+    }}
+
+    - Utilisez uniquement les informations du texte d'entrée. N'ajoutez aucune information supplémentaire.
+    - Si le texte d'entrée est vide, retournez un JSON vide.
+    - Créez autant de nœuds et de relations que nécessaire pour offrir un contexte riche et détaillé.
+    - Un assistant de connaissance basé sur l'IA doit pouvoir lire ce graphe et comprendre immédiatement le contexte pour poser des questions détaillées.
+    Utilisez uniquement les nœuds et relations suivants (s'ils sont fournis) :
+  
+
+    Attribuez un identifiant unique (chaîne de caractères) à chaque nœud et réutilisez-le pour définir les relations.
+    Respectez les types de nœuds source et cible pour les relations, ainsi que la direction des relations.
+
+    Ne retournez aucune information supplémentaire autre que le JSON.
+
+  
+
+    Texte d'entrée :
+
+    '''
+
+    kg_builder_pdf = SimpleKGPipeline(
+      llm=llm,
+      driver=neo4j_driver,
+      text_splitter=FixedSizeSplitter(chunk_size=1024, chunk_overlap=200),
+      embedder=embeddings,
+      entities=node_labels,
+      relations=rel_types,
+      prompt_template=prompt_template,
+      from_pdf=True
+    )
+
+    # Charger et prétraiter les PDF
+    pdf_files = get_existing_pdf()
+    texts = []
+    for pdf_file in pdf_files:
+            text = load_and_preprocess_pdf(pdf_file)
+            texts.extend(split_text(text))
+
+    results = kg_builder_pdf.run_async(texts)
+    graph.add_graph_documents(results)
+
+if __name__ == "__main__":
+    generate_graph()

pinecone_utilsB.py

@@ -1,17 +1,12 @@
 from sentence_transformers import SentenceTransformer
 from pinecone_text.sparse import BM25Encoder
-from langchain.retrievers import PineconeHybridSearchRetriever
 from langchain.embeddings import HuggingFaceEmbeddings
-from langchain_pinecone import PineconeVectorStore
-from langchain.schema import Document
-import pinecone
 import streamlit as st
 from config import sparse_index as indexB
 import nltk
 import zlib
 import base64
 import json
-import os
 import hashlib
 import uuid
 
@@ -120,9 +115,6 @@ def index_pdf_B(texts):
 
 def hybrid_search(query):
         """Récupère les documents pertinents en combinant les résultats de Pinecone et BM25."""
-        #if not is_initialized():
-            #st.warning("L'index BM25 n'est pas encore prêt. Veuillez patienter pendant l'indexation...")
-            #return []
 
         try:
             # Générer le vecteur dense pour la requête