Creazione function e database_hundling

app.py

@@ -1,8 +1,9 @@
-# main.py
+# app.py
 
 import gradio as gr
+import logging
 from app.logging_config import configure_logging
-from app.document_handling import list_databases
+from app.functions.database_handling import list_databases
 from ui.chatbot_tab import create_chatbot_tab
 from ui.db_management_tab import create_db_management_tab
 from ui.document_management_tab import create_document_management_tab
@@ -14,27 +15,37 @@ configure_logging()
 
 def update_all_dropdowns():
     """
-    Aggiorna tutti i dropdown con la lista aggiornata dei database.
-    Questo potrebbe essere esteso per aggiornare tutti i dropdown necessari.
+    Aggiorna tutti i dropdown in tutte le tab.
+    Nel tuo scenario, hai 6 dropdown totali (2 nella tab DB, 2 nella tab Documenti,
+    eventualmente 1 nella tab Chatbot, 1 in altre tab, ecc.).
+    Se ne hai di più o di meno, modifica il numero nel range.
     """
     databases = list_databases()
-    updates = [gr.update(choices=databases) for _ in range(6)]
-    return updates
+    # Imposta la prima voce selezionata (value) solo se la lista non è vuota
+    # e aggiorna le "choices" di tutti i dropdown.
+    return [gr.update(choices=databases, value=databases[0] if databases else None) for _ in range(6)]
 
 def main():
     """Funzione principale che crea e lancia l'app Gradio."""
-    with gr.Blocks() as rag_chatbot:
-        gr.Markdown("# Chatbot basato su RAG")
+    logging.info("Avvio applicazione")
+    try:
+        with gr.Blocks() as rag_chatbot:
+            gr.Markdown("# Chatbot basato su RAG")
+            logging.info("Interfaccia Gradio inizializzata")
+            
+            # Crea i vari tab dell'interfaccia
+            create_chatbot_tab()
+            create_db_management_tab(update_all_dropdowns)       # Passiamo la callback
+            create_document_management_tab(update_all_dropdowns) # Passiamo la callback
+            create_document_view_tab()
+            create_new_features_tab()
+            logging.info("Tab dell'interfaccia creati con successo")
         
-        # Crea i vari tab dell'interfaccia
-        create_chatbot_tab()
-        create_db_management_tab(update_all_dropdowns)
-        create_document_management_tab(update_all_dropdowns)
-        create_document_view_tab()
-        create_new_features_tab()
-    
-    # Avvia l'app
-    rag_chatbot.launch()
+        # Avvia l'app
+        logging.info("Avvio server Gradio")
+        rag_chatbot.launch()
+    except Exception as e:
+        logging.error(f"Errore durante l'avvio: {str(e)}", exc_info=True)
 
 if __name__ == "__main__":
     main()

app/document_handling.py

@@ -81,63 +81,6 @@ def answer_question(question, db_name="default_db"):
     results = [doc.page_content for doc in docs]
     return "\n\n".join(results)
 
-# -------------- DATABASE MANAGEMENT TAB FUNCTIONS --------------
-def create_database(db_name):
-    logging.info(f"Creating database: {db_name}")
-    db_path = f"faiss_index_{db_name}"
-    
-    if os.path.exists(db_path):
-        return f"Il database {db_name} esiste già."
-    
-    try:
-        os.makedirs(db_path)
-        logging.info(f"Database {db_name} created successfully.")
-        databases = list_databases()
-        return (f"Database {db_name} creato con successo.", databases)
-    except Exception as e:
-        logging.error(f"Errore nella creazione del database: {e}")
-        return (f"Errore nella creazione del database: {e}", [])
-
-def delete_database(db_name):
-    db_path = f"faiss_index_{db_name}"
-    if not os.path.exists(db_path):
-        return f"Il database {db_name} non esiste."
-    try:
-        shutil.rmtree(db_path)
-        logging.info(f"Database {db_name} eliminato con successo.")
-        return f"Database {db_name} eliminato con successo."
-    except OSError as e:
-        logging.error(f"Impossibile eliminare il database {db_name}: {e}")
-        return f"Impossibile eliminare il database {db_name}: {e}"
-
-def modify_database(old_db_name, new_db_name):
-    old_db_path = f"faiss_index_{old_db_name}"
-    new_db_path = f"faiss_index_{new_db_name}"
-    if not os.path.exists(old_db_path):
-        return f"Il database {old_db_name} non esiste."
-    if os.path.exists(new_db_path):
-        return f"Il database {new_db_name} esiste già."
-    try:
-        os.rename(old_db_path, new_db_path)
-        return f"Database {old_db_name} rinominato in {new_db_name} con successo."
-    except Exception as e:
-        return f"Errore durante la modifica del database: {e}"
-
-def list_databases():
-    try:
-        databases = []
-        for item in os.listdir():
-            if os.path.isdir(item) and item.startswith("faiss_index_"):
-                db_name = item.replace("faiss_index_", "")
-                databases.append(db_name)
-        # Ensure "default_db" is in the list
-        if "default_db" not in databases:
-            databases.append("default_db")
-        return databases
-    except Exception as e:
-        logging.error(f"Error listing databases: {e}")
-        return []
-
 # -------------- DOCUMENT MANAGEMENT TAB FUNCTIONS --------------
 def upload_and_index(files, title, author, db_name="default_db"):
     if not files:
@@ -153,6 +96,7 @@ def upload_and_index(files, title, author, db_name="default_db"):
             elif file.name.endswith('.docx'):
                 text = extract_text_from_docx(file.name)
             else:
+                # File .txt o altro testo semplice
                 with open(file.name, 'r', encoding='utf-8') as f:
                     text = f.read()
                     
@@ -195,13 +139,14 @@ def upload_and_index(files, title, author, db_name="default_db"):
             texts = [doc["content"] for doc in documents]
             metadatas = [{k: v for k, v in doc.items() if k != "content"} for doc in documents]
             
+            # Crea o sovrascrivi l'indice FAISS con questi documenti
             vectorstore = FAISS.from_texts(texts, embeddings, metadatas=metadatas)
             vectorstore.save_local(db_path)
             
-            # Salva i metadati del documento
+            # Salva i metadati del documento su file
             save_metadata(doc_metadata, db_name)
             
-            return f"Documenti indicizzati con successo nel database {db_name}!"
+            return f"Documenti indicizzati con successo nel database '{db_name}'!"
         except Exception as e:
             logging.error(f"Errore durante l'indicizzazione: {e}")
             return f"Errore durante l'indicizzazione: {e}"
@@ -219,6 +164,9 @@ def list_indexed_files(db_name="default_db"):
         with open(metadata_file, 'r') as f:
             metadata = json.load(f)
         
+        if not metadata:
+            return "Nessun documento nel database."
+        
         output = []
         for doc in metadata:
             output.append(
@@ -235,11 +183,16 @@ 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 = f"faiss_index_{db_name}"
     file_list_path = os.path.join(db_path, "file_list.txt")
     
     if not os.path.exists(file_list_path):
-        return "Database non trovato."
+        return "Database non trovato (file_list.txt mancante)."
     
     try:
         # Leggi la lista dei file
@@ -247,14 +200,14 @@ def delete_file_from_database(file_name, db_name="default_db"):
             files = f.readlines()
         
         # Rimuovi il file dalla lista
-        files = [f.strip() for f in files if f.strip() != file_name]
+        files = [line.strip() for line in files if line.strip() != file_name]
         
         # Riscrivi la lista aggiornata
         with open(file_list_path, "w") as f:
-            for file in files:
-                f.write(f"{file}\n")
+            for fl in files:
+                f.write(f"{fl}\n")
         
-        return f"File {file_name} rimosso dal database {db_name}."
+        return f"File '{file_name}' rimosso dal database '{db_name}'."
     except Exception as e:
         return f"Errore durante la rimozione del file: {e}"
 
@@ -264,10 +217,10 @@ def list_indexed_documents(db_name="default_db"):
     metadata_file = os.path.join(db_path, "metadata.json")
     
     if not os.path.exists(db_path):
-        return f"Il database {db_name} non esiste."
+        return f"Il database '{db_name}' non esiste."
     
     if not os.path.exists(metadata_file):
-        return f"Nessun documento nel database {db_name}."
+        return f"Nessun documento nel database '{db_name}'."
     
     try:
         with open(metadata_file, 'r') as f:
@@ -299,7 +252,7 @@ def list_indexed_documents(db_name="default_db"):
 def search_documents(query, db_name="default_db"):
     db_path = f"faiss_index_{db_name}"
     if not os.path.exists(db_path):
-        logging.warning(f"L'indice FAISS per il database {db_name} non esiste.")
+        logging.warning(f"L'indice FAISS per il database '{db_name}' non esiste.")
         return "Database non trovato."
     
     embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
@@ -316,5 +269,5 @@ def search_documents(query, db_name="default_db"):
     return "\n\n".join(results)
 
 def generate_summary(db_name="default_db"):
-    # Placeholder for summarization logic
-    return "This is a summary of the documents in the database."
+    # Placeholder per la logica di summarization
+    return "This is a summary of the documents in the database."

app/functions/database_handling.py

@@ -0,0 +1,59 @@
+import logging
+import os
+import shutil
+
+# -------------- DATABASE MANAGEMENT TAB FUNCTIONS --------------
+def create_database(db_name):
+    logging.info(f"Creating database: {db_name}")
+    db_path = f"faiss_index_{db_name}"
+
+    if os.path.exists(db_path):
+        return f"Il database '{db_name}' esiste già."
+
+    try:
+        os.makedirs(db_path)
+        logging.info(f"Database {db_name} created successfully.")
+        return f"Database '{db_name}' creato con successo."
+    except Exception as e:
+        logging.error(f"Errore nella creazione del database: {e}")
+        return f"Errore nella creazione del database: {e}"
+
+def delete_database(db_name):
+    db_path = f"faiss_index_{db_name}"
+    if not os.path.exists(db_path):
+        return f"Il database '{db_name}' non esiste."
+    try:
+        shutil.rmtree(db_path)
+        logging.info(f"Database {db_name} eliminato con successo.")
+        return f"Database '{db_name}' eliminato con successo."
+    except OSError as e:
+        logging.error(f"Impossibile eliminare il database {db_name}: {e}")
+        return f"Impossibile eliminare il database '{db_name}': {e}"
+
+def modify_database(old_db_name, new_db_name):
+    old_db_path = f"faiss_index_{old_db_name}"
+    new_db_path = f"faiss_index_{new_db_name}"
+    if not os.path.exists(old_db_path):
+        return f"Il database '{old_db_name}' non esiste."
+    if os.path.exists(new_db_path):
+        return f"Il database '{new_db_name}' esiste già."
+    try:
+        os.rename(old_db_path, new_db_path)
+        return f"Database '{old_db_name}' rinominato in '{new_db_name}' con successo."
+    except Exception as e:
+        return f"Errore durante la modifica del database: {e}"
+
+def list_databases():
+    try:
+        databases = []
+        for item in os.listdir():
+            if os.path.isdir(item) and item.startswith("faiss_index_"):
+                db_name = item.replace("faiss_index_", "")
+                databases.append(db_name)
+        # Ensure "default_db" is in the list
+        if "default_db" not in databases:
+            databases.append("default_db")
+        return databases
+    except Exception as e:
+        logging.error(f"Error listing databases: {e}")
+        return []

app/llm_handling_2.py

@@ -1,34 +0,0 @@
-import logging
-from langchain_openai import ChatOpenAI
-from app.config import OPENAI_API_KEY
-
-def answer_question(question):
-    logging.info(f"Chiamata all'LLM con domanda: {question}")
-    sys = (
-        "Sei un assistente AI per la lingua Italiana di nome Counselorbot. "
-        "Rispondi nella lingua usata per la domanda in modo chiaro, semplice ed esaustivo."
-    )
-
-    messages = [
-        {"role": "system", "content": sys},
-        {"role": "user", "content": question}
-    ]
-    logging.info(f"Messages sent to LLM: {messages}")
-
-    try:
-        llm = ChatOpenAI(
-            model="gpt-4o-mini",
-            openai_api_key=OPENAI_API_KEY,
-            temperature=0.6,
-            max_tokens=512,
-            top_p=0.9
-        )
-        response = llm.invoke(input=messages)
-        logging.info(f"Contesto RAG inviato all'LLM: {messages}")
-        logging.info(f"Risposta ricevuta dall'LLM: {response}")
-        answer = response.content.strip()
-        logging.info(f"Domanda: {question} | Risposta: {answer}")
-        return answer
-    except Exception as e:
-        logging.error(f"Errore durante la generazione della risposta: {e}")
-        return f"Errore durante la generazione della risposta: {e}"

app/llm_handling_3.py

@@ -1,76 +0,0 @@
-import logging
-from openai import OpenAI
-from langchain_community.vectorstores import FAISS
-from langchain_community.embeddings import HuggingFaceEmbeddings
-from app.config import OPENAI_API_KEY
-import gradio as gr
-import os
-import shutil
-
-logging.basicConfig(level=logging.INFO)
-
-def answer_question(question, db_name, chat_history=None):
-    if chat_history is None:
-        chat_history = []
-
-    logging.info(f"Inizio elaborazione domanda: {question} per database: {db_name}")
-    
-    try:
-        embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
-        db_path = f"faiss_index_{db_name}"
-        
-        if not os.path.exists(db_path):
-            return [{"role": "user", "content": question},
-                   {"role": "assistant", "content": "Database non trovato"}]
-        
-        vectorstore = FAISS.load_local(db_path, embeddings, allow_dangerous_deserialization=True)
-        relevant_docs = vectorstore.similarity_search(question, k=3)
-        
-        # Prepara il contesto dai documenti
-        context = "\n".join([doc.page_content for doc in relevant_docs])
-        
-        client = OpenAI(api_key=OPENAI_API_KEY)
-        
-        messages = [
-            {"role": "system", "content": f"Usa questo contesto per rispondere: {context}"},
-            {"role": "user", "content": question}
-        ]
-        
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",  # Cambiato da gpt-4o-mini a un modello supportato
-            messages=messages,
-            temperature=0,
-            max_tokens=2048
-        )
-        
-        answer = response.choices[0].message.content
-        
-        return [
-            {"role": "user", "content": question},
-            {"role": "assistant", "content": answer}
-        ]
-
-    except Exception as e:
-        logging.error(f"Errore durante la generazione della risposta: {e}")
-        return [
-            {"role": "user", "content": question},
-            {"role": "assistant", "content": f"Si è verificato un errore: {str(e)}"}
-        ]
-
-# Nel document_handling.py, aggiornare delete_database per restituire anche l'aggiornamento del dropdown
-def delete_database(db_name):
-    db_path = f"faiss_index_{db_name}"
-    if not os.path.exists(db_path):
-        return f"Il database {db_name} non esiste.", gr.Dropdown.update(choices=list_databases())
-    try:
-        shutil.rmtree(db_path)
-        logging.info(f"Database {db_name} eliminato con successo.")
-        return f"Database {db_name} eliminato con successo.", gr.Dropdown.update(choices=list_databases())
-    except OSError as e:
-        logging.error(f"Impossibile eliminare il database {db_name}: {e}")
-        return f"Impossibile eliminare il database {db_name}: {e}", gr.Dropdown.update(choices=list_databases())
-
-# Manca la chiamata a ensure_default_db()
-if __name__ == "__main__":
-    ensure_default_db()  # Aggiungere questa chiamata
-    rag_chatbot.launch(share=True)

app/logging_config.py

@@ -1,12 +1,51 @@
 import logging
-from dotenv import load_dotenv
-
-# Carica variabili d'ambiente dal file .env
-load_dotenv()
+import os
+from datetime import datetime
+from logging.handlers import RotatingFileHandler
 
 def configure_logging():
-    logging.basicConfig(
-        filename="rag_chatbot.log",
-        level=logging.INFO,
-        format="%(asctime)s - %(levelname)s - %(message)s"
-    )
+    """Configura le impostazioni di logging dell'applicazione."""
+    # Percorso assoluto per la directory logs
+    base_dir = os.path.dirname(os.path.abspath(__file__))
+    log_directory = os.path.join(base_dir, "logs")
+    
+    # Crea la directory dei log se non esiste
+    if not os.path.exists(log_directory):
+        os.makedirs(log_directory)
+    
+    # Nome file log con timestamp
+    timestamp = datetime.now().strftime("%Y%m%d")
+    log_file = os.path.join(log_directory, f"app_{timestamp}.log")
+    
+    # Configura il logger root
+    logger = logging.getLogger()
+    logger.setLevel(logging.INFO)
+    
+    # Formattazione del log dettagliata
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - [%(levelname)s] - %(message)s - (%(filename)s:%(lineno)d)'
+    )
+    
+    # Handler per il file con rotazione (10MB per file)
+    file_handler = RotatingFileHandler(
+        log_file, 
+        maxBytes=10*1024*1024,  # 10MB
+        backupCount=10,
+        encoding='utf-8'
+    )
+    file_handler.setFormatter(formatter)
+    file_handler.setLevel(logging.INFO)
+    
+    # Handler per la console
+    console_handler = logging.StreamHandler()
+    console_handler.setFormatter(formatter)
+    console_handler.setLevel(logging.INFO)
+    
+    # Rimuovi handler esistenti e aggiungi i nuovi
+    logger.handlers.clear()
+    logger.addHandler(file_handler)
+    logger.addHandler(console_handler)
+    
+    # Test di scrittura
+    logging.info(f"Logging inizializzato - File: {log_file}")
+    logging.info("Test scrittura log")

logging_config.py

@@ -1,40 +0,0 @@
-import logging
-import os
-from logging.handlers import RotatingFileHandler
-
-def configure_logging():
-    """Configura le impostazioni di logging dell'applicazione."""
-    # Crea la directory dei log se non esiste
-    log_directory = "logs"
-    if not os.path.exists(log_directory):
-        os.makedirs(log_directory)
-    
-    # Percorso completo del file di log
-    log_file = os.path.join(log_directory, "app.log")
-    
-    # Configura il logger root
-    logger = logging.getLogger()
-    logger.setLevel(logging.INFO)
-    
-    # Formattazione del log
-    formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-    
-    # Handler per il file con rotazione
-    file_handler = RotatingFileHandler(log_file, maxBytes=1024*1024, backupCount=5)
-    file_handler.setFormatter(formatter)
-    file_handler.setLevel(logging.INFO)
-    
-    # Handler per la console
-    console_handler = logging.StreamHandler()
-    console_handler.setFormatter(formatter)
-    console_handler.setLevel(logging.INFO)
-    
-    # Rimuovi eventuali handler esistenti
-    logger.handlers.clear()
-    
-    # Aggiungi i nuovi handler
-    logger.addHandler(file_handler)
-    logger.addHandler(console_handler)
-    
-    # Log di test per verifica
-    logging.info("Logging configurato con successo")

ui/chatbot_tab.py

@@ -1,7 +1,7 @@
 # ui/chatbot_tab.py
 
 import gradio as gr
-from app.document_handling import list_databases
+from app.functions.database_handling import list_databases
 from utils.helpers import extract_text_from_files
 from app.llm_handling import answer_question
 

ui/db_management_tab.py

@@ -1,16 +1,10 @@
-# ui/db_management_tab.py
-
 import gradio as gr
-from app.document_handling import create_database, modify_database, delete_database, list_databases
+#from app.document_handling import create_database, modify_database, delete_database, list_databases
+from app.functions.database_handling import create_database, modify_database, delete_database, list_databases
 
-def create_db_management_tab(update_dropdowns):
+def create_db_management_tab(update_all_dropdowns=None):
     """Crea il tab 'Gestione Database' dell'interfaccia Gradio."""
     
-    def update_dropdowns_callback():
-        """Aggiorna tutti i dropdown con la lista aggiornata dei database."""
-        databases = list_databases()
-        return [gr.update(choices=databases) for _ in range(6)]
-
     # Ottieni la lista iniziale dei database
     databases = list_databases()
 
@@ -26,43 +20,53 @@ def create_db_management_tab(update_dropdowns):
             
             with gr.Column():
                 gr.Markdown("### Rinomina Database")
-                modify_db_old_name = gr.Dropdown(choices=databases, label="Database da Rinominare")
+                modify_db_old_name = gr.Dropdown(
+                    choices=databases, 
+                    label="Database da Rinominare"
+                )
                 modify_db_new_name = gr.Textbox(label="Nuovo Nome")
                 modify_db_button = gr.Button("Rinomina Database")
                 modify_output = gr.Textbox(label="Stato Modifica")
             
             with gr.Column():
                 gr.Markdown("### Elimina Database") 
-                delete_db_dropdown = gr.Dropdown(choices=databases, label="Database da Eliminare")
+                delete_db_dropdown = gr.Dropdown(
+                    choices=databases, 
+                    label="Database da Eliminare"
+                )
                 delete_db_button = gr.Button("Elimina Database")
                 delete_output = gr.Textbox(label="Stato Eliminazione")
         
         # Eventi per i bottoni di gestione DB
         create_db_button.click(
-            create_database,
+            fn=create_database,
             inputs=db_name_input,
             outputs=create_output
         ).then(
-            update_dropdowns,
+            fn=update_all_dropdowns,       # <--- callback globale
+            inputs=[],
             outputs=[modify_db_old_name, delete_db_dropdown]
         )
 
         modify_db_button.click(
-            modify_database,
+            fn=modify_database,
             inputs=[modify_db_old_name, modify_db_new_name],
             outputs=modify_output
         ).then(
-            update_dropdowns,
+            fn=update_all_dropdowns,       # <--- callback globale
+            inputs=[],
             outputs=[modify_db_old_name, delete_db_dropdown]
         )
 
         delete_db_button.click(
-            delete_database,
+            fn=delete_database,
             inputs=delete_db_dropdown,
             outputs=delete_output
         ).then(
-            update_dropdowns,
+            fn=update_all_dropdowns,       # <--- callback globale
+            inputs=[],
             outputs=[modify_db_old_name, delete_db_dropdown]
         )
     
-    return
+    # Ritorna i componenti che vogliamo poter aggiornare/agganciare
+    return [modify_db_old_name, delete_db_dropdown, create_db_button, modify_db_button, delete_db_button]

ui/document_management_tab.py

@@ -1,27 +1,32 @@
-# ui/document_management_tab.py
-
 import gradio as gr
-from app.document_handling import upload_and_index, list_indexed_files, delete_file_from_database, list_databases
+import logging
+from app.document_handling import upload_and_index, list_indexed_files, delete_file_from_database
+from app.functions.database_handling import list_databases
 
-def create_document_management_tab(update_dropdowns):
+def create_document_management_tab(update_all_dropdowns=None):
     """Crea il tab 'Gestione Documenti' dell'interfaccia Gradio."""
     
     def upload_and_index_callback(files, title, author, db_name):
         """Carica e indicizza i documenti, quindi aggiorna la lista dei file."""
-        status = upload_and_index(files, title, author, db_name)
-        return status
+        try:
+            status = upload_and_index(files, title, author, db_name)
+            logging.info(f"Upload completato: {status}")
+            return status
+        except Exception as e:
+            logging.error(f"Errore durante l'upload: {str(e)}")
+            return f"Errore: {str(e)}"
 
     def list_files_callback(db_name):
         """Elenca i file indicizzati nel database specificato."""
         files = list_indexed_files(db_name)
-        return "\n".join(files)
+        return files
 
     def delete_file_callback(file_name, db_name):
         """Elimina un file dal database e aggiorna la lista."""
         status = delete_file_from_database(file_name, db_name)
         return status
 
-    # Ottieni la lista aggiornata dei database
+    # Ottieni la lista dei database
     databases = list_databases()
 
     with gr.Tab("Gestione Documenti"):
@@ -45,48 +50,56 @@ def create_document_management_tab(update_dropdowns):
             
             upload_button = gr.Button("Indicizza Documenti")
             upload_output = gr.Textbox(label="Stato Upload")
-            
-            with gr.Column():
-                gr.Markdown("### Documenti nel Database")
+
+            gr.Markdown("### Gestione File")
+            with gr.Row():
                 db_name_list = gr.Dropdown(
-                    choices=databases, 
-                    label="Seleziona Database", 
+                    choices=databases,
+                    label="Database",
                     value="default_db"
                 )
-                list_button = gr.Button("Visualizza Files")
-                list_output = gr.Textbox(label="Files nel Database")
-                delete_file_input = gr.Textbox(label="Nome file da eliminare")
+                list_button = gr.Button("Lista File")
+            list_output = gr.Textbox(label="File nel Database")
+
+            with gr.Row():
+                delete_file_input = gr.Textbox(label="Nome File da Eliminare")
                 delete_file_button = gr.Button("Elimina File")
-                delete_file_output = gr.Textbox(label="Stato Eliminazione")
-        
-        # Eventi per i bottoni
+            delete_file_output = gr.Textbox(label="Stato Eliminazione")
+
+        # Eventi
         upload_button.click(
-            upload_and_index_callback,
+            fn=upload_and_index_callback,
             inputs=[file_input, title_input, author_input, db_name_upload],
             outputs=upload_output
         ).then(
-            lambda db: list_indexed_files(db),
-            inputs=db_name_list,
+            fn=update_all_dropdowns,            # <--- callback globale
+            inputs=[],
+            outputs=[db_name_upload, db_name_list]
+        ).then(
+            fn=list_files_callback,
+            inputs=[db_name_list],
             outputs=list_output
         )
 
         list_button.click(
-            list_indexed_files,
-            inputs=db_name_list,
+            fn=list_files_callback,
+            inputs=[db_name_list],
             outputs=list_output
         )
 
         delete_file_button.click(
-            delete_file_callback,
+            fn=delete_file_callback,
             inputs=[delete_file_input, db_name_list],
             outputs=delete_file_output
         ).then(
-            list_indexed_files,
-            inputs=db_name_list,
-            outputs=list_output
-        ).then(
-            update_dropdowns,
+            fn=update_all_dropdowns,           # <--- callback globale
+            inputs=[],
             outputs=[db_name_upload, db_name_list]
+        ).then(
+            fn=list_files_callback,
+            inputs=[db_name_list],
+            outputs=list_output
         )
     
-    return
+    # Ritorna i dropdown (e altri componenti, se servono) per poterli aggiornare
+    return [db_name_upload, db_name_list, upload_button, list_button, delete_file_button]

ui/document_view_tab.py

@@ -1,8 +1,8 @@
 # ui/document_view_tab.py
 
 import gradio as gr
-from app.document_handling import list_indexed_documents, list_databases
-
+from app.document_handling import list_indexed_documents
+from app.functions.database_handling import list_databases
 def create_document_view_tab():
     """Crea il tab 'Visualizza Documenti Indicizzati' dell'interfaccia Gradio."""
     

ui/new_features_tab.py

@@ -1,7 +1,8 @@
 # ui/new_features_tab.py
 
 import gradio as gr
-from app.document_handling import search_documents, list_databases
+from app.document_handling import search_documents
+from app.functions.database_handling import list_databases
 
 def create_new_features_tab():
     """Crea il tab 'Nuove Funzionalità' dell'interfaccia Gradio."""