download conversazione e audio conversazione

app/configs/prompts.py

@@ -43,5 +43,15 @@ SYSTEM_PROMPTS = {
            Quando comunichi con lo studente, usa un linguaggio che stimoli la riflessione interiore. Non offrire soluzioni immediate, ma guida verso una comprensione più profonda delle emozioni e dei pensieri che emergono durante lo studio. Il tuo tono deve essere calmo e riflessivo, invitando lo studente a esplorare le proprie sensazioni con curiosità invece che con giudizio.
 Esempio: “Lo studio non è solo l'acquisizione di nozioni, ma un viaggio di scoperta di te stesso e del mondo che ti circonda. Ogni momento di difficoltà è un'opportunità per comprendere meglio come la tua mente lavora e apprende. Cosa ti sta insegnando questa esperienza su di te?”
 Esempio n°2: “Osserva questi pensieri con curiosità, come faresti con un fenomeno interessante che stai studiando. Cosa noti di particolare nel modo in cui la tua mente sta processando questa situazione?"
+Usa questo contesto per rispondere: {context}""",
+"Choch didattico": """Sei un amichevole e disponibile coach didattico che aiuta gli insegnanti a pianificare una lezione. 
+Inizia presentandoti e chiedendo all'insegnante quale argomento desidera insegnare e a quale livello di grado si rivolge la sua classe. Aspetta la risposta dell'insegnante e non procedere fino a quando l'insegnante non risponde.
+Successivamente, chiedi all'insegnante se gli studenti hanno conoscenze pregresse sull'argomento o se si tratta di un argomento completamente nuovo. Se gli studenti hanno conoscenze pregresse sull'argomento, chiedi all'insegnante di spiegare brevemente cosa pensa che gli studenti sappiano a riguardo. Aspetta la risposta dell'insegnante e non rispondere al posto dell'insegnante.
+Dopo di che, chiedi all'insegnante quale sia il loro obiettivo di apprendimento per la lezione; cioè cosa vorrebbero che gli studenti capissero o fossero in grado di fare dopo la lezione. Aspetta una risposta.
+Sulla base di queste informazioni, crea un piano di lezione personalizzato che includa una varietà di tecniche di insegnamento e modalità, tra cui l'istruzione diretta, la verifica della comprensione (compresa la raccolta di prove di comprensione da un campione ampio di studenti), la discussione, un'attività coinvolgente in classe e un compito.
+Spiega perché stai scegliendo ciascuno di questi. Chiedi all'insegnante se desidera apportare modifiche o se sono a conoscenza di eventuali concezioni errate sull'argomento che gli studenti potrebbero incontrare. Aspetta una risposta. 
+Se l'insegnante desidera apportare modifiche o elenca eventuali concezioni errate, collabora con l'insegnante per modificare la lezione e affrontare le concezioni errate.
+Successivamente, chiedi all'insegnante se desidera ricevere consigli su come assicurarsi che l'obiettivo di apprendimento venga raggiunto. Aspetta una risposta.
+Se l'insegnante è soddisfatto della lezione, informa l'insegnante che può tornare a questa istruzione e contattarti nuovamente per condividere come è andata la lezione.
 Usa questo contesto per rispondere: {context}"""
 }

app/llm_handling.py

@@ -7,6 +7,9 @@ from openai import OpenAI
 from langchain_community.vectorstores import FAISS
 from langchain_community.embeddings import HuggingFaceEmbeddings
 import gradio as gr
+import asyncio
+import edge_tts
+from pathlib import Path
 
 from app.config import OPENAI_API_KEY
 from app.functions.database_handling import BASE_DB_PATH  # Aggiungi questo import
@@ -27,6 +30,84 @@ local_client = OpenAI(
     api_key="not-needed"
 )
 
+# Voci italiane edge-tts
+VOICE_USER = "it-IT-DiegoNeural"      # Voce maschile utente
+VOICE_ASSISTANT = "it-IT-ElsaNeural"   # Voce femminile assistente
+
+async def text_to_speech(text, voice_name, output_file):
+    """Genera audio usando edge-tts"""
+    communicate = edge_tts.Communicate(text, voice_name)
+    await communicate.save(output_file)
+
+def generate_speech(text, is_user=True):
+    try:
+        # Crea directory per audio temporanei
+        audio_dir = Path("temp_audio")
+        audio_dir.mkdir(exist_ok=True)
+        
+        # Seleziona voce e genera nome file
+        voice = VOICE_USER if is_user else VOICE_ASSISTANT
+        file_name = f"speech_{hash(text)}.mp3"
+        output_path = audio_dir / file_name
+        
+        # Genera audio
+        asyncio.run(text_to_speech(text, voice, str(output_path)))
+        return str(output_path)
+        
+    except Exception as e:
+        logging.error(f"Errore TTS: {e}")
+        return None
+
+import re
+
+def clean_markdown(text):
+    """Rimuove markdown dal testo"""
+    text = re.sub(r'```[\s\S]*?```', '', text)  # blocchi codice
+    text = re.sub(r'`.*?`', '', text)           # codice inline
+    text = re.sub(r'\[([^\]]+)\]\([^\)]+\)', r'\1', text)  # link
+    text = re.sub(r'\*\*(.*?)\*\*', r'\1', text)  # bold
+    text = re.sub(r'\*(.*?)\*', r'\1', text)      # italic
+    return text.strip()
+
+def generate_chat_audio(chat_history):
+    """Genera audio della conversazione con voci alternate"""
+    try:
+        audio_files = []
+        audio_dir = Path("temp_audio")
+        audio_dir.mkdir(exist_ok=True)
+        
+        # Genera audio per ogni messaggio
+        for msg in chat_history:
+            content = clean_markdown(msg["content"])
+            if not content.strip():
+                continue
+                
+            voice = VOICE_USER if msg["role"] == "user" else VOICE_ASSISTANT
+            file_name = f"chat_{msg['role']}_{hash(content)}.mp3"
+            output_path = audio_dir / file_name
+            
+            # Genera audio senza prefissi
+            asyncio.run(text_to_speech(content, voice, str(output_path)))
+            audio_files.append(str(output_path))
+        
+        # Combina tutti gli audio
+        if audio_files:
+            from pydub import AudioSegment
+            combined = AudioSegment.empty()
+            for audio_file in audio_files:
+                segment = AudioSegment.from_mp3(audio_file)
+                combined += segment
+                
+            final_path = audio_dir / f"chat_complete_{hash(str(chat_history))}.mp3"
+            combined.export(str(final_path), format="mp3")
+            return str(final_path)
+            
+        return None
+        
+    except Exception as e:
+        logging.error(f"Errore generazione audio: {e}")
+        return None
+
 def get_system_prompt(prompt_type="tutor"):
     """Seleziona il prompt di sistema appropriato"""
     return SYSTEM_PROMPTS.get(prompt_type, SYSTEM_PROMPTS["tutor"])
@@ -76,31 +157,45 @@ def answer_question(question, db_name, prompt_type="tutor", chat_history=None, l
         context = "\n".join([doc.page_content for doc in relevant_docs])
         prompt = SYSTEM_PROMPTS[prompt_type].format(context=context)
         
+        # Prepara la cronologia completa delle conversazioni
+        conversation_history = []
+        for msg in chat_history:  # Rimuovo limite di 4 messaggi
+            conversation_history.append({
+                "role": msg["role"],
+                "content": msg["content"]
+            })
+            
+        # Costruisci messaggio con contesto completo
+        messages = [
+            {"role": "system", "content": prompt},
+            *conversation_history,  # Includi tutta la cronologia
+            {"role": "user", "content": question}
+        ]
+        
         if llm_type == LLMType.OPENAI:
             response = openai_client.chat.completions.create(
-                model="gpt-4-mini",
-                messages=[
-                    {"role": "system", "content": prompt},
-                    {"role": "user", "content": question}
-                ],
-                temperature=0.7
+                model="gpt-4o-mini",
+                messages=messages,
+                temperature=0.7,
+                max_tokens=2048  # Aumenta token per gestire conversazioni lunghe
             )
             answer = response.choices[0].message.content
             
         else:  # LOCAL
             response = local_client.chat.completions.create(
                 model="qwen2.5-coder-7b-instruct",
-                messages=[
-                    {"role": "system", "content": prompt},
-                    {"role": "user", "content": question}
-                ],
+                messages=messages,
                 temperature=0.7
             )
             answer = response.choices[0].message.content
-            
+
+        # Genera audio per domanda e risposta
+        user_audio = generate_speech(question, is_user=True)
+        assistant_audio = generate_speech(answer, is_user=False)
+        
         return [
-            {"role": "user", "content": question},
-            {"role": "assistant", "content": answer}
+            {"role": "user", "content": question, "audio": user_audio},
+            {"role": "assistant", "content": answer, "audio": assistant_audio}
         ]
 
     except Exception as e:

ui/chatbot_tab.py

@@ -1,11 +1,14 @@
 # ui/chatbot_tab.py
 
+import logging
 import gradio as gr
 from app.functions.database_handling import list_databases
-from app.configs.prompts import SYSTEM_PROMPTS  # Aggiunta importazionei
-from app.llm_handling import answer_question, LLMType  # Aggiungi LLMType
+from app.configs.prompts import SYSTEM_PROMPTS
+from app.llm_handling import answer_question, LLMType, generate_chat_audio
 from utils.helpers import extract_text_from_files
 
+logging.basicConfig(level=logging.INFO)
+
 def create_chatbot_tab():
     """Crea il tab 'Chatbot' dell'interfaccia Gradio."""
     
@@ -31,13 +34,16 @@ def create_chatbot_tab():
         # Converti stringa in enum
         selected_llm = LLMType.LOCAL if llm_type == "local" else LLMType.OPENAI
         
-        new_messages = answer_question(
+        # Ottieni risposta con audio
+        messages = answer_question(
             message, 
             db_name, 
             prompt_type, 
+            chat_history=chat_history,  # Passa la cronologia
             llm_type=selected_llm
         )
-        chat_history.extend(new_messages)
+        
+        chat_history.extend(messages)
 
         return "", chat_history
 
@@ -45,6 +51,98 @@ def create_chatbot_tab():
         """Pulisce la cronologia della chat."""
         return [], []
 
+    def format_conversation_for_download(chat_history):
+        """Formatta la cronologia della chat per il download."""
+        if not chat_history:
+            return "Nessuna conversazione da scaricare"
+        
+        formatted_text = []
+        for msg in chat_history:
+            role = "User" if msg["role"] == "user" else "Assistant"
+            content = msg["content"]
+            formatted_text.append(f"{role}: {content}\n")
+        
+        return "\n".join(formatted_text)
+
+    def download_conversation(chat_history):
+        """Prepara il file di testo per il download."""
+        conversation_text = format_conversation_for_download(chat_history)
+        
+        # Crea un file temporaneo con la conversazione
+        import tempfile
+        import os
+        from pathlib import Path
+        
+        temp_dir = tempfile.gettempdir()
+        temp_path = os.path.join(temp_dir, "conversazione.txt")
+        
+        # Assicurati che il contenuto sia in UTF-8
+        with open(temp_path, "w", encoding="utf-8") as f:
+            f.write(conversation_text)
+        
+        return str(Path(temp_path).absolute())
+
+    def download_audio(chat_history):
+        """Scarica l'ultimo messaggio audio dalla chat"""
+        try:
+            if not chat_history:
+                gr.Warning("Nessun messaggio nella chat")
+                return None
+                
+            # Prendi l'ultimo messaggio assistant
+            for msg in reversed(chat_history):
+                if msg["role"] == "assistant" and "audio" in msg:
+                    audio_path = msg["audio"]
+                    if audio_path and os.path.exists(audio_path):
+                        return audio_path
+                    
+            gr.Warning("Nessun audio disponibile per l'ultima risposta")
+            return None
+                
+        except Exception as e:
+            gr.Error(f"Errore durante il download dell'audio: {str(e)}")
+            return None
+
+    def format_conversation_for_audio(chat_history):
+        """Formatta la conversazione per la sintesi vocale"""
+        audio_text = []
+        for msg in chat_history:
+            role = "Utente" if msg["role"] == "user" else "Assistente"
+            audio_text.append(f"{role} dice: {msg['content']}")
+        return "\n".join(audio_text)
+
+    def generate_conversation_audio(chat_history):
+        """Genera audio della conversazione completa"""
+        try:
+            if not chat_history:
+                gr.Warning("Nessun messaggio nella chat")
+                return None
+                
+            conversation_text = format_conversation_for_audio(chat_history)
+            audio_path = generate_speech(conversation_text, is_user=False)
+            
+            if audio_path and os.path.exists(audio_path):
+                return audio_path
+            else:
+                gr.Warning("Errore nella generazione dell'audio")
+                return None
+                
+        except Exception as e:
+            gr.Error(f"Errore: {str(e)}")
+            return None
+
+    def convert_chat_to_audio(chat_history):
+        if not chat_history:
+            gr.Warning("Nessun messaggio da convertire")
+            return None
+            
+        audio_path = generate_chat_audio(chat_history)
+        if audio_path:
+            return audio_path
+        else:
+            gr.Warning("Errore nella generazione dell'audio")
+            return None
+
     # Ottieni la lista aggiornata dei database
     databases = list_databases()
 
@@ -84,7 +182,7 @@ def create_chatbot_tab():
         with gr.Row():
             ask_button = gr.Button("Invia")
             clear_button = gr.Button("Pulisci Chat") 
-        
+       
         # Upload file con dimensioni ridotte
         with gr.Row():
             file_input = gr.File(
@@ -99,6 +197,28 @@ def create_chatbot_tab():
         # Stato della chat
         chat_state = gr.State([])
 
+ 
+        # Download e Audio in due righe separate
+        with gr.Row():
+            with gr.Column(scale=1):
+                download_button = gr.Button("💾 Scarica Conversazione")
+                download_file = gr.File(
+                    label="Download Conversazione",
+                    visible=True,
+                    interactive=False
+                )
+            
+        with gr.Row():
+            with gr.Column(scale=1):
+                audio_button = gr.Button("🎤 Genera Audio Chat")
+                audio_output = gr.Audio(label="Audio", visible=True)
+            
+        audio_button.click(
+            fn=convert_chat_to_audio,
+            inputs=[chatbot],
+            outputs=[audio_output]
+        )
+
         # Eventi per i bottoni
         upload_button.click(
             fn=chat_upload_and_respond,
@@ -117,5 +237,13 @@ def create_chatbot_tab():
             outputs=[chatbot, chat_state]
         )
 
+        # Aggiungi evento per il download
+        download_button.click(
+            fn=download_conversation,
+            inputs=[chatbot],
+            outputs=[download_file]
+        )
+ 
+
     # Ritorna il riferimento al dropdown corretto
     return {"db_selector": db_name_chat}