Architecture B Updated

.env

@@ -0,0 +1,9 @@
+MISTRAL_API_KEY ="EZ71WTJ4KzfANWluyosmRvIvmhjOjTDt"
+
+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"

app.py

@@ -103,9 +103,9 @@ def main():
     use_architecture_B = st.checkbox("Utiliser l'architecture B (avancée)")
 
     # Indexer le PDF (à exécuter une seule fois ou lorsque le PDF change)
-    pdf_path = get_existing_pdf()
-    if pdf_path:
-        index_pdf(pdf_path, use_architecture_B=use_architecture_B)
+    #pdf_path = get_existing_pdf()
+    #if pdf_path:
+        #index_pdf(pdf_path, use_architecture_B=use_architecture_B)
         
     display_sidebar()
     display_chat_history()

initIndex.py

@@ -8,7 +8,7 @@ from pinecone_utilsB import *
 
 
 search_engine = HybridSearchEngine()
-
+#pdf_path = get_existing_pdf()
 
 def index_pdf(pdf_path, use_architecture_B=False):
     """Indexe un PDF dans Pinecone."""

pinecone_utilsB.py

@@ -11,35 +11,28 @@ import nltk
 import zlib
 import base64
 import json
+import os
 nltk.download('punkt_tab')
 
-
-
-if "bm25_corpus" not in st.session_state:
-    st.session_state.bm25_corpus = []
-if "indexing_done" not in st.session_state:
-    st.session_state.indexing_done = False
-
-CONFIG_FILE = "indexing_state.json"
-
-def load_indexing_state():
-    """Charge l'état d'indexation depuis un fichier."""
-    if os.path.exists(CONFIG_FILE):
-        with open(CONFIG_FILE, "r") as f:
-            return json.load(f)
-    return {"indexed_files": []}
-
-def save_indexing_state(state):
-    """Sauvegarde l'état d'indexation dans un fichier."""
-    with open(CONFIG_FILE, "w") as f:
-        json.dump(state, f)
-
 class HybridSearchEngine:
     def __init__(self):
+        # Initialisation des modèles et encodeurs
         self.model = SentenceTransformer("intfloat/multilingual-e5-large")
-        self.sparse_encoder = BM25Encoder().default()
+        self.sparse_encoder = BM25Encoder().default()  # Initialisation de BM25Encoder avec des valeurs par défaut
+
+        # Créer une instance de HuggingFaceEmbeddings
         self.embeddings = HuggingFaceEmbeddings(model_name="intfloat/multilingual-e5-large")
+
+        # Utiliser st.session_state pour stocker l'état de l'indexation
+        if "bm25_corpus" not in st.session_state:
+            st.session_state.bm25_corpus = []
+        if "indexing_done" not in st.session_state:
+            st.session_state.indexing_done = False  # Ajout d'un indicateur d'indexation
+
+        # Initialisation du PineconeVectorStore
         self.vectorstore = PineconeVectorStore(index=indexB, embedding=self.embeddings)
+
+        # Initialisation du retriever hybride
         self.retriever = PineconeHybridSearchRetriever(
             embeddings=self.embeddings,
             sparse_encoder=self.sparse_encoder,
@@ -47,73 +40,110 @@ class HybridSearchEngine:
         )
 
     def is_initialized(self):
-        """Vérifie si l'index BM25 est bien prêt à être utilisé."""
-        return bool(st.session_state.bm25_corpus) and st.session_state.indexing_done
+        """Vérifie si l'index BM25 est initialisé."""
+        return bool(st.session_state.bm25_corpus)
 
-    def index_pdf_B(self, texts, pdf_path):
-        """Indexe les textes en évitant les doublons."""
-        if not texts:
-            st.error("La liste des textes ne peut pas être vide.")
-            return
+    def tokenize(self, text):
+        """Tokenise un texte avec NLTK."""
+        return nltk.word_tokenize(text.lower())
+    def get_existing_vectors(self):
+        """Récupère les textes compressés déjà indexés dans Pinecone."""
+        existing_texts = set()
 
-        if st.session_state.indexing_done:
-            st.write("L'indexation est déjà terminée, pas besoin de la refaire.")
-            return
+        try:
+            # Effectuer une recherche avec un mot-clé fictif pour récupérer des documents
+            results = self.vectorstore.similarity_search("random_query", k=10000)  # Ajuster k selon l'index
+
+            for doc in results:
+                if "compressed_text" in doc.metadata:
+                    existing_texts.add(doc.metadata["compressed_text"])  # Stocker les textes existants
 
-        indexing_state = load_indexing_state()
-        if pdf_path in indexing_state["indexed_files"]:
-            st.write("Ce fichier PDF a déjà été indexé.")
+        except Exception as e:
+            st.error(f"Erreur lors de la récupération des vecteurs existants : {e}")
+
+        return existing_texts
+
+
+    def index_pdf_B(self, texts):
+        """Indexe les textes en évitant les doublons (même contenu)."""
+        if not texts:
+            st.error("La liste des textes ne peut pas être vide.")
             return
 
+        st.session_state.indexing_done = False
         st.write("Indexation en cours, veuillez patienter...")
 
+        # Récupérer les textes déjà indexés dans Pinecone
         existing_texts = self.get_existing_vectors()
 
-        # Entraîner BM25 uniquement si ce n'est pas déjà fait
+        # Initialiser BM25
         st.session_state.bm25_corpus = texts
         self.sparse_encoder.fit(texts)
 
         documents = []
-        for text in texts:
+        for i, text in enumerate(texts):
             chunks = self.split_text_into_chunks(text, max_chunk_size=1024)
-            for chunk in chunks:
+            for j, chunk in enumerate(chunks):
                 compressed_chunk = self.compress_text(chunk)
+
+                # Vérifier si ce texte est déjà dans l'index Pinecone
                 if compressed_chunk in existing_texts:
-                    continue
+                    continue  # Ignorer ce document car il est déjà indexé
 
+                # Générer un ID unique pour ce chunk
                 doc_id = f"doc_{zlib.crc32(chunk.encode('utf-8'))}"
+
                 metadata = {"compressed_text": compressed_chunk}
-                if self.get_metadata_size(metadata) <= 40960:
-                    documents.append(Document(page_content=chunk, metadata=metadata))
+                metadata_size = self.get_metadata_size(metadata)
 
+                if metadata_size <= 40960:  # 40 KB
+                    document = Document(
+                        page_content=chunk,
+                        metadata=metadata
+                    )
+                    documents.append((doc_id, document))
+
+        # Ajouter uniquement les nouveaux documents
         if documents:
-            self.vectorstore.add_documents(documents)
+            self.vectorstore.add_documents([doc for _, doc in documents])  # Remplacer upsert() par add_documents()
 
-        # ✅ Marquer l'indexation comme terminée de manière permanente
-        indexing_state["indexed_files"].append(pdf_path)
-        save_indexing_state(indexing_state)
         st.session_state.indexing_done = True
-
         st.success("Indexation terminée sans duplication de contenu.")
 
     def hybrid_search(self, query):
-        """Effectue une recherche hybride combinant BM25 et Pinecone."""
+        """Récupère les documents pertinents en combinant les résultats de Pinecone et BM25."""
         if not self.is_initialized():
             st.warning("L'index BM25 n'est pas encore prêt. Veuillez patienter pendant l'indexation...")
             return []
 
         try:
+            # Recherche hybride avec PineconeHybridSearchRetriever
             results = self.retriever.get_relevant_documents(query)
+
+            # Récupérer les documents pertinents
             relevant_docs = []
             for result in results:
-                metadata = result.metadata or {}
+                # Vérifier si le résultat est un objet Document
+                if hasattr(result, "metadata"):
+                    metadata = result.metadata or {}  # Assurez-vous que metadata n'est jamais None
+                else:
+                    metadata = {}
+
+                # Vérifier si 'context' existe avant d'y accéder
+                if "context" in metadata:
+                    _ = metadata.pop("context", None)  # Sécuriser l'accès à 'context'
+
                 compressed_text = metadata.get("compressed_text")
                 if compressed_text:
                     relevant_docs.append(self.decompress_text(compressed_text))
+
             return relevant_docs
+    
+
         except Exception as e:
             st.error(f"Erreur lors de la recherche hybride : {e}")
             return []
+        print(relevant_docs)
 
     def compress_text(self, text):
         """Compresse un texte en base64."""