Update app.py

app.py

@@ -13,13 +13,14 @@ import edge_tts
 import asyncio
 import requests
 from collections import defaultdict
-from audio_recorder_streamlit import audio_recorder
 import streamlit.components.v1 as components
 from urllib.parse import quote
 from xml.etree import ElementTree as ET
 from datasets import load_dataset
+import base64
+import re
 
-# 🧠 Initialize session state variables 
+# 🧠 Initialize session state variables
 SESSION_VARS = {
     'search_history': [],          # Track search history
     'last_voice_input': "",        # Last voice input
@@ -35,10 +36,11 @@ SESSION_VARS = {
     'dataset_info': None,         # Dataset metadata
     'nps_submitted': False,       # Track if user submitted NPS
     'nps_last_shown': None,       # When NPS was last shown
-    'voice_recorder_key': str(datetime.now())  # Unique key for voice recorder
+    'old_val': None,              # Previous voice input value
+    'voice_text': None            # Processed voice text
 }
 
-# 📊 Constants
+# Constants
 ROWS_PER_PAGE = 100
 MIN_SEARCH_SCORE = 0.3
 EXACT_MATCH_BOOST = 2.0
@@ -48,235 +50,312 @@ for var, default in SESSION_VARS.items():
     if var not in st.session_state:
         st.session_state[var] = default
 
-class NPSTracker:
-    """🎯 Net Promoter Score Tracker - Measuring happiness in numbers!"""
-    
-    def __init__(self, log_file="nps_logs.csv"):
-        self.log_file = Path(log_file)
-        self.initialize_log()
+# Voice Component Setup
+def create_voice_component():
+    """Create the voice input component"""
+    mycomponent = components.declare_component(
+        "mycomponent",
+        path="mycomponent"
+    )
+    return mycomponent
+
+# Utility Functions
+def clean_for_speech(text: str) -> str:
+    """Clean text for speech synthesis"""
+    text = text.replace("\n", " ")
+    text = text.replace("</s>", " ")
+    text = text.replace("#", "")
+    text = re.sub(r"\(https?:\/\/[^\)]+\)", "", text)
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+async def edge_tts_generate_audio(text, voice="en-US-AriaNeural", rate=0, pitch=0):
+    """Generate audio using Edge TTS"""
+    text = clean_for_speech(text)
+    if not text.strip():
+        return None
+    rate_str = f"{rate:+d}%"
+    pitch_str = f"{pitch:+d}Hz"
+    communicate = edge_tts.Communicate(text, voice, rate=rate_str, pitch=pitch_str)
+    out_fn = f"speech_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp3"
+    await communicate.save(out_fn)
+    return out_fn
+
+def speak_with_edge_tts(text, voice="en-US-AriaNeural", rate=0, pitch=0):
+    """Wrapper for edge TTS generation"""
+    return asyncio.run(edge_tts_generate_audio(text, voice, rate, pitch))
+
+def play_and_download_audio(file_path):
+    """Play and provide download link for audio"""
+    if file_path and os.path.exists(file_path):
+        st.audio(file_path)
+        dl_link = f'<a href="data:audio/mpeg;base64,{base64.b64encode(open(file_path,"rb").read()).decode()}" download="{os.path.basename(file_path)}">Download {os.path.basename(file_path)}</a>'
+        st.markdown(dl_link, unsafe_allow_html=True)
+
+@st.cache_resource
+def get_model():
+    """Get sentence transformer model"""
+    return SentenceTransformer('all-MiniLM-L6-v2')
+
+@st.cache_data
+def load_dataset_page(dataset_id, token, page, rows_per_page):
+    """Load dataset page with caching"""
+    try:
+        start_idx = page * rows_per_page
+        end_idx = start_idx + rows_per_page
+        dataset = load_dataset(
+            dataset_id,
+            token=token,
+            streaming=False,
+            split=f'train[{start_idx}:{end_idx}]'
+        )
+        return pd.DataFrame(dataset)
+    except Exception as e:
+        st.error(f"Error loading page {page}: {str(e)}")
+        return pd.DataFrame()
+
+@st.cache_data
+def get_dataset_info(dataset_id, token):
+    """Get dataset info with caching"""
+    try:
+        dataset = load_dataset(dataset_id, token=token, streaming=True)
+        return dataset['train'].info
+    except Exception as e:
+        st.error(f"Error loading dataset info: {str(e)}")
+        return None
+
+def fetch_dataset_info(dataset_id):
+    """Fetch dataset information"""
+    info_url = f"https://huggingface.co/api/datasets/{dataset_id}"
+    try:
+        response = requests.get(info_url, timeout=30)
+        if response.status_code == 200:
+            return response.json()
+    except Exception as e:
+        st.warning(f"Error fetching dataset info: {e}")
+    return None
+
+def generate_filename(text):
+    """Generate unique filename from text"""
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    safe_text = re.sub(r'[^\w\s-]', '', text[:50]).strip().lower()
+    safe_text = re.sub(r'[-\s]+', '-', safe_text)
+    return f"{timestamp}_{safe_text}"
+
+def render_result(result):
+    """Render a single search result"""
+    score = result.get('relevance_score', 0)
+    result_filtered = {k: v for k, v in result.items() 
+                      if k not in ['relevance_score', 'video_embed', 'description_embed', 'audio_embed']}
     
-    def initialize_log(self):
-        """📝 Create log file if it doesn't exist"""
-        if not self.log_file.exists():
-            df = pd.DataFrame(columns=['timestamp', 'score', 'feedback'])
-            df.to_csv(self.log_file, index=False)
+    if 'youtube_id' in result:
+        st.video(f"https://youtube.com/watch?v={result['youtube_id']}&t={result.get('start_time', 0)}")
     
-    def log_response(self, score, feedback=""):
-        """🖊️ Log new NPS response"""
-        new_entry = pd.DataFrame([{
-            'timestamp': datetime.now().isoformat(),
-            'score': score,
-            'feedback': feedback
-        }])
-        
-        if self.log_file.exists():
-            df = pd.read_csv(self.log_file)
-            df = pd.concat([df, new_entry], ignore_index=True)
-        else:
-            df = new_entry
-        
-        df.to_csv(self.log_file, index=False)
+    cols = st.columns([2, 1])
+    with cols[0]:
+        text_content = []
+        for key, value in result_filtered.items():
+            if isinstance(value, (str, int, float)):
+                st.write(f"**{key}:** {value}")
+                if isinstance(value, str) and len(value.strip()) > 0:
+                    text_content.append(f"{key}: {value}")
     
-    def get_nps_stats(self, days=30):
-        """📊 Calculate NPS stats for recent period"""
-        if not self.log_file.exists():
-            return {
-                'nps_score': 0,
-                'promoters': 0,
-                'passives': 0,
-                'detractors': 0,
-                'total_responses': 0,
-                'recent_feedback': []
-            }
+    with cols[1]:
+        st.metric("Relevance", f"{score:.2%}")
         
-        df = pd.read_csv(self.log_file)
-        df['timestamp'] = pd.to_datetime(df['timestamp'])
-        
-        cutoff = datetime.now() - timedelta(days=days)
-        recent_df = df[df['timestamp'] > cutoff]
-        
-        if len(recent_df) == 0:
-            return {
-                'nps_score': 0,
-                'promoters': 0,
-                'passives': 0,
-                'detractors': 0,
-                'total_responses': 0,
-                'recent_feedback': []
-            }
-        
-        total = len(recent_df)
-        promoters = len(recent_df[recent_df['score'] >= 9])
-        passives = len(recent_df[recent_df['score'].between(7, 8)])
-        detractors = len(recent_df[recent_df['score'] <= 6])
+        voices = {
+            "Aria (US Female)": "en-US-AriaNeural",
+            "Guy (US Male)": "en-US-GuyNeural",
+            "Sonia (UK Female)": "en-GB-SoniaNeural",
+            "Tony (UK Male)": "en-GB-TonyNeural"
+        }
         
-        nps = ((promoters/total) - (detractors/total)) * 100
+        selected_voice = st.selectbox(
+            "Voice:",
+            list(voices.keys()),
+            key=f"voice_{result.get('video_id', '')}"
+        )
         
-        recent_feedback = recent_df[recent_df['feedback'].notna()].sort_values(
-            'timestamp', ascending=False
-        )['feedback'].head(5).tolist()
+        if st.button("🔊 Read", key=f"read_{result.get('video_id', '')}"):
+            text_to_read = ". ".join(text_content)
+            audio_file = speak_with_edge_tts(text_to_read, voices[selected_voice])
+            if audio_file:
+                play_and_download_audio(audio_file)
+
+class FastDatasetSearcher:
+    """Fast dataset search with semantic and token matching"""
+    
+    def __init__(self, dataset_id="tomg-group-umd/cinepile"):
+        self.dataset_id = dataset_id
+        self.text_model = get_model()
+        self.token = os.environ.get('DATASET_KEY')
+        if not self.token:
+            st.error("Please set the DATASET_KEY environment variable")
+            st.stop()
         
-        return {
-            'nps_score': round(nps, 1),
-            'promoters': promoters,
-            'passives': passives,
-            'detractors': detractors,
-            'total_responses': total,
-            'recent_feedback': recent_feedback
-        }
+        if st.session_state['dataset_info'] is None:
+            st.session_state['dataset_info'] = get_dataset_info(self.dataset_id, self.token)
+
+    def load_page(self, page=0):
+        """Load a specific page of data"""
+        return load_dataset_page(self.dataset_id, self.token, page, ROWS_PER_PAGE)
 
-def setup_voice_recorder():
-    """🎤 Create an in-browser voice recorder component"""
-    return components.html(
-        """
-        <div style="display: flex; flex-direction: column; align-items: center; gap: 10px;">
-            <button id="startButton" 
-                    style="padding: 10px 20px; background: #ff4b4b; color: white; border: none; border-radius: 5px; cursor: pointer">
-                Start Recording
-            </button>
-            <button id="stopButton" 
-                    style="padding: 10px 20px; background: #4b4bff; color: white; border: none; border-radius: 5px; cursor: pointer"
-                    disabled>
-                Stop Recording
-            </button>
-            <audio id="audioPlayback" controls style="display: none;"></audio>
-            <div id="statusText" style="color: #666;">Ready to record...</div>
-        </div>
-        <script>
-        let mediaRecorder;
-        let audioChunks = [];
+    def quick_search(self, query, df):
+        """Perform quick search with semantic similarity"""
+        if df.empty or not query.strip():
+            return df
         
-        document.getElementById('startButton').onclick = async () => {
-            try {
-                const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
-                mediaRecorder = new MediaRecorder(stream);
+        try:
+            searchable_cols = []
+            for col in df.columns:
+                sample_val = df[col].iloc[0]
+                if not isinstance(sample_val, (np.ndarray, bytes)):
+                    searchable_cols.append(col)
+            
+            query_lower = query.lower()
+            query_terms = set(query_lower.split())
+            query_embedding = self.text_model.encode([query], show_progress_bar=False)[0]
+            
+            scores = []
+            matched_any = []
+            
+            for _, row in df.iterrows():
+                text_parts = []
+                row_matched = False
+                exact_match = False
                 
-                mediaRecorder.ondataavailable = (e) => {
-                    audioChunks.push(e.data);
-                };
+                priority_fields = ['description', 'matched_text']
+                other_fields = [col for col in searchable_cols if col not in priority_fields]
                 
-                mediaRecorder.onstop = () => {
-                    const audioBlob = new Blob(audioChunks, { type: 'audio/wav' });
-                    const audioUrl = URL.createObjectURL(audioBlob);
-                    document.getElementById('audioPlayback').src = audioUrl;
-                    document.getElementById('audioPlayback').style.display = 'block';
-                    
-                    // Send to Python
-                    const reader = new FileReader();
-                    reader.readAsDataURL(audioBlob);
-                    reader.onloadend = () => {
-                        window.parent.postMessage({
-                            type: 'voiceData',
-                            data: reader.result
-                        }, '*');
-                    };
-                };
+                for col in priority_fields:
+                    if col in row:
+                        val = row[col]
+                        if val is not None:
+                            val_str = str(val).lower()
+                            if query_lower in val_str.split():
+                                exact_match = True
+                            if any(term in val_str.split() for term in query_terms):
+                                row_matched = True
+                            text_parts.append(str(val))
                 
-                mediaRecorder.start();
-                document.getElementById('startButton').disabled = true;
-                document.getElementById('stopButton').disabled = false;
-                document.getElementById('statusText').textContent = 'Recording...';
+                for col in other_fields:
+                    val = row[col]
+                    if val is not None:
+                        val_str = str(val).lower()
+                        if query_lower in val_str.split():
+                            exact_match = True
+                        if any(term in val_str.split() for term in query_terms):
+                            row_matched = True
+                        text_parts.append(str(val))
                 
-            } catch (err) {
-                console.error('Error:', err);
-                document.getElementById('statusText').textContent = 'Error: ' + err.message;
-            }
-        };
-        
-        document.getElementById('stopButton').onclick = () => {
-            mediaRecorder.stop();
-            document.getElementById('startButton').disabled = false;
-            document.getElementById('stopButton').disabled = true;
-            document.getElementById('statusText').textContent = 'Recording complete!';
-        };
-        </script>
-        """,
-        height=200,
-    )
-
-def render_nps_sidebar():
-    """🎨 Show NPS metrics in sidebar"""
-    tracker = NPSTracker()
-    stats = tracker.get_nps_stats()
-    
-    st.sidebar.markdown("### 📊 User Satisfaction Metrics")
-    
-    score_color = (
-        "🟢" if stats['nps_score'] >= 50 else 
-        "🟡" if stats['nps_score'] >= 0 else 
-        "🔴"
-    )
-    st.sidebar.metric(
-        "Net Promoter Score",
-        f"{score_color} {stats['nps_score']}"
-    )
-    
-    st.sidebar.markdown("#### Response Breakdown")
-    col1, col2, col3 = st.sidebar.columns(3)
-    with col1:
-        st.metric("😃", stats['promoters'])
-    with col2:
-        st.metric("😐", stats['passives'])
-    with col3:
-        st.metric("😕", stats['detractors'])
-    
-    if stats['recent_feedback']:
-        st.sidebar.markdown("#### Recent Feedback")
-        for feedback in stats['recent_feedback']:
-            st.sidebar.info(feedback[:100] + "..." if len(feedback) > 100 else feedback)
-
-def render_nps_survey():
-    """🎯 Show NPS survey form"""
-    tracker = NPSTracker()
-    
-    st.markdown("### 📝 Your Feedback Matters!")
-    score = st.slider(
-        "How likely are you to recommend this search tool to others?",
-        0, 10, 
-        help="0 = Not likely at all, 10 = Extremely likely"
-    )
-    
-    feedback = st.text_area("Additional feedback (optional)")
-    
-    if st.button("Submit Feedback", key="nps_submit"):
-        tracker.log_response(score, feedback)
-        st.session_state['nps_submitted'] = True
-        st.success("Thank you for your feedback! 🙏")
-        st.experimental_rerun()
-
-[... Rest of your existing code for search functionality ...]
+                text = ' '.join(text_parts)
+                
+                if text.strip():
+                    text_tokens = set(text.lower().split())
+                    matching_terms = query_terms.intersection(text_tokens)
+                    keyword_score = len(matching_terms) / len(query_terms)
+                    
+                    text_embedding = self.text_model.encode([text], show_progress_bar=False)[0]
+                    semantic_score = float(cosine_similarity([query_embedding], [text_embedding])[0][0])
+                    
+                    combined_score = 0.7 * keyword_score + 0.3 * semantic_score
+                    
+                    if exact_match:
+                        combined_score *= EXACT_MATCH_BOOST
+                    elif row_matched:
+                        combined_score *= 1.2
+                else:
+                    combined_score = 0.0
+                    row_matched = False
+                
+                scores.append(combined_score)
+                matched_any.append(row_matched)
+            
+            results_df = df.copy()
+            results_df['score'] = scores
+            results_df['matched'] = matched_any
+            
+            filtered_df = results_df[
+                (results_df['matched']) |
+                (results_df['score'] > MIN_SEARCH_SCORE)
+            ]
+            
+            return filtered_df.sort_values('score', ascending=False)
+            
+        except Exception as e:
+            st.error(f"Search error: {str(e)}")
+            return df
 
 def main():
-    st.title("🎥 Smart Video Search with Voice & Feedback")
+    st.title("🎥 Smart Video & Voice Search")
     
-    # Initialize search
-    search = VideoSearch()
+    # Initialize components
+    voice_component = create_voice_component()
+    search = FastDatasetSearcher()
     
-    # Add NPS metrics to sidebar
-    with st.sidebar:
-        render_nps_sidebar()
+    # Voice input at top level
+    voice_val = voice_component(my_input_value="Start speaking...")
+    
+    # Show voice input if detected
+    if voice_val:
+        voice_text = str(voice_val).strip()
+        edited_input = st.text_area("✏️ Edit Voice Input:", value=voice_text, height=100)
+        
+        run_option = st.selectbox("Select Search Type:", 
+                                ["Quick Search", "Deep Search", "Voice Summary"])
         
-        # Show survey periodically
-        current_time = datetime.now()
-        if (not st.session_state.get('nps_submitted') and 
-            (not st.session_state.get('nps_last_shown') or 
-             current_time - st.session_state['nps_last_shown'] > timedelta(hours=24))):
-            with st.expander("📝 Quick Feedback", expanded=True):
-                render_nps_survey()
-                st.session_state['nps_last_shown'] = current_time
+        col1, col2 = st.columns(2)
+        with col1:
+            autorun = st.checkbox("⚡ Auto-Run", value=False)
+        with col2:
+            full_audio = st.checkbox("🔊 Full Audio", value=False)
+        
+        input_changed = (voice_text != st.session_state.get('old_val'))
+        
+        if autorun and input_changed:
+            st.session_state['old_val'] = voice_text
+            with st.spinner("Processing voice input..."):
+                if run_option == "Quick Search":
+                    results = search.quick_search(edited_input, search.load_page())
+                    for i, result in enumerate(results.iterrows(), 1):
+                        with st.expander(f"Result {i}", expanded=(i==1)):
+                            render_result(result[1])
+                            
+                elif run_option == "Deep Search":
+                    with st.spinner("Performing deep search..."):
+                        results = []
+                        for page in range(3):  # Search first 3 pages
+                            df = search.load_page(page)
+                            results.extend(search.quick_search(edited_input, df).iterrows())
+                        
+                        for i, result in enumerate(results, 1):
+                            with st.expander(f"Result {i}", expanded=(i==1)):
+                                render_result(result[1])
+                                
+                elif run_option == "Voice Summary":
+                    audio_file = speak_with_edge_tts(edited_input)
+                    if audio_file:
+                        play_and_download_audio(audio_file)
+                        
+        elif st.button("🔍 Search"):
+            st.session_state['old_val'] = voice_text
+            with st.spinner("Processing..."):
+                results = search.quick_search(edited_input, search.load_page())
+                for i, result in enumerate(results.iterrows(), 1):
+                    with st.expander(f"Result {i}", expanded=(i==1)):
+                        render_result(result[1])
     
     # Create main tabs
     tab1, tab2, tab3, tab4 = st.tabs([
-        "🔍 Search", "🎙️ Voice Input", "📚 ArXiv", "📂 Files"
+        "🔍 Search", "🎙️ Voice", "💾 History", "⚙️ Settings"
     ])
     
-    # Search Tab
     with tab1:
-        st.subheader("Search Videos")
+        st.subheader("🔍 Search")
         col1, col2 = st.columns([3, 1])
         with col1:
             query = st.text_input("Enter search query:", 
-                                value="" if st.session_state['initial_search_done'] else "aliens")
+                                value="" if st.session_state['initial_search_done'] else "")
         with col2:
             search_column = st.selectbox("Search in:", 
                                        ["All Fields"] + st.session_state['search_columns'])
@@ -292,56 +371,101 @@ def main():
             selected_column = None if search_column == "All Fields" else search_column
             
             with st.spinner("Searching..."):
-                results = search.search(query, selected_column, num_results)
-            
-            if results:
-                st.session_state['search_history'].append({
-                    'query': query,
-                    'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                    'results': results[:5]
-                })
+                df = search.load_page()
+                results = search.quick_search(query, df)
                 
-                st.write(f"Found {len(results)} results:")
-                for i, result in enumerate(results, 1):
-                    with st.expander(f"Result {i}", expanded=(i==1)):
-                        render_result(result)
-            else:
-                st.warning("No matching results found.")
+                if len(results) > 0:
+                    st.session_state['search_history'].append({
+                        'query': query,
+                        'timestamp': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                        'results': results[:5]
+                    })
+                    
+                    st.write(f"Found {len(results)} results:")
+                    for i, (_, result) in enumerate(results.iterrows(), 1):
+                        if i > num_results:
+                            break
+                        with st.expander(f"Result {i}", expanded=(i==1)):
+                            render_result(result)
+                else:
+                    st.warning("No matching results found.")
     
-    # Voice Input Tab
     with tab2:
-        st.subheader("Voice Search")
-        st.write("🎙️ Record your query:")
+        st.subheader("🎙️ Voice Input")
+        st.write("Use the voice input above to start speaking, or record a new message:")
         
-        voice_recorder = setup_voice_recorder()
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("🎙️ Start New Recording"):
+                st.session_state['recording'] = True
+                st.experimental_rerun()
+        with col2:
+            if st.button("🛑 Stop Recording"):
+                st.session_state['recording'] = False
+                st.experimental_rerun()
         
-        if 'voice_data' in st.session_state:
-            with st.spinner("Processing voice..."):
-                voice_query = transcribe_audio(st.session_state['voice_data'])
-                st.markdown("**Transcribed Text:**")
-                st.write(voice_query)
-                
-                if st.button("🔍 Search with Voice"):
-                    results = search.search(voice_query, None, 20)
-                    for i, result in enumerate(results, 1):
-                        with st.expander(f"Result {i}", expanded=(i==1)):
-                            render_result(result)
+        if st.session_state.get('recording', False):
+            voice_component = create_voice_component()
+            new_val = voice_component(my_input_value="Recording...")
+            if new_val:
+                st.text_area("Recorded Text:", value=new_val, height=100)
+                if st.button("🔍 Search with Recording"):
+                    with st.spinner("Processing recording..."):
+                        df = search.load_page()
+                        results = search.quick_search(new_val, df)
+                        for i, (_, result) in enumerate(results.iterrows(), 1):
+                            with st.expander(f"Result {i}", expanded=(i==1)):
+                                render_result(result)
     
-    # ArXiv Tab
     with tab3:
-        st.subheader("ArXiv Search")
-        arxiv_query = st.text_input("Search ArXiv:", value=st.session_state['arxiv_last_query'])
-        vocal_summary = st.checkbox("🎙 Quick Audio Summary", value=True)
-        titles_summary = st.checkbox("🔖 Titles Only", value=True)
-        full_audio = st.checkbox("📚 Full Audio Summary", value=False)
-        
-        if st.button("🔍 Search ArXiv"):
-            st.session_state['arxiv_last_query'] = arxiv_query
-            perform_arxiv_lookup(arxiv_query, vocal_summary, titles_summary, full_audio)
+        st.subheader("💾 Search History")
+        if not st.session_state['search_history']:
+            st.info("No search history yet. Try searching for something!")
+        else:
+            for entry in reversed(st.session_state['search_history']):
+                with st.expander(f"🕒 {entry['timestamp']} - {entry['query']}", expanded=False):
+                    for i, result in enumerate(entry['results'], 1):
+                        st.write(f"**Result {i}:**")
+                        if isinstance(result, pd.Series):
+                            render_result(result)
+                        else:
+                            st.write(result)
     
-    # File Manager Tab
     with tab4:
-        show_file_manager()
+        st.subheader("⚙️ Settings")
+        st.write("Voice Settings:")
+        default_voice = st.selectbox(
+            "Default Voice:",
+            [
+                "en-US-AriaNeural",
+                "en-US-GuyNeural",
+                "en-GB-SoniaNeural",
+                "en-GB-TonyNeural"
+            ],
+            index=0,
+            key="default_voice"
+        )
+        
+        st.write("Search Settings:")
+        st.slider("Minimum Search Score:", 0.0, 1.0, MIN_SEARCH_SCORE, 0.1)
+        st.slider("Exact Match Boost:", 1.0, 3.0, EXACT_MATCH_BOOST, 0.1)
+        
+        if st.button("🗑️ Clear Search History"):
+            st.session_state['search_history'] = []
+            st.success("Search history cleared!")
+            st.experimental_rerun()
+    
+    # Sidebar with metrics
+    with st.sidebar:
+        st.subheader("📊 Search Metrics")
+        total_searches = len(st.session_state['search_history'])
+        st.metric("Total Searches", total_searches)
+        
+        if total_searches > 0:
+            recent_searches = st.session_state['search_history'][-5:]
+            st.write("Recent Searches:")
+            for entry in reversed(recent_searches):
+                st.write(f"🔍 {entry['query']}")
 
 if __name__ == "__main__":
     main()