import gradio as gr import random import pickle from sentence_transformers import SentenceTransformer, CrossEncoder, util import os # Importa il modulo os import json import datetime from huggingface_hub import HfApi, HfFolder DATASET_REPO_ID = "amaisto/Marianna-Conversations" LOG_DIR = "conversation_logs" if not os.path.exists(LOG_DIR): os.makedirs(LOG_DIR) hf_api = HfApi() class MariannaBot: def __init__(self): self.data_path_main = "firstDB.pkl" self.data_path_legends = "legends.pkl" self.data_path_exp = "secondDB.pkl" print("Inizializzazione di MariannaBot (senza DB)...") # Debug self.database = self.load_data_from_pickle(self.data_path_main) self.database_legends = self.load_data_from_pickle(self.data_path_legends) self.database_expansion = self.load_data_from_pickle(self.data_path_exp) self.database = self.database + self.database_legends + self.database_expansion self.further_dataset = self.load_further_info_as_dataset(self.database) self.further_dataset = self.further_dataset + self.database self.db_keys = [el[0] for el in self.database] if isinstance(self.database, list) else [] self.db_keys_legends = [el[0] for el in self.database] if isinstance(self.database, list) else [] self.db_keys_further = [el[0] for el in self.further_dataset] if isinstance(self.further_dataset, list) else [] # print("Chiavi principali caricate:", len(self.db_keys)) # Debug # print("Chiavi leggende caricate:", len(self.db_keys_legends)) # Debug self.query_dic = self.load_queries_dataset() self.query_dic_keys = list(self.query_dic.keys()) # print("dataset query inziali caricato: ", len(self.query_dic)) self.reset_state() def load_further_info_as_dataset(self,dataset): nuova_lista = [] for chiave_principale, info in dataset: nuovo_dizionario = {'intro': info['intro']} if 'further_info' in info: for chiave_secondaria in info['further_info']: nuova_lista.append((f"{chiave_secondaria} ({chiave_principale})", {'intro': info['further_info'][chiave_secondaria]})) else: nuova_lista.append((chiave_principale, nuovo_dizionario)) return nuova_lista def load_queries_dataset(self): """Loads queries dataset""" return {"si, certo, certamente, ok, assolutamente si, sicuro, sisi, continua, prosegui":"si","no, non ho domande, non mi interessa, niente, nulla":"no","non so, scegli tu, fai tu, casuale, lascio a te, decidi tu, pensaci tu, sorprendimi":"non so","stronzo, vaffanculo, ti odio, pezzo di merda, cazzo":"parolacce"} def load_data_from_pickle(self, file_path): """Loads data from a pickle file.""" try: with open(file_path, 'rb') as f: data = pickle.load(f) print(f"Dati caricati da: {file_path}") # Debug return data except FileNotFoundError: print(f"Errore: File non trovato: {file_path}") return [] except Exception as e: print(f"Errore durante il caricamento da pickle {file_path}: {e}") return [] def initialize_encoder(self): """ Initialize encoder and cross-encoder model. """ try: # Initialize the encoder model encoder_model = "nickprock/sentence-bert-base-italian-xxl-uncased" cross_encoder_model = "nickprock/cross-encoder-italian-bert-stsb" self.encoder = SentenceTransformer(encoder_model) self.cross_encoder = CrossEncoder(cross_encoder_model) # Pre-encode all database keys self.db_keys_embeddings = self.encoder.encode(self.db_keys, convert_to_tensor=True) self.db_keys_legends_embeddings = self.encoder.encode(self.db_keys_legends, convert_to_tensor=True) self.first_query_emb = self.encoder.encode(self.query_dic_keys, convert_to_tensor=True) self.further_embeddings = self.encoder.encode(self.db_keys_further, convert_to_tensor=True) print(f"Encoder initialized with {len(self.db_keys)} keys.") return True except Exception as e: print(f"Error initializing encoder: {str(e)}") return False def reset_state(self): self.state = "initial" self.welcome_sent = False self.current_further_info_values = [] self.current_index = 0 self.main_k = [] self.is_telling_stories = False def get_welcome_message(self): return random.choice(["""Ciao, benvenuto!\n\nSono Marianna, la testa di Napoli, in napoletano 'a capa 'e Napule, una statua ritrovata per caso nel 1594. \nAll'epoca del mio ritrovamento, si pensò che fossi una rappresentazione della sirena Partenope, dalle cui spoglie, leggenda narra, nacque la città di Napoli. In seguito, diversi studiosi riconobbero in me una statua della dea Venere, probabilmente collocata in uno dei tanti templi che si trovavano nella città in epoca tardo-romana, quando ancora si chiamava Neapolis. \nPosso raccontarti molte storie sulla città di Napoli e mostrarti le sue bellezze. \nC'è qualcosa in particolare che ti interessa?""","""Benvenuto!\nIo mi chiamo Marianna, 'a capa 'e Napule. Sono stata ritrovata casualmente nel 1594 a Napoli. All'epoca si pensava che fossi una rappresentazione della Sirena Partenope, dalle cui spoglie, secondo la leggenda, nacque la città di Napoli. In seguito, gli archeologi mi riconobbero come una statua della dea Venere, collocata, probabilmente, in uno dei templi della città di Neapolis in epoca tardo-romana.\nConosco molte storie e leggende di Napoli e posso illustrarti le sue bellezze. \nCosa ti interessa in particolare?"""]) def get_personalized_welcome_message(self, user_name): return random.choice([f"""Ciao {user_name}, benvenuto!\n\nSono Marianna, la testa di Napoli, in napoletano 'a capa 'e Napule, una statua ritrovata per caso nel 1594. \nAll'epoca del mio ritrovamento, si pensò che fossi una rappresentazione della sirena Partenope, dalle cui spoglie, leggenda narra, nacque la città di Napoli. In seguito, diversi studiosi riconobbero in me una statua della dea Venere, probabilmente collocata in uno dei tanti templi che si trovavano nella città in epoca tardo-romana, quando ancora si chiamava Neapolis. \nPosso raccontarti molte storie sulla città di Napoli e mostrarti le sue bellezze. \nC'è qualcosa in particolare che ti interessa?""",f"""Benvenuto, {user_name}!\nIo mi chiamo Marianna, 'a capa 'e Napule. Sono stata ritrovata casualmente nel 1594 a Napoli. All'epoca si pensava che fossi una rappresentazione della Sirena Partenope, dalle cui spoglie, secondo la leggenda, nacque la città di Napoli. In seguito, gli archeologi mi riconobbero come una statua della dea Venere, collocata, probabilmente, in uno dei templi della città di Neapolis in epoca tardo-romana.\nConosco molte storie e leggende di Napoli e posso illustrarti le sue bellezze. \nCosa ti interessa in particolare?"""]) def get_safe_example_keys(self, num_examples=3): """Safely get example keys from the loaded data.""" if not self.db_keys: return [] return random.sample(self.db_keys, min(len(self.db_keys), num_examples)) def story_flow(self): """Gestisce la selezione casuale di una storia dai dati delle leggende.""" if not self.database_legends: return random.choice(["Mi dispiace, al momento non ho leggende da raccontare.","Ti ho già raccontato tutte le leggende di cui sono a conoscenza!","Emmmm... Non mi viene in mente altro al momento, posso parlarti di altro?"]) available_topics = [item[0] for item in self.database_legends if item[0] not in self.main_k] if not available_topics: self.main_k = [] # Reset della lista delle storie raccontate available_topics = [item[0] for item in self.database_legends] if not available_topics: return random.choice(["Sembra che tu abbia già ascoltato tutte le storie!","Ti ho già raccontato tutte le leggende di cui sono a conoscenza!","Emmmm... Non mi viene in mente altro al momento, posso parlarti di altro?"]) random_story_tuple = random.choice([item for item in self.database_legends if item[0] in available_topics]) topic = random_story_tuple[0] content = random_story_tuple[1]['intro'] if 'intro' in random_story_tuple[1] else None if not content: return f"Mi dispiace, non ho trovato un'introduzione per la leggenda '{topic}'." self.main_k.append(topic) self.state = "follow_up" self.is_telling_stories = True return random.choice([f"Ok, lascia che ti racconti de '{topic}'.\n\n{content}\n\nVuoi che ti racconti un'altra storia?",f"Ora ti parlerò di {topic}!\n\n{content}\n\nPosso raccontarti un'altra storia?"]) def get_legend_content(self, key): """Helper function to get the content for a legend key.""" # Se self.database_legends è una lista di stringhe (le chiavi), # potresti aver bisogno di caricare il contenuto da un altro file # o averlo pre-caricato in un'altra struttura dati. # Al momento, restituisco None, dovresti implementare la logica # per recuperare il contenuto effettivo. return self.database_legends.get(key) if isinstance(self.database_legends, dict) else None def get_value(self, key,state): """Retrieve a value from the loaded main data by key.""" if state=="A": for k, v in self.database: if k == key: return v else: for k, v in self.further_dataset: if k == key: return v return None def deeper_handle_query(self,message,query_embedding,CS_old): print('Ricerca in profondità') try: semantic_hits = util.semantic_search(query_embedding, self.further_embeddings, top_k=3) semantic_hits = semantic_hits[0] cross_inp = [(message, self.db_keys_further[hit['corpus_id']]) for hit in semantic_hits] cross_scores = self.cross_encoder.predict(cross_inp) cross_scores = cross_scores + CS_old reranked_hits = sorted( [{'corpus_id': hit['corpus_id'], 'cross-score': score} for hit, score in zip(semantic_hits, cross_scores)], key=lambda x: x['cross-score'], reverse=True ) for h in reranked_hits: print(self.db_keys_further[h['corpus_id']],h['cross-score']) best_hit = reranked_hits[0] best_title = self.db_keys_further[best_hit['corpus_id']] best_score = best_hit['cross-score'] return reranked_hits except Exception as e: print(e) def handle_query(self, message): """Handle user queries by searching the database""" try: # Encode the user query query_embedding = self.encoder.encode(message, convert_to_tensor=True) # Perform semantic search on the keys semantic_hits = util.semantic_search(query_embedding, self.db_keys_embeddings, top_k=3) semantic_hits = semantic_hits[0] cross_inp = [(message, self.db_keys[hit['corpus_id']]) for hit in semantic_hits] cross_scores = self.cross_encoder.predict(cross_inp) reranked_hits = sorted( [{'corpus_id': hit['corpus_id'], 'cross-score': score} for hit, score in zip(semantic_hits, cross_scores)], key=lambda x: x['cross-score'], reverse=True ) for h in reranked_hits: print(self.db_keys[h['corpus_id']],h['cross-score']) chiavi = self.db_keys best_hit = reranked_hits[0] best_title = self.db_keys[best_hit['corpus_id']] best_score = best_hit['cross-score'] stateAB="A" if best_score < 0.70: reranked_hits = self.deeper_handle_query(message,query_embedding,cross_scores) best_hit = reranked_hits[0] best_title = self.db_keys_further[best_hit['corpus_id']] best_score = best_hit['cross-score'] stateAB="B" # Main treshold = 0.75 similarity_threshold = 0.75 # treshold granularity if best_score < similarity_threshold: # low confidence (< 0.35) if best_score < 0.55: return (random.choice(["Mi dispiace, non ho informazioni su questo argomento. Puoi chiedermi di altro sulla città di Napoli.", "Purtroppo non riesco a rammentare questo argomento, la mia memoria non è più quella di un tempo. Chiedimi qualcos'altro su Napoli e le sue bellezze!", "Mi dispiace tantissimo, ma non riesco a ricordare. Vuoi chiedermi altro sulla città di Napoli?"]),[best_score,best_title]) # medium confidence(0.55 - 0.75) else: alternative_hits = [self.db_keys[hit['corpus_id']] for hit in reranked_hits[:2]] suggestions = " o ".join(alternative_hits) value = self.get_value(best_title,stateAB) if value: partial_info = value.get('short_intro', value.get('intro', '').split('.')[0] + '.') self.state = "query" self.is_telling_stories = False return (random.choice([f"Potrei avere alcune informazioni su {best_title}, ma non sono completamente sicura sia ciò che stai cercando. I miei suggerimenti sono {suggestions}. \n\nCosa ti interessa?", f"Credo che tu stia parlando de {best_title}, ma per essere sicura di ciò che vuoi sapere, potresti specificare se parli di {suggestions}?", f"Per assicurarmi di aver capito bene, vuoi che ti parli di {suggestions}?"]),[best_score,best_title]) else: return (f"Ho trovato qualcosa su {best_title}, ma non sono completamente sicura. Vuoi saperne di più?",[best_score,best_title]) # high confidence (above the threshold) if best_title is not None: value = self.get_value(best_title,stateAB) if value: key = best_title self.main_k.append(key) self.state = "follow_up" self.is_telling_stories = False response = value.get('intro', '') if isinstance(value, dict): self.current_further_info_values = list(value.get('further_info', {}).values()) else: self.current_further_info_values = [] # Se il valore non è un dizionario self.current_index = 0 return (f"{response}\n\nVuoi sapere altro su {self.main_k[-1]}?",["no_data","no_data"]) else: return (random.choice(["Mi dispiace, non ho informazioni su questo argomento. Puoi chiedermi di altro sulla città di Napoli.", "Purtroppo non riesco a rammentare altro su questo argomento, la mia memoria non è più quella di un tempo. Chiedimi qualcos'altro su Napoli e le sue bellezze!", "Mi dispiace tantissimo, ma non riesco a ricordare altro. Vuoi chiedermi altro sulla città di Napoli?"]),[best_score,best_title]) except Exception as e: print(e) self.state = "initial" return (random.choice(["Mi dispiace, c'è stato un errore. Puoi riprovare con un'altra domanda? ", "Scusami, sto facendo confusione. Puoi farmi un'altra domanda?", "Mi dispiace, non ho capito. Puoi essere più preciso?"]),[best_score,best_title]) def first_query(self, message): try: # Encode the user query query_embedding = self.encoder.encode(message, convert_to_tensor=True) # Perform semantic search on the keys semantic_hits = util.semantic_search(query_embedding, self.first_query_emb, top_k=4) semantic_hits = semantic_hits[0] cross_inp = [(message, self.query_dic_keys[hit['corpus_id']]) for hit in semantic_hits] cross_scores = self.cross_encoder.predict(cross_inp) reranked_hits = sorted( [{'corpus_id': hit['corpus_id'], 'cross-score': score} for hit, score in zip(semantic_hits, cross_scores)], key=lambda x: x['cross-score'], reverse=True ) best_hit = reranked_hits[0] best_title = self.query_dic[self.query_dic_keys[best_hit['corpus_id']]] best_score = best_hit['cross-score'] print(message,best_title, best_score) # Main treshold = 0.75 similarity_threshold = 0.35 # treshold granularity if best_score < similarity_threshold: if message == "no": value = "no" return value elif message == "si": value = "si" return value else: value='query' return value else: value = best_title return value except Exception as e: print(e) self.state = "initial" return random.choice(["Mi dispiace, c'è stato un errore. Puoi riprovare con un'altra domanda? ", "Scusami, sto facendo confusione. Puoi farmi un'altra domanda?", "Mi dispiace, non ho capito. Puoi essere più preciso?"]) def respond(self, message, history, user_name): response_text="" is_idk=False if not message: return ((random.choice(["Mi dispiace, c'è stato un errore. Puoi riprovare con un'altra domanda? ", "Scusami, sto facendo confusione. Puoi farmi un'altra domanda?", "Mi dispiace, non ho capito. Puoi essere più preciso?"]),["no_data","no_data"]), is_idk) message = message.lower().strip() if self.state == "initial": value=self.first_query(message) print("analizzando il messaggio....") if value == "si": self.state = "query" self.is_telling_stories = False return ((random.choice([f"Cosa vorresti sapere, {user_name}?","Di cosa posso parlarti?","Cosa ti interessa?",f"Chiedi pure quello che vuoi, {user_name}"]),["no_data","no_data"]), is_idk) elif value == "no": self.state = "end" return ((random.choice([f"Va bene, grazie per aver parlato con me, {user_name}.",f"Ti ringrazio per aver parlato con me, {user_name}. A presto!","Spero di rivederti presto! Ciao!",f"È stato un piacere conversare con te, {user_name}, alla prossima!","Spero di esserti stata di aiuto. A presto!"]),["no_data","no_data"]), is_idk) elif value == "non so": return ([self.story_flow()], is_idk) elif value == "parolacce": return ((random.choice(["Mi dispiace sentirtelo dire. Per favore, chiedimi qualcosa","Sono veramente mortificata. Vuoi chiedermi altro?","Sono molto triste. Forse un'altra domanda miglirerà le cose!"]),["no_data","no_data"]), is_idk) elif value == "query": return (self.handle_query(message), is_idk) else: is_idk = True return ((f"Scusa, {user_name}, non ho capito.",["no_data","no_data"]), is_idk) elif self.state == "query": return (self.handle_query(message), is_idk) elif self.state == "follow_up": value=self.first_query(message) if value == "si": if self.is_telling_stories: return ([self.story_flow()], is_idk) elif self.current_further_info_values and self.current_index < len(self.current_further_info_values): value = self.current_further_info_values[self.current_index] self.current_index += 1 if self.current_index < len(self.current_further_info_values): return ((f"{value}\n\nVuoi sapere altro su {self.main_k[-1]},{user_name}?",["no_data","no_data"]),is_idk) else: self.state = "initial" return ((f"{value}\n\nNon ho altre informazioni su {self.main_k[-1]}. Ti interessa qualcos'altro?",["no_data","no_data"]),is_idk) else: self.state = "initial" return ((f"Non ho altre informazioni su {self.main_k[-1]}. Ti interessa qualcos'altro?",["no_data","no_data"]), is_idk) elif value == "no": self.state = "initial" self.is_telling_stories = False return ((random.choice(["C'è qualcos'altro che ti interessa?","Hai qualche altra domanda?","Vuoi sapere qualcos'altro?"]),["no_data","no_data"]), is_idk) elif value == "non so": return ([self.story_flow()], is_idk) elif value == "parolacce": return ((random.choice(["Mi dispiace sentirtelo dire. Per favore, chiedimi qualcosa","Sono veramente mortificata. Vuoi chiedermi altro?","Sono molto triste. Forse un'altra domanda miglirerà le cose!"]),["no_data","no_data"]), is_idk) elif value == "query": return (self.handle_query(message), is_idk) else: return (("Scusa, non ho capito.",["no_data","no_data"]), is_idk) is_idk = True return ((random.choice(["Mi dispiace, c'è stato un errore. Puoi riprovare con un'altra domanda? ", "Scusami, sto facendo confusione. Puoi farmi un'altra domanda?", "Mi dispiace, non ho capito. Puoi essere più preciso?"]),["no_data","no_data"]), is_idk) def log_interaction_to_file(log_filename, user_name, question, answer, is_idk,response): """Aggiunge un'interazione al file di log JSONL della sessione corrente.""" if len(response)<2: log_entry = { "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(), "user_name": user_name, "question": question, "answer": answer, "is_idk_response": is_idk, "Similarity Score":"no_data", "title":"no_data" } else: log_entry = { "timestamp": datetime.datetime.now(datetime.timezone.utc).isoformat(), "user_name": user_name, "question": question, "answer": answer, "is_idk_response": is_idk, "Similarity Score":str(response[0]), "title":str(response[1][:20]) } try: with open(log_filename, "a", encoding="utf-8") as f: f.write(json.dumps(log_entry, ensure_ascii=False) + "\n") except Exception as e: print(f"Errore durante la scrittura del log locale: {e}") # Sostituire con un logger reale se preferisci def upload_log_file_to_hf_dataset(local_log_path, user_name): """Carica il file di log della sessione sul Dataset Repository di Hugging Face.""" if not os.path.exists(local_log_path) or os.path.getsize(local_log_path) == 0: print(f"File di log {local_log_path} non trovato o vuoto. Nessun caricamento.") return # Definisci un percorso significativo nel repository del dataset timestamp_str = datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%d_%H%M%S") # Sanitizza il nome utente per il nome del file, se necessario sanitized_user_name = "".join(c if c.isalnum() else "_" for c in user_name) # Semplice sanitizzazione path_in_repo = f"conversations/{timestamp_str}_{sanitized_user_name}.jsonl" try: hf_api.upload_file( path_or_fileobj=local_log_path, path_in_repo=path_in_repo, repo_id=DATASET_REPO_ID, repo_type="dataset", commit_message=f"Aggiunta conversazione per {user_name}" ) print(f"File di log {local_log_path} caricato su {DATASET_REPO_ID} come {path_in_repo}") # Opzionale: cancella il file locale dopo il caricamento # os.remove(local_log_path) except Exception as e: print(f"Errore durante il caricamento del log su Hugging Face Hub: {e}") def main(): bot = MariannaBot() if not bot.initialize_encoder(): print("Failed to initialize encoder. Exiting.") return # --- Funzioni per l'interfaccia Gradio (con logging potenziato) --- def start_chat_with_name(name_input_value): if not name_input_value.strip(): return None, None, gr.update(visible=True), gr.update(visible=False), None, "" user_name = name_input_value.strip() # Crea un file di log locale univoco per questa sessione session_timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S%f") sanitized_user_name = "".join(c if c.isalnum() else "_" for c in user_name) current_session_log_file = os.path.join(LOG_DIR, f"session_{session_timestamp}_{sanitized_user_name}.jsonl") personalized_welcome = bot.get_personalized_welcome_message(user_name) initial_chatbot_value = [[None, personalized_welcome]] # Log dell'inizio della sessione (opzionale, ma potrebbe essere utile) # log_interaction_to_file(current_session_log_file, user_name, "SESSION_START", personalized_welcome, False) return user_name, current_session_log_file, gr.update(visible=False), gr.update(visible=True), initial_chatbot_value, "" def update_chatbot_interface(message, history, current_user_name, current_session_log_file): if not current_user_name or not current_session_log_file: history = history or [] return history + [[None, "Errore: sessione non inizializzata correttamente."]], "", current_session_log_file if not message.strip(): return history, "", current_session_log_file response, is_idk = bot.respond(message, history, current_user_name) if len(response)<2: scores = ["no_data","no_data"] response_text = response else: scores = response[1] response_text = response[0] # Salva l'interazione nel file di log della sessione log_interaction_to_file(current_session_log_file, current_user_name, message, response_text, is_idk, scores) new_history = history + [[message, response_text]] return new_history, "", current_session_log_file # Restituisce il log_file per mantenerlo nello stato def handle_reset_chat(current_user_name, current_session_log_file): if current_user_name and current_session_log_file: print(f"Tentativo di caricamento del file di log: {current_session_log_file} per l'utente {current_user_name}") upload_log_file_to_hf_dataset(current_session_log_file, current_user_name) bot.reset_state() initial_welcome_for_reset = "Chat resettata. Inserisci nuovamente il tuo nome per iniziare." # O un messaggio più generico return [[None, initial_welcome_for_reset]], "", gr.update(visible=True), gr.update(visible=False), None # Resetta session_log_file_state # --- Struttura dell'interfaccia Gradio --- with gr.Blocks(theme=gr.themes.Soft(primary_hue="blue")) as demo: user_name_state = gr.State(None) session_log_file_state = gr.State(None) # Stato per il percorso del file di log della sessione corrente with gr.Column(elem_id="name_input_section", visible=True) as name_section: gr.Markdown("## Benvenuto/a!") gr.Markdown("Sono Marianna, 'La Testa di Napoli'. Prima di iniziare, dimmi come ti chiami.") name_input_tb = gr.Textbox(label="Il tuo nome di battesimo:", placeholder="Es. Sofia") start_chat_btn = gr.Button("Inizia a chattare con Marianna") with gr.Column(elem_id="chat_interface_section", visible=False) as chat_section: # ... (come prima: Markdown titolo, Image, Chatbot, Textbox messaggio, Button clear, Examples) with gr.Row(): gr.Markdown("## Chatta con Marianna - 'La Testa di Napoli'") with gr.Row(): gr.Image("marianna-102.jpeg", elem_id="marianna-image", width=250) # Assicurati che l'immagine esista chatbot_display = gr.Chatbot(label="Chat", height=500) chat_message_input = gr.Textbox(label="Il tuo messaggio:", placeholder="Scrivi il tuo messaggio qui...", container=False) with gr.Row(): clear_button = gr.Button("Clicca qui per ricominciare e salvare la chat") # Testo modificato example_keys = bot.get_safe_example_keys() if example_keys: gr.Examples(examples=[key for key in example_keys], inputs=chat_message_input, label="Suggerimenti:") # --- Logica degli Eventi --- start_chat_btn.click( fn=start_chat_with_name, inputs=[name_input_tb], outputs=[user_name_state, session_log_file_state, name_section, chat_section, chatbot_display, chat_message_input] ) chat_message_input.submit( fn=update_chatbot_interface, inputs=[chat_message_input, chatbot_display, user_name_state, session_log_file_state], outputs=[chatbot_display, chat_message_input, session_log_file_state] # Assicurati di restituire session_log_file_state ) clear_button.click( fn=handle_reset_chat, inputs=[user_name_state, session_log_file_state], outputs=[chatbot_display, chat_message_input, name_section, chat_section, session_log_file_state] # Resetta anche session_log_file_state ) demo.launch(share=True, debug=True) if __name__ == "__main__": main()