v2.1 - works - but without syncs of voice and music.

README.md

@@ -147,7 +147,7 @@ cd src
 python app.py
 ```
 
-5. Open your browser to `http://localhost:7863`
+5. Open your browser to `http://localhost:7870`
 
 ## 📖 How to Use
 

run.py

@@ -12,7 +12,7 @@ from app import demo
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7870,
+        server_port=7871,
         share=False
     )
 

src/app.py

@@ -22,9 +22,61 @@ from rag_system import RadioRAGSystem
 from voice_input import VoiceInputService
 from user_memory import UserMemoryService
 
+
+def create_youtube_player_html(youtube_id: str, title: str, artist: str, url: str) -> str:
+    """Create YouTube player iframe HTML"""
+    return f"""
+<iframe width="100%" height="500"
+src="https://www.youtube.com/embed/{youtube_id}?autoplay=1"
+allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture"
+allowfullscreen>
+</iframe>
+"""
+
+
+def create_podcast_player_html(youtube_id: str, title: str, host: str, url: str) -> str:
+    """Create podcast YouTube player iframe HTML"""
+    return f"""
+<iframe width="100%" height="500"
+src="https://www.youtube.com/embed/{youtube_id}?autoplay=1"
+allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture"
+allowfullscreen>
+</iframe>
+"""
+
+
+def create_placeholder_html(title: str, artist: str, delay_s: float, media_type: str = "music") -> str:
+    """Create placeholder HTML shown while waiting for host speech to end"""
+    bg_color = "#1a1a2e" if media_type == "music" else "#6b46c1"
+    icon = "🎵" if media_type == "music" else "🎙️"
+    return f"""
+    <div style="padding: 1rem; background: linear-gradient(135deg, {bg_color} 0%, #16213e 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
+        <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">{icon} {title}</h4>
+        <p style="margin: 0 0 0.75rem 0; color: #aaa; font-size: 0.9em;">by {artist}</p>
+        <div style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000; display: flex; align-items: center; justify-content: center;">
+            <div style="position: absolute; top: 50%; left: 50%; transform: translate(-50%, -50%); text-align: center; color: #fff;">
+                <div style="font-size: 3em; margin-bottom: 0.5rem;">⏳</div>
+                <p style="margin: 0; font-size: 0.9em;">Video starts in {delay_s:.0f}s...</p>
+                <p style="margin: 0.5rem 0 0 0; font-size: 0.8em; color: #888;">After host finishes speaking</p>
+            </div>
+        </div>
+    </div>
+    """
+
+
+def get_pending_player():
+    """Check if there's a pending player ready to show"""
+    pending = radio_state.get("pending_player")
+    if pending and time.time() >= pending.get("ready_at", 0):
+        html = pending.get("html", "")
+        radio_state["pending_player"] = None  # Clear it
+        return html
+    return None
+
 # Global state
 radio_state = {
     "is_playing": False,
+    "is_stopped": False,  # User explicitly stopped (vs just paused)
     "current_segment_index": 0,
     "planned_show": [],
     "user_preferences": {},
@@ -35,12 +87,15 @@ radio_state = {
     "last_segment": None,
     "current_track": None,  # Currently playing track for like/dislike
     "user_id": None,  # Current user ID
+    "auto_play": True,  # Auto-play next segment when current finishes
     "content_filter": {
         "music": True,
         "news": True,
         "podcasts": True,
         "stories": True
-    }
+    },
+    # Pending media player (to be added after host speech ends)
+    "pending_player": None,  # {"html": "...", "ready_at": timestamp}
 }
 
 # Initialize services
@@ -178,12 +233,9 @@ def start_radio_stream():
 def start_and_play_first_segment():
     """
     One-shot helper for the UI:
-    - Plan the show (skeleton only, no LLM – but YouTube search can take a few seconds)
-    - Immediately generate + play the first segment (LLM + TTS)
+    - If resuming from stop: continue from next segment
+    - If fresh start: Plan the show and play first segment
     Returns everything needed to update the UI in a single call.
-    
-    NOTE: Total time is ~10-15s on first click (YouTube search + LLM + TTS).
-    We print progress to console so you can see it's not stuck.
     """
     print("▶️ [start_and_play_first_segment] Starting...")
     
@@ -220,6 +272,26 @@ def start_and_play_first_segment():
             }
             print("📋 Using default preferences")
     
+    # Check if resuming from stopped state
+    if radio_state.get("is_stopped") and radio_state.get("planned_show"):
+        print("▶️ Resuming from stopped state...")
+        radio_state["is_playing"] = True
+        radio_state["is_stopped"] = False
+        radio_state["stop_flag"] = False
+        
+        # Play next segment (continuing from where we stopped)
+        segment_info, host_audio, music_html, progress, now_playing, llm_script = play_next_segment()
+        
+        return (
+            "▶️ Resuming radio...",
+            segment_info,
+            host_audio,
+            music_html,
+            progress,
+            now_playing,
+            llm_script,
+        )
+    
     if radio_state["is_playing"]:
         return (
             "📻 Radio is already playing!",
@@ -231,6 +303,9 @@ def start_and_play_first_segment():
     import time
     t0 = time.time()
     
+    # Fresh start - reset and plan new show
+    reset_radio()
+    
     # Step 1: Plan skeleton show (YouTube searches happen here)
     print("  [1/3] Planning show (searching YouTube)...")
     user_id = radio_state.get("user_id")
@@ -246,10 +321,7 @@ def start_and_play_first_segment():
     radio_state["current_segment_index"] = 0
     radio_state["is_playing"] = True
     radio_state["stop_flag"] = False
-    radio_state["current_news_batches"] = []
-    radio_state["news_total_batches"] = 0
-    radio_state["news_batches_played"] = 0
-    radio_state["last_segment"] = None
+    radio_state["is_stopped"] = False
     
     # Step 2 & 3: Generate and play first segment (LLM + TTS inside play_next_segment)
     print("  [2/3] Generating first segment (LLM)...")
@@ -271,8 +343,20 @@ def start_and_play_first_segment():
 
 def play_next_segment():
     """Play the next segment in the show - returns host audio and music audio separately"""
+    # If stopped, resume first
+    if radio_state.get("is_stopped"):
+        print("▶️ Resuming from stopped state in play_next_segment...")
+        radio_state["is_stopped"] = False
+        radio_state["stop_flag"] = False
+        radio_state["is_playing"] = True
+    
     if not radio_state["is_playing"]:
-        return "⏸️ Radio stopped", None, None, None, "", ""
+        # If we have a planned show, try to resume
+        if radio_state.get("planned_show"):
+            radio_state["is_playing"] = True
+            radio_state["stop_flag"] = False
+        else:
+            return "⏸️ No show planned. Click 'Generate & Play' to start.", None, None, None, "", ""
     
     if radio_state["stop_flag"]:
         radio_state["is_playing"] = False
@@ -416,47 +500,53 @@ def play_next_segment():
                         youtube_id = track["url"].split("v=")[-1].split("&")[0]
                     
                     if youtube_id:
-                        # Get host audio duration to calculate delay
-                        delay_ms = 0
-                        if host_audio_file and os.path.exists(host_audio_file):
-                            try:
-                                audio = AudioSegment.from_file(host_audio_file)
-                                duration_ms = len(audio)
-                                delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
-                                print(f"⏱️ Host audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
-                            except Exception as e:
-                                print(f"⚠️ Could not get audio duration: {e}")
+                        # # COMMENTED OUT: Delayed loading mechanism
+                        # # Get host audio duration to calculate delay
+                        # delay_ms = 0
+                        # delay_s = 0.0
+                        # if host_audio_file and os.path.exists(host_audio_file):
+                        #     try:
+                        #         audio = AudioSegment.from_file(host_audio_file)
+                        #         duration_ms = len(audio)
+                        #         delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
+                        #         delay_s = delay_ms / 1000.0
+                        #         print(f"⏱️ Host audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
+                        #     except Exception as e:
+                        #         print(f"⚠️ Could not get audio duration: {e}")
                         
-                        # YouTube iframe with delayed display via CSS animation
-                        music_player_html = f"""
-                        <style>
-                            @keyframes showYoutube {{
-                                from {{ opacity: 0; }}
-                                to {{ opacity: 1; }}
-                            }}
-                            .youtube-delayed {{
-                                animation: showYoutube 0.5s ease-in forwards;
-                                animation-delay: {delay_ms}ms;
-                                opacity: 0;
-                            }}
-                        </style>
-                        <div style="padding: 1rem; background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
-                            <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">🎵 {track.get('title', 'Unknown')}</h4>
-                            <p style="margin: 0 0 0.75rem 0; color: #aaa; font-size: 0.9em;">by {track.get('artist', 'Unknown')}</p>
-                            <div class="youtube-delayed" style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
-                                <iframe 
-                                    style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none;"
-                                    src="https://www.youtube.com/embed/{youtube_id}?autoplay=1&rel=0&modestbranding=1&playsinline=1"
-                                    allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
-                                    allowfullscreen>
-                                </iframe>
-                            </div>
-                            <p style="margin-top: 0.75rem; font-size: 0.85em; margin-bottom: 0;">
-                                <a href="{track['url']}" target="_blank" style="color: #ff4757; text-decoration: none;">🔗 Open on YouTube</a>
-                            </p>
-                        </div>
-                        """
-                        print(f"✅ YouTube player created: {track.get('title', 'Unknown')} (ID: {youtube_id}) - shows after {delay_ms}ms")
+                        # # Store the actual iframe HTML for later (after host speech ends)
+                        # actual_player_html = create_youtube_player_html(
+                        #     youtube_id,
+                        #     track.get('title', 'Unknown'),
+                        #     track.get('artist', 'Unknown'),
+                        #     track['url']
+                        # )
+                        
+                        # # Schedule the player to be ready after the delay
+                        # radio_state["pending_player"] = {
+                        #     "html": actual_player_html,
+                        #     "ready_at": time.time() + delay_s,
+                        #     "type": "music",
+                        #     "title": track.get('title', 'Unknown')
+                        # }
+                        
+                        # # Return placeholder initially (no iframe yet!)
+                        # music_player_html = create_placeholder_html(
+                        #     track.get('title', 'Unknown'),
+                        #     track.get('artist', 'Unknown'),
+                        #     delay_s,
+                        #     "music"
+                        # )
+                        # print(f"✅ YouTube player scheduled: {track.get('title', 'Unknown')} (ID: {youtube_id}) - iframe added after {delay_s:.1f}s")
+                        
+                        # Simple immediate iframe - start track with host
+                        music_player_html = create_youtube_player_html(
+                            youtube_id,
+                            track.get('title', 'Unknown'),
+                            track.get('artist', 'Unknown'),
+                            track['url']
+                        )
+                        print(f"✅ YouTube player created immediately: {track.get('title', 'Unknown')} (ID: {youtube_id})")
                     else:
                         # Fallback: Just show link
                         music_player_html = f"""
@@ -526,47 +616,52 @@ def play_next_segment():
         if podcast.get("source") == "youtube" and podcast.get("youtube_id"):
             youtube_id = podcast.get("youtube_id", "")
             
-            # Get host audio duration to calculate delay
-            delay_ms = 0
-            if host_audio_file and os.path.exists(host_audio_file):
-                try:
-                    audio = AudioSegment.from_file(host_audio_file)
-                    duration_ms = len(audio)
-                    delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
-                    print(f"⏱️ Podcast host audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
-                except Exception as e:
-                    print(f"⚠️ Could not get audio duration: {e}")
-            
-            # YouTube iframe with delayed display
-            music_player_html = f"""
-            <style>
-                @keyframes showPodcast {{
-                    from {{ opacity: 0; }}
-                    to {{ opacity: 1; }}
-                }}
-                .podcast-delayed {{
-                    animation: showPodcast 0.5s ease-in forwards;
-                    animation-delay: {delay_ms}ms;
-                    opacity: 0;
-                }}
-            </style>
-            <div style="padding: 1rem; background: linear-gradient(135deg, #6b46c1 0%, #9f7aea 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
-                <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">🎙️ {podcast.get('title', 'Podcast')}</h4>
-                <p style="margin: 0 0 0.75rem 0; color: #e9d8fd; font-size: 0.9em;">by {podcast.get('host', 'Unknown Host')}</p>
-                <div class="podcast-delayed" style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
-                    <iframe 
-                        style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none;"
-                        src="https://www.youtube.com/embed/{youtube_id}?autoplay=1&rel=0&modestbranding=1&playsinline=1"
-                        allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
-                        allowfullscreen>
-                    </iframe>
-                </div>
-                <p style="margin-top: 0.75rem; font-size: 0.85em; margin-bottom: 0;">
-                    <a href="{podcast.get('url', '#')}" target="_blank" style="color: #e9d8fd; text-decoration: none;">🔗 Open on YouTube</a>
-                </p>
-            </div>
-            """
-            print(f"✅ Podcast YouTube player created: {podcast.get('title', 'Unknown')} (ID: {youtube_id}) - shows after {delay_ms}ms")
+            # # COMMENTED OUT: Delayed loading mechanism
+            # # Get host audio duration to calculate delay
+            # delay_ms = 0
+            # if host_audio_file and os.path.exists(host_audio_file):
+            #     try:
+            #         audio = AudioSegment.from_file(host_audio_file)
+            #         duration_ms = len(audio)
+            #         delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
+            #         print(f"⏱️ Podcast host audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
+            #     except Exception as e:
+            #         print(f"⚠️ Could not get audio duration: {e}")
+            
+            # # Store the actual iframe HTML for later (after host speech ends)
+            # delay_s = delay_ms / 1000.0
+            # actual_player_html = create_podcast_player_html(
+            #     youtube_id,
+            #     podcast.get('title', 'Podcast'),
+            #     podcast.get('host', 'Unknown Host'),
+            #     podcast.get('url', '#')
+            # )
+            
+            # # Schedule the player to be ready after the delay
+            # radio_state["pending_player"] = {
+            #     "html": actual_player_html,
+            #     "ready_at": time.time() + delay_s,
+            #     "type": "podcast",
+            #     "title": podcast.get('title', 'Unknown')
+            # }
+            
+            # # Return placeholder initially (no iframe yet!)
+            # music_player_html = create_placeholder_html(
+            #     podcast.get('title', 'Podcast'),
+            #     podcast.get('host', 'Unknown Host'),
+            #     delay_s,
+            #     "podcast"
+            # )
+            # print(f"✅ Podcast YouTube player scheduled: {podcast.get('title', 'Unknown')} (ID: {youtube_id}) - iframe added after {delay_s:.1f}s")
+            
+            # Simple immediate iframe - start podcast with host
+            music_player_html = create_podcast_player_html(
+                youtube_id,
+                podcast.get('title', 'Podcast'),
+                podcast.get('host', 'Unknown Host'),
+                podcast.get('url', '#')
+            )
+            print(f"✅ Podcast YouTube player created immediately: {podcast.get('title', 'Unknown')} (ID: {youtube_id})")
         elif podcast.get("url") and "youtube" in podcast.get("url", ""):
             # Fallback: extract YouTube ID from URL and create simple embed
             url = podcast.get("url", "")
@@ -577,45 +672,50 @@ def play_next_segment():
                 youtube_id = url.split("youtu.be/")[-1].split("?")[0]
             
             if youtube_id:
-                # Get host audio duration to calculate delay
-                delay_ms = 0
-                if host_audio_file and os.path.exists(host_audio_file):
-                    try:
-                        audio = AudioSegment.from_file(host_audio_file)
-                        duration_ms = len(audio)
-                        delay_ms = max(0, duration_ms - 3000)
-                    except:
-                        pass
+                # # COMMENTED OUT: Delayed loading mechanism
+                # # Get host audio duration to calculate delay
+                # delay_ms = 0
+                # if host_audio_file and os.path.exists(host_audio_file):
+                #     try:
+                #         audio = AudioSegment.from_file(host_audio_file)
+                #         duration_ms = len(audio)
+                #         delay_ms = max(0, duration_ms - 3000)
+                #     except:
+                #         pass
                 
-                music_player_html = f"""
-                <style>
-                    @keyframes showPodcast2 {{
-                        from {{ opacity: 0; }}
-                        to {{ opacity: 1; }}
-                    }}
-                    .podcast-delayed-2 {{
-                        animation: showPodcast2 0.5s ease-in forwards;
-                        animation-delay: {delay_ms}ms;
-                        opacity: 0;
-                    }}
-                </style>
-                <div style="padding: 1rem; background: linear-gradient(135deg, #6b46c1 0%, #9f7aea 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
-                    <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">🎙️ {podcast.get('title', 'Podcast')}</h4>
-                    <p style="margin: 0 0 0.75rem 0; color: #e9d8fd; font-size: 0.9em;">by {podcast.get('host', 'Unknown Host')}</p>
-                    <div class="podcast-delayed-2" style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; border-radius: 8px;">
-                        <iframe 
-                            src="https://www.youtube.com/embed/{youtube_id}?autoplay=1&rel=0&modestbranding=1&playsinline=1" 
-                            style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none;"
-                            allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture"
-                            allowfullscreen>
-                        </iframe>
-                    </div>
-                    <p style="margin-top: 0.75rem; font-size: 0.85em; margin-bottom: 0;">
-                        <a href="{url}" target="_blank" style="color: #e9d8fd; text-decoration: none;">🔗 Open on YouTube</a>
-                    </p>
-                </div>
-                """
-                print(f"✅ Podcast iframe player created: {podcast.get('title', 'Unknown')} (ID: {youtube_id}) - shows after {delay_ms}ms")
+                # delay_s = delay_ms / 1000.0
+                # actual_player_html = create_podcast_player_html(
+                #     youtube_id,
+                #     podcast.get('title', 'Podcast'),
+                #     podcast.get('host', 'Unknown Host'),
+                #     url
+                # )
+                
+                # # Schedule the player to be ready after the delay
+                # radio_state["pending_player"] = {
+                #     "html": actual_player_html,
+                #     "ready_at": time.time() + delay_s,
+                #     "type": "podcast",
+                #     "title": podcast.get('title', 'Unknown')
+                # }
+                
+                # # Return placeholder initially
+                # music_player_html = create_placeholder_html(
+                #     podcast.get('title', 'Podcast'),
+                #     podcast.get('host', 'Unknown Host'),
+                #     delay_s,
+                #     "podcast"
+                # )
+                # print(f"✅ Podcast iframe player scheduled: {podcast.get('title', 'Unknown')} (ID: {youtube_id}) - iframe added after {delay_s:.1f}s")
+                
+                # Simple immediate iframe
+                music_player_html = create_podcast_player_html(
+                    youtube_id,
+                    podcast.get('title', 'Podcast'),
+                    podcast.get('host', 'Unknown Host'),
+                    url
+                )
+                print(f"✅ Podcast iframe player created immediately: {podcast.get('title', 'Unknown')} (ID: {youtube_id})")
     
     # Progress info
     progress = f"Segment {radio_state['current_segment_index']}/{len(radio_state['planned_show'])}"
@@ -654,21 +754,38 @@ def play_next_segment():
     return segment_info, host_audio_file, music_player_html, progress, get_now_playing(segment), display_script
 
 def stop_radio():
-    """Stop the radio stream - clears audio and music player"""
+    """Stop the radio stream - pauses at current segment without resetting"""
     radio_state["stop_flag"] = True
     radio_state["is_playing"] = False
-    radio_state["planned_show"] = []
-    radio_state["current_segment_index"] = 0
+    radio_state["is_stopped"] = True
+    # DON'T reset planned_show or current_segment_index - allow resuming
+    
+    current_idx = radio_state.get("current_segment_index", 0)
+    total_segments = len(radio_state.get("planned_show", []))
     
-    # Return status, clear audio, clear music player, reset progress, reset now playing
+    status_msg = f"⏹️ Stopped at segment {current_idx}/{total_segments}. Click 'Generate & Play' or 'Next Segment' to continue."
+    
+    # Return status, clear audio, clear music player, progress, now playing
     return (
-        "⏹️ Radio stopped.",
+        status_msg,
         None,  # Clear audio
         "",    # Clear music player HTML
-        "Stopped",
-        "📻 Ready to start"
+        f"Stopped at {current_idx}/{total_segments}",
+        f"⏸️ Paused - Segment {current_idx}/{total_segments}"
     )
 
+
+def reset_radio():
+    """Fully reset the radio - called when starting fresh"""
+    radio_state["stop_flag"] = False
+    radio_state["is_playing"] = False
+    radio_state["is_stopped"] = False
+    radio_state["planned_show"] = []
+    radio_state["current_segment_index"] = 0
+    radio_state["current_news_batches"] = []
+    radio_state["news_total_batches"] = 0
+    radio_state["news_batches_played"] = 0
+
 def format_segment_info(segment: Dict[str, Any]) -> str:
     """Format segment information for display"""
     seg_type = segment["type"]
@@ -849,48 +966,53 @@ def handle_voice_request():
                 youtube_id = track["url"].split("v=")[-1].split("&")[0]
             
             if youtube_id:
-                # Get host audio duration to calculate delay
-                delay_ms = 0
-                if audio_file and os.path.exists(audio_file):
-                    try:
-                        audio = AudioSegment.from_file(audio_file)
-                        duration_ms = len(audio)
-                        delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
-                        print(f"⏱️ Voice request audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
-                    except Exception as e:
-                        print(f"⚠️ Could not get audio duration: {e}")
+                # # COMMENTED OUT: Delayed loading mechanism
+                # # Get host audio duration to calculate delay
+                # delay_ms = 0
+                # if audio_file and os.path.exists(audio_file):
+                #     try:
+                #         audio = AudioSegment.from_file(audio_file)
+                #         duration_ms = len(audio)
+                #         delay_ms = max(0, duration_ms - 3000)  # Start 3 seconds before end
+                #         print(f"⏱️ Voice request audio: {duration_ms}ms, YouTube delay: {delay_ms}ms")
+                #     except Exception as e:
+                #         print(f"⚠️ Could not get audio duration: {e}")
                 
-                # YouTube embed with delayed display
-                music_player_html = f"""
-                <style>
-                    @keyframes showVoiceYoutube {{
-                        from {{ opacity: 0; }}
-                        to {{ opacity: 1; }}
-                    }}
-                    .voice-youtube-delayed {{
-                        animation: showVoiceYoutube 0.5s ease-in forwards;
-                        animation-delay: {delay_ms}ms;
-                        opacity: 0;
-                    }}
-                </style>
-                <div style="padding: 1rem; background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%); border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 15px rgba(0,0,0,0.3);">
-                    <h4 style="margin: 0 0 0.75rem 0; color: #fff; font-size: 1.1em;">🎵 {track.get('title', 'Unknown')}</h4>
-                    <p style="margin: 0 0 0.75rem 0; color: #aaa; font-size: 0.9em;">by {track.get('artist', 'Unknown')}</p>
-                    <div class="voice-youtube-delayed" style="position: relative; width: 100%; padding-bottom: 56.25%; border-radius: 8px; overflow: hidden; background: #000;">
-                        <iframe 
-                            style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border: none;"
-                            src="https://www.youtube.com/embed/{youtube_id}?autoplay=1&rel=0&modestbranding=1&playsinline=1"
-                            allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"
-                            allowfullscreen>
-                        </iframe>
-                    </div>
-                    <p style="margin-top: 0.75rem; font-size: 0.85em; margin-bottom: 0;">
-                        <a href="{track['url']}" target="_blank" style="color: #ff4757; text-decoration: none;">🔗 Open on YouTube</a>
-                    </p>
-                </div>
-                """
-                print(f"✅ Voice request YouTube player created - shows after {delay_ms}ms")
-                print(f"✅ YouTube player created: {track.get('title', 'Unknown')} (ID: {youtube_id})")
+                # # Store the actual iframe HTML for later (after host speech ends)
+                # delay_s = delay_ms / 1000.0
+                # actual_player_html = create_youtube_player_html(
+                #     youtube_id,
+                #     track.get('title', 'Unknown'),
+                #     track.get('artist', 'Unknown'),
+                #     track['url']
+                # )
+                
+                # # Schedule the player to be ready after the delay
+                # radio_state["pending_player"] = {
+                #     "html": actual_player_html,
+                #     "ready_at": time.time() + delay_s,
+                #     "type": "music",
+                #     "title": track.get('title', 'Unknown')
+                # }
+                
+                # # Return placeholder initially (no iframe yet!)
+                # music_player_html = create_placeholder_html(
+                #     track.get('title', 'Unknown'),
+                #     track.get('artist', 'Unknown'),
+                #     delay_s,
+                #     "music"
+                # )
+                # print(f"✅ Voice request YouTube player scheduled - iframe added after {delay_s:.1f}s")
+                # print(f"✅ YouTube player scheduled: {track.get('title', 'Unknown')} (ID: {youtube_id})")
+                
+                # Simple immediate iframe - start track with host
+                music_player_html = create_youtube_player_html(
+                    youtube_id,
+                    track.get('title', 'Unknown'),
+                    track.get('artist', 'Unknown'),
+                    track['url']
+                )
+                print(f"✅ Voice request YouTube player created immediately: {track.get('title', 'Unknown')} (ID: {youtube_id})")
             else:
                 music_player_html = f"""
                 <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
@@ -1156,8 +1278,133 @@ custom_css = """
 }
 """
 
+# Auto-play JavaScript (injected in head)
+auto_play_head = """
+<script>
+(function() {
+    let autoPlayEnabled = true;
+    let nextSegmentTimeout = null;
+    let currentAudioElement = null;
+    let musicPlayDuration = 60000;  // Wait 60 seconds for music to play
+    
+    function clickNextSegment() {
+        const buttons = document.querySelectorAll('button');
+        for (let btn of buttons) {
+            if (btn.textContent.includes('Next Segment')) {
+                console.log('⏭️ Auto-clicking Next Segment button...');
+                btn.click();
+                return true;
+            }
+        }
+        return false;
+    }
+    
+    function onAudioEnded() {
+        if (!autoPlayEnabled) return;
+        
+        console.log('🎵 Host audio ended, scheduling next segment in ' + (musicPlayDuration/1000) + 's...');
+        
+        // Clear any existing timeout
+        if (nextSegmentTimeout) clearTimeout(nextSegmentTimeout);
+        
+        // Wait for music/podcast to play, then auto-advance
+        nextSegmentTimeout = setTimeout(function() {
+            clickNextSegment();
+        }, musicPlayDuration);
+    }
+    
+    function setupAutoPlay() {
+        // Find all audio elements in the host_audio container
+        const audioContainer = document.querySelector('#host_audio');
+        if (!audioContainer) {
+            return;
+        }
+        
+        const audio = audioContainer.querySelector('audio');
+        if (!audio) {
+            return;
+        }
+        
+        // If this is a different audio element than before, set up new listener
+        if (audio !== currentAudioElement) {
+            console.log('🔄 New audio element detected, setting up auto-play...');
+            currentAudioElement = audio;
+            
+            // Remove old listener if exists (defensive)
+            audio.removeEventListener('ended', onAudioEnded);
+            
+            // Add new listener
+            audio.addEventListener('ended', onAudioEnded);
+            
+            console.log('✅ Auto-play listener attached to audio element');
+        }
+    }
+    
+    // Set up on load
+    if (document.readyState === 'loading') {
+        document.addEventListener('DOMContentLoaded', function() {
+            setupAutoPlay();
+        });
+    } else {
+        setupAutoPlay();
+    }
+    
+    // Re-setup when DOM changes (Gradio updates audio element)
+    const observer = new MutationObserver(function(mutations) {
+        // Check if audio-related changes
+        for (let mutation of mutations) {
+            if (mutation.type === 'childList') {
+                // Look for audio element changes
+                const hasAudioChange = Array.from(mutation.addedNodes).some(node => 
+                    node.nodeType === 1 && (node.tagName === 'AUDIO' || node.querySelector && node.querySelector('audio'))
+                );
+                if (hasAudioChange || mutation.target.id === 'host_audio' || 
+                    (mutation.target.closest && mutation.target.closest('#host_audio'))) {
+                    setupAutoPlay();
+                    break;
+                }
+            }
+        }
+    });
+    
+    // Start observing after a short delay to let Gradio initialize
+    setTimeout(function() {
+        observer.observe(document.body, { childList: true, subtree: true });
+        setupAutoPlay();  // Initial setup
+        
+        // Also periodically check (backup)
+        setInterval(setupAutoPlay, 5000);
+    }, 2000);
+    
+    // Expose functions globally
+    window.toggleAutoPlay = function(enabled) {
+        autoPlayEnabled = enabled;
+        console.log('Auto-play ' + (enabled ? 'enabled' : 'disabled'));
+    };
+    
+    window.setMusicPlayDuration = function(ms) {
+        musicPlayDuration = ms;
+        console.log('Music play duration set to ' + (ms/1000) + 's');
+    };
+    
+    window.cancelNextSegment = function() {
+        if (nextSegmentTimeout) {
+            clearTimeout(nextSegmentTimeout);
+            nextSegmentTimeout = null;
+            console.log('⏹️ Next segment cancelled');
+        }
+    };
+    
+    window.playNextNow = function() {
+        if (nextSegmentTimeout) clearTimeout(nextSegmentTimeout);
+        clickNextSegment();
+    };
+})();
+</script>
+"""
+
 # Build Gradio Interface
-with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft(), head=auto_play_head) as demo:
     
     # Hidden state for user ID (persisted via localStorage)
     user_id_state = gr.State(value=None)
@@ -1314,6 +1561,27 @@ with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft()) as
             audio_output = gr.Audio(label="🔊 Host Speech", autoplay=True, type="filepath", elem_id="host_audio")
             music_player = gr.HTML(label="🎵 Music/Podcast Player (streaming)")
             
+            # # COMMENTED OUT: Timer to check for pending players (delayed loading mechanism)
+            # # Timer to check for pending players (polls every 2 seconds)
+            # player_timer = gr.Timer(value=2, active=True)
+            
+            # def check_pending_player():
+            #     """Check if there's a pending player ready to show"""
+            #     pending = radio_state.get("pending_player")
+            #     if pending and time.time() >= pending.get("ready_at", 0):
+            #         html = pending.get("html", "")
+            #         title = pending.get("title", "Unknown")
+            #         radio_state["pending_player"] = None  # Clear it
+            #         print(f"▶️ Adding iframe for: {title}")
+            #         return html
+            #     return gr.update()  # No change
+            
+            # player_timer.tick(
+            #     fn=check_pending_player,
+            #     inputs=[],
+            #     outputs=[music_player]
+            # )
+            
             status_text = gr.Textbox(label="Status", value="Ready", interactive=False, visible=False)
             
             # Connect buttons
@@ -1332,7 +1600,8 @@ with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft()) as
             stop_btn.click(
                 fn=stop_radio,
                 inputs=[],
-                outputs=[status_text, audio_output, music_player, progress_text, now_playing]
+                outputs=[status_text, audio_output, music_player, progress_text, now_playing],
+                js="() => { if(window.cancelNextSegment) window.cancelNextSegment(); }"
             )
             
             # Voice input button - direct click without .then() chain
@@ -1609,7 +1878,7 @@ Your passphrase: **{passphrase}**
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7870,
+        server_port=7871,
         share=False
     )
 

src/mcp_servers/music_server.py

@@ -26,6 +26,34 @@ class MusicMCPServer:
         os.makedirs(self.cache_dir, exist_ok=True)
         # Cache for embed check results to avoid repeated API calls
         self._embed_cache = {}
+        # Rate limiting for YouTube API (prevent blocking)
+        self._last_youtube_call = 0
+        self._min_call_interval = 3.0  # Minimum 3 seconds between YouTube calls
+        # Track recently played to avoid repeats
+        self._recently_played = []  # List of video IDs
+        self._max_recent = 20  # Remember last 20 tracks
+    
+    def _rate_limit_youtube(self):
+        """Enforce rate limiting for YouTube API calls"""
+        import time as time_module
+        current_time = time_module.time()
+        elapsed = current_time - self._last_youtube_call
+        if elapsed < self._min_call_interval:
+            sleep_time = self._min_call_interval - elapsed
+            print(f"⏳ Rate limiting: waiting {sleep_time:.1f}s before YouTube call...")
+            time_module.sleep(sleep_time)
+        self._last_youtube_call = time_module.time()
+    
+    def _add_to_recently_played(self, video_id: str):
+        """Track a video as recently played"""
+        if video_id and video_id not in self._recently_played:
+            self._recently_played.append(video_id)
+            if len(self._recently_played) > self._max_recent:
+                self._recently_played.pop(0)
+    
+    def _is_recently_played(self, video_id: str) -> bool:
+        """Check if a video was recently played"""
+        return video_id in self._recently_played
     
     def check_video_embeddable(self, video_id: str) -> bool:
         """
@@ -95,7 +123,7 @@ class MusicMCPServer:
             self._embed_cache[video_id] = False
             return False
         
-    def search_youtube_music(self, query: str, limit: int = 5, fast: bool = False, check_embed: bool = True) -> List[Dict[str, Any]]:
+    def search_youtube_music(self, query: str, limit: int = 5, fast: bool = False, check_embed: bool = False) -> List[Dict[str, Any]]:
         """
         Search for free music on YouTube
         
@@ -103,11 +131,14 @@ class MusicMCPServer:
             query: Search query (e.g., "pop music", "jazz instrumental", "song name")
             limit: Number of results to fetch (will randomly select one)
             fast: If True, use flat extraction for faster results (less metadata)
-            check_embed: If True, verify videos are embeddable (recommended)
+            check_embed: If True, verify videos are embeddable (slower but more reliable)
             
         Returns:
             List of track dictionaries with YouTube URLs
         """
+        # Apply rate limiting
+        self._rate_limit_youtube()
+        
         tracks = []
         try:
             # Use extract_flat for faster search (no full video info)
@@ -119,7 +150,8 @@ class MusicMCPServer:
             }
             
             # Search for more results to allow for filtering and random selection
-            search_limit = max(limit * 3, 15) if check_embed else max(limit, 10)
+            # Increase limit to account for filtering out recently played
+            search_limit = max(limit * 3, 15)
             
             with yt_dlp.YoutubeDL(ydl_opts) as ydl:
                 # Don't add "music" if query already contains it or is specific
@@ -155,14 +187,19 @@ class MusicMCPServer:
                     if len(valid_entries) > 1:
                         random.shuffle(valid_entries)
                     
-                    # Check embeddability and take requested limit
+                    # Filter, check embeddability, avoid recently played, and take requested limit
                     for entry in valid_entries:
                         if len(tracks) >= limit:
                             break
                             
                         video_id = entry.get('id') or entry.get('url', '')
                         if video_id:
-                            # Check if video is embeddable
+                            # Skip recently played tracks
+                            if self._is_recently_played(video_id):
+                                print(f"  ✗ Skipping recently played: {entry.get('title', 'Unknown')}")
+                                continue
+                            
+                            # Check if video is embeddable (optional)
                             if check_embed and not self.check_video_embeddable(video_id):
                                 print(f"  ✗ Skipping non-embeddable: {entry.get('title', 'Unknown')}")
                                 continue
@@ -177,7 +214,9 @@ class MusicMCPServer:
                                 "source": "youtube"
                             }
                             tracks.append(track)
-                            print(f"  ✓ Found embeddable: {track['title']} by {track['artist']}")
+                            # Mark as recently played
+                            self._add_to_recently_played(video_id)
+                            print(f"  ✓ Found: {track['title']} by {track['artist']}")
                             
         except Exception as e:
             print(f"❌ Error searching YouTube: {e}")

src/mcp_servers/podcast_server.py

@@ -18,6 +18,23 @@ class PodcastMCPServer:
         self.name = "podcast_server"
         self.description = "Provides podcast recommendations from YouTube"
         self._embed_cache = {}
+        # Rate limiting
+        self._last_youtube_call = 0
+        self._min_call_interval = 3.0  # Minimum 3 seconds between YouTube calls
+        # Track recently played podcasts
+        self._recently_played = []
+        self._max_recent = 10
+    
+    def _rate_limit_youtube(self):
+        """Enforce rate limiting for YouTube API calls"""
+        import time as time_module
+        current_time = time_module.time()
+        elapsed = current_time - self._last_youtube_call
+        if elapsed < self._min_call_interval:
+            sleep_time = self._min_call_interval - elapsed
+            print(f"⏳ Podcast rate limiting: waiting {sleep_time:.1f}s...")
+            time_module.sleep(sleep_time)
+        self._last_youtube_call = time_module.time()
     
     def check_video_embeddable(self, video_id: str) -> bool:
         """Check if a YouTube video is embeddable"""
@@ -85,6 +102,9 @@ class PodcastMCPServer:
             print("⚠️ yt-dlp not available, using demo podcasts")
             return self._get_demo_podcasts(category, limit)
         
+        # Apply rate limiting
+        self._rate_limit_youtube()
+        
         try:
             # Build search query for podcasts
             search_query = f"{query} podcast {category}"

src/radio_agent.py

@@ -11,6 +11,7 @@ from mcp_servers.music_server import MusicMCPServer
 from mcp_servers.news_server import NewsMCPServer
 from mcp_servers.podcast_server import PodcastMCPServer
 from rag_system import RadioRAGSystem
+from user_memory import UserMemoryService
 
 # -----------------------------------------------------------------------------
 # LLM Logging Setup
@@ -218,7 +219,7 @@ class RadioAgent:
                     model=self.config.nebius_model,
                     messages=[{"role": "user", "content": prompt}],
                     temperature=0.9,
-                    max_tokens=200 #200
+                    max_tokens=100 #200
                 )
                 text = response.choices[0].message.content.strip()
                 llm_logger.info(
@@ -248,7 +249,7 @@ class RadioAgent:
                     model=self.config.nebius_model,
                     messages=[{"role": "user", "content": prompt}],
                     temperature=0.9,
-                    max_tokens=200 #100
+                    max_tokens=100 #200
                 )
                 text = response.choices[0].message.content.strip()
                 llm_logger.info(
@@ -263,19 +264,75 @@ class RadioAgent:
         
         return f"That's all for now, {name}! Thanks for tuning in to AI Radio. Come back soon for more personalized content!"
     
-    def _plan_music_segment(self, preferences: Dict[str, Any]) -> Dict[str, Any]:
-        """Plan a music segment using Music MCP Server (no LLM yet)"""
-        genres = preferences.get('favorite_genres', ['pop'])
-        mood = preferences.get('mood', 'happy')
+    def _plan_music_segment(self, preferences: Dict[str, Any], user_id: str = None) -> Dict[str, Any]:
+        """Plan a music segment using Music MCP Server with RAG preferences"""
+        # Get user preferences from RAG (more accurate than just preferences dict)
+        rag_prefs = {}
+        if user_id and self.rag_system:
+            try:
+                rag_prefs = self.rag_system.get_user_preferences(user_id)
+                print(f"🎵 [RAG] Retrieved preferences for user {user_id}: genres={rag_prefs.get('favorite_genres', [])}")
+            except Exception as e:
+                print(f"⚠️ [RAG] Could not get preferences: {e}")
         
-        # Use MCP server to get music
-        tracks = self.music_server.search_free_music(
-            genre=random.choice(genres),
-            mood=mood,
-            limit=1
-        )
+        # Use RAG preferences if available, otherwise fall back to provided preferences
+        genres = rag_prefs.get('favorite_genres') or preferences.get('favorite_genres', ['pop'])
+        mood = rag_prefs.get('mood') or preferences.get('mood', 'happy')
         
-        track = tracks[0] if tracks else None
+        # Get recently played tracks from user memory to avoid duplicates
+        played_video_ids = set()
+        if user_id:
+            try:
+                user_memory = UserMemoryService()
+                play_history = user_memory.get_play_history(user_id)
+                # Extract YouTube IDs from history
+                for entry in play_history:
+                    if entry.get('youtube_id'):
+                        played_video_ids.add(entry['youtube_id'])
+                    elif entry.get('url') and 'youtube.com' in entry.get('url', ''):
+                        # Extract ID from URL
+                        url = entry['url']
+                        if 'v=' in url:
+                            vid_id = url.split('v=')[-1].split('&')[0]
+                            played_video_ids.add(vid_id)
+                print(f"🎵 [RAG] Found {len(played_video_ids)} previously played tracks to avoid")
+            except Exception as e:
+                print(f"⚠️ Could not get play history: {e}")
+        
+        # Search for music, filtering out played tracks
+        max_attempts = 5
+        track = None
+        for attempt in range(max_attempts):
+            # Use MCP server to get music
+            tracks = self.music_server.search_free_music(
+                genre=random.choice(genres) if genres else 'pop',
+                mood=mood,
+                limit=10  # Get more results to filter from
+            )
+            
+            # Filter out already played tracks
+            available_tracks = [
+                t for t in tracks 
+                if t.get('youtube_id') and t['youtube_id'] not in played_video_ids
+            ]
+            
+            if available_tracks:
+                track = random.choice(available_tracks)
+                # Mark as recently played in music server to avoid duplicates
+                if track.get('youtube_id'):
+                    self.music_server._add_to_recently_played(track['youtube_id'])
+                print(f"✅ [RAG] Selected new track: {track.get('title', 'Unknown')} (not in history)")
+                break
+            else:
+                print(f"⚠️ [RAG] All tracks already played, trying different genre...")
+                # Try a different genre if all tracks were played
+                if attempt < max_attempts - 1:
+                    genres = [g for g in genres if g != random.choice(genres)] or ['pop']
+        
+        # If still no track, use any available (fallback)
+        if not track and tracks:
+            track = tracks[0]
+            print(f"⚠️ Using track despite possible duplicate: {track.get('title', 'Unknown')}")
         
         return {
             'type': 'music',
@@ -375,7 +432,7 @@ class RadioAgent:
                 model=self.config.nebius_model,
                 messages=[{"role": "user", "content": prompt}],
                 temperature=0.9,
-                max_tokens=400 #400
+                max_tokens=100 #400
             )
             text = response.choices[0].message.content.strip()
             
@@ -419,7 +476,7 @@ class RadioAgent:
                 # Generate full news script (1-2 minutes of speech)
                 news_text = "\n".join([f"- {item['title']}: {item['summary']}" for item in news_items[:3]])
                 prompt = f"""You are a professional radio news presenter named Lera. Say that this is news time on the show.
-                Present these news items in a conversational, engaging way. This should be about 1 minute of speech (about 200-250 words, max_tokens = 800):
+                Present these news items in a conversational, engaging way. This should be about 1 minute of speech (about 200-250 words, max_tokens = 400):
                 
                 News text:
                 {news_text}
@@ -438,7 +495,7 @@ class RadioAgent:
                     model=self.config.nebius_model,
                     messages=[{"role": "user", "content": prompt}],
                     temperature=0.9,
-                    max_tokens=800 #800
+                    max_tokens=100 #400
                 )
                 full_script = response.choices[0].message.content.strip()
                 llm_logger.info(
@@ -492,7 +549,7 @@ class RadioAgent:
                 model=self.config.nebius_model,
                 messages=[{"role": "user", "content": prompt}],
                 temperature=0.8,
-                max_tokens=200 #200
+                max_tokens=100 #200
             )
             text = response.choices[0].message.content.strip()
             llm_logger.info(
@@ -519,7 +576,7 @@ class RadioAgent:
                 model=self.config.nebius_model,
                 messages=[{"role": "user", "content": prompt}],
                 temperature=0.9,
-                max_tokens=600 #600
+                max_tokens=100 #600
             )
             text = response.choices[0].message.content.strip()
             llm_logger.info(
@@ -553,7 +610,7 @@ Don't use emojis. Just speak naturally like a real DJ."""
                 model=self.config.nebius_model,
                 messages=[{"role": "user", "content": prompt}],
                 temperature=0.9,
-                max_tokens=200 #60 # Keep it short for fast response
+                max_tokens=100 #200 # Keep it short for fast response
             )
             text = response.choices[0].message.content.strip()
             llm_logger.info(
@@ -655,12 +712,14 @@ Don't use emojis. Just speak naturally like a real DJ."""
                 else:
                     print(f"🎵 [RAG] Using genre: {selected_genre} (from preferences)")
                 
-                tracks = self.music_server.search_free_music(
-                    genre=selected_genre,
-                    mood=mood,
-                    limit=1
-                )
-                segment["track"] = tracks[0] if tracks else None
+                # Update preferences with RAG-suggested genre
+                updated_prefs = prefs.copy()
+                if selected_genre not in updated_prefs.get('favorite_genres', []):
+                    updated_prefs['favorite_genres'] = updated_prefs.get('favorite_genres', []) + [selected_genre]
+                
+                # Use _plan_music_segment which handles RAG preferences and duplicate checking
+                music_segment = self._plan_music_segment(updated_prefs, user_id=user_id)
+                segment["track"] = music_segment.get("track")
             
             track = segment.get("track")
             if track and not segment.get("commentary"):

src/rag_system.py

@@ -541,8 +541,12 @@ Feedback: {user_feedback or 'No feedback'}
                     
                     # Log each retrieved document
                     preview = node.text[:100].replace('\n', ' ')
-                    rag_logger.info(f"  📄 Retrieved #{len(results)}: user_id={node_user_id}, type={node_type}, item_type={item_type}, score={score:.4f if score else 'N/A'}, preview='{preview}...'")
-                    print(f"  📄 [RAG] Retrieved #{len(results)}: {node_type} (user: {node_user_id}, score: {score:.4f if score else 'N/A'}) - {preview}...")
+                    try:
+                        score_str = f"{float(score):.4f}" if score is not None else "N/A"
+                    except (TypeError, ValueError):
+                        score_str = str(score) if score is not None else "N/A"
+                    rag_logger.info(f"  📄 Retrieved #{len(results)}: user_id={node_user_id}, type={node_type}, item_type={item_type}, score={score_str}, preview='{preview}...'")
+                    print(f"  📄 [RAG] Retrieved #{len(results)}: {node_type} (user: {node_user_id}, score: {score_str}) - {preview}...")
                     
                     # Stop if we have enough results for this user
                     if len(results) >= top_k:
@@ -561,8 +565,12 @@ Feedback: {user_feedback or 'No feedback'}
                         "metadata": node.metadata
                     }
                     results.append(result)
-                    rag_logger.warning(f"  ⚠️  Retrieved #{len(results)} (parse error): user_id={node_user_id}, score={score}, text_preview='{node.text[:50]}...'")
-                    print(f"  ⚠️  [RAG] Retrieved #{len(results)} (parse error, user: {node_user_id}, score: {score:.4f if score else 'N/A'})")
+                    try:
+                        score_str = f"{float(score):.4f}" if score is not None else "N/A"
+                    except (TypeError, ValueError):
+                        score_str = str(score) if score is not None else "N/A"
+                    rag_logger.warning(f"  ⚠️  Retrieved #{len(results)} (parse error): user_id={node_user_id}, score={score_str}, text_preview='{node.text[:50]}...'")
+                    print(f"  ⚠️  [RAG] Retrieved #{len(results)} (parse error, user: {node_user_id}, score: {score_str})")
                     
                     if len(results) >= top_k:
                         break