v1

INSTALL_FFMPEG.md

@@ -0,0 +1,52 @@
+# 🎵 Installing FFmpeg for Music Playback
+
+FFmpeg is required to download and convert YouTube audio for playback in the app.
+
+## macOS Installation
+
+```bash
+brew install ffmpeg
+```
+
+## Linux Installation
+
+```bash
+# Ubuntu/Debian
+sudo apt-get update
+sudo apt-get install ffmpeg
+
+# Fedora/CentOS
+sudo dnf install ffmpeg
+
+# Arch Linux
+sudo pacman -S ffmpeg
+```
+
+## Windows Installation
+
+1. Download from: https://ffmpeg.org/download.html
+2. Extract to a folder (e.g., `C:\ffmpeg`)
+3. Add to PATH:
+   - System Properties → Environment Variables
+   - Add `C:\ffmpeg\bin` to Path
+
+## Verify Installation
+
+```bash
+ffmpeg -version
+```
+
+You should see version information if installed correctly.
+
+## Alternative: Use YouTube Links
+
+If you can't install ffmpeg, the app will still work! It will:
+- Show track information
+- Provide YouTube links to listen
+- All other features work normally
+- Music just won't play directly in the app
+
+## Note
+
+FFmpeg is only needed for downloading YouTube audio. All other features (host speech, news, podcasts, stories) work without it!
+

INSTALL_VOICE_INPUT.md

@@ -0,0 +1,82 @@
+# 🎤 Voice Input Installation Guide
+
+The voice input feature requires `pyaudio`, which needs the PortAudio library to be installed first.
+
+## macOS Installation
+
+1. **Install PortAudio using Homebrew:**
+   ```bash
+   brew install portaudio
+   ```
+
+2. **Install pyaudio:**
+   ```bash
+   pip install pyaudio
+   ```
+
+## Linux Installation
+
+1. **Install PortAudio development libraries:**
+   ```bash
+   sudo apt-get update
+   sudo apt-get install portaudio19-dev python3-pyaudio
+   ```
+
+   Or for other distributions:
+   ```bash
+   # Fedora/CentOS
+   sudo dnf install portaudio-devel
+   
+   # Arch Linux
+   sudo pacman -S portaudio
+   ```
+
+2. **Install pyaudio:**
+   ```bash
+   pip install pyaudio
+   ```
+
+## Windows Installation
+
+1. **Download and install PortAudio:**
+   - Download from: http://files.portaudio.com/download.html
+   - Or use pre-built wheels:
+   ```bash
+   pip install pipwin
+   pipwin install pyaudio
+   ```
+
+## Alternative: Use Text Input
+
+If you can't install pyaudio, you can still use the app! The voice input feature will be disabled, but you can:
+- Type your song requests in the preferences
+- Use the regular radio controls
+- All other features work without voice input
+
+## Verify Installation
+
+After installing, test with:
+```bash
+python -c "import speech_recognition as sr; print('✅ Speech recognition ready!')"
+python -c "import pyaudio; print('✅ PyAudio ready!')"
+```
+
+## Troubleshooting
+
+**Error: "portaudio.h not found"**
+- Make sure PortAudio is installed before pyaudio
+- On macOS, use Homebrew: `brew install portaudio`
+
+**Error: "No module named 'pyaudio'"**
+- Install pyaudio: `pip install pyaudio`
+- Make sure PortAudio is installed first
+
+**Microphone not detected**
+- Check microphone permissions in system settings
+- On macOS: System Settings → Privacy & Security → Microphone
+- Make sure your app has microphone access
+
+## Note
+
+Voice input is **optional**. The app works perfectly without it - you just won't be able to request songs by voice. All other features (radio, music, news, etc.) work normally.
+

app.py

@@ -10,6 +10,7 @@ from config import get_config
 from radio_agent import RadioAgent
 from tts_service import TTSService
 from rag_system import RadioRAGSystem
+from voice_input import VoiceInputService
 
 # Global state
 radio_state = {
@@ -17,16 +18,24 @@ radio_state = {
     "current_segment_index": 0,
     "planned_show": [],
     "user_preferences": {},
-    "stop_flag": False
+    "stop_flag": False,
+    "content_filter": {
+        "music": True,
+        "news": True,
+        "podcasts": True,
+        "stories": True
+    }
 }
 
 # Initialize services
 config = get_config()
 agent = RadioAgent(config)
 tts_service = TTSService(api_key=config.elevenlabs_api_key, voice_id=config.elevenlabs_voice_id)
+voice_input_service = VoiceInputService()
 
 def save_preferences(name: str, favorite_genres: List[str], interests: List[str], 
-                     podcast_interests: List[str], mood: str) -> str:
+                     podcast_interests: List[str], mood: str, 
+                     music_filter: bool, news_filter: bool, podcast_filter: bool, story_filter: bool) -> str:
     """Save user preferences to RAG system"""
     preferences = {
         "name": name or "Friend",
@@ -37,6 +46,14 @@ def save_preferences(name: str, favorite_genres: List[str], interests: List[str]
         "timestamp": time.time()
     }
     
+    # Update content filter
+    radio_state["content_filter"] = {
+        "music": music_filter,
+        "news": news_filter,
+        "podcasts": podcast_filter,
+        "stories": story_filter
+    }
+    
     radio_state["user_preferences"] = preferences
     agent.rag_system.store_user_preferences(preferences)
     
@@ -45,15 +62,16 @@ def save_preferences(name: str, favorite_genres: List[str], interests: List[str]
 def start_radio_stream():
     """Start the radio stream"""
     if not radio_state["user_preferences"]:
-        return "⚠️ Please set your preferences first!", None, None, ""
+        return "⚠️ Please set your preferences first!", None, None, None, ""
     
     if radio_state["is_playing"]:
-        return "📻 Radio is already playing!", None, None, ""
+        return "📻 Radio is already playing!", None, None, None, ""
     
-    # Plan the show
+    # Plan the show with content filter
     show_plan = agent.plan_radio_show(
         user_preferences=radio_state["user_preferences"],
-        duration_minutes=30
+        duration_minutes=30,
+        content_filter=radio_state["content_filter"]
     )
     
     radio_state["planned_show"] = show_plan
@@ -61,20 +79,20 @@ def start_radio_stream():
     radio_state["is_playing"] = True
     radio_state["stop_flag"] = False
     
-    return "🎵 Starting your personalized radio show...", None, None, ""
+    return "🎵 Starting your personalized radio show...", None, None, None, ""
 
 def play_next_segment():
-    """Play the next segment in the show"""
+    """Play the next segment in the show - returns host audio and music audio separately"""
     if not radio_state["is_playing"]:
-        return "⏸️ Radio stopped", None, None, ""
+        return "⏸️ Radio stopped", None, None, None, ""
     
     if radio_state["stop_flag"]:
         radio_state["is_playing"] = False
-        return "⏸️ Radio paused", None, None, ""
+        return "⏸️ Radio paused", None, None, None, ""
     
     if radio_state["current_segment_index"] >= len(radio_state["planned_show"]):
         radio_state["is_playing"] = False
-        return "🎊 Show completed! Hope you enjoyed it.", None, None, ""
+        return "🎊 Show completed! Hope you enjoyed it.", None, None, None, ""
     
     # Get current segment
     segment = radio_state["planned_show"][radio_state["current_segment_index"]]
@@ -87,36 +105,152 @@ def play_next_segment():
     segment_info = format_segment_info(segment)
     
     # Generate TTS for host commentary
-    audio_file = None
-    if segment["type"] in ["intro", "outro", "news", "story"]:
+    host_audio_file = None
+    music_player_html = ""
+    
+    if segment["type"] in ["intro", "outro", "story"]:
         text = get_segment_text(segment)
         if text and tts_service.client:
             audio_bytes = tts_service.text_to_speech(text)
             if audio_bytes:
-                audio_file = f"segment_{radio_state['current_segment_index']}.mp3"
-                tts_service.save_audio(audio_bytes, audio_file)
+                host_audio_file = f"segment_{radio_state['current_segment_index']}.mp3"
+                tts_service.save_audio(audio_bytes, host_audio_file)
+    
+    elif segment["type"] == "news":
+        # Handle batched news generation
+        script_batches = segment.get("script_batches", segment.get("script", []))
+        if isinstance(script_batches, list) and script_batches:
+            # Generate first batch immediately (user doesn't wait)
+            first_batch = script_batches[0]
+            if tts_service.client:
+                audio_bytes = tts_service.text_to_speech(first_batch)
+                if audio_bytes:
+                    host_audio_file = f"segment_{radio_state['current_segment_index']}_batch_1.mp3"
+                    tts_service.save_audio(audio_bytes, host_audio_file)
+            # Store remaining batches for sequential playback
+            segment["remaining_batches"] = script_batches[1:] if len(script_batches) > 1 else []
+        else:
+            # Fallback for old format
+            text = get_segment_text(segment)
+            if text and tts_service.client:
+                audio_bytes = tts_service.text_to_speech(text)
+                if audio_bytes:
+                    host_audio_file = f"segment_{radio_state['current_segment_index']}.mp3"
+                    tts_service.save_audio(audio_bytes, host_audio_file)
     
     elif segment["type"] == "music":
-        # For music, generate commentary
+        # For music: generate host commentary, then get music
         commentary = segment.get("commentary", "")
+        
+        # Generate host commentary
         if commentary and tts_service.client:
             audio_bytes = tts_service.text_to_speech(commentary)
             if audio_bytes:
-                audio_file = f"segment_{radio_state['current_segment_index']}.mp3"
-                tts_service.save_audio(audio_bytes, audio_file)
+                host_audio_file = f"segment_{radio_state['current_segment_index']}_host.mp3"
+                tts_service.save_audio(audio_bytes, host_audio_file)
+        
+        # Get music track and create streaming player
+        track = segment.get("track", {})
+        if track:
+            print(f"🎵 Preparing music: {track.get('title', 'Unknown')} by {track.get('artist', 'Unknown')}")
+            
+            # Get streaming URL for YouTube or SoundCloud
+            if track.get("source") == "youtube" and track.get("url"):
+                try:
+                    # Extract YouTube ID
+                    youtube_id = track.get("youtube_id", "")
+                    if not youtube_id and "v=" in track["url"]:
+                        youtube_id = track["url"].split("v=")[-1].split("&")[0]
+                    
+                    if youtube_id:
+                        # Use YouTube embed player
+                        # Note: Autoplay may be blocked by browser policies, user can click play
+                        music_player_html = f"""
+                        <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
+                            <h4 style="margin: 0 0 0.5rem 0;">🎵 {track.get('title', 'Unknown')} - {track.get('artist', 'Unknown')}</h4>
+                            <div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; background: #000; border-radius: 8px;">
+                                <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
+                                    loading="lazy">
+                                </iframe>
+                            </div>
+                            <p style="margin-top: 0.5rem; font-size: 0.85em; color: #666; margin-bottom: 0;">
+                                <a href="{track['url']}" target="_blank" style="color: #0066cc; text-decoration: none;">🔗 Open on YouTube</a>
+                                <span style="margin-left: 1rem; color: #999;">💡 Click ▶️ to play if autoplay is blocked</span>
+                            </p>
+                        </div>
+                        """
+                        print(f"✅ YouTube player created: {track.get('title', 'Unknown')} (ID: {youtube_id})")
+                    else:
+                        # Fallback: Just show link
+                        music_player_html = f"""
+                        <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
+                            <h4>🎵 {track.get('title', 'Unknown')} - {track.get('artist', 'Unknown')}</h4>
+                            <p>Click to listen:</p>
+                            <a href="{track['url']}" target="_blank" style="display: inline-block; padding: 0.5rem 1rem; background: #ff0000; color: white; text-decoration: none; border-radius: 5px;">
+                                ▶️ Play on YouTube
+                            </a>
+                        </div>
+                        """
+                except Exception as e:
+                    print(f"❌ Error getting music: {e}")
+                    # Fallback: Just show YouTube link
+                    music_player_html = f"""
+                    <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
+                        <h4>🎵 {track.get('title', 'Unknown')} - {track.get('artist', 'Unknown')}</h4>
+                        <p>Click to listen:</p>
+                        <a href="{track['url']}" target="_blank" style="display: inline-block; padding: 0.5rem 1rem; background: #ff0000; color: white; text-decoration: none; border-radius: 5px;">
+                            ▶️ Play on YouTube
+                        </a>
+                    </div>
+                    """
+            elif track.get("source") == "soundcloud" and track.get("url"):
+                # SoundCloud embed player
+                try:
+                    music_player_html = f"""
+                    <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
+                        <h4>🎵 {track.get('title', 'Unknown')} - {track.get('artist', 'Unknown')}</h4>
+                        <iframe width="100%" height="166" scrolling="no" frameborder="no" 
+                                src="https://w.soundcloud.com/player/?url={track['url']}&color=%23ff5500&auto_play=true&hide_related=false&show_comments=true&show_user=true&show_reposts=false&show_teaser=true"></iframe>
+                        <p style="margin-top: 0.5rem; font-size: 0.9em; color: #666;">
+                            <a href="{track['url']}" target="_blank">🔗 Open on SoundCloud</a>
+                        </p>
+                    </div>
+                    """
+                    print(f"✅ Streaming from SoundCloud: {track.get('title', 'Unknown')}")
+                except Exception as e:
+                    print(f"❌ Error with SoundCloud: {e}")
+                    music_player_html = f"""
+                    <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
+                        <h4>🎵 {track.get('title', 'Unknown')} - {track.get('artist', 'Unknown')}</h4>
+                        <a href="{track['url']}" target="_blank" style="display: inline-block; padding: 0.5rem 1rem; background: #ff5500; color: white; text-decoration: none; border-radius: 5px;">
+                            ▶️ Play on SoundCloud
+                        </a>
+                    </div>
+                    """
+            else:
+                # Demo track - no actual audio file
+                print("ℹ️ Demo track (no audio file available)")
+                music_player_html = ""
     
     elif segment["type"] == "podcast":
+        # For podcast: generate intro
         intro = segment.get("intro", "")
+        
         if intro and tts_service.client:
             audio_bytes = tts_service.text_to_speech(intro)
             if audio_bytes:
-                audio_file = f"segment_{radio_state['current_segment_index']}.mp3"
-                tts_service.save_audio(audio_bytes, audio_file)
+                host_audio_file = f"segment_{radio_state['current_segment_index']}_host.mp3"
+                tts_service.save_audio(audio_bytes, host_audio_file)
     
     # Progress info
     progress = f"Segment {radio_state['current_segment_index']}/{len(radio_state['planned_show'])}"
     
-    return segment_info, audio_file, progress, get_now_playing(segment)
+    # Return: segment_info, host_audio, music_player_html, progress, now_playing
+    return segment_info, host_audio_file, music_player_html, progress, get_now_playing(segment)
 
 def stop_radio():
     """Stop the radio stream"""
@@ -137,25 +271,41 @@ def format_segment_info(segment: Dict[str, Any]) -> str:
     elif seg_type == "music":
         track = segment.get("track", {})
         if track:
-            return f"""🎵 **Now Playing**
+            music_info = f"""🎵 **Now Playing**
             
 **{track['title']}**
 by {track['artist']}
 
 Genre: {track['genre']}
-Duration: {track['duration']}s
+Duration: {track.get('duration', 'Unknown')}s
 
 *{segment.get('commentary', '')}*
 """
+            # Add YouTube link if available
+            if segment.get("_youtube_url"):
+                music_info += f"\n\n🔗 [Listen on YouTube]({segment['_youtube_url']})"
+            elif track.get("url") and "youtube" in track.get("url", ""):
+                music_info += f"\n\n🔗 [Listen on YouTube]({track['url']})"
+            
+            return music_info
         return "🎵 Music Time!"
     
     elif seg_type == "news":
         news_items = segment.get("news_items", [])
         news_text = "📰 **News Update**\n\n"
-        news_text += segment.get("script", "")
+        
+        # Handle batched script (list) or old format (string)
+        script = segment.get("script", segment.get("script_batches", ""))
+        if isinstance(script, list):
+            # Join all batches for display
+            news_text += " ".join(script)
+        else:
+            # Old format - string
+            news_text += str(script) if script else ""
+        
         news_text += "\n\n**Headlines:**\n"
         for item in news_items[:2]:
-            news_text += f"\n• {item['title']}"
+            news_text += f"\n• {item.get('title', 'No title')}"
         return news_text
     
     elif seg_type == "podcast":
@@ -185,16 +335,116 @@ def get_segment_text(segment: Dict[str, Any]) -> str:
     seg_type = segment["type"]
     
     if seg_type in ["intro", "outro", "story"]:
-        return segment.get("content", "")
+        return str(segment.get("content", ""))
     elif seg_type == "news":
-        return segment.get("script", "")
+        # Handle batched news
+        script_batches = segment.get("script_batches", segment.get("script", []))
+        if isinstance(script_batches, list):
+            if script_batches:
+                return " ".join(str(batch) for batch in script_batches)  # Join all batches
+            return ""
+        return str(script_batches) if script_batches else ""  # Fallback
     elif seg_type == "music":
-        return segment.get("commentary", "")
+        return str(segment.get("commentary", ""))
     elif seg_type == "podcast":
-        return segment.get("intro", "")
+        return str(segment.get("intro", ""))
     
     return ""
 
+def handle_voice_request():
+    """Handle voice input request for song"""
+    # Check if voice input is available
+    if not voice_input_service.available:
+        return "⚠️ Voice input is not available. Please install PortAudio and pyaudio.\n\nSee INSTALL_VOICE_INPUT.md for instructions.\n\nYou can still request songs by typing in preferences!", None, ""
+    
+    try:
+        # Listen and recognize
+        recognized_text = voice_input_service.listen_and_recognize(timeout=5, phrase_time_limit=10)
+        
+        if not recognized_text:
+            return "❌ Could not recognize speech. Please try again.", None, ""
+        
+        # Process the request
+        song_request = voice_input_service.process_song_request(recognized_text)
+        print(f"🎤 Processed request: {song_request}")
+        
+        # Search for music
+        tracks = agent.music_server.search_by_request(song_request)
+        
+        if not tracks:
+            return f"❌ Could not find music for: '{recognized_text}'. Try saying something like 'play pop music' or 'play a song by [artist name]'!", None, ""
+        
+        # Get the first matching track
+        track = tracks[0]
+        print(f"🎵 Selected track: {track.get('title', 'Unknown')} by {track.get('artist', 'Unknown')}")
+        
+        # Generate host response
+        host_response = f"Great choice! I found '{track['title']}' by {track['artist']}. Let me play that for you!"
+        
+        # Generate TTS for host response
+        audio_file = None
+        if tts_service.client:
+            audio_bytes = tts_service.text_to_speech(host_response)
+            if audio_bytes:
+                audio_file = f"voice_request_{int(time.time())}.mp3"
+                tts_service.save_audio(audio_bytes, audio_file)
+        
+        # Create music player HTML
+        music_player_html = ""
+        if track.get("source") == "youtube":
+            youtube_id = track.get("youtube_id", "")
+            if not youtube_id and "v=" in track.get("url", ""):
+                youtube_id = track["url"].split("v=")[-1].split("&")[0]
+            
+            if youtube_id:
+                # Use YouTube embed player
+                music_player_html = f"""
+                <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
+                    <h4 style="margin: 0 0 0.5rem 0;">🎵 {track.get('title', 'Unknown')} - {track.get('artist', 'Unknown')}</h4>
+                    <div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden; max-width: 100%; background: #000; border-radius: 8px;">
+                        <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
+                            loading="lazy">
+                        </iframe>
+                    </div>
+                    <p style="margin-top: 0.5rem; font-size: 0.85em; color: #666; margin-bottom: 0;">
+                        <a href="{track['url']}" target="_blank" style="color: #0066cc; text-decoration: none;">🔗 Open on YouTube</a>
+                        <span style="margin-left: 1rem; color: #999;">💡 Click ▶️ to play if autoplay is blocked</span>
+                    </p>
+                </div>
+                """
+                print(f"✅ YouTube player created for voice request: {track.get('title', 'Unknown')} (ID: {youtube_id})")
+            else:
+                music_player_html = f"""
+                <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
+                    <h4>🎵 {track.get('title', 'Unknown')} - {track.get('artist', 'Unknown')}</h4>
+                    <a href="{track['url']}" target="_blank" style="display: inline-block; padding: 0.5rem 1rem; background: #ff0000; color: white; text-decoration: none; border-radius: 5px;">
+                        ▶️ Play on YouTube
+                    </a>
+                </div>
+                """
+        elif track.get("source") == "soundcloud":
+            # SoundCloud embed player
+            music_player_html = f"""
+            <div style="padding: 1rem; background: #f0f0f0; border-radius: 10px; margin: 1rem 0;">
+                <h4>🎵 {track.get('title', 'Unknown')} - {track.get('artist', 'Unknown')}</h4>
+                <iframe width="100%" height="166" scrolling="no" frameborder="no" 
+                        src="https://w.soundcloud.com/player/?url={track['url']}&color=%23ff5500&auto_play=true&hide_related=false&show_comments=true&show_user=true&show_reposts=false&show_teaser=true"></iframe>
+                <p style="margin-top: 0.5rem; font-size: 0.9em; color: #666;">
+                    <a href="{track['url']}" target="_blank">🔗 Open on SoundCloud</a>
+                </p>
+            </div>
+            """
+        
+        # Add to current show or play immediately
+        return f"✅ {host_response}\n\n🎵 Playing: {track['title']} by {track['artist']}", audio_file, music_player_html
+        
+    except Exception as e:
+        return f"❌ Error processing voice request: {e}", None, ""
+
 def get_now_playing(segment: Dict[str, Any]) -> str:
     """Get now playing text"""
     seg_type = segment["type"]
@@ -298,11 +548,18 @@ with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft()) as
                 next_btn = gr.Button("⏭️ Next Segment", variant="secondary", size="lg", elem_classes="control-button")
                 stop_btn = gr.Button("⏹️ Stop", variant="stop", size="lg", elem_classes="control-button")
             
+            with gr.Row():
+                voice_btn = gr.Button("🎤 Ask for a Song", variant="primary", size="lg", elem_classes="control-button")
+                voice_status = gr.Textbox(label="Voice Request", value="Click to request a song by voice", interactive=False)
+            
             progress_text = gr.Textbox(label="Progress", value="Ready to start", interactive=False)
             
             segment_info = gr.Markdown("**Welcome!** Set your preferences and start the radio.", elem_id="segment-display")
             
-            audio_output = gr.Audio(label="🔊 Now Playing", autoplay=True, type="filepath")
+            gr.Markdown("**💡 Tip:** Host speech plays first, then music/podcasts will stream automatically!")
+            
+            audio_output = gr.Audio(label="🔊 Host Speech", autoplay=True, type="filepath")
+            music_player = gr.HTML(label="🎵 Music/Podcast Player (streaming)")
             
             status_text = gr.Textbox(label="Status", value="Ready", interactive=False)
             
@@ -310,17 +567,17 @@ with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft()) as
             start_btn.click(
                 fn=start_radio_stream,
                 inputs=[],
-                outputs=[status_text, audio_output, progress_text, now_playing]
+                outputs=[status_text, audio_output, music_player, progress_text, now_playing]
             ).then(
                 fn=play_next_segment,
                 inputs=[],
-                outputs=[segment_info, audio_output, progress_text, now_playing]
+                outputs=[segment_info, audio_output, music_player, progress_text, now_playing]
             )
             
             next_btn.click(
                 fn=play_next_segment,
                 inputs=[],
-                outputs=[segment_info, audio_output, progress_text, now_playing]
+                outputs=[segment_info, audio_output, music_player, progress_text, now_playing]
             )
             
             stop_btn.click(
@@ -328,6 +585,18 @@ with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft()) as
                 inputs=[],
                 outputs=[status_text]
             )
+            
+            # Voice input button
+            voice_btn.click(
+                fn=handle_voice_request,
+                inputs=[],
+                outputs=[voice_status, audio_output, music_player]
+            ).then(
+                # After voice request, update status
+                fn=lambda status, audio, player: (status, audio, player),
+                inputs=[voice_status, audio_output, music_player],
+                outputs=[voice_status, audio_output, music_player]
+            )
         
         # Tab 2: Preferences
         with gr.Tab("⚙️ Your Preferences"):
@@ -370,12 +639,22 @@ with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft()) as
                         value=["technology"]
                     )
             
+            gr.Markdown("### 🎛️ Content Filter")
+            gr.Markdown("Choose what types of content you want to hear:")
+            
+            with gr.Row():
+                music_filter = gr.Checkbox(label="🎵 Music", value=True)
+                news_filter = gr.Checkbox(label="📰 News", value=True)
+                podcast_filter = gr.Checkbox(label="🎙️ Podcasts", value=True)
+                story_filter = gr.Checkbox(label="📖 AI Stories", value=True)
+            
             save_pref_btn = gr.Button("💾 Save Preferences", variant="primary", size="lg")
             pref_status = gr.Textbox(label="Status", interactive=False)
             
             save_pref_btn.click(
                 fn=save_preferences,
-                inputs=[name_input, genres_input, interests_input, podcast_input, mood_input],
+                inputs=[name_input, genres_input, interests_input, podcast_input, mood_input,
+                       music_filter, news_filter, podcast_filter, story_filter],
                 outputs=[pref_status]
             )
         
@@ -458,7 +737,7 @@ with gr.Blocks(css=custom_css, title="AI Radio 🎵", theme=gr.themes.Soft()) as
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7860,
+        server_port=7861,
         share=False
     )
 

config.py

@@ -10,6 +10,8 @@ class RadioConfig(BaseModel):
     google_api_key: str = "AIzaSyB5F9P0oDZ6fgW8GgADfwnwcg-GkHrdo74"
     llamaindex_api_key: str = "llx-WRsj0iehk2ZlSlNIenOLyyhO9X1yFT4CmJXpl0qk6hapFi01"
     nebius_api_key: str = "v1.CmQKHHN0YXRpY2tleS1lMDB0eTkxeTdwY3lxNDk5OWcSIXNlcnZpY2VhY2NvdW50LWUwMGowemtmZWpqc2E3ZHF3aDIMCKb4oskGENS9j8MBOgwIpfu6lAcQgOqAhwNAAloDZTAw.AAAAAAAAAAGEI_L5sJCQ7XR93nSzvXCPO-J3-gHjqPiRqrvkrMLeDtd-70zGWB1-c8yovnX-q7yEc1dHOnA2L8FUa3Le6X8D"
+    nebius_api_base: str = "https://api.nebius.ai/v1"  # Nebius OpenAI-compatible endpoint
+    nebius_model: str = "gpt-oss-120b"  # GPT-OSS-120B model from Nebius
     
     # Voice Settings
     elevenlabs_voice_id: str = "21m00Tcm4TlvDq8ikWAM"  # Default voice (Rachel)

mcp_servers/music_server.py

@@ -1,7 +1,9 @@
 """MCP Server for Music Recommendations"""
 import json
 import requests
-from typing import List, Dict, Any
+import yt_dlp
+import os
+from typing import List, Dict, Any, Optional
 from dataclasses import dataclass
 
 @dataclass
@@ -19,11 +21,216 @@ class MusicMCPServer:
     def __init__(self):
         self.name = "music_server"
         self.description = "Provides music recommendations and free music tracks"
+        self.cache_dir = "music_cache"
+        os.makedirs(self.cache_dir, exist_ok=True)
         
+    def search_youtube_music(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Search for free music on YouTube
+        
+        Args:
+            query: Search query (e.g., "pop music", "jazz instrumental", "song name")
+            limit: Number of results
+            
+        Returns:
+            List of track dictionaries with YouTube URLs
+        """
+        tracks = []
+        try:
+            # First try with extract_flat=False to get full info
+            ydl_opts = {
+                'quiet': True,
+                'no_warnings': True,
+                'extract_flat': False,  # Get full info for better results
+                'default_search': 'ytsearch',
+                'format': 'bestaudio/best',
+            }
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                # Don't add "music" if query already contains it or is specific
+                if "music" not in query.lower() and len(query.split()) < 4:
+                    search_query = f"ytsearch{limit}:{query} music"
+                else:
+                    search_query = f"ytsearch{limit}:{query}"
+                
+                print(f"🔍 YouTube search query: '{search_query}'")
+                results = ydl.extract_info(search_query, download=False)
+                
+                # Handle different result formats from yt-dlp
+                entries = None
+                
+                if isinstance(results, dict):
+                    # Standard format with entries list
+                    if 'entries' in results:
+                        entries = results['entries']
+                    # Sometimes the dict itself contains video info
+                    elif 'id' in results:
+                        entries = [results]
+                elif isinstance(results, list):
+                    entries = results
+                
+                if entries:
+                    for entry in entries[:limit]:
+                        if entry and isinstance(entry, dict):
+                            video_id = entry.get('id') or entry.get('url', '').split('v=')[-1].split('&')[0] if 'v=' in str(entry.get('url', '')) else None
+                            if video_id:
+                                track = {
+                                    "title": entry.get('title', 'Unknown'),
+                                    "artist": entry.get('uploader', entry.get('channel', entry.get('channel_name', 'Unknown Artist'))),
+                                    "url": f"https://www.youtube.com/watch?v={video_id}",
+                                    "youtube_id": video_id,
+                                    "duration": entry.get('duration', 0),
+                                    "genre": query.split()[0] if query else "unknown",
+                                    "source": "youtube"
+                                }
+                                tracks.append(track)
+                                print(f"  ✓ Found: {track['title']} by {track['artist']}")
+                else:
+                    # Fallback: try extract_flat=True
+                    print("  ⚠️ Trying flat extraction...")
+                    ydl_opts_flat = {
+                        'quiet': True,
+                        'no_warnings': True,
+                        'extract_flat': True,
+                        'default_search': 'ytsearch',
+                    }
+                    with yt_dlp.YoutubeDL(ydl_opts_flat) as ydl_flat:
+                        results_flat = ydl_flat.extract_info(f"ytsearch{limit}:{query}", download=False)
+                        if isinstance(results_flat, dict) and 'entries' in results_flat:
+                            for entry in results_flat['entries'][:limit]:
+                                if entry and isinstance(entry, dict) and entry.get('id'):
+                                    track = {
+                                        "title": entry.get('title', 'Unknown'),
+                                        "artist": entry.get('uploader', 'Unknown Artist'),
+                                        "url": f"https://www.youtube.com/watch?v={entry.get('id', '')}",
+                                        "youtube_id": entry.get('id', ''),
+                                        "duration": entry.get('duration', 0),
+                                        "genre": query.split()[0] if query else "unknown",
+                                        "source": "youtube"
+                                    }
+                                    tracks.append(track)
+                                    print(f"  ✓ Found (flat): {track['title']} by {track['artist']}")
+        except Exception as e:
+            print(f"❌ Error searching YouTube: {e}")
+            import traceback
+            traceback.print_exc()
+        
+        return tracks
+    
+    def search_soundcloud_music(self, query: str, limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Search for free music on SoundCloud
+        
+        Args:
+            query: Search query (e.g., "pop music", "jazz instrumental")
+            limit: Number of results
+            
+        Returns:
+            List of track dictionaries with SoundCloud URLs
+        """
+        tracks = []
+        try:
+            ydl_opts = {
+                'quiet': True,
+                'no_warnings': True,
+                'extract_flat': True,
+                'default_search': 'scsearch',
+                'format': 'bestaudio/best',
+            }
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                search_query = f"{query} music"
+                results = ydl.extract_info(search_query, download=False)
+                
+                if 'entries' in results:
+                    for entry in results['entries'][:limit]:
+                        if entry:
+                            track = {
+                                "title": entry.get('title', 'Unknown'),
+                                "artist": entry.get('uploader', 'Unknown Artist'),
+                                "url": entry.get('url', entry.get('webpage_url', '')),
+                                "duration": entry.get('duration', 0),
+                                "genre": query.split()[0] if query else "unknown",
+                                "source": "soundcloud"
+                            }
+                            tracks.append(track)
+        except Exception as e:
+            print(f"Error searching SoundCloud: {e}")
+        
+        return tracks
+    
+    def get_audio_url(self, youtube_url: str) -> Optional[str]:
+        """
+        Get direct audio URL from YouTube video
+        
+        Args:
+            youtube_url: YouTube video URL
+            
+        Returns:
+            Direct audio URL or None
+        """
+        try:
+            ydl_opts = {
+                'format': 'bestaudio/best',
+                'quiet': True,
+                'no_warnings': True,
+            }
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                info = ydl.extract_info(youtube_url, download=False)
+                if 'url' in info:
+                    return info['url']
+        except Exception as e:
+            print(f"Error getting audio URL: {e}")
+        
+        return None
+    
+    def download_audio(self, youtube_url: str, output_path: str) -> Optional[str]:
+        """
+        Download audio from YouTube to local file
+        
+        Args:
+            youtube_url: YouTube video URL
+            output_path: Path to save audio file (without extension)
+            
+        Returns:
+            Path to downloaded file or None
+        """
+        try:
+            # Ensure output path doesn't have extension (yt-dlp adds it)
+            if output_path.endswith('.mp3'):
+                output_path = output_path[:-4]
+            
+            ydl_opts = {
+                'format': 'bestaudio/best',
+                'outtmpl': output_path + '.%(ext)s',
+                'postprocessors': [{
+                    'key': 'FFmpegExtractAudio',
+                    'preferredcodec': 'mp3',
+                    'preferredquality': '192',
+                }],
+                'quiet': True,
+                'no_warnings': True,
+            }
+            
+            with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+                ydl.download([youtube_url])
+                # Check for downloaded file
+                if os.path.exists(output_path + '.mp3'):
+                    return output_path + '.mp3'
+                # Sometimes it might be .m4a or other format
+                for ext in ['.mp3', '.m4a', '.webm', '.ogg']:
+                    if os.path.exists(output_path + ext):
+                        return output_path + ext
+        except Exception as e:
+            print(f"Error downloading audio: {e}")
+        
+        return None
+    
     def search_free_music(self, genre: str = "pop", mood: str = "happy", limit: int = 5) -> List[Dict[str, Any]]:
         """
         Search for free music tracks based on genre and mood
-        Uses Free Music Archive API (simulated for demo)
+        Uses YouTube and SoundCloud for free music
         
         Args:
             genre: Music genre (pop, rock, jazz, classical, electronic, etc.)
@@ -33,33 +240,83 @@ class MusicMCPServer:
         Returns:
             List of track dictionaries
         """
-        # In production, integrate with actual free music APIs like:
-        # - Free Music Archive (FMA)
-        # - Jamendo API
-        # - ccMixter
-        # For now, return demo tracks
+        # Try YouTube first
+        query = f"{genre} {mood}"
+        youtube_tracks = self.search_youtube_music(query, limit=limit)
+        
+        if youtube_tracks:
+            return youtube_tracks
         
+        # Try SoundCloud as fallback
+        soundcloud_tracks = self.search_soundcloud_music(query, limit=limit)
+        if soundcloud_tracks:
+            return soundcloud_tracks
+        
+        # Fallback to demo tracks with real YouTube URLs (free music streams)
         demo_tracks = {
             "pop": [
-                {"title": "Sunshine Day", "artist": "Happy Vibes", "url": "demo_track_1.mp3", "duration": 180, "genre": "pop"},
-                {"title": "Feel Good", "artist": "The Cheerful", "url": "demo_track_2.mp3", "duration": 200, "genre": "pop"},
-                {"title": "Summer Love", "artist": "Pop Stars", "url": "demo_track_3.mp3", "duration": 195, "genre": "pop"},
+                {
+                    "title": "Lofi Hip Hop Radio", 
+                    "artist": "ChilledCow", 
+                    "url": "https://www.youtube.com/watch?v=jfKfPfyJRdk",
+                    "youtube_id": "jfKfPfyJRdk",
+                    "duration": 0,  # Live stream
+                    "genre": "pop", 
+                    "source": "youtube"
+                },
+                {
+                    "title": "Synthwave Radio", 
+                    "artist": "Free Music", 
+                    "url": "https://www.youtube.com/watch?v=4xDzrJKXOOY",
+                    "youtube_id": "4xDzrJKXOOY",
+                    "duration": 0,
+                    "genre": "pop", 
+                    "source": "youtube"
+                },
             ],
             "rock": [
-                {"title": "Thunder Road", "artist": "Rock Squad", "url": "demo_track_4.mp3", "duration": 220, "genre": "rock"},
-                {"title": "Electric Soul", "artist": "The Rockers", "url": "demo_track_5.mp3", "duration": 210, "genre": "rock"},
+                {
+                    "title": "Rock Music Stream", 
+                    "artist": "Free Music", 
+                    "url": "https://www.youtube.com/watch?v=jfKfPfyJRdk",
+                    "youtube_id": "jfKfPfyJRdk",
+                    "duration": 0, 
+                    "genre": "rock", 
+                    "source": "youtube"
+                },
             ],
             "jazz": [
-                {"title": "Midnight Blue", "artist": "Jazz Ensemble", "url": "demo_track_6.mp3", "duration": 240, "genre": "jazz"},
-                {"title": "Smooth Sax", "artist": "Cool Jazz Band", "url": "demo_track_7.mp3", "duration": 260, "genre": "jazz"},
+                {
+                    "title": "Jazz Music", 
+                    "artist": "Free Music", 
+                    "url": "https://www.youtube.com/watch?v=jfKfPfyJRdk",
+                    "youtube_id": "jfKfPfyJRdk",
+                    "duration": 0, 
+                    "genre": "jazz", 
+                    "source": "youtube"
+                },
             ],
             "classical": [
-                {"title": "Morning Sonata", "artist": "Classical Orchestra", "url": "demo_track_8.mp3", "duration": 300, "genre": "classical"},
-                {"title": "Peaceful Symphony", "artist": "Chamber Ensemble", "url": "demo_track_9.mp3", "duration": 280, "genre": "classical"},
+                {
+                    "title": "Classical Music", 
+                    "artist": "Free Music", 
+                    "url": "https://www.youtube.com/watch?v=jfKfPfyJRdk",
+                    "youtube_id": "jfKfPfyJRdk",
+                    "duration": 0, 
+                    "genre": "classical", 
+                    "source": "youtube"
+                },
             ],
             "electronic": [
-                {"title": "Digital Dreams", "artist": "Synth Wave", "url": "demo_track_10.mp3", "duration": 190, "genre": "electronic"},
-                {"title": "Neon Lights", "artist": "Electro Beats", "url": "demo_track_11.mp3", "duration": 185, "genre": "electronic"},
+                {
+                    "title": "Electronic Beats", 
+                    "artist": "Free Music", 
+                    "url": "https://www.youtube.com/watch?v=jfKfPfyJRdk",
+                    "youtube_id": "jfKfPfyJRdk",
+                    "duration": 0, 
+                    "genre": "electronic", 
+                    "source": "youtube"
+                },
             ]
         }
         
@@ -68,6 +325,81 @@ class MusicMCPServer:
         
         return tracks[:limit]
     
+    def search_by_request(self, song_request: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """
+        Search for music based on voice request
+        
+        Args:
+            song_request: Dictionary with song request details
+            
+        Returns:
+            List of matching tracks
+        """
+        # Build search query from request
+        # Prefer original text, but clean it up
+        if song_request.get("original_text"):
+            original = song_request["original_text"]
+            # Remove common filler words but keep the core query
+            filler_words = ["play", "put on", "listen to", "want to hear", "i want to", "can you", "please"]
+            query = original.lower()
+            for filler in filler_words:
+                query = query.replace(filler, "").strip()
+            query = " ".join(query.split())  # Clean up spaces
+            # If query is too short or unclear, use original
+            if len(query.split()) < 2:
+                query = original
+        else:
+            # Build query from parts
+            query_parts = []
+            if song_request.get("song") and len(song_request["song"].split()) > 1:
+                query_parts.append(song_request["song"])
+            elif song_request.get("song"):
+                # Single word song - add genre or use as-is
+                if song_request.get("genre"):
+                    query_parts.append(song_request["genre"])
+                else:
+                    query_parts.append(song_request["song"])
+            if song_request.get("artist"):
+                query_parts.append(song_request["artist"])
+            if song_request.get("genre") and song_request["genre"] not in " ".join(query_parts):
+                query_parts.append(song_request["genre"])
+            
+            query = " ".join(query_parts) if query_parts else "music"
+        
+        print(f"🔍 Searching for music: '{query}'")
+        
+        # Try YouTube first
+        tracks = self.search_youtube_music(query, limit=5)
+        
+        if tracks:
+            print(f"✅ Found {len(tracks)} tracks on YouTube")
+            return tracks
+        
+        # If YouTube fails, try SoundCloud
+        print("⚠️ YouTube search failed, trying SoundCloud...")
+        tracks = self.search_soundcloud_music(query, limit=5)
+        
+        if tracks:
+            print(f"✅ Found {len(tracks)} tracks on SoundCloud")
+            return tracks
+        
+        # If both fail, try a simpler query
+        print("⚠️ Both searches failed, trying simplified query...")
+        if song_request.get("song"):
+            simple_query = song_request["song"]
+            tracks = self.search_youtube_music(simple_query, limit=5)
+            if tracks:
+                return tracks
+        
+        # Last resort: search by genre or mood
+        if song_request.get("genre"):
+            tracks = self.search_free_music(genre=song_request["genre"], limit=5)
+            if tracks:
+                return tracks
+        
+        print("❌ No tracks found")
+        return []
+    
     def get_personalized_playlist(self, user_preferences: Dict[str, Any]) -> List[Dict[str, Any]]:
         """
         Generate personalized playlist based on user preferences

mcp_servers/news_server.py

@@ -3,6 +3,7 @@ import requests
 import feedparser
 from typing import List, Dict, Any
 from datetime import datetime
+import time
 
 class NewsMCPServer:
     """MCP Server for fetching and curating news"""
@@ -11,30 +12,40 @@ class NewsMCPServer:
         self.name = "news_server"
         self.description = "Fetches latest news from various sources"
         
-        # Free RSS feeds
+        # More reliable RSS feeds with fallbacks
         self.news_feeds = {
             "technology": [
-                "https://feeds.bbci.co.uk/news/technology/rss.xml",
-                "https://www.theverge.com/rss/index.xml"
+                "https://rss.cnn.com/rss/edition.rss",  # CNN Tech
+                "https://feeds.feedburner.com/oreilly/radar",  # O'Reilly Radar
+                "https://www.wired.com/feed/rss"  # Wired
             ],
             "world": [
-                "https://feeds.bbci.co.uk/news/world/rss.xml",
-                "https://rss.nytimes.com/services/xml/rss/nyt/World.xml"
+                "https://rss.cnn.com/rss/edition.rss",  # CNN World
+                "https://feeds.reuters.com/reuters/topNews",  # Reuters Top News
+                "https://rss.nytimes.com/services/xml/rss/nyt/World.xml"  # NYT World
             ],
             "business": [
-                "https://feeds.bbci.co.uk/news/business/rss.xml",
+                "https://feeds.reuters.com/reuters/businessNews",  # Reuters Business
+                "https://rss.cnn.com/rss/money_latest.rss",  # CNN Money
             ],
             "entertainment": [
-                "https://feeds.bbci.co.uk/news/entertainment_and_arts/rss.xml",
+                "https://rss.cnn.com/rss/edition_entertainment.rss",  # CNN Entertainment
+                "https://www.rollingstone.com/feed",  # Rolling Stone
             ],
             "science": [
-                "https://feeds.bbci.co.uk/news/science_and_environment/rss.xml",
+                "https://rss.cnn.com/rss/edition_space.rss",  # CNN Science
+                "https://feeds.feedburner.com/sciencealert-latestnews",  # Science Alert
             ]
         }
+        
+        # NewsAPI.org (free tier - 100 requests/day)
+        # You can get a free API key from https://newsapi.org/
+        self.newsapi_key = None  # Optional - can be added later
+        self.newsapi_base = "https://newsapi.org/v2"
     
     def fetch_news(self, category: str = "world", limit: int = 5) -> List[Dict[str, Any]]:
         """
-        Fetch latest news from RSS feeds
+        Fetch latest news from RSS feeds with better error handling
         
         Args:
             category: News category (technology, world, business, entertainment, science)
@@ -43,31 +54,67 @@ class NewsMCPServer:
         Returns:
             List of news items
         """
-        try:
-            feeds = self.news_feeds.get(category, self.news_feeds["world"])
-            all_news = []
-            
-            for feed_url in feeds[:2]:  # Use first 2 feeds
-                try:
-                    feed = feedparser.parse(feed_url)
-                    for entry in feed.entries[:limit]:
-                        news_item = {
-                            "title": entry.get("title", ""),
-                            "summary": entry.get("summary", entry.get("description", ""))[:200],
-                            "link": entry.get("link", ""),
-                            "published": entry.get("published", ""),
-                            "category": category
-                        }
-                        all_news.append(news_item)
-                except Exception as e:
-                    print(f"Error fetching from {feed_url}: {e}")
+        all_news = []
+        
+        # Try RSS feeds first
+        feeds = self.news_feeds.get(category, self.news_feeds["world"])
+        
+        for feed_url in feeds:
+            try:
+                # Add timeout and headers for better reliability
+                headers = {
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                }
+                
+                # Parse feed with timeout
+                feed = feedparser.parse(feed_url)
+                
+                # Check if feed is valid
+                if not feed.entries:
                     continue
-            
+                
+                for entry in feed.entries[:limit]:
+                    # Safely extract fields
+                    title = str(entry.get("title", "")).strip()
+                    summary = str(entry.get("summary", entry.get("description", ""))).strip()
+                    link = str(entry.get("link", "")).strip()
+                    published = str(entry.get("published", entry.get("updated", ""))).strip()
+                    
+                    if not title:  # Skip if no title
+                        continue
+                    
+                    # Truncate summary safely
+                    if summary:
+                        summary = summary[:200] + "..." if len(summary) > 200 else summary
+                    else:
+                        summary = "No summary available."
+                    
+                    news_item = {
+                        "title": title,
+                        "summary": summary,
+                        "link": link if link else "#",
+                        "published": published if published else datetime.now().strftime("%Y-%m-%d"),
+                        "category": category
+                    }
+                    all_news.append(news_item)
+                    
+                    if len(all_news) >= limit:
+                        break
+                
+                if len(all_news) >= limit:
+                    break
+                    
+            except Exception as e:
+                print(f"Error fetching from {feed_url}: {e}")
+                continue
+        
+        # If we got some news, return it
+        if all_news:
             return all_news[:limit]
         
-        except Exception as e:
-            print(f"Error fetching news: {e}")
-            return self._get_demo_news(category, limit)
+        # Fallback to demo news if all feeds fail
+        print(f"All feeds failed for {category}, using demo news")
+        return self._get_demo_news(category, limit)
     
     def _get_demo_news(self, category: str, limit: int) -> List[Dict[str, Any]]:
         """Return demo news items when RSS feeds fail"""

radio_agent.py

@@ -3,7 +3,8 @@ import json
 import random
 from typing import Dict, Any, List, Generator
 from datetime import datetime
-import google.generativeai as genai
+from openai import OpenAI
+# import google.generativeai as genai  # Commented out - using Nebius/OpenAI instead
 
 from mcp_servers.music_server import MusicMCPServer
 from mcp_servers.news_server import NewsMCPServer
@@ -16,27 +17,47 @@ class RadioAgent:
     def __init__(self, config):
         self.config = config
         
-        # Initialize Gemini LLM
-        if config.google_api_key:
-            genai.configure(api_key=config.google_api_key)
-            self.model = genai.GenerativeModel('gemini-pro')
-        else:
-            self.model = None
+        # Initialize Nebius/OpenAI LLM (GPT-OSS-120B) with error handling
+        self.client = None
+        if config.nebius_api_key:
+            try:
+                self.client = OpenAI(
+                    api_key=config.nebius_api_key,
+                    base_url=config.nebius_api_base
+                )
+                # Test the connection
+                self.client.models.list()
+            except Exception as e:
+                print(f"Warning: Could not initialize Nebius/OpenAI LLM: {e}")
+                print("Radio agent will work in fallback mode with limited LLM features")
+                self.client = None
+        
+        # # Initialize Gemini LLM with error handling (COMMENTED OUT - for future use)
+        # self.model = None
+        # if config.google_api_key:
+        #     try:
+        #         genai.configure(api_key=config.google_api_key)
+        #         self.model = genai.GenerativeModel('gemini-1.0-pro')
+        #     except Exception as e:
+        #         print(f"Warning: Could not initialize Gemini LLM: {e}")
+        #         print("Radio agent will work in fallback mode with limited LLM features")
+        #         self.model = None
         
         # Initialize MCP Servers
         self.music_server = MusicMCPServer()
         self.news_server = NewsMCPServer()
         self.podcast_server = PodcastMCPServer()
         
-        # Initialize RAG System
-        self.rag_system = RadioRAGSystem(config.google_api_key)
+        # Initialize RAG System (using Nebius API key)
+        self.rag_system = RadioRAGSystem(config.nebius_api_key, config.nebius_api_base, config.nebius_model)
         
         # Agent state
         self.is_streaming = False
         self.current_segment = None
         self.segment_history = []
         
-    def plan_radio_show(self, user_preferences: Dict[str, Any], duration_minutes: int = 30) -> List[Dict[str, Any]]:
+    def plan_radio_show(self, user_preferences: Dict[str, Any], duration_minutes: int = 30, 
+                       content_filter: Dict[str, bool] = None) -> List[Dict[str, Any]]:
         """
         Plan a personalized radio show based on user preferences
         This demonstrates autonomous planning behavior
@@ -44,35 +65,65 @@ class RadioAgent:
         Args:
             user_preferences: User's preferences and mood
             duration_minutes: Total duration of the show
+            content_filter: Dictionary with content type filters (music, news, podcasts, stories)
             
         Returns:
             List of planned segments
         """
         segments = []
         
+        # Default filter - all enabled
+        if content_filter is None:
+            content_filter = {
+                "music": True,
+                "news": True,
+                "podcasts": True,
+                "stories": True
+            }
+        
         # Get user preferences from RAG
         stored_prefs = self.rag_system.get_user_preferences()
         merged_prefs = {**stored_prefs, **user_preferences}
         
-        # Calculate segment distribution
+        # Calculate segment distribution based on filter
         total_segments = max(5, duration_minutes // 5)
         
-        music_count = int(total_segments * self.config.music_ratio)
-        news_count = int(total_segments * self.config.news_ratio)
-        podcast_count = int(total_segments * self.config.podcast_ratio)
-        story_count = max(1, int(total_segments * self.config.story_ratio))
+        music_count = int(total_segments * self.config.music_ratio) if content_filter.get("music", True) else 0
+        news_count = int(total_segments * self.config.news_ratio) if content_filter.get("news", True) else 0
+        podcast_count = int(total_segments * self.config.podcast_ratio) if content_filter.get("podcasts", True) else 0
+        story_count = max(1, int(total_segments * self.config.story_ratio)) if content_filter.get("stories", True) else 0
         
         # Balance to total
-        remaining = total_segments - (music_count + news_count + podcast_count + story_count)
-        music_count += remaining
+        total_planned = music_count + news_count + podcast_count + story_count
+        if total_planned == 0:
+            # If all filtered out, enable music as default
+            music_count = total_segments
+        else:
+            remaining = total_segments - total_planned
+            # Distribute remaining to enabled types
+            enabled_types = sum([content_filter.get("music", True), content_filter.get("news", True), 
+                                content_filter.get("podcasts", True), content_filter.get("stories", True)])
+            if enabled_types > 0:
+                per_type = remaining // enabled_types
+                if content_filter.get("music", True):
+                    music_count += per_type
+                if content_filter.get("news", True):
+                    news_count += per_type
+                if content_filter.get("podcasts", True):
+                    podcast_count += per_type
+                if content_filter.get("stories", True):
+                    story_count += per_type
         
         # Create segment plan
-        segment_types = (
-            ['music'] * music_count +
-            ['news'] * news_count +
-            ['podcast'] * podcast_count +
-            ['story'] * story_count
-        )
+        segment_types = []
+        if content_filter.get("music", True):
+            segment_types.extend(['music'] * music_count)
+        if content_filter.get("news", True):
+            segment_types.extend(['news'] * news_count)
+        if content_filter.get("podcasts", True):
+            segment_types.extend(['podcast'] * podcast_count)
+        if content_filter.get("stories", True):
+            segment_types.extend(['story'] * story_count)
         
         # Shuffle for variety
         random.shuffle(segment_types)
@@ -105,40 +156,73 @@ class RadioAgent:
         return segments
     
     def _generate_intro(self, preferences: Dict[str, Any]) -> str:
-        """Generate personalized radio intro"""
+        """Generate personalized radio intro - longer and more engaging"""
         mood = preferences.get('mood', 'happy')
         name = preferences.get('name', 'friend')
         time_of_day = self._get_time_of_day()
+        interests = preferences.get('interests', ['technology'])
         
-        if self.model:
+        if self.client:
             try:
-                prompt = f"""You are a charismatic radio host. Create a warm, engaging {time_of_day} greeting 
-                for {name}. The listener is feeling {mood}. Keep it energetic and personal, 2-3 sentences.
-                Make them excited to listen!"""
+                prompt = f"""You are a charismatic, entertaining radio host. Create a warm, engaging {time_of_day} greeting 
+                for {name}. The listener is feeling {mood} and interested in {', '.join(interests[:2])}.
                 
-                response = self.model.generate_content(prompt)
-                return response.text
+                Make it:
+                - 4-6 sentences long (about 30-40 seconds of speech)
+                - Energetic and personal
+                - Include a fun fact or light joke related to their interests
+                - Make them excited to listen!
+                - Sound natural and conversational, like a real radio host"""
+                
+                response = self.client.chat.completions.create(
+                    model=self.config.nebius_model,
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=0.9,
+                    max_tokens=400
+                )
+                return response.choices[0].message.content.strip()
             except Exception as e:
                 print(f"Error generating intro: {e}")
         
+        # # Gemini fallback (COMMENTED OUT - for future use)
+        # if self.model:
+        #     try:
+        #         response = self.model.generate_content(prompt)
+        #         return response.text
+        #     except Exception as e:
+        #         print(f"Error generating intro: {e}")
+        
         # Fallback intro
-        return f"Good {time_of_day}, {name}! Welcome to your personal AI Radio station. We've got an amazing show lined up for you today!"
+        return f"Good {time_of_day}, {name}! Welcome to your personal AI Radio station. We've got an amazing show lined up for you today! Did you know that music can actually boost your productivity? That's right! So sit back, relax, and let's get this party started!"
     
     def _generate_outro(self, preferences: Dict[str, Any]) -> str:
         """Generate personalized radio outro"""
         name = preferences.get('name', 'friend')
         
-        if self.model:
+        if self.client:
             try:
                 prompt = f"""You are a charismatic radio host wrapping up a show. 
                 Create a warm, friendly goodbye message for {name}. 
                 Thank them for listening and invite them back. Keep it 2 sentences."""
                 
-                response = self.model.generate_content(prompt)
-                return response.text
+                response = self.client.chat.completions.create(
+                    model=self.config.nebius_model,
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=0.8,
+                    max_tokens=100
+                )
+                return response.choices[0].message.content.strip()
             except Exception as e:
                 print(f"Error generating outro: {e}")
         
+        # # Gemini fallback (COMMENTED OUT - for future use)
+        # if self.model:
+        #     try:
+        #         response = self.model.generate_content(prompt)
+        #         return response.text
+        #     except Exception as e:
+        #         print(f"Error generating outro: {e}")
+        
         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]:
@@ -166,21 +250,22 @@ class RadioAgent:
         }
     
     def _plan_news_segment(self, preferences: Dict[str, Any]) -> Dict[str, Any]:
-        """Plan a news segment using News MCP Server"""
+        """Plan a news segment using News MCP Server - with batched generation"""
         interests = preferences.get('interests', ['world'])
         category = random.choice(interests)
         
         # Use MCP server to get news
-        news_items = self.news_server.fetch_news(category=category, limit=2)
+        news_items = self.news_server.fetch_news(category=category, limit=3)
         
-        # Generate news script
-        script = self._generate_news_script(news_items, preferences)
+        # Generate news script in batches
+        script_batches = self._generate_news_script(news_items, preferences)
         
         return {
             'type': 'news',
             'news_items': news_items,
-            'script': script,
-            'duration': 2
+            'script': script_batches,  # Now a list of batches
+            'script_batches': script_batches,  # For easy access
+            'duration': 2  # Will be updated based on actual length
         }
     
     def _plan_podcast_segment(self, preferences: Dict[str, Any]) -> Dict[str, Any]:
@@ -218,40 +303,85 @@ class RadioAgent:
         }
     
     def _generate_music_commentary(self, track: Dict[str, Any], preferences: Dict[str, Any]) -> str:
-        """Generate commentary for music track"""
-        if not track or not self.model:
+        """Generate longer, more engaging commentary for music track with jokes/facts"""
+        if not track or not self.client:
             return f"Here's a great track for you!"
         
+        mood = preferences.get('mood', 'happy')
+        interests = preferences.get('interests', [])
+        
         try:
-            prompt = f"""You are an energetic radio DJ. Introduce this song in 1-2 sentences:
+            prompt = f"""You are an energetic, entertaining radio DJ. Introduce this song in a fun, engaging way:
             Title: {track['title']}
             Artist: {track['artist']}
             Genre: {track['genre']}
+            Listener mood: {mood}
             
-            Be enthusiastic and brief!"""
+            Make it:
+            - 4-6 sentences long (about 30-40 seconds of speech)
+            - Include a fun fact about the genre, artist, or music in general
+            - Add a light joke or witty comment
+            - Be enthusiastic and engaging
+            - Sound natural, like a real radio host
+            - Connect it to the listener's mood if possible"""
             
-            response = self.model.generate_content(prompt)
-            return response.text
+            response = self.client.chat.completions.create(
+                model=self.config.nebius_model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.9,
+                max_tokens=300
+            )
+            return response.choices[0].message.content.strip()
         except Exception as e:
-            return f"Coming up: {track['title']} by {track['artist']}!"
+            return f"Coming up: {track['title']} by {track['artist']}! This is a fantastic {track['genre']} track that's perfect for your {mood} mood. Let's enjoy this one!"
     
-    def _generate_news_script(self, news_items: List[Dict[str, Any]], preferences: Dict[str, Any]) -> str:
-        """Generate news segment script"""
+    def _generate_news_script(self, news_items: List[Dict[str, Any]], preferences: Dict[str, Any]) -> List[str]:
+        """Generate news segment script in batches (1-2 minutes total, ~200-250 words)"""
         if not news_items:
-            return "That's all for news. Back to music!"
+            return ["That's all for news. Back to music!"]
         
-        if self.model:
+        if self.client:
             try:
-                news_text = "\n".join([f"- {item['title']}: {item['summary']}" for item in news_items[:2]])
-                prompt = f"""You are a radio news presenter. Present these news items in a conversational, 
-                engaging way. Keep it under 100 words:
+                # 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. Present these news items in a conversational, 
+                engaging way. This should be 1-2 minutes of speech (about 200-250 words):
                 
                 {news_text}
                 
-                Be informative but friendly!"""
+                Requirements:
+                - Provide context and background for each story
+                - Explain why these stories matter
+                - Use smooth transitions between stories
+                - Be informative but friendly and conversational
+                - Add brief analysis or implications when relevant
+                - Sound natural, like a real radio news anchor"""
+                
+                response = self.client.chat.completions.create(
+                    model=self.config.nebius_model,
+                    messages=[{"role": "user", "content": prompt}],
+                    temperature=0.7,
+                    max_tokens=600
+                )
+                full_script = response.choices[0].message.content.strip()
+                
+                # Split into batches (approximately 50-60 words each for smooth playback)
+                # This allows streaming without waiting for full generation
+                sentences = full_script.split('. ')
+                batches = []
+                current_batch = ""
+                
+                for sentence in sentences:
+                    if len(current_batch.split()) < 50:
+                        current_batch += sentence + ". "
+                    else:
+                        batches.append(current_batch.strip())
+                        current_batch = sentence + ". "
+                
+                if current_batch:
+                    batches.append(current_batch.strip())
                 
-                response = self.model.generate_content(prompt)
-                return response.text
+                return batches if batches else [full_script]
             except Exception as e:
                 print(f"Error generating news script: {e}")
         
@@ -259,11 +389,11 @@ class RadioAgent:
         script = "In the news today: "
         for item in news_items[:2]:
             script += f"{item['title']}. "
-        return script
+        return [script]
     
     def _generate_podcast_intro(self, podcast: Dict[str, Any], preferences: Dict[str, Any]) -> str:
         """Generate podcast introduction"""
-        if not podcast or not self.model:
+        if not podcast or not self.client:
             return "Time for an interesting podcast!"
         
         try:
@@ -275,14 +405,19 @@ class RadioAgent:
             
             Make listeners want to check it out!"""
             
-            response = self.model.generate_content(prompt)
-            return response.text
+            response = self.client.chat.completions.create(
+                model=self.config.nebius_model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.8,
+                max_tokens=150
+            )
+            return response.choices[0].message.content.strip()
         except Exception as e:
             return f"Check out {podcast['title']} hosted by {podcast['host']}!"
     
     def _generate_story(self, mood: str, interests: List[str]) -> str:
         """Generate an interesting story or fun fact"""
-        if not self.model:
+        if not self.client:
             return "Here's a fun fact: Music can boost your mood and productivity!"
         
         try:
@@ -290,8 +425,13 @@ class RadioAgent:
             prompt = f"""Share a fascinating, {mood} story or fun fact about {interest}. 
             Keep it engaging and under 100 words. Perfect for radio listeners!"""
             
-            response = self.model.generate_content(prompt)
-            return response.text
+            response = self.client.chat.completions.create(
+                model=self.config.nebius_model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.9,
+                max_tokens=200
+            )
+            return response.choices[0].message.content.strip()
         except Exception as e:
             return "Here's something interesting: The world's oldest radio station has been broadcasting since 1920!"
     

rag_system.py

@@ -6,20 +6,57 @@ from datetime import datetime
 from llama_index.core import VectorStoreIndex, Document, Settings
 from llama_index.core.storage.storage_context import StorageContext
 from llama_index.core.vector_stores import SimpleVectorStore
-from llama_index.embeddings.gemini import GeminiEmbedding
-from llama_index.llms.gemini import Gemini
+from llama_index.llms.openai import OpenAI as LlamaOpenAI
+# from llama_index.embeddings.gemini import GeminiEmbedding  # Commented out - using Nebius instead
+# from llama_index.llms.gemini import Gemini  # Commented out - using Nebius instead
 
 class RadioRAGSystem:
     """RAG system for storing and retrieving user preferences and listening history"""
     
-    def __init__(self, google_api_key: str):
-        """Initialize RAG system with LlamaIndex"""
-        self.google_api_key = google_api_key
+    def __init__(self, nebius_api_key: str, nebius_api_base: str, nebius_model: str):
+        """Initialize RAG system with LlamaIndex using Nebius/OpenAI"""
+        self.nebius_api_key = nebius_api_key
+        self.nebius_api_base = nebius_api_base
+        self.nebius_model = nebius_model
+        self.llm_available = False
+        self.embedding_available = False
         
-        # Configure LlamaIndex settings
-        if google_api_key:
-            Settings.llm = Gemini(api_key=google_api_key, model="models/gemini-pro")
-            Settings.embed_model = GeminiEmbedding(api_key=google_api_key, model_name="models/embedding-001")
+        # Configure LlamaIndex settings with Nebius/OpenAI
+        if nebius_api_key:
+            try:
+                Settings.llm = LlamaOpenAI(
+                    api_key=nebius_api_key,
+                    api_base=nebius_api_base,
+                    model=nebius_model,
+                    temperature=0.7
+                )
+                self.llm_available = True
+            except Exception as e:
+                print(f"Warning: Could not initialize Nebius/OpenAI LLM: {e}")
+                print("RAG system will work in fallback mode without LLM features")
+                self.llm_available = False
+            
+            # For embeddings, we'll use a simple approach or skip for now
+            # Embeddings can be added later if needed
+            self.embedding_available = False  # Disabled for now - can add OpenAI embeddings later
+        
+        # # Configure LlamaIndex settings with Gemini (COMMENTED OUT - for future use)
+        # if google_api_key:
+        #     try:
+        #         Settings.llm = Gemini(api_key=google_api_key, model="models/gemini-1.0-pro")
+        #         self.llm_available = True
+        #     except Exception as e:
+        #         print(f"Warning: Could not initialize Gemini LLM: {e}")
+        #         print("RAG system will work in fallback mode without LLM features")
+        #         self.llm_available = False
+        #     
+        #     try:
+        #         Settings.embed_model = GeminiEmbedding(api_key=google_api_key, model_name="models/embedding-001")
+        #         self.embedding_available = True
+        #     except Exception as e:
+        #         print(f"Warning: Could not initialize Gemini Embeddings: {e}")
+        #         print("RAG system will work in fallback mode without embeddings")
+        #         self.embedding_available = False
         
         # Initialize vector store
         self.vector_store = SimpleVectorStore()
@@ -39,11 +76,15 @@ class RadioRAGSystem:
                 with open(self.user_data_file, 'r') as f:
                     data = json.load(f)
                     self.documents = [Document(text=json.dumps(d)) for d in data]
-                    if self.documents and self.google_api_key:
-                        self.index = VectorStoreIndex.from_documents(
-                            self.documents,
-                            storage_context=self.storage_context
-                        )
+                    if self.documents and self.embedding_available:
+                        try:
+                            self.index = VectorStoreIndex.from_documents(
+                                self.documents,
+                                storage_context=self.storage_context
+                            )
+                        except Exception as e:
+                            print(f"Warning: Could not build vector index: {e}")
+                            self.index = None
             except Exception as e:
                 print(f"Error loading user data: {e}")
     
@@ -67,12 +108,16 @@ class RadioRAGSystem:
         doc = Document(text=json.dumps(pref_doc))
         self.documents.append(doc)
         
-        # Rebuild index
-        if self.google_api_key:
-            self.index = VectorStoreIndex.from_documents(
-                self.documents,
-                storage_context=self.storage_context
-            )
+        # Rebuild index if embeddings are available
+        if self.embedding_available:
+            try:
+                self.index = VectorStoreIndex.from_documents(
+                    self.documents,
+                    storage_context=self.storage_context
+                )
+            except Exception as e:
+                print(f"Warning: Could not rebuild index: {e}")
+                self.index = None
         
         self._save_user_data()
     
@@ -89,12 +134,16 @@ class RadioRAGSystem:
         doc = Document(text=json.dumps(history_doc))
         self.documents.append(doc)
         
-        # Rebuild index
-        if self.google_api_key:
-            self.index = VectorStoreIndex.from_documents(
-                self.documents,
-                storage_context=self.storage_context
-            )
+        # Rebuild index if embeddings are available
+        if self.embedding_available:
+            try:
+                self.index = VectorStoreIndex.from_documents(
+                    self.documents,
+                    storage_context=self.storage_context
+                )
+            except Exception as e:
+                print(f"Warning: Could not rebuild index: {e}")
+                self.index = None
         
         self._save_user_data()
     
@@ -114,7 +163,7 @@ class RadioRAGSystem:
     
     def get_recommendations(self, query: str) -> Dict[str, Any]:
         """Get personalized recommendations based on user history and preferences"""
-        if not self.index or not self.google_api_key:
+        if not self.index or not self.llm_available:
             return self._get_default_recommendations()
         
         try:

requirements.txt

@@ -1,9 +1,11 @@
 gradio==4.44.0
-google-generativeai>=0.5.2,<0.6.0
+openai>=1.0.0
+# google-generativeai>=0.5.2,<0.6.0  # Commented out - using Nebius instead
 elevenlabs==1.10.0
 llama-index==0.11.20
-llama-index-llms-gemini==0.3.4
-llama-index-embeddings-gemini==0.2.2
+llama-index-llms-openai>=0.1.5
+# llama-index-llms-gemini==0.3.4  # Commented out - using Nebius instead
+# llama-index-embeddings-gemini==0.2.2  # Commented out - using Nebius instead
 requests==2.32.3
 python-dotenv==1.0.1
 pydantic==2.9.2
@@ -14,3 +16,9 @@ sse-starlette==2.1.3
 pydantic-settings==2.5.2
 chromadb==0.5.5
 audioop-lts
+speechrecognition>=3.10.0
+# pyaudio>=0.2.11  # Optional - requires PortAudio. Install with: brew install portaudio (macOS) or apt-get install portaudio19-dev (Linux)
+yt-dlp>=2024.1.0
+pydub>=0.25.1
+# Note: ffmpeg is required for audio conversion
+# Install with: brew install ffmpeg (macOS) or sudo apt-get install ffmpeg (Linux)

tts_service.py

@@ -43,11 +43,11 @@ class TTSService:
         try:
             voice_to_use = voice_id or self.voice_id
             
-            # Generate audio
+            # Generate audio using newer model (free tier compatible)
             audio = self.client.generate(
                 text=text,
                 voice=voice_to_use,
-                model="eleven_monolingual_v1"
+                model="eleven_turbo_v2_5"  # Updated to newer model for free tier
             )
             
             # Convert generator to bytes
@@ -79,11 +79,11 @@ class TTSService:
         try:
             voice_to_use = voice_id or self.voice_id
             
-            # Stream audio
+            # Stream audio using newer model (free tier compatible)
             audio_stream = self.client.generate(
                 text=text,
                 voice=voice_to_use,
-                model="eleven_monolingual_v1",
+                model="eleven_turbo_v2_5",  # Updated to newer model for free tier
                 stream=True
             )
             

voice_input.py

@@ -0,0 +1,161 @@
+"""Voice Input Service for Speech Recognition"""
+import speech_recognition as sr
+from typing import Optional, Callable
+import io
+
+class VoiceInputService:
+    """Service for handling voice input and speech recognition"""
+    
+    def __init__(self):
+        """Initialize voice input service"""
+        self.recognizer = sr.Recognizer()
+        self.microphone = None
+        self.available = False
+        
+        try:
+            # Try to initialize microphone (requires pyaudio)
+            self.microphone = sr.Microphone()
+            # Adjust for ambient noise
+            with self.microphone as source:
+                self.recognizer.adjust_for_ambient_noise(source, duration=0.5)
+            self.available = True
+        except OSError as e:
+            print(f"Warning: Could not initialize microphone: {e}")
+            print("Voice input will not be available")
+            print("To enable voice input, install PortAudio:")
+            print("  macOS: brew install portaudio")
+            print("  Linux: sudo apt-get install portaudio19-dev")
+            print("  Then: pip install pyaudio")
+            self.available = False
+        except Exception as e:
+            print(f"Warning: Could not initialize microphone: {e}")
+            print("Voice input will not be available")
+            self.available = False
+    
+    def listen_and_recognize(self, timeout: int = 5, phrase_time_limit: int = 10) -> Optional[str]:
+        """
+        Listen to microphone and recognize speech
+        
+        Args:
+            timeout: Maximum time to wait for speech to start
+            phrase_time_limit: Maximum time for a phrase
+            
+        Returns:
+            Recognized text or None if error
+        """
+        if not self.available or not self.microphone:
+            return None
+        
+        try:
+            with self.microphone as source:
+                print("Listening... Speak now!")
+                audio = self.recognizer.listen(
+                    source,
+                    timeout=timeout,
+                    phrase_time_limit=phrase_time_limit
+                )
+            
+            print("Processing speech...")
+            # Use Google's free speech recognition API
+            text = self.recognizer.recognize_google(audio)
+            print(f"Recognized: {text}")
+            return text
+            
+        except sr.WaitTimeoutError:
+            print("No speech detected within timeout")
+            return None
+        except sr.UnknownValueError:
+            print("Could not understand audio")
+            return None
+        except sr.RequestError as e:
+            print(f"Error with speech recognition service: {e}")
+            return None
+        except Exception as e:
+            print(f"Error during voice recognition: {e}")
+            return None
+    
+    def process_song_request(self, recognized_text: str) -> dict:
+        """
+        Process a song request from recognized speech
+        
+        Args:
+            recognized_text: Text recognized from speech
+            
+        Returns:
+            Dictionary with song request details
+        """
+        text_lower = recognized_text.lower()
+        
+        # Extract keywords
+        request = {
+            "original_text": recognized_text,
+            "action": None,
+            "song": None,
+            "artist": None,
+            "genre": None,
+            "mood": None
+        }
+        
+        # Remove common action words to get the actual query
+        # Order matters - longer phrases first
+        action_phrases = [
+            "i want to hear", "i want to", "want to hear", 
+            "i'd like to hear", "i would like to hear",
+            "play", "put on", "listen to", "i want", 
+            "can you", "please", "i'd like", "i would like"
+        ]
+        cleaned_text = recognized_text.lower()
+        for phrase in action_phrases:
+            if phrase in cleaned_text:
+                cleaned_text = cleaned_text.replace(phrase, "").strip()
+                break  # Only remove one phrase
+        
+        # Clean up extra spaces and remove standalone "i", "a", "the"
+        words = cleaned_text.split()
+        words = [w for w in words if w not in ["i", "a", "an", "the"]]
+        cleaned_text = " ".join(words).strip()
+        
+        # Detect action
+        if any(word in text_lower for word in ["play", "put on", "listen to", "want to hear"]):
+            request["action"] = "play"
+        elif any(word in text_lower for word in ["skip", "next", "change"]):
+            request["action"] = "skip"
+        else:
+            request["action"] = "play"  # Default
+        
+        # Try to extract song/artist/genre
+        # Simple keyword extraction - can be enhanced with NLP
+        if "by" in text_lower:
+            parts = text_lower.split("by")
+            if len(parts) == 2:
+                request["song"] = parts[0].strip()
+                request["artist"] = parts[1].strip()
+        else:
+            # If no "by", treat the cleaned text as the song/query
+            # But remove genre/mood words that are already extracted
+            song_text = cleaned_text if cleaned_text else recognized_text
+            if request.get("genre"):
+                # Remove genre from song text
+                song_text = song_text.replace(request["genre"], "").strip()
+            if request.get("mood"):
+                # Remove mood from song text
+                song_text = song_text.replace(request["mood"], "").strip()
+            song_text = " ".join(song_text.split())  # Clean up spaces
+            request["song"] = song_text if song_text else recognized_text
+        
+        # Check for genre keywords
+        genres = ["pop", "rock", "jazz", "classical", "electronic", "hip-hop", "hip hop", "country", "indie", "rap", "blues", "folk"]
+        for genre in genres:
+            if genre in text_lower:
+                request["genre"] = genre
+                break
+        
+        # Check for mood keywords
+        moods = ["happy", "sad", "energetic", "calm", "relaxed", "focused", "upbeat", "chill"]
+        for mood in moods:
+            if mood in text_lower:
+                request["mood"] = mood
+                break
+        
+        return request
+