Update app.py

app.py

@@ -6,112 +6,54 @@ import os
 import json
 import gradio as gr
 from tools.final_answer import FinalAnswerTool
-import tempfile
-import shutil
 
-# Constantes
+# File to save the history of recognized songs
 HISTORY_FILE = "song_history.json"
 
+# Supported languages (sin alemán)
 LANGUAGES = {
     "English": "en",
     "Español": "es",
     "Français": "fr"
 }
 
-MESSAGES = {
-    "en": {
-        "title": "# 🎵 Music Recognition & Fun Facts",
-        "subtitle": "Identify songs, learn interesting facts about artists, and chat about music",
-        "language_label": "Choose your language",
-        "rec_button": "REC FOR 10 SECONDS",
-        "recognize_button": "RECOGNIZE SONG",
-        "no_audio": "Please record an audio clip",
-        "loading": "Recording... Click Stop when done (10 seconds max)",
-        "audio_loaded": "✅ Audio loaded! Ready to recognize",
-        "uploading": "Please wait while the audio is being uploaded...",
-        "searching": "Searching your song in the sonic multiverse, please wait to discover amazing facts about your artist. This is a beta version, it might be a bit slow, please be patient...",
-        "recognized": "✅ Song successfully recognized!",
-        "error": "❌ Error recognizing the song: {error}",
-        "artist_info_title": "### 🌟 About the Artist",
-        "history_title": "### History of recognized songs",
-        "history_button": "View History",
-        "history_limit_label": "Number of songs to show",
-        "no_history": "📋 No song recognition history yet",
-        "empty_history": "📋 Song history is empty",
-        "history_error": "❌ Error getting history: {error}",
-        "chat_title": "### Ask me more about this artist or music in general",
-        "chat_placeholder": "Ask about the artist, song, or anything music related...",
-        "chat_button": "Send"
-    },
-    "es": {
-        "title": "# 🎵 Reconocimiento Musical y Datos Curiosos",
-        "subtitle": "Identifica canciones, aprende datos interesantes sobre artistas y chatea sobre música",
-        "language_label": "Elige tu idioma",
-        "rec_button": "GRABAR POR 10 SEGUNDOS",
-        "recognize_button": "RECONOCER CANCIÓN",
-        "no_audio": "Por favor graba un clip de audio",
-        "loading": "Grabando... Haz clic en Detener cuando termines (máximo 10 segundos)",
-        "audio_loaded": "✅ ¡Audio cargado! Listo para reconocer",
-        "uploading": "Por favor espera mientras se carga el audio...",
-        "searching": "Buscando tu canción en el multiverso sónico, por favor espera para descubrir datos increíbles sobre tu artista. Esta es una versión beta, puede ser un poco lenta, por favor ten paciencia...",
-        "recognized": "✅ ¡Canción reconocida con éxito!",
-        "error": "❌ Error al reconocer la canción: {error}",
-        "artist_info_title": "### 🌟 Sobre el Artista",
-        "history_title": "### Historial de canciones reconocidas",
-        "history_button": "Ver Historial",
-        "history_limit_label": "Número de canciones a mostrar",
-        "no_history": "📋 No hay historial de canciones reconocidas todavía",
-        "empty_history": "📋 El historial de canciones está vacío",
-        "history_error": "❌ Error al obtener el historial: {error}",
-        "chat_title": "### Pregúntame más sobre este artista o música en general",
-        "chat_placeholder": "Pregunta sobre el artista, la canción o cualquier tema musical...",
-        "chat_button": "Enviar"
-    },
-    "fr": {
-        "title": "# 🎵 Reconnaissance Musicale et Anecdotes",
-        "subtitle": "Identifiez des chansons, découvrez des faits intéressants sur les artistes et discutez de musique",
-        "language_label": "Choisissez votre langue",
-        "rec_button": "ENREGISTRER PENDANT 10 SECONDES",
-        "recognize_button": "RECONNAÎTRE LA CHANSON",
-        "no_audio": "Veuillez enregistrer un clip audio",
-        "loading": "Enregistrement... Cliquez sur Arrêter quand c'est fini (10 secondes maximum)",
-        "audio_loaded": "✅ Audio chargé ! Prêt à reconnaître",
-        "uploading": "Veuillez patienter pendant le chargement de l'audio...",
-        "searching": "Recherche de votre chanson dans le multivers sonore, veuillez patienter pour découvrir des faits incroyables sur votre artiste. Ceci est une version bêta, cela peut être un peu lent, soyez patient...",
-        "recognized": "✅ Chanson reconnue avec succès !",
-        "error": "❌ Erreur lors de la reconnaissance de la chanson : {error}",
-        "artist_info_title": "### 🌟 À propos de l'Artiste",
-        "history_title": "### Historique des chansons reconnues",
-        "history_button": "Voir l'Historique",
-        "history_limit_label": "Nombre de chansons à afficher",
-        "no_history": "📋 Aucun historique de reconnaissance de chansons pour l'instant",
-        "empty_history": "📋 L'historique des chansons est vide",
-        "history_error": "❌ Erreur lors de l'obtention de l'historique : {error}",
-        "chat_title": "### Posez-moi des questions sur cet artiste ou la musique en général",
-        "chat_placeholder": "Posez des questions sur l'artiste, la chanson ou tout sujet musical...",
-        "chat_button": "Envoyer"
-    }
-}
-
-# Herramientas
+# Tool to recognize songs using AudD
 @tool
 def recognize_song(audio_path: str) -> dict:
+    """Recognizes a song from an audio file
+    Args:
+        audio_path: path to the audio file to recognize
+    """
     AUDD_API_TOKEN = os.getenv("AUDD_API_TOKEN")
+    
     if not os.path.exists(audio_path):
         return {"error": "The audio file does not exist"}
+    
     try:
         with open(audio_path, 'rb') as file:
-            data = {'api_token': AUDD_API_TOKEN, 'return': 'spotify,apple_music'}
-            files = {'file': file}
+            data = {
+                'api_token': AUDD_API_TOKEN,
+                'return': 'spotify,apple_music'
+            }
+            files = {
+                'file': file
+            }
             response = requests.post('https://api.audd.io/', data=data, files=files)
+            
         if response.status_code != 200:
             return {"error": f"API Error: {response.status_code}"}
+            
         result = response.json()
+        
         if result['status'] == 'error':
             return {"error": result['error']['error_message']}
+            
         if not result.get('result'):
             return {"error": "Could not recognize the song"}
+            
         song_info = result['result']
+        
+        # Create object with song information
         song_data = {
             "Song": song_info.get('title', 'Unknown'),
             "Artist": song_info.get('artist', 'Unknown'),
@@ -120,92 +62,156 @@ def recognize_song(audio_path: str) -> dict:
             "Apple Music": song_info.get('apple_music', {}).get('url', 'Not available'),
             "Recognition Date": datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
         }
+        
+        # Save to history
         save_to_history(song_data)
+        
         return song_data
+        
     except Exception as e:
         return {"error": f"Error processing audio: {str(e)}"}
 
+# Function to save song to history
 def save_to_history(song_data):
+    """Saves a song to the history"""
     try:
+        # Load existing history or create new
         if os.path.exists(HISTORY_FILE):
             with open(HISTORY_FILE, 'r') as f:
-                history = json.load(f) if f.read().strip() else []
+                try:
+                    history = json.load(f)
+                except json.JSONDecodeError:
+                    history = []
         else:
             history = []
+        
+        # Add song to the beginning of history (most recent first)
         history.insert(0, song_data)
+        
+        # Limit history to the 50 most recent songs
         if len(history) > 50:
             history = history[:50]
+        
+        # Save updated history
         with open(HISTORY_FILE, 'w') as f:
             json.dump(history, f, indent=2)
+            
     except Exception as e:
         print(f"Error saving to history: {str(e)}")
 
+# Tool to view song history
 @tool
-def view_song_history(limit: int = 10, language: str = "en") -> str:
-    lang = LANGUAGES.get(language, "en")
+def view_song_history(limit: int = 10) -> str:
+    """Shows the history of recognized songs
+    Args:
+        limit: maximum number of songs to display (default 10)
+    """
     try:
         if not os.path.exists(HISTORY_FILE):
-            return f"📋 {MESSAGES[lang]['no_history']}"
+            return "📋 No song recognition history yet."
+        
         with open(HISTORY_FILE, 'r') as f:
-            history = json.load(f)
+            try:
+                history = json.load(f)
+            except json.JSONDecodeError:
+                return "📋 Error loading song history."
+        
         if not history:
-            return f"📋 {MESSAGES[lang]['empty_history']}"
+            return "📋 Song history is empty."
+        
+        # Limit the number of songs to display
         history = history[:min(limit, len(history))]
-        result = f"📋 **{MESSAGES[lang]['history_title']}:**\n\n"
+        
+        # Format output
+        result = "📋 **Song Recognition History:**\n\n"
+        
         for i, song in enumerate(history, 1):
             result += f"{i}. **{song.get('Song', 'Unknown')}** - *{song.get('Artist', 'Unknown')}*\n"
             result += f"   📀 Album: {song.get('Album', 'Unknown')}\n"
+            
             if song.get('Spotify', 'Not available') != 'Not available':
                 result += f"   🎧 [Spotify]({song.get('Spotify')})\n"
+                
             if song.get('Apple Music', 'Not available') != 'Not available':
                 result += f"   🍏 [Apple Music]({song.get('Apple Music')})\n"
+                
             result += f"   🕒 Recognized on: {song.get('Recognition Date', 'Unknown date')}\n\n"
+        
         return result
+        
     except Exception as e:
-        return f"❌ {MESSAGES[lang]['history_error'].format(error=str(e))}"
+        return f"❌ Error getting history: {str(e)}"
 
+# Tool to get artist information in selected language (sin alemán)
 @tool
-def get_artist_info(artist_name: str, song_title: str, language: str = "en") -> dict:
+def get_artist_info(artist_name: str, language: str = "en") -> str:
+    """Gets background information and fun facts about a music artist in the specified language
+    Args:
+        artist_name: name of the artist to get information about
+        language: language code (en, es, fr)
+    """
+    # Language-specific prompts (sin alemán)
     prompts = {
-        "en": f"Provide interesting and fun facts about the music artist '{artist_name}' that fans would love to know. Include stories about their career, personal anecdotes, how their song '{song_title}' was created if known, or surprising facts about their life. Include an image URL if possible. Focus on highlighting their contributions to music and anything that makes them unique as an artist. Keep it engaging and positive.",
-        "es": f"Proporciona datos interesantes y curiosos sobre el artista musical '{artist_name}' que a los fans les encantaría conocer. Incluye historias sobre su carrera, anécdotas personales, cómo se creó su canción '{song_title}' si se sabe, o datos sorprendentes sobre su vida. Incluye una URL de imagen si es posible. Céntrate en destacar sus contribuciones a la música y cualquier cosa que les haga únicos como artistas. Mantenlo atractivo y positivo.",
-        "fr": f"Fournissez des faits intéressants et amusants sur l'artiste musical '{artist_name}' que les fans aimeraient connaître. Incluez des histoires sur leur carrière, des anecdotes personnelles, comment leur chanson '{song_title}' a été créée si connu, ou des faits surprenants sur leur vie. Incluez une URL d'image si possible. Concentrez-vous sur la mise en valeur de leurs contributions à la musique et tout ce qui les rend uniques en tant qu'artiste. Gardez-le engageant et positif.",
+        "en": f"Provide interesting and fun facts about the music artist '{artist_name}' that fans would love to know. Include stories about their career, personal anecdotes, how their most famous songs were created, or surprising facts about their life. Focus on highlighting their contributions to music and anything that makes them unique as an artist. Keep it engaging and positive.",
+        "es": f"Proporciona datos interesantes y curiosos sobre el artista musical '{artist_name}' que a los fans les encantaría conocer. Incluye historias sobre su carrera, anécdotas personales, cómo se crearon sus canciones más famosas o datos sorprendentes sobre su vida. Céntrate en destacar sus contribuciones a la música y cualquier cosa que les haga únicos como artistas. Mantenlo atractivo y positivo.",
+        "fr": f"Fournissez des faits intéressants et amusants sur l'artiste musical '{artist_name}' que les fans aimeraient connaître. Incluez des histoires sur leur carrière, des anecdotes personnelles, comment leurs chansons les plus célèbres ont été créées, ou des faits surprenants sur leur vie. Concentrez-vous sur la mise en valeur de leurs contributions à la musique et tout ce qui les rend uniques en tant qu'artiste. Gardez-le engageant et positif."
     }
-    language = language if language in prompts else "en"
-    messages = [{"role": "user", "content": prompts[language]}]
+    
+    # Default to English if language not supported
+    if language not in prompts:
+        language = "en"
+    
+    # Create messages for the model
+    messages = [
+        {"role": "user", "content": prompts[language]}
+    ]
+    
     try:
+        # Using the same model that powers our agent
         response = model(messages)
-        content = response.content
-        image_url = None
-        if "[Image:" in content:
-            start = content.find("[Image:") + 7
-            end = content.find("]", start)
-            image_url = content[start:end].strip()
-            content = content[:start-7] + content[end+1:]
-        return {"text": content.strip(), "image": image_url}
+        return response.content
     except Exception as e:
-        return {"text": f"Could not retrieve information about {artist_name}: {str(e)}", "image": None}
+        return f"Could not retrieve information about {artist_name}: {str(e)}"
 
+# Chat with LLM tool (sin alemán)
 @tool
 def chat_with_assistant(query: str, artist_info: str = "", language: str = "en") -> str:
+    """Chat with the AI assistant about any music related topic in the specified language
+    Args:
+        query: user's question or request
+        artist_info: previous artist info to provide context
+        language: language code (en, es, fr)
+    """
+    # Language-specific system messages (sin alemán)
     system_messages = {
         "en": "You are a music expert assistant who specializes in providing engaging information about artists, songs, and music history. Focus on sharing interesting, fun facts that highlight the artist's unique contributions and stories.",
         "es": "Eres un asistente experto en música que se especializa en proporcionar información interesante sobre artistas, canciones e historia musical. Céntrate en compartir datos curiosos e interesantes que destaquen las contribuciones únicas y las historias del artista.",
-        "fr": "Vous êtes un assistant expert en musique qui se spécialise dans la fourniture d'informations intéressantes sur les artistes, les chansons et l'histoire de la musique. Concentrez-vous sur le partage de faits intéressants et amusants qui mettent en évidence les contributions uniques et les histoires de l'artiste.",
+        "fr": "Vous êtes un assistant expert en musique qui se spécialise dans la fourniture d'informations intéressantes sur les artistes, les chansons et l'histoire de la musique. Concentrez-vous sur le partage de faits intéressants et amusants qui mettent en évidence les contributions uniques et les histoires de l'artiste."
     }
-    language = language if language in system_messages else "en"
-    context = f"Previous context about the artist: {artist_info}\n\n" if artist_info else ""
+    
+    # Default to English if language not supported
+    if language not in system_messages:
+        language = "en"
+    
+    # Create context
+    context = ""
+    if artist_info:
+        context = f"Previous context about the artist: {artist_info}\n\n"
+    
+    # Create messages for the model
     messages = [
         {"role": "system", "content": system_messages[language]},
         {"role": "user", "content": context + query}
     ]
+    
     try:
+        # Using the model to generate a response
         response = model(messages)
         return response.content
     except Exception as e:
         return f"Sorry, I couldn't process your request: {str(e)}"
 
-# Configuración del agente
+# Agent configuration
 final_answer = FinalAnswerTool()
 model = HfApiModel(
     max_tokens=2096,
@@ -217,9 +223,16 @@ model = HfApiModel(
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
 
+# Agent definition
 agent = CodeAgent(
     model=model,
-    tools=[final_answer, recognize_song, view_song_history, get_artist_info, chat_with_assistant],
+    tools=[
+        final_answer,
+        recognize_song,
+        view_song_history,
+        get_artist_info,
+        chat_with_assistant
+    ],
     max_steps=8,
     verbosity_level=1,
     grammar=None,
@@ -229,177 +242,194 @@ agent = CodeAgent(
     prompt_templates=prompt_templates
 )
 
-# Descargar imagen (función auxiliar)
-def download_image(image_url):
-    if not image_url:
-        return ""
-    try:
-        response = requests.get(image_url, stream=True)
-        if response.status_code == 200:
-            temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.jpg')
-            shutil.copyfileobj(response.raw, temp_file)
-            temp_file.close()
-            return temp_file.name
-        return ""
-    except Exception:
-        return ""
-
-# Interfaz de usuario con Gradio
-with gr.Blocks(title="Music Recognition & Fun Facts", css=".large-text {font-size: 1.5em !important;} .big-button {font-size: 1.2em; padding: 15px 30px;}") as demo:
+# Gradio user interface
+with gr.Blocks(title="Music Recognition & Fun Facts") as demo:
+    # State variables
     selected_language = gr.State("en")
     song_info_state = gr.State(None)
     artist_info_state = gr.State("")
-    audio_status = gr.State("no_audio")
-
-    title = gr.Markdown(value=MESSAGES["en"]["title"], elem_id="title")
-    subtitle = gr.Markdown(value=MESSAGES["en"]["subtitle"], elem_id="subtitle")
-
+    audio_status = gr.State("no_audio")  # States: no_audio, loading, ready
+    
+    # Title and intro
+    gr.Markdown("# 🎵 Music Recognition & Fun Facts")
+    gr.Markdown("Identify songs, learn interesting facts about artists, and chat about music")
+    
+    # Language selection
     with gr.Row():
         language_dropdown = gr.Dropdown(
-            choices=[("English", "en"), ("Español", "es"), ("Français", "fr")],
-            value="en",
-            label=MESSAGES["en"]["language_label"]
+            choices=list(LANGUAGES.keys()),
+            value="English",
+            label="Choose your language"
         )
-
+    
+    # Combined recognition and chat interface
     with gr.Tab("Song Recognition & Chat"):
-        audio_status_msg = gr.Markdown(value=MESSAGES["en"]["no_audio"], elem_id="audio_status_msg")
+        # Audio status message
+        audio_status_msg = gr.Markdown("*Por favor, graba o sube un clip de audio*")
+        
+        # Song recognition section
         with gr.Row():
             with gr.Column(scale=1):
-                audio_input = gr.Audio(type="filepath", visible=False)
-                record_btn = gr.Button(value=MESSAGES["en"]["rec_button"], elem_classes="big-button", variant="primary", elem_id="record_btn")
-                audio_loaded_msg = gr.Markdown("", elem_classes="large-text")
-                recognize_btn = gr.Button(value=MESSAGES["en"]["recognize_button"], variant="secondary", elem_id="recognize_btn")
-
+                # Configuramos el componente de audio para usar el micrófono directamente
+                audio_input = gr.Audio(source="microphone", type="filepath", visible=False)
+                record_btn = gr.Button("🎙 REC MUSIC", size="lg", variant="primary")
+                recognize_btn = gr.Button("🔍 RECOGNIZE SONG", variant="secondary")
+        
+        # Recognition results section (separate from chat)
         with gr.Row():
             recognition_results = gr.Markdown("")
-
+        
+        # Artist info section
         with gr.Row():
-            artist_info_text = gr.Markdown("")
-            artist_info_image = gr.Image(type="filepath")
-
-        chat_title = gr.Markdown(value=MESSAGES["en"]["chat_title"], elem_id="chat_title")
-        chat_history = gr.Chatbot(label="Music Chat", type="messages")
-
+            artist_facts = gr.Markdown("")
+        
+        # Chat section
+        gr.Markdown("### Pregúntame más sobre este artista o música en general")
+        chat_history = gr.Chatbot(label="Music Chat")
+        
         with gr.Row():
             chat_input = gr.Textbox(
-                placeholder=MESSAGES["en"]["chat_placeholder"],
-                label="Your question",
-                elem_id="chat_input"
+                placeholder="Pregunta sobre el artista, la canción o cualquier tema musical...",
+                label="Tu pregunta"
             )
-            chat_btn = gr.Button(value=MESSAGES["en"]["chat_button"], variant="primary", elem_id="chat_btn")
-
+            chat_btn = gr.Button("Enviar", variant="primary")
+        
+        # Function to handle audio recording
+        def toggle_audio_widget():
+            return gr.update(visible=True), "loading", "*Espera mientras se graba el audio... Haz clic en Stop cuando termines*"
+        
+        # Function to update status when audio is recorded
+        def update_audio_status(audio_path):
+            if audio_path:
+                return "ready", "✅ *¡Audio cargado! Listo para reconocer. Presiona RECOGNIZE SONG*"
+            else:
+                return "no_audio", "*Por favor, graba o sube un clip de audio*"
+        
+        # Recognition function (sin alemán)
+        def process_audio(audio_path, language_name, status):
+            if not audio_path or status != "ready":
+                return None, "", "", "*Por favor, graba un clip de audio primero*"
+            
+            lang_code = LANGUAGES.get(language_name, "en")
+            
+            try:
+                result = recognize_song(audio_path)
+                
+                if "error" in result:
+                    return None, "", "", f"Error al reconocer la canción: {result['error']}"
+                
+                # Get artist information in selected language
+                artist_info = get_artist_info(result['Artist'], lang_code)
+                
+                # Format recognition result based on language
+                if lang_code == "en":
+                    recognition_msg = f"### 🎵 Recognized Song: {result['Song']}\n\n"
+                    recognition_msg += f"**🎤 Artist:** {result['Artist']}\n"
+                    recognition_msg += f"**📀 Album:** {result['Album']}\n\n"
+                    if result['Spotify'] != "Not available":
+                        recognition_msg += f"**🎧 [Listen on Spotify]({result['Spotify']})**\n"
+                    if result['Apple Music'] != "Not available":
+                        recognition_msg += f"**🍏 [Listen on Apple Music]({result['Apple Music']})**\n"
+                elif lang_code == "es":
+                    recognition_msg = f"### 🎵 Canción Reconocida: {result['Song']}\n\n"
+                    recognition_msg += f"**🎤 Artista:** {result['Artist']}\n"
+                    recognition_msg += f"**📀 Álbum:** {result['Album']}\n\n"
+                    if result['Spotify'] != "Not available":
+                        recognition_msg += f"**🎧 [Escuchar en Spotify]({result['Spotify']})**\n"
+                    if result['Apple Music'] != "Not available":
+                        recognition_msg += f"**🍏 [Escuchar en Apple Music]({result['Apple Music']})**\n"
+                elif lang_code == "fr":
+                    recognition_msg = f"### 🎵 Chanson Reconnue: {result['Song']}\n\n"
+                    recognition_msg += f"**🎤 Artiste:** {result['Artist']}\n"
+                    recognition_msg += f"**📀 Album:** {result['Album']}\n\n"
+                    if result['Spotify'] != "Not available":
+                        recognition_msg += f"**🎧 [Écouter sur Spotify]({result['Spotify']})**\n"
+                    if result['Apple Music'] != "Not available":
+                        recognition_msg += f"**🍏 [Écouter sur Apple Music]({result['Apple Music']})**\n"
+                
+                # Artist info section title based on language
+                if lang_code == "en":
+                    artist_facts_title = f"### 🌟 About {result['Artist']}\n\n"
+                elif lang_code == "es":
+                    artist_facts_title = f"### 🌟 Sobre {result['Artist']}\n\n"
+                elif lang_code == "fr":
+                    artist_facts_title = f"### 🌟 À propos de {result['Artist']}\n\n"
+                
+                # Format the artist info with a title
+                artist_facts_content = artist_facts_title + artist_info
+                
+                # Update status message
+                status_msg = "*¡Canción reconocida con éxito! Haz preguntas sobre el artista en el chat abajo*"
+                
+                return result, recognition_msg, artist_facts_content, status_msg
+            
+            except Exception as e:
+                return None, "", "", f"❌ Error procesando el audio: {str(e)}"
+        
+        # Chat function
+        def process_chat(query, language_name, song_info, artist_info):
+            if not query:
+                return []
+            
+            lang_code = LANGUAGES.get(language_name, "en")
+            
+            try:
+                # Get response
+                response = chat_with_assistant(query, artist_info, lang_code)
+                
+                return [(query, response)]
+            except Exception as e:
+                return [(query, f"Lo siento, no pude procesar tu solicitud: {str(e)}")]
+        
+        # Event handlers
+        record_btn.click(
+            fn=toggle_audio_widget,
+            inputs=[],
+            outputs=[audio_input, audio_status, audio_status_msg]
+        )
+        
+        audio_input.change(
+            fn=update_audio_status,
+            inputs=[audio_input],
+            outputs=[audio_status, audio_status_msg]
+        )
+        
+        recognize_btn.click(
+            fn=process_audio,
+            inputs=[audio_input, language_dropdown, audio_status],
+            outputs=[song_info_state, recognition_results, artist_facts, audio_status_msg]
+        ).then(
+            fn=lambda a: a,
+            inputs=[artist_facts],
+            outputs=[artist_info_state]
+        )
+        
+        chat_btn.click(
+            fn=process_chat,
+            inputs=[chat_input, language_dropdown, song_info_state, artist_info_state],
+            outputs=[chat_history]
+        ).then(
+            fn=lambda: "",  # Clear input after sending
+            inputs=[],
+            outputs=[chat_input]
+        )
+    
     with gr.Tab("Song History"):
-        gr.Markdown(value=MESSAGES["en"]["history_title"])
+        gr.Markdown("### Historial de canciones reconocidas")
+        
         with gr.Row():
-            history_limit = gr.Slider(minimum=5, maximum=50, value=10, step=5, label=MESSAGES["en"]["history_limit_label"], elem_id="history_limit")
-            view_history_btn = gr.Button(value=MESSAGES["en"]["history_button"], elem_id="view_history_btn")
+            history_limit = gr.Slider(minimum=5, maximum=50, value=10, step=5, label="Número de canciones a mostrar")
+            view_history_btn = gr.Button("📋 Ver Historial")
+        
         history_output = gr.Markdown()
-
-    def update_ui(language_name):
-        lang = LANGUAGES.get(language_name, "en")
-        return (
-            MESSAGES[lang]["title"],
-            MESSAGES[lang]["subtitle"],
-            MESSAGES[lang]["no_audio"],
-            MESSAGES[lang]["rec_button"],
-            MESSAGES[lang]["recognize_button"],
-            MESSAGES[lang]["chat_title"],
-            MESSAGES[lang]["chat_placeholder"],
-            MESSAGES[lang]["chat_button"],
-            MESSAGES[lang]["history_limit_label"],
-            MESSAGES[lang]["history_button"]
+        
+        def view_history_process(limit):
+            return view_song_history(int(limit))
+        
+        view_history_btn.click(
+            fn=view_history_process,
+            inputs=[history_limit],
+            outputs=[history_output]
         )
 
-    language_dropdown.change(
-        fn=update_ui,
-        inputs=[language_dropdown],
-        outputs=[title, subtitle, audio_status_msg, record_btn, recognize_btn, chat_title, chat_input, chat_btn, history_limit, view_history_btn]
-    )
-
-    def toggle_audio_widget(language_name):
-        lang = LANGUAGES.get(language_name, "en")
-        return gr.update(visible=True), "loading", MESSAGES[lang]["loading"]
-
-    record_btn.click(
-        fn=toggle_audio_widget,
-        inputs=[language_dropdown],
-        outputs=[audio_input, audio_status, audio_status_msg]
-    )
-
-    def update_audio_status(audio_path, language_name):
-        lang = LANGUAGES.get(language_name, "en")
-        if audio_path:
-            return "ready", MESSAGES[lang]["audio_loaded"]
-        else:
-            return "no_audio", MESSAGES[lang]["no_audio"]
-
-    audio_input.change(
-        fn=update_audio_status,
-        inputs=[audio_input, language_dropdown],
-        outputs=[audio_status, audio_loaded_msg]
-    )
-
-    def process_audio(audio_path, language_name, status):
-        lang = LANGUAGES.get(language_name, "en")
-        if not audio_path or status != "ready":
-            return None, "", "", MESSAGES[lang]["no_audio"], ""
-        yield None, "", "", MESSAGES[lang]["uploading"], ""
-        yield None, "", "", MESSAGES[lang]["searching"], ""
-        try:
-            result = recognize_song(audio_path)
-            if "error" in result:
-                return None, "", "", MESSAGES[lang]["error"].format(error=result['error']), ""
-            artist_info = get_artist_info(result['Artist'], result['Song'], lang)
-            recognition_msg = f"### 🎵 Recognized Song: {result['Song']}\n\n**🎤 Artist:** {result['Artist']}\n**📀 Album:** {result['Album']}\n\n"
-            if result['Spotify'] != "Not available":
-                recognition_msg += f"**🎧 [Listen on Spotify]({result['Spotify']})**\n"
-            if result['Apple Music'] != "Not available":
-                recognition_msg += f"**🍏 [Listen on Apple Music]({result['Apple Music']})**\n"
-            artist_facts_content = f"{MESSAGES[lang]['artist_info_title']}\n\n{artist_info['text']}"
-            image_filepath = download_image(artist_info['image']) if artist_info['image'] else ""
-            status_msg = MESSAGES[lang]["recognized"]
-            return result, recognition_msg, artist_facts_content, status_msg, image_filepath
-        except Exception as e:
-            return None, "", "", MESSAGES[lang]["error"].format(error=str(e)), ""
-
-    recognize_btn.click(
-        fn=process_audio,
-        inputs=[audio_input, language_dropdown, audio_status],
-        outputs=[song_info_state, recognition_results, artist_info_text, audio_status_msg, artist_info_image]
-    ).then(
-        fn=lambda a: a,
-        inputs=[artist_info_text],
-        outputs=[artist_info_state]
-    )
-
-    def process_chat(query, language_name, song_info, artist_info):
-        lang = LANGUAGES.get(language_name, "en")
-        if not query:
-            return []
-        try:
-            response = chat_with_assistant(query, artist_info, lang)
-            return [(query, response)]
-        except Exception as e:
-            return [(query, f"Sorry, I couldn't process your request: {str(e)}")]
-
-    chat_btn.click(
-        fn=process_chat,
-        inputs=[chat_input, language_dropdown, song_info_state, artist_info_state],
-        outputs=[chat_history]
-    ).then(
-        fn=lambda: "",
-        inputs=[],
-        outputs=[chat_input]
-    )
-
-    def view_history_process(limit, language_name):
-        lang = LANGUAGES.get(language_name, "en")
-        return view_song_history(int(limit), lang)
-
-    view_history_btn.click(
-        fn=view_history_process,
-        inputs=[history_limit, language_dropdown],
-        outputs=[history_output]
-    )
-
 demo.launch()