Update pinecone_utilsB.py

pinecone_utilsB.py

@@ -1,117 +1,153 @@
 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 the Document class
 import pinecone
 import streamlit as st
-from config import sparse_index as indexB, llm
+from config import sparse_index as indexB
 import nltk
-from nltk.corpus import stopwords
 import zlib
 import base64
-from rank_bm25 import BM25Okapi
-import numpy as np
-nltk.download("stopwords")  
-
-
-nltk.download("punkt_tab")
 
 class HybridSearchEngine:
     def __init__(self):
+        # Initialisation des modèles et encodeurs
         self.model = SentenceTransformer("intfloat/multilingual-e5-large")
-        
-        # Initialisation des variables Streamlit
-        if "bm25_index" not in st.session_state:
-            st.session_state.bm25_index = None
+        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  
+            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,
+            index=indexB
+        )
 
     def is_initialized(self):
-        return st.session_state.bm25_index is not None and bool(st.session_state.bm25_corpus)
+        """Vérifie si l'index BM25 est initialisé."""
+        return bool(st.session_state.bm25_corpus)
 
     def tokenize(self, text):
-        stop_words = set(stopwords.words("french"))
-        tokens = nltk.word_tokenize(text.lower())
-        return [t for t in tokens if t.isalnum() and t not in stop_words] 
+        """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()
+
+        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
+
+        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.session_state.indexing_done = False
         st.write("Indexation en cours, veuillez patienter...")
 
-        dense_vectors = self.model.encode([t[:512] for t in texts])  
+        # Récupérer les textes déjà indexés dans Pinecone
+        existing_texts = self.get_existing_vectors()
 
-        st.session_state.bm25_corpus = texts  
-        tokenized_corpus = [self.tokenize(text) for text in texts]
-        if not any(tokenized_corpus):
-            st.error("Le corpus tokenisé est vide. Vérifiez vos textes.")
-            return
-
-        st.session_state.bm25_index = BM25Okapi(tokenized_corpus)
-        st.session_state.indexing_done = True  
-        st.success("Indexation BM25 terminée avec succès.")
+        # Initialiser BM25
+        st.session_state.bm25_corpus = texts
+        self.sparse_encoder.fit(texts)
 
-        # Indexer les vecteurs dans Pinecone
-        for i, (dense_vector, text) in enumerate(zip(dense_vectors, texts)):
+        documents = []
+        for i, text in enumerate(texts):
             chunks = self.split_text_into_chunks(text, max_chunk_size=1024)
             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  # 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}
+                metadata_size = self.get_metadata_size(metadata)
 
-                if self.get_metadata_size(metadata) > 40960:
-                    chunk = chunk[:512]  
-                    compressed_chunk = self.compress_text(chunk)
-                    metadata = {"compressed_text": compressed_chunk}
-                    if self.get_metadata_size(metadata) > 40960:
-                        continue  
-
-                indexB.upsert([
-                    {
-                        "id": f"vec_{i}_{j}",  
-                        "values": dense_vector.tolist(),  
-                        "metadata": metadata  
-                    }
-                ])
+                if metadata_size <= 40960:  # 40 KB
+                    document = Document(
+                        page_content=chunk,
+                        metadata=metadata
+                    )
+                    documents.append((doc_id, document))
 
-    def hybrid_search(self, query):
-        query_dense_vector = self.model.encode([query[:512]]).tolist()[0]
+        # Ajouter uniquement les nouveaux documents
+        if documents:
+            self.vectorstore.add_documents([doc for _, doc in documents])  # Remplacer upsert() par add_documents()
+
+        st.session_state.indexing_done = True
+        st.success("Indexation terminée sans duplication de contenu.")
 
+    def hybrid_search(self, query):
+        """Récupère les documents pertinents en combinant les résultats de Pinecone et BM25."""
         if not self.is_initialized():
-            st.error("BM25 n'est pas encore indexé. Exécutez l'indexation d'abord.")
+            st.warning("L'index BM25 n'est pas encore prêt. Veuillez patienter pendant l'indexation...")
             return []
 
-        tokenized_query = self.tokenize(query)
-        sparse_scores = st.session_state.bm25_index.get_scores(tokenized_query)
+        try:
+            # Recherche hybride avec PineconeHybridSearchRetriever
+            results = self.retriever.get_relevant_documents(query)
 
-        if np.max(sparse_scores) > 0:
-            sparse_scores = (sparse_scores - np.min(sparse_scores)) / (np.max(sparse_scores) - np.min(sparse_scores) + 1e-9)
+            # Récupérer les documents pertinents
+            relevant_docs = []
+            for result in results:
+                # 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 = {}
 
-        alpha = 0.7  
-        hybrid_scores = alpha * np.array(query_dense_vector) + (1 - alpha) * np.pad(sparse_scores, (0, max(0, len(query_dense_vector) - len(sparse_scores))), 'constant')
+                # Vérifier si 'context' existe avant d'y accéder
+                if "context" in metadata:
+                    _ = metadata.pop("context", None)  # Sécuriser l'accès à 'context'
 
-        results = indexB.query(
-            vector=hybrid_scores.tolist(),
-            top_k=30,
-            include_metadata=True,
-        )
+                compressed_text = metadata.get("compressed_text")
+                if compressed_text:
+                    relevant_docs.append(self.decompress_text(compressed_text))
 
-        relevant_docs = []
-        for match in results.get("matches", []):
-            metadata = match.get("metadata", {})
-            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 []
 
-        return relevant_docs
 
     def compress_text(self, text):
+        """Compresse un texte en base64."""
         compressed = zlib.compress(text.encode("utf-8"))
         return base64.b64encode(compressed).decode("utf-8")
 
     def decompress_text(self, compressed_text):
+        """Décompresse un texte compressé en base64."""
         try:
             compressed_data = base64.b64decode(compressed_text.encode("utf-8"))
             return zlib.decompress(compressed_data).decode("utf-8")
@@ -119,8 +155,10 @@ class HybridSearchEngine:
             st.error(f"Erreur de décompression : {e}")
             return ""
 
-    def split_text_into_chunks(self, text, max_chunk_size=512):
+    def split_text_into_chunks(self, text, max_chunk_size=1024):
+        """Divise un texte en morceaux de taille maximale `max_chunk_size`."""
         return [text[i:i+max_chunk_size] for i in range(0, len(text), max_chunk_size)]
 
     def get_metadata_size(self, metadata):
-        return len(str(metadata).encode("utf-8"))
+        """Calcule la taille des métadonnées en octets."""
+        return len(str(metadata).encode("utf-8"))