fonti aggiustato, almeno spero

app/document_handling.py

@@ -41,13 +41,22 @@ def upload_and_index(files, title, author, db_name="default_db"):
     
     embeddings = get_embeddings()
     existing_vectorstore = None
+    current_chunk_offset = 0
     
     try:
+        # Calcola l'ultimo ID chunk utilizzato
+        last_chunk_id = 0
+        if os.path.exists(os.path.join(db_path, "metadata.json")):
+            with open(os.path.join(db_path, "metadata.json"), 'r') as f:
+                existing_metadata = json.load(f)
+                last_chunk_id = sum(doc['chunks'] for doc in existing_metadata)
+    
         if os.path.exists(os.path.join(db_path, "index.faiss")):
             existing_vectorstore = FAISS.load_local(db_path, embeddings, allow_dangerous_deserialization=True)
     except Exception as e:
         logging.error(f"Errore caricamento vectorstore esistente: {e}")
         existing_vectorstore = None
+        last_chunk_id = 0
     
     # Processa i nuovi file
     for file in files:
@@ -62,11 +71,6 @@ def upload_and_index(files, title, author, db_name="default_db"):
                     
             chunks = create_chunks(text)
             
-            # Calcola l'offset per i nuovi chunks
-            chunk_offset = 0
-            if existing_vectorstore:
-                chunk_offset = len(existing_vectorstore.docstore._dict)
-            
             doc_meta = DocumentMetadata(
                 filename=os.path.basename(file.name),
                 title=title,
@@ -76,18 +80,23 @@ def upload_and_index(files, title, author, db_name="default_db"):
             )
             doc_metadata.append(doc_meta)
             
+            # Aggiungi metadati a ogni chunk
             for i, chunk in enumerate(chunks):
+                chunk_id = last_chunk_id + i
                 chunk_metadata = {
                     "content": chunk,
                     "source": os.path.basename(file.name),
                     "title": title,
                     "author": author,
-                    "chunk_index": chunk_offset + i,
-                    "total_chunks": len(chunks),
-                    "upload_date": doc_meta.upload_date
+                    "chunk_id": chunk_id,  # ID univoco del chunk
+                    "doc_chunk_index": i,  # Indice del chunk nel documento
+                    "total_doc_chunks": len(chunks),
+                    "filename": os.path.basename(file.name)  # Aggiunto per riferimento
                 }
                 documents.append(chunk_metadata)
             
+            last_chunk_id += len(chunks)
+            
         except Exception as e:
             logging.error(f"Errore durante la lettura del file {file.name}: {e}")
             continue
@@ -105,11 +114,9 @@ def upload_and_index(files, title, author, db_name="default_db"):
             
             vectorstore.save_local(db_path)
             
+            # Aggiorna metadata.json
             final_metadata = merge_metadata([], doc_metadata, db_name)
-            
-            # Salva i metadati
-            metadata_path = os.path.join(db_path, "metadata.json")
-            with open(metadata_path, 'w') as f:
+            with open(os.path.join(db_path, "metadata.json"), 'w') as f:
                 json.dump(final_metadata, f, indent=2)
             
             return True, "Documenti indicizzati con successo!", f"Database '{db_name}' aggiornato"
@@ -151,32 +158,62 @@ def list_indexed_files(db_name="default_db"):
         return f"Errore nella lettura dei metadati: {e}"
 
 def delete_file_from_database(file_name, db_name="default_db"):
-    """
-    Esempio semplificato: potresti voler rimuovere i chunk
-    da FAISS. Attualmente, la funzione gestisce un 'file_list.txt',
-    ma devi adattarla alle tue esigenze di rimozione dei chunk.
-    """
-    db_path = os.path.join(BASE_DB_PATH, f"faiss_index_{db_name}")  # Modifica qui
-    file_list_path = os.path.join(db_path, "file_list.txt")
+    """Elimina un file e i suoi chunks dal database."""
+    db_path = os.path.join(BASE_DB_PATH, f"faiss_index_{db_name}")
+    metadata_path = os.path.join(db_path, "metadata.json")
     
-    if not os.path.exists(file_list_path):
-        return "Database non trovato (file_list.txt mancante)."
+    if not os.path.exists(metadata_path):
+        return "Database non trovato (metadata.json mancante)."
     
     try:
-        # Leggi la lista dei file
-        with open(file_list_path, "r") as f:
-            files = f.readlines()
+        # Carica i metadati esistenti
+        with open(metadata_path, 'r') as f:
+            metadata = json.load(f)
+        
+        # Trova il file da eliminare
+        file_index = next((i for i, doc in enumerate(metadata) 
+                          if doc['filename'] == file_name), -1)
+        
+        if file_index == -1:
+            return f"File '{file_name}' non trovato nel database."
+            
+        # Carica il vectorstore esistente
+        embeddings = get_embeddings()
+        vectorstore = FAISS.load_local(db_path, embeddings, allow_dangerous_deserialization=True)
         
-        # Rimuovi il file dalla lista
-        files = [line.strip() for line in files if line.strip() != file_name]
+        # Calcola l'intervallo di chunks da rimuovere
+        chunks_before = sum(doc['chunks'] for doc in metadata[:file_index])
+        chunks_to_remove = metadata[file_index]['chunks']
         
-        # Riscrivi la lista aggiornata
-        with open(file_list_path, "w") as f:
-            for fl in files:
-                f.write(f"{fl}\n")
+        # Estrai tutti i documenti tranne quelli da rimuovere
+        all_docs = list(vectorstore.docstore._dict.items())
+        docs_to_keep = (
+            all_docs[:chunks_before] + 
+            all_docs[chunks_before + chunks_to_remove:]
+        )
+        
+        # Rimuovi il file dai metadati
+        metadata.pop(file_index)
+        
+        # Ricrea il vectorstore da zero
+        if docs_to_keep:
+            texts = [doc[1].page_content for doc in docs_to_keep]
+            metadatas = [doc[1].metadata for doc in docs_to_keep]
+            new_vectorstore = FAISS.from_texts(texts, embeddings, metadatas=metadatas)
+            new_vectorstore.save_local(db_path)
+        else:
+            # Se non ci sono più documenti, rimuovi il vectorstore
+            os.remove(os.path.join(db_path, "index.faiss"))
+            os.remove(os.path.join(db_path, "index.pkl"))
+        
+        # Salva i metadati aggiornati
+        with open(metadata_path, 'w') as f:
+            json.dump(metadata, f, indent=2)
+            
+        return f"File '{file_name}' eliminato con successo."
         
-        return f"File '{file_name}' rimosso dal database '{db_name}'."
     except Exception as e:
-        return f"Errore durante la rimozione del file: {e}"
+        logging.error(f"Errore durante l'eliminazione: {e}")
+        return f"Errore durante l'eliminazione: {e}"
 
 

app/llm_handling.py

@@ -112,9 +112,17 @@ def answer_question(question, db_name, prompt_type="tutor", chat_history=None, l
         for doc in relevant_docs:
             meta = doc.metadata
             title = meta.get('title', 'Unknown')
-            chunk_index = meta.get('chunk_index', 0)
+            author = meta.get('author', 'Unknown')
+            filename = meta.get('filename', 'Unknown')
+            chunk_id = meta.get('chunk_id', 0)  # Usa l'ID univoco del chunk
             total_doc_chunks = total_chunks.get(title, 0)
-            sources.append(f"📚 {meta['title']} (Author: {meta['author']}) - Chunk {chunk_index+1} di {total_doc_chunks}")
+            
+            # Usa lo stesso formato di chunks_viewer_tab.py
+            chunk_info = f"📚 Chunk {chunk_id} - {title} ({filename})"
+            if author != 'Unknown':
+                chunk_info += f" - Author: {author}"
+            
+            sources.append(chunk_info)
 
         # Prepara contesto e prompt
         context = "\n".join([doc.page_content for doc in relevant_docs])

ui/chunks_viewer_tab.py

@@ -18,14 +18,26 @@ def create_chunks_viewer_tab():
             
         try:
             metadata_path = os.path.join(BASE_DB_PATH, f"faiss_index_{db_name}", "metadata.json")
+            vectorstore_path = os.path.join(BASE_DB_PATH, f"faiss_index_{db_name}")
+            
+            # Carica metadati e vectorstore
             with open(metadata_path, 'r') as f:
                 metadata = json.load(f)
             
-            # Crea lista di chunks con formato "Chunk X - Titolo"
+            embeddings = get_embeddings()
+            vectorstore = FAISS.load_local(vectorstore_path, embeddings, allow_dangerous_deserialization=True)
+            
+            # Crea lista di chunks con formato "Chunk X - Titolo (File)"
             chunk_list = []
+            current_index = 0
+            
             for doc in metadata:
                 for i in range(doc['chunks']):
-                    chunk_list.append(f"Chunk {i+1} - {doc['title']}")
+                    # Recupera il contenuto del chunk per verifica
+                    doc_id = list(vectorstore.docstore._dict.keys())[current_index]
+                    chunk_metadata = vectorstore.docstore._dict[doc_id].metadata
+                    chunk_list.append(f"Chunk {current_index} - {doc['title']} ({doc['filename']})")
+                    current_index += 1
             
             return gr.Dropdown(choices=chunk_list, interactive=True), ""
         except Exception as e:
@@ -42,14 +54,11 @@ def create_chunks_viewer_tab():
             embeddings = get_embeddings()
             vectorstore = FAISS.load_local(db_path, embeddings, allow_dangerous_deserialization=True)
             
-            # Estrai il numero del chunk dal formato "Chunk X - Titolo"
-            chunk_num = int(chunk_id.split(" - ")[0].replace("Chunk ", "")) - 1
+            # Estrai il numero del chunk
+            chunk_num = int(chunk_id.split(" - ")[0].replace("Chunk ", ""))
             
-            # Verifica che l'indice sia valido
+            # Recupera il chunk usando l'ID univoco
             doc_ids = list(vectorstore.docstore._dict.keys())
-            if chunk_num >= len(doc_ids):
-                return f"Errore: chunk {chunk_num + 1} non trovato nel database"
-            
             chunk_content = vectorstore.docstore._dict[doc_ids[chunk_num]].page_content
             return chunk_content